From e9b0698f2a7f27adc1fa4464276d14a51f4025ea Mon Sep 17 00:00:00 2001 From: btp <842297171@qq.com> Date: Sat, 27 May 2017 15:35:50 +0800 Subject: [PATCH 01/15] 170537-Generic --- src/btp/oneP/GenericErase.java | 22 ++++++++++++++++++++++ src/btp/oneP/GenericEvaluate.java | 29 +++++++++++++++++++++++++++++ src/btp/oneP/ListCopy.java | 24 ++++++++++++++++++++++++ 3 files changed, 75 insertions(+) create mode 100644 src/btp/oneP/GenericErase.java create mode 100644 src/btp/oneP/GenericEvaluate.java create mode 100644 src/btp/oneP/ListCopy.java diff --git a/src/btp/oneP/GenericErase.java b/src/btp/oneP/GenericErase.java new file mode 100644 index 0000000..ac37850 --- /dev/null +++ b/src/btp/oneP/GenericErase.java @@ -0,0 +1,22 @@ +package btp.oneP; + +import java.lang.reflect.Method; +import java.util.ArrayList; + +public class GenericErase { + + public static void main(String[] args) { + ArrayList sl = new ArrayList(); + sl.add("Magic"); + Class clazz = sl.getClass(); + try{ + Method method = clazz.getMethod("add", Object.class); + method.invoke(sl, 1); + System.out.println(sl); + //out:[Magic, 1] + }catch(Exception e){ + e.printStackTrace(); + } + } + +} diff --git a/src/btp/oneP/GenericEvaluate.java b/src/btp/oneP/GenericEvaluate.java new file mode 100644 index 0000000..caa27e1 --- /dev/null +++ b/src/btp/oneP/GenericEvaluate.java @@ -0,0 +1,29 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collection; + +public class GenericEvaluate { + + public static void main(String[] args) { + Collection> c1 = new ArrayList>(); + Collection> c2 = c1; + //Collection> c3 = c1; + Collection> c4 = c1; + + Collection> c5 = new ArrayList>(); + //Collection> c6 = c5; + Collection> c7 = c5; + //Collection> c8 = c5; + Collection> c9 = c5; + } + +} + +class Pair{ + +} + +class SubTypeOfPair extends Pair{ + +} diff --git a/src/btp/oneP/ListCopy.java b/src/btp/oneP/ListCopy.java new file mode 100644 index 0000000..9c4cae4 --- /dev/null +++ b/src/btp/oneP/ListCopy.java @@ -0,0 +1,24 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class ListCopy { + + public static void copy(List src,List dest){ + for(T t:src){ + dest.add(t); + } + } + + public static void main(String[] args) { + List sList = new ArrayList(Arrays.asList(new String[]{"hehe","xixi","caca"})); + List oList = new ArrayList(); + copy(sList,oList); + for(Object o:oList){ + System.out.println(o); + } + } + +} From effccdb633d3703548e70935377919202105fe20 Mon Sep 17 00:00:00 2001 From: btp <842297171@qq.com> Date: Sun, 28 May 2017 16:15:08 +0800 Subject: [PATCH 02/15] 0528-Generic --- src/btp/oneP/Byteset.java | 14 ++++ src/btp/oneP/CRGWithBasicHolder.java | 27 ++++++++ src/btp/oneP/CaptureConversion.java | 24 +++++++ src/btp/oneP/CheckedList.java | 39 +++++++++++ src/btp/oneP/ClassCasting.java | 26 +++++++ src/btp/oneP/ComparablePet.java | 30 +++++++++ src/btp/oneP/Covarance.java | 90 +++++++++++++++++++++++++ src/btp/oneP/Employee.java | 33 +++++++++ src/btp/oneP/GenericExceptionTest.java | 11 +++ src/btp/oneP/SelfBounded.java | 52 ++++++++++++++ src/btp/oneP/ThrowGenericException.java | 83 +++++++++++++++++++++++ src/btp/oneP/Wildcards.java | 15 +++++ 12 files changed, 444 insertions(+) create mode 100644 src/btp/oneP/Byteset.java create mode 100644 src/btp/oneP/CRGWithBasicHolder.java create mode 100644 src/btp/oneP/CaptureConversion.java create mode 100644 src/btp/oneP/CheckedList.java create mode 100644 src/btp/oneP/ClassCasting.java create mode 100644 src/btp/oneP/ComparablePet.java create mode 100644 src/btp/oneP/Covarance.java create mode 100644 src/btp/oneP/Employee.java create mode 100644 src/btp/oneP/GenericExceptionTest.java create mode 100644 src/btp/oneP/SelfBounded.java create mode 100644 src/btp/oneP/ThrowGenericException.java diff --git a/src/btp/oneP/Byteset.java b/src/btp/oneP/Byteset.java new file mode 100644 index 0000000..35a79c7 --- /dev/null +++ b/src/btp/oneP/Byteset.java @@ -0,0 +1,14 @@ +package btp.oneP; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +public class Byteset { + Byte[] possibles = {1,2,3,4,5,6,7,8,9}; + Set myset = new HashSet(Arrays.asList(possibles)); + + Set myset2 = new HashSet(Arrays.asList(new Byte[]{1,2,3,4,5,6,7,8,9})); + //The parameterized method asList(Byte...) of type Arrays is not applicable for the arguments (Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer) + //Set myset3 = new HashSet(Arrays.asList(1,2,3,4,5,6,7,8,9)); +} diff --git a/src/btp/oneP/CRGWithBasicHolder.java b/src/btp/oneP/CRGWithBasicHolder.java new file mode 100644 index 0000000..d20f854 --- /dev/null +++ b/src/btp/oneP/CRGWithBasicHolder.java @@ -0,0 +1,27 @@ +package btp.oneP; + +public class CRGWithBasicHolder { + + public static void main(String[] args) { + Subtype st1 = new Subtype(),st2 = new Subtype(); + st1.set(st2); + Subtype st3 = st1.get(); + st1.f(); + } + +} + +class BasicHolder{ + T element; + void set(T t){ + element = t; + } + T get(){ + return this.element; + } + void f(){ + System.out.println(this.element.getClass().getName()); + } +} + +class Subtype extends BasicHolder{} \ No newline at end of file diff --git a/src/btp/oneP/CaptureConversion.java b/src/btp/oneP/CaptureConversion.java new file mode 100644 index 0000000..964ae23 --- /dev/null +++ b/src/btp/oneP/CaptureConversion.java @@ -0,0 +1,24 @@ +package btp.oneP; + +public class CaptureConversion { + + static void f1(Holder holder){ + T t = holder.get(); + System.out.println(t.getClass().getSimpleName()); + } + + static void f2(Holder holder){ + f1(holder); + } + public static void main(String[] args) { + Holder raw = new Holder(1); + f1(raw); + f2(raw); + Holder rawBasic = new Holder(); + rawBasic.set(new Object()); + f2(rawBasic); + Holder wildcarded = new Holder(1.0); + f2(wildcarded); + } + +} diff --git a/src/btp/oneP/CheckedList.java b/src/btp/oneP/CheckedList.java new file mode 100644 index 0000000..cf99872 --- /dev/null +++ b/src/btp/oneP/CheckedList.java @@ -0,0 +1,39 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class CheckedList { + + @SuppressWarnings("unchecked") + static void oldStyleMethod(List probablyDogs){ + probablyDogs.add(new Cat()); + } + + public static void main(String[] args) { + List dogs1 = new ArrayList(); + oldStyleMethod(dogs1); + System.out.println(dogs1); + Lists2 = Collections.checkedList(new ArrayList(), Dog.class); + try{ + oldStyleMethod(s2); + }catch(Exception e){ + e.printStackTrace(); + } + + //work fine + List pets = Collections.checkedList(new ArrayList(), Pet.class); + pets.add(new Dog()); + pets.add(new Cat()); + pets.add(new Pet()); + oldStyleMethod(pets); + System.out.println(pets); + } + +} + +class Pet{} +class Dog extends Pet{} +class Cat extends Pet{} + diff --git a/src/btp/oneP/ClassCasting.java b/src/btp/oneP/ClassCasting.java new file mode 100644 index 0000000..b80fa8c --- /dev/null +++ b/src/btp/oneP/ClassCasting.java @@ -0,0 +1,26 @@ +package btp.oneP; + +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.util.List; + +public class ClassCasting { + + public void f(String...args) throws FileNotFoundException, IOException, ClassNotFoundException{ + ObjectInputStream in = new ObjectInputStream( + new FileInputStream(args[0])); + //List lwl = List.class.ClassCasting(in.readObject()); + //List lw2 = (List)List.class.cast(in.readObject()); + List lw2 = List.class.cast(in.readObject()); + } + + public static void main(String[] args) { + // TODO Auto-generated method stub + + } + +} + +class Widget{} diff --git a/src/btp/oneP/ComparablePet.java b/src/btp/oneP/ComparablePet.java new file mode 100644 index 0000000..ba87d94 --- /dev/null +++ b/src/btp/oneP/ComparablePet.java @@ -0,0 +1,30 @@ +package btp.oneP; + +public class ComparablePet implements Comparable { + + @Override + public int compareTo(ComparablePet o) { + return 0; + } + +} + +//以下是错误的，等于同时两个泛型参数 +//class Cat extends ComparablePet implements Comparable{} + + +class Hamster extends ComparablePet implements Comparable{ + //其实这就等于重写，子类Hamster重写了父类ComparablePet的方法 + @Override + public int compareTo(ComparablePet o) { + return 0; + } +} + +//Gecko和Hanster的效果一样 +class Gecko extends ComparablePet{ + @Override + public int compareTo(ComparablePet o) { + return 0; + } +} \ No newline at end of file diff --git a/src/btp/oneP/Covarance.java b/src/btp/oneP/Covarance.java new file mode 100644 index 0000000..9fecfcf --- /dev/null +++ b/src/btp/oneP/Covarance.java @@ -0,0 +1,90 @@ +package btp.oneP; + +public class Covarance { + + public static void main(String[] args) { + // TODO Auto-generated method stub + BaseX bx = new BaseX(); + DerivedX dx = new DerivedX(); + DerivedSetter d = new DerivedSetter(); + d.set(dx); + d.set(bx); + //---------------- + DerivedGS dgs = new DerivedGS(); + dgs.set(bx); + dgs.set(dx); + + } + +} + +class BaseX{} +class DerivedX extends BaseX{} + +interface OrdinaryGetter{ + BaseX get(); +} + +interface DerivedGetter extends OrdinaryGetter{ + DerivedX get(); +} + +class CovariantReturnTypes{ + void test(DerivedGetter d){ + DerivedX d2 = d.get(); + } +} + +interface GenericGetter>{ + T get(); +} + +interface Getter extends GenericGetter{ + +} + +class GenericsAndReturnTypes{ + void test(Getter g){ + Getter result = g.get(); + GenericGetter gg = g.get(); + } +} + + +class OrdinarySetter{ + void set(BaseX base){ + System.out.println("OrdinarySetter.set(BaseX)"); + } +} + +class DerivedSetter extends OrdinarySetter{ + //这不是重写，这是重载 + void set(DerivedX derived){ + System.out.println("DerivedSetter.set(Derived)"); + } +} + +interface SelfBoundSetter>{ + void set(T arg); +} + +interface GSetter extends SelfBoundSetter{} + +class SelfBoundingAndCovariantArgument{ + void testA(GSetter s1,GSetter s2,SelfBoundSetter sbs){ + s1.set(s2); + //s1.set(sbs); + } +} + +class GenericSetter{ + void set(T t){ + System.out.println("GenericSetter.set(Base)"); + } +} + +class DerivedGS extends GenericSetter{ + void set(DerivedX derivedx){ + System.out.println("DerivedGS.set(Derived)"); + } +} \ No newline at end of file diff --git a/src/btp/oneP/Employee.java b/src/btp/oneP/Employee.java new file mode 100644 index 0000000..0a98de3 --- /dev/null +++ b/src/btp/oneP/Employee.java @@ -0,0 +1,33 @@ +package btp.oneP; + +public class Employee implements Payable{ + + @Override + public void getPay() { + // TODO Auto-generated method stub + + } + +} + + +interface Payable{ + void getPay(); +} + +class Hourly extends Employee implements Payable{} + + + +/*public class Employee implements Payable{ + + @Override + public void getPay() { + // TODO Auto-generated method stub + + } + +} + + +class Hourly extends Employee implements Payable{}*/ \ No newline at end of file diff --git a/src/btp/oneP/GenericExceptionTest.java b/src/btp/oneP/GenericExceptionTest.java new file mode 100644 index 0000000..e26e6cf --- /dev/null +++ b/src/btp/oneP/GenericExceptionTest.java @@ -0,0 +1,11 @@ +package btp.oneP; +//The generic class GenericExceptionTest may not subclass java.lang.Throwable +//public class GenericExceptionTest extends Exception X +public class GenericExceptionTest{ + + public static void main(String[] args) { + // TODO Auto-generated method stub + + } + +} diff --git a/src/btp/oneP/SelfBounded.java b/src/btp/oneP/SelfBounded.java new file mode 100644 index 0000000..2c23aff --- /dev/null +++ b/src/btp/oneP/SelfBounded.java @@ -0,0 +1,52 @@ +package btp.oneP; + +//泛型归根到底就是一种限定 +public class SelfBounded>{ + T element; + SelfBounded set(T t){ + this.element = t; + return this; + } + T get(){ + return this.element; + } + + public static void main(String[] args) { + AS as = new AS(); + as.set(new AS()); + as=as.set(new AS()).get(); + as = as.get(); + CS cs = new CS(); + cs = cs.set(new CS()).get(); + + BS bs = new BS(); + bs.set(new AS()); + as = bs.get(); + as = bs.set(new AS()).get(); + } + +} +/* + * T为AS + * AS继承自SelfBounded + */ +class AS extends SelfBounded{} + +/* + * T为BS + * BS继承自SelfBounded + */ +class BS extends SelfBounded{} + +class CS extends SelfBounded{} + +class D{} +/* + * D不是集成自SelfBounded，所以出错 + */ +//class E extends SelfBounded{} +/* + * SelfBounded渴望一个类型参数，但是没有，所以会出警告 + */ +class F extends SelfBounded{} + diff --git a/src/btp/oneP/ThrowGenericException.java b/src/btp/oneP/ThrowGenericException.java new file mode 100644 index 0000000..295bcea --- /dev/null +++ b/src/btp/oneP/ThrowGenericException.java @@ -0,0 +1,83 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.List; + +public class ThrowGenericException { + + public static void main(String[] args) { + ProcessRunner runner = new ProcessRunner(); + for(int i=0;i<3;i++){ + runner.add(new Processor1()); + } + try{ + System.out.println(runner.processAll()); + }catch(Failure1 e){ + e.printStackTrace(); + } + + ProcessRunner runner2 = new ProcessRunner(); + for(int i=0;i<3;i++){ + runner2.add(new Processor2()); + } + + try{ + System.out.println(runner2.processAll()); + }catch(Failure2 e){ + e.printStackTrace(); + } + } + +} + +interface Processor{ + void process(List resultCollector) throws E; +} + +class ProcessRunner + extends ArrayList>{ + List processAll() throws E{ + List resultCollector = new ArrayList(); + for(Processor p:this){ + p.process(resultCollector); + } + return resultCollector; + } +} + +class Failure1 extends Exception{} + +class Processor1 implements Processor{ + static int count = 3; + @Override + public void process(List resultCollector) throws Failure1 { + if(count-- > 1){ + resultCollector.add("Hep!"); + }else{ + resultCollector.add("Ho!"); + } + if(count < 0){ + throw new Failure1(); + } + } + +} + + +class Failure2 extends Exception{} + +class Processor2 implements Processor{ + static int count = 3; + @Override + public void process(List resultCollector) throws Failure2 { + if(count-- == 0){ + resultCollector.add(47); + }else{ + resultCollector.add(11); + } + if(count < 0){ + throw new Failure2(); + } + } + +} diff --git a/src/btp/oneP/Wildcards.java b/src/btp/oneP/Wildcards.java index 6dbdec3..4a5cec9 100644 --- a/src/btp/oneP/Wildcards.java +++ b/src/btp/oneP/Wildcards.java @@ -62,6 +62,21 @@ public static void main(String[] args) { System.out.println(r3); Long r4 = exact1(bounded); System.out.println(r4); + + Long r5 = exact2(raw,lng); + Long r6 = exact2(qualified,lng); + //Long r7 = exact2(unbounded,lng); + //Long r8 = exact2(bounded,lng); + + Long r9 = wildSubtype(raw,lng); + Long r10 = wildSubtype(qualified,lng); + Object r11 = wildSubtype(unbounded,lng); + Long r12 = wildSubtype(bounded,lng); + + wildSupertype(raw,lng); + wildSupertype(qualified,lng); + //wildSupertype(unbounded,lng); + //wildSupertype(bounded,lng); } } From 8ab3b67c4672db1ee14a1d3cc768280f608ef7a8 Mon Sep 17 00:00:00 2001 From: btp <842297171@qq.com> Date: Tue, 30 May 2017 23:33:31 +0800 Subject: [PATCH 03/15] Chapter-15-Generic-btp0530 --- src/btp/oneP/ApplyTest.java | 93 ++++++++++++++ src/btp/oneP/Decoration.java | 67 ++++++++++ src/btp/oneP/DecoratorTest.java | 163 ++++++++++++++++++++++++ src/btp/oneP/DogsAndRobots.java | 61 +++++++++ src/btp/oneP/DynamicProxyMixin.java | 58 +++++++++ src/btp/oneP/Fill2Test.java | 57 +++++++++ src/btp/oneP/FillTest.java | 45 +++++++ src/btp/oneP/Functional.java | 187 ++++++++++++++++++++++++++++ src/btp/oneP/LatentReflection.java | 58 +++++++++ 9 files changed, 789 insertions(+) create mode 100644 src/btp/oneP/ApplyTest.java create mode 100644 src/btp/oneP/Decoration.java create mode 100644 src/btp/oneP/DecoratorTest.java create mode 100644 src/btp/oneP/DogsAndRobots.java create mode 100644 src/btp/oneP/DynamicProxyMixin.java create mode 100644 src/btp/oneP/Fill2Test.java create mode 100644 src/btp/oneP/FillTest.java create mode 100644 src/btp/oneP/Functional.java create mode 100644 src/btp/oneP/LatentReflection.java diff --git a/src/btp/oneP/ApplyTest.java b/src/btp/oneP/ApplyTest.java new file mode 100644 index 0000000..08e3eef --- /dev/null +++ b/src/btp/oneP/ApplyTest.java @@ -0,0 +1,93 @@ +package btp.oneP; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; + +public class ApplyTest { + + public static void main(String[] args) throws NoSuchMethodException, SecurityException { + List shapes = new ArrayList(); + for(int i=0;i<10;i++){ + shapes.add(new Shape()); + } + Apply.apply(shapes, Shape.class.getMethod("rotate")); + + Apply.apply(shapes, Shape.class.getMethod("resize", int.class), 5); + + + List squares = new ArrayList(); + for(int i=0;i<10;i++){ + squares.add(new Square()); + } + Apply.apply(squares, Square.class.getMethod("rotate")); + + Apply.apply(squares, Square.class.getMethod("resize", int.class), 5); + + + Apply.apply(new FilledList(Shape.class,5), Shape.class.getMethod("rotate")); + Apply.apply(new FilledList(Square.class,18), Shape.class.getMethod("resize", int.class),15); + + SimpleQueue shapeQ = new SimpleQueue(); + for(int i=0;i<5;i++){ + shapeQ.add(new Shape()); + shapeQ.add(new Square()); + } + Apply.apply(shapeQ, Shape.class.getMethod("rotate")); + } + +} + +class Apply{ + public static > void apply(S seq,Method f,Object...args){ + try{ + for(T t:seq){ + f.invoke(t, args); + } + }catch(Exception e){ + throw new RuntimeException(); + } + } +} + +class Shape{ + public void rotate(){ + System.out.println(this+" rotate"); + } + public void resize(int newSize){ + System.out.println(this+" resize"+newSize); + } +} + +class Square extends Shape{} + +class FilledList extends ArrayList{ + public FilledList(Class type,int size){ + try{ + for(int i = 0;i implements Iterable{ + private LinkedList storage = new LinkedList(); + public void add(T t){ + this.storage.offer(t); + } + public T get(){ + return this.storage.poll(); + } + @Override + public Iterator iterator() { + return this.storage.iterator(); + } + +} + + diff --git a/src/btp/oneP/Decoration.java b/src/btp/oneP/Decoration.java new file mode 100644 index 0000000..65f7b3c --- /dev/null +++ b/src/btp/oneP/Decoration.java @@ -0,0 +1,67 @@ +package btp.oneP; + +import java.util.Date; + +public class Decoration { + + public static void main(String[] args) { + TimeStamped t = new TimeStamped(new Basic()); + TimeStamped t2 = new TimeStamped(new SerialNumbered(new Basic())); + //t2.getSerialNumber();//Not available + System.out.println(t2.getStamp()); + SerialNumbered s = new SerialNumbered(new Basic()); + SerialNumbered s2 = new SerialNumbered(new TimeStamped(new Basic())); + SerialNumbered s3 = new SerialNumbered(new TimeStamped(new Basic())); + System.out.println(s.getSerialNumber()); + System.out.println(s2.getSerialNumber()); + System.out.println(s3.getSerialNumber()); + //s2.getStamp();//Not available + } + +} + + +class Basic{ + private String value; + public void set(String value){ + this.value = value; + } + public String get(){ + return value; + } +} + +class Decorator extends Basic{ + protected Basic basic; + public Decorator(Basic basic){ + this.basic = basic; + } + public void set(String val){ + basic.set(val); + } + public String get(){ + return basic.get(); + } +} + +class TimeStamped extends Decorator{ + private final long timeStamp; + public TimeStamped(Basic basic) { + super(basic); + timeStamp = new Date().getTime(); + } + public long getStamp(){ + return timeStamp; + } +} + +class SerialNumbered extends Decorator{ + private static long counter = 1; + private final long serialNumber = counter++; + public SerialNumbered(Basic basic) { + super(basic); + } + public long getSerialNumber(){ + return serialNumber; + } +} \ No newline at end of file diff --git a/src/btp/oneP/DecoratorTest.java b/src/btp/oneP/DecoratorTest.java new file mode 100644 index 0000000..6efc792 --- /dev/null +++ b/src/btp/oneP/DecoratorTest.java @@ -0,0 +1,163 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.List; + +public class DecoratorTest { + + @SuppressWarnings("static-access") + public static void main(String[] args) { + OriginalCoffee originalCoffee = new OriginalCoffee(); + double priceMilk = 10.0; + Milk milkCoffee = new Milk(originalCoffee,priceMilk); + milkCoffee.mixing(); + System.out.println("当前咖啡中的配料："+milkCoffee.foodList); + System.out.println("当前咖啡价格："+milkCoffee.getPrice()); + System.out.println("---------------------------"); + double priceMatcha = 20.0; + Matcha matchaCoffee = new Matcha(milkCoffee,priceMatcha); + matchaCoffee.mixing(); + System.out.println("当前咖啡中的配料："+matchaCoffee.foodList); + System.out.println("当前咖啡价格："+matchaCoffee.getPrice()); + System.out.println("---------------------------"); + double priceChocolate = 30.0; + Chocolate chocolateCoffee = new Chocolate(matchaCoffee,priceChocolate); + chocolateCoffee.mixing(); + System.out.println("当前咖啡中的配料："+chocolateCoffee.foodList); + System.out.println("当前咖啡价格："+chocolateCoffee.getPrice()); + System.out.println("---------------------------"); + } + +} + +/** + * 装饰品和被装饰器的共同接口 + * + */ +interface CoffeeTaste{ + //返回价格 + double getPrice(); + //搅拌咖啡 + void mixing(); +} + +/** + * 原始的被装饰器 + * + */ +class OriginalCoffee implements CoffeeTaste{ + private String name; + public OriginalCoffee(){ + name = "原味咖啡"; + System.out.println("原味咖啡的价格是：50"); + } + @Override + public double getPrice() { + //原味咖啡的价钱 + return 50; + } + + @Override + public void mixing() { + System.out.println("--搅拌咖啡"); + } + +} + +/** + * 装饰品的共同父类 + * + */ +abstract class SnacksAndDesserts implements CoffeeTaste{ + public static List foodList= new ArrayList(); + //小食和甜品的价格 + private double additionalPrice; + //要加入小食和甜品的咖啡 + CoffeeTaste coffeeTaste; + public SnacksAndDesserts(CoffeeTaste coffeeTaste,double additionalPrice){ + this.coffeeTaste = coffeeTaste; + this.additionalPrice = additionalPrice; + } + //返回价格 + @Override + public double getPrice() { + double priceNow = coffeeTaste.getPrice()+additionalPrice; + return priceNow; + } + + abstract void add(); +} + +/** + * 牛奶类 + * + */ +class Milk extends SnacksAndDesserts{ + + public Milk(CoffeeTaste coffeeTaste, double additionalPrice) { + super(coffeeTaste, additionalPrice); + System.out.println("O(∩_∩)O~~牛奶的价格是："+additionalPrice); + } + + @Override + void add() { + System.out.println("--咖啡中加入牛奶"); + SnacksAndDesserts.foodList.add("牛奶"); + } + + @Override + public void mixing() { + add(); + System.out.println("--牛奶加入咖啡中搅拌"); + } + + +} + + +/** + * 抹茶类 + */ +class Matcha extends SnacksAndDesserts{ + + public Matcha(CoffeeTaste coffeeTaste, double additionalPrice) { + super(coffeeTaste, additionalPrice); + System.out.println("O(∩_∩)O~~抹茶的价格是："+additionalPrice); + } + + @Override + void add() { + System.out.println("--咖啡中混入抹茶"); + SnacksAndDesserts.foodList.add("抹茶"); + } + + @Override + public void mixing() { + add(); + System.out.println("--抹茶加入咖啡中搅拌"); + } +} + +/** + * 巧克力类 + */ + +class Chocolate extends SnacksAndDesserts{ + + public Chocolate(CoffeeTaste coffeeTaste, double additionalPrice) { + super(coffeeTaste, additionalPrice); + System.out.println("O(∩_∩)O~~巧克力的价格是："+additionalPrice); + } + + @Override + void add() { + System.out.println("--咖啡中加入巧克力"); + SnacksAndDesserts.foodList.add("巧克力"); + } + + @Override + public void mixing() { + add(); + System.out.println("--咖啡加入咖啡中搅拌"); + } +} diff --git a/src/btp/oneP/DogsAndRobots.java b/src/btp/oneP/DogsAndRobots.java new file mode 100644 index 0000000..ecb0865 --- /dev/null +++ b/src/btp/oneP/DogsAndRobots.java @@ -0,0 +1,61 @@ +package btp.oneP; + +public class DogsAndRobots { + + public static void main(String[] args) { + PerformingDog d = new PerformingDog(); + Robott r = new Robott(); + Communicate.perform(d); + Communicate.perform(r); + } + +} + +interface Performs{ + void speak(); + void sit(); +} + +class PerformingDog extends Dog implements Performs{ + + @Override + public void speak() { + System.out.println("Woof!"); + } + + @Override + public void sit() { + System.out.println("Sitting!"); + } + + public void reproduce(){} +} + +class Robott implements Performs{ + + @Override + public void speak() { + System.out.println("Click!"); + } + + @Override + public void sit() { + System.out.println("Clank!"); + } + + public void oilChange(){} + +} + +class Communicate{ + public static void perform(T performs){ + performs.speak(); + performs.sit(); + } + + //下面和上面的一样，不构成重载 + /*public static void perform(Performs p){ + p.speak(); + p.sit(); + }*/ +} \ No newline at end of file diff --git a/src/btp/oneP/DynamicProxyMixin.java b/src/btp/oneP/DynamicProxyMixin.java new file mode 100644 index 0000000..d8385d7 --- /dev/null +++ b/src/btp/oneP/DynamicProxyMixin.java @@ -0,0 +1,58 @@ +package btp.oneP; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.util.HashMap; +import java.util.Map; + +public class DynamicProxyMixin { + + public static void main(String[] args) { + } + +} + +class MixinProxy implements InvocationHandler{ + Map delegatesByMethod; + public MixinProxy(TwoTuple>...pairs){ + this.delegatesByMethod = new HashMap(); + for(TwoTuple> pair:pairs){ + for(Method m : pair.second.getMethods()){ + String methodName = m.getName(); + if(!this.delegatesByMethod.containsKey(methodName)){ + this.delegatesByMethod.put(methodName, pair.first); + } + } + } + } + + + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + String methodName = method.getName(); + Object delegate = this.delegatesByMethod.get(methodName); + return method.invoke(delegate, args); + } + + public static Object newInstance(TwoTuple...pairs){ + Class[] interfaces = new Class[pairs.length]; + for(int i=0;i{ + K first; + V second; + public TwoTuple(K k,V v){ + this.first = k; + this.second = v; + } +} diff --git a/src/btp/oneP/Fill2Test.java b/src/btp/oneP/Fill2Test.java new file mode 100644 index 0000000..9e39fe5 --- /dev/null +++ b/src/btp/oneP/Fill2Test.java @@ -0,0 +1,57 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public class Fill2Test { + + public static void main(String[] args) { + List carrier = new ArrayList(); + Fill2.fill(new AddableCollectionAdapter(carrier), Contract.class, 3); + Fill2.fill(Adapter.collectionAdapter(carrier), Contract.class, 2); + System.out.println(carrier); + } + +} + +interface Addable{ + void add(T t); +} + +class Fill2{ + public static void fill(Addable addable,Class classToken,int size){ + for(int i=0;i implements Addable{ + private Collection c; + public AddableCollectionAdapter(Collection c){ + this.c = c; + } + @Override + public void add(T t) { + c.add(t); + } + +} + +class Adapter{ + public static Addable collectionAdapter(Collection c){ + return new AddableCollectionAdapter(c); + } +} + +class AddableSimpleQueue extends SimpleQueue implements Addable{ + public void add(T t){ + super.add(t); + } +} diff --git a/src/btp/oneP/FillTest.java b/src/btp/oneP/FillTest.java new file mode 100644 index 0000000..acaefe2 --- /dev/null +++ b/src/btp/oneP/FillTest.java @@ -0,0 +1,45 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public class FillTest { + + public static void main(String[] args) { + List contracts = new ArrayList(); + Fill.fill(contracts, Contract.class, 3); + System.out.println(contracts); + + Fill.fill(contracts, TitleTransfer.class, 2); + System.out.println(contracts); + + SimpleQueue cq = new SimpleQueue(); + //Fill.fill(cq, Contract.class, 3); + } + +} + +class Fill{ + public static void fill(Collection collection,Class classToken,int size){ + for(int i=0;i li = Arrays.asList(1,2,3,4,5,6,7); + Integer result = reduce(li,new IntegerAdder()); + System.out.println(result); + + result = reduce(li,new IntegerSubtracter()); + System.out.println(result); + + System.out.println(fillter(li,new GreaterThan(4))); + + System.out.println(forEach(li,new MultiplyingIntegerCollector()).result()); + + System.out.println(forEach(fillter(li,new GreaterThan(4)), + new MultiplyingIntegerCollector()).result()); + + MathContext mc = new MathContext(7); + List lbd = Arrays.asList(new BigDecimal(1.1,mc),new BigDecimal(2.2,mc) + ,new BigDecimal(3.3,mc),new BigDecimal(4.4,mc)); + BigDecimal rbd = reduce(lbd,new BigDecimalAdder()); + System.out.println(rbd); + + System.out.println(fillter(lbd,new GreaterThan(new BigDecimal(3)))); + + List lbi = new ArrayList(); + BigInteger bi = BigInteger.valueOf(11); + for(int i=0;i<11;i++){ + lbi.add(bi); + bi = bi.nextProbablePrime(); + } + System.out.println(lbi); + + BigInteger rbi = reduce(lbi,new BigIntegerAdder()); + System.out.println(rbi); + + System.out.println(rbi.isProbablePrime(5)); + + List lal = Arrays.asList(new AtomicLong(11),new AtomicLong(47), + new AtomicLong(74),new AtomicLong(133)); + AtomicLong ral = reduce(lal,new AtomicLongAdder()); + System.out.println(ral); + System.out.println(transform(lbd,new BigDecimalUlp())); + } + + public static T reduce(Iterable seq,Combiner combiner){ + Iterator it = seq.iterator(); + if(it.hasNext()){ + T result = it.next(); + while(it.hasNext()){ + result = combiner.combine(result, it.next()); + } + return result; + } + return null; + } + + public static Collector forEach(Iterable seq,Collector func){ + for(T t:seq){ + func.function(t); + } + return func; + } + + public static List transform(Iterable seq,UnaryFunction func){ + List result = new ArrayList(); + for(T t:seq){ + result.add(func.function(t)); + } + return result; + } + + public static List fillter(Iterable seq,UnaryPredicated pred){ + List result = new ArrayList(); + for(T t:seq){ + if(pred.test(t)){ + result.add(t); + } + } + return result; + } + + static class IntegerAdder implements Combiner{ + + @Override + public Integer combine(Integer x, Integer y) { + return x+y; + } + + } + + static class IntegerSubtracter implements Combiner{ + + @Override + public Integer combine(Integer x, Integer y) { + return x-y; + } + + } + + static class BigDecimalAdder implements Combiner{ + + @Override + public BigDecimal combine(BigDecimal x, BigDecimal y) { + return x.add(y); + } + + } + + static class BigIntegerAdder implements Combiner{ + + @Override + public BigInteger combine(BigInteger x, BigInteger y) { + return x.add(y); + } + + } + + static class AtomicLongAdder implements Combiner{ + + @Override + public AtomicLong combine(AtomicLong x, AtomicLong y) { + return new AtomicLong(x.addAndGet(y.get())); + } + + } + + static class BigDecimalUlp implements UnaryFunction{ + + @Override + public BigDecimal function(BigDecimal x) { + return x.ulp(); + } + + } + + static class GreaterThan> implements UnaryPredicated{ + private T bound; + public GreaterThan(T bound){ + this.bound = bound; + } + @Override + public boolean test(T x) { + return x.compareTo(bound)>0; + } + + } + + static class MultiplyingIntegerCollector implements Collector{ + + private Integer val = 1; + @Override + public Integer function(Integer x) { + val *= x; + return val; + } + + @Override + public Integer result() { + return val; + } + + } +} +interface Combiner { + T combine(T x,T y); +} +interface UnaryFunction{ + R function(T x); +} +interface Collector extends UnaryFunction{ + T result(); +} +interface UnaryPredicated{ + boolean test(T x); +} diff --git a/src/btp/oneP/LatentReflection.java b/src/btp/oneP/LatentReflection.java new file mode 100644 index 0000000..f9b8bea --- /dev/null +++ b/src/btp/oneP/LatentReflection.java @@ -0,0 +1,58 @@ +package btp.oneP; + +import java.lang.reflect.Method; + +public class LatentReflection { + + public static void main(String[] args) { + CommunicateReflectively.perform(new SmartDog()); + CommunicateReflectively.perform(new Robott()); + CommunicateReflectively.perform(new Mime()); + } + +} + + +class Mime{ + public void walkAgainstTheWind(){} + public void sit(){ + System.out.println("Pretending to sit"); + } + public void pushInvisibleWalls(){} + public String toString(){ + return "Mime"; + } +} + +class SmartDog{ + public void speak(){ + System.out.println("Wolf!"); + } + public void sit(){ + System.out.println("Sitting!"); + } + public void reproduce(){} +} + +class CommunicateReflectively{ + public static void perform(Object speaker){ + Class clazz = speaker.getClass(); + try{ + try{ + Method speak = clazz.getMethod("speak"); + speak.invoke(speaker); + }catch(NoSuchMethodException e){ + System.out.println(speaker+" cannot speak"); + } + + try{ + Method sit = clazz.getMethod("sit"); + sit.invoke(speaker); + }catch(NoSuchMethodException e){ + System.out.println(speaker+" cannot sit"); + } + }catch(Exception e){ + throw new RuntimeException(speaker.toString(),e); + } + } +} \ No newline at end of file From 812aa12a3c5441a442f662919ab35459e166924d Mon Sep 17 00:00:00 2001 From: btp <842297171@qq.com> Date: Sat, 3 Jun 2017 23:37:22 +0800 Subject: [PATCH 04/15] Chapter-16-Arrays-btp170603 --- src/btp/oneP/ArrayOfGenerics.java | 31 ++++++++++ src/btp/oneP/ArrayOptions.java | 56 +++++++++++++++++++ src/btp/oneP/ArrayTest.java | 16 ++++++ src/btp/oneP/ContainerComparison.java | 43 ++++++++++++++ src/btp/oneP/IceCream.java | 40 +++++++++++++ .../oneP/MultidimensionalPrimitiveArray.java | 14 +++++ src/btp/oneP/ParameterizedArrayType.java | 34 +++++++++++ src/btp/oneP/ThreeWithNew.java | 19 +++++++ 8 files changed, 253 insertions(+) create mode 100644 src/btp/oneP/ArrayOfGenerics.java create mode 100644 src/btp/oneP/ArrayOptions.java create mode 100644 src/btp/oneP/ArrayTest.java create mode 100644 src/btp/oneP/ContainerComparison.java create mode 100644 src/btp/oneP/IceCream.java create mode 100644 src/btp/oneP/MultidimensionalPrimitiveArray.java create mode 100644 src/btp/oneP/ParameterizedArrayType.java create mode 100644 src/btp/oneP/ThreeWithNew.java diff --git a/src/btp/oneP/ArrayOfGenerics.java b/src/btp/oneP/ArrayOfGenerics.java new file mode 100644 index 0000000..8ab2dc6 --- /dev/null +++ b/src/btp/oneP/ArrayOfGenerics.java @@ -0,0 +1,31 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class ArrayOfGenerics { + + public static void main(String[] args) { + //编译期不能实例化泛型数组，但是可以创建泛型数组的引用 + List[] ls; + List[] la = new List[10]; + ls = (List[])la; + ls[0] = new ArrayList(Arrays.asList("hehe","keke","xixi")); + //ls[1] = new ArrayList(); + + Object[] objects = ls; + objects[1] = new ArrayList(Arrays.asList(1,2,3,4,5)); + System.out.println(Arrays.toString(la)); + System.out.println(la.getClass().getName()); + System.out.println(Arrays.toString(ls)); + System.out.println(ls.getClass().getName()); + System.out.println(Arrays.toString(objects)); + System.out.println(objects.getClass().getName()); + List[] spheres = (List[])new List[10]; + for(int i=0;i<10;i++){ + spheres[i] = new ArrayList(); + } + } + +} diff --git a/src/btp/oneP/ArrayOptions.java b/src/btp/oneP/ArrayOptions.java new file mode 100644 index 0000000..2686afc --- /dev/null +++ b/src/btp/oneP/ArrayOptions.java @@ -0,0 +1,56 @@ +package btp.oneP; + +import java.util.Arrays; + +public class ArrayOptions { + + public static void main(String[] args) { + BerylliumSphere[] a = null; + BerylliumSphere[] b = new BerylliumSphere[5]; + System.out.println(a); + System.out.println(b); + System.out.println(Arrays.toString(b)); + + BerylliumSphere[] c = new BerylliumSphere[4]; + for(int i=0;i sphereList = new ArrayList(); + for(int i=0;i<5;i++){ + sphereList.add(new BerylliumSphere()); + } + System.out.println(sphereList); + System.out.println(sphereList.get(4)); + + int[] integers = {0,1,2,3,4,5}; + System.out.println(integers); + System.out.println(integers[4]); + + List intList = new ArrayList(Arrays.asList(0,1,2,3,4,5)); + intList.add(97); + System.out.println(intList); + System.out.println(intList.get(4)); + + } + +} + +class BerylliumSphere{ + private static long counter; + private final long id = counter++; + public String toString(){ + return "Sphere"+id; + } +} diff --git a/src/btp/oneP/IceCream.java b/src/btp/oneP/IceCream.java new file mode 100644 index 0000000..da7415b --- /dev/null +++ b/src/btp/oneP/IceCream.java @@ -0,0 +1,40 @@ +package btp.oneP; + +import java.util.Arrays; +import java.util.Random; + +public class IceCream { + + private static Random rand = new Random(47); + static final String[] FLAVORS = { + "Chocolate","Strawberry","Vanilla","Mint Chip", + "Mocha Almond Fudge","Rum Raisin","Praline","Mud" + }; + + public static String[] flavorSet(int n){ + if(n>FLAVORS.length){ + throw new IllegalArgumentException("Set too big"); + } + String[] results = new String[n]; + boolean[] picked = new boolean[FLAVORS.length]; + for(int i=0;i().f(ints); + System.out.println(Arrays.toString(ints2)); + System.out.println(ints == ints2); + + Double[] doubles2 = new ClassParameter().f(doubles); + System.out.println(Arrays.toString(doubles2)); + + ints = MethodParameter.f(ints); + System.out.println(Arrays.toString(ints)); + doubles = MethodParameter.f(doubles); + } + +} + +class ClassParameter{ + public T[] f(T[] args){ + return args; + } +} + +class MethodParameter{ + public static T[] f(T[] arg){ + return arg; + } +} \ No newline at end of file diff --git a/src/btp/oneP/ThreeWithNew.java b/src/btp/oneP/ThreeWithNew.java new file mode 100644 index 0000000..5843303 --- /dev/null +++ b/src/btp/oneP/ThreeWithNew.java @@ -0,0 +1,19 @@ +package btp.oneP; + +import java.util.Arrays; + +public class ThreeWithNew { + + public static void main(String[] args) { + int[][][] a = new int[2][2][4]; + System.out.println(a); + System.out.println(Arrays.toString(a)); + System.out.println("a.length:"+a.length); + System.out.println(Arrays.toString(a[0])); + System.out.println("a[0].length:"+a[0].length); + System.out.println(Arrays.toString(a[1])); + System.out.println("a[1].length:"+a[1].length); + System.out.println(Arrays.toString(a[0][1])); + } + +} From 233b2a0d62490525582e6a3ba4db425b0062900d Mon Sep 17 00:00:00 2001 From: btp <842297171@qq.com> Date: Sun, 18 Jun 2017 22:20:12 +0800 Subject: [PATCH 05/15] Chapter-17-Collections-btp170618 --- src/btp/oneP/CollectionDataTest.java | 44 +++++++++++ src/btp/oneP/FillingLists.java | 30 ++++++++ src/btp/oneP/MapDataTest.java | 111 +++++++++++++++++++++++++++ 3 files changed, 185 insertions(+) create mode 100644 src/btp/oneP/CollectionDataTest.java create mode 100644 src/btp/oneP/FillingLists.java create mode 100644 src/btp/oneP/MapDataTest.java diff --git a/src/btp/oneP/CollectionDataTest.java b/src/btp/oneP/CollectionDataTest.java new file mode 100644 index 0000000..6dc1c1e --- /dev/null +++ b/src/btp/oneP/CollectionDataTest.java @@ -0,0 +1,44 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.Set; + +public class CollectionDataTest { + + public static void main(String[] args) { + Set set = new LinkedHashSet(new CollectionData(new Government(),7)); + set.addAll(CollectionData.list(new Government(), 7)); + System.out.println(set); + } + +} + +class CollectionData extends ArrayList { + public CollectionData(GeneratorN gen,int quantity){ + for(int i=0;i CollectionData list(GeneratorN gen,int quantity){ + return new CollectionData(gen,quantity); + } +} + +interface GeneratorN{ + T next(); +} + +class Government implements GeneratorN{ + String[] foundation = "you are a hero not a coward".split(" "); + private int index; + @Override + public String next() { + // TODO Auto-generated method stub + return foundation[index++]; + } + +} + + diff --git a/src/btp/oneP/FillingLists.java b/src/btp/oneP/FillingLists.java new file mode 100644 index 0000000..abeb033 --- /dev/null +++ b/src/btp/oneP/FillingLists.java @@ -0,0 +1,30 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class FillingLists { + + @SuppressWarnings("unchecked") + public static void main(String[] args) { + List list = (List) Collections.nCopies(4, new StringAddress("hehe")); + System.out.println(list); + list = new ArrayList(list); + System.out.println(list); + + Collections.fill(list, new StringAddress("xixi")); + System.out.println(list); + } + +} + +class StringAddress{ + private String s; + public StringAddress(String s){ + this.s = s; + } + public String toString(){ + return super.toString()+" "+s; + } +} diff --git a/src/btp/oneP/MapDataTest.java b/src/btp/oneP/MapDataTest.java new file mode 100644 index 0000000..5588eaa --- /dev/null +++ b/src/btp/oneP/MapDataTest.java @@ -0,0 +1,111 @@ +package btp.oneP; + +import java.util.Iterator; +import java.util.LinkedHashMap; + +public class MapDataTest { + + public static void main(String[] args) { + System.out.println(MapData.map(new Letters(), 11)); + + System.out.println(MapData.map(new Letters(), "Pop")); + } + +} + + +class PairN{ + public final K key; + public final V value; + public PairN(K k,V v){ + this.key = k; + this.value = v; + } +} + +class MapData extends LinkedHashMap{ + public MapData(GeneratorN> gen,int quantity){ + for(int i=0;i p = gen.next(); + this.put(p.key, p.value); + } + } + + public MapData(GeneratorN genK,GeneratorN genV,int quantity){ + for(int i=0;i genK,V value,int quantity){ + for(int i=0;i genK,GeneratorN genV){ + for(K key:genK){ + this.put(key,genV.next()); + } + } + + public MapData(Iterable genK, V value){ + for(K key:genK){ + this.put(key, value); + } + } + + public static MapData map(GeneratorN> gen,int quantity){ + return new MapData(gen,quantity); + } + + public static MapData map(GeneratorN genK,GeneratorN genV,int quantity){ + return new MapData(genK,genV,quantity); + } + + public static MapData map(GeneratorN genK,V value,int quantity){ + return new MapData(genK,value,quantity); + } + + public static MapData map(Iterable genK,GeneratorN genV){ + return new MapData(genK,genV); + } + + public static MapData map(Iterable genK,V value){ + return new MapData(genK,value); + } +} + +class Letters implements GeneratorN>, + Iterable{ + + private int size = 9; + private int number = 1; + private char letter = 'A'; + + @Override + public PairN next() { + return new PairN(number++,""+letter++); + } + + @Override + public Iterator iterator() { + // TODO Auto-generated method stub + return new Iterator(){ + + @Override + public boolean hasNext() { + // TODO Auto-generated method stub + return number < size; + } + + @Override + public Integer next() { + // TODO Auto-generated method stub + return number++; + } + + }; + } + +} \ No newline at end of file From cdaa8e02b7b6cdf1820baa39bdb107edccec9f1c Mon Sep 17 00:00:00 2001 From: btp <842297171@qq.com> Date: Mon, 10 Jul 2017 20:23:51 +0800 Subject: [PATCH 06/15] Chapter 17 collections btp170710 --- Study.iml | 12 ++ src/btp/oneP/ABtpTest.java | 10 +- src/btp/oneP/CollectionMethod.java | 53 ++++++++ src/btp/oneP/CountingIntegerList.java | 33 +++++ src/btp/oneP/CountingMapData.java | 61 +++++++++ src/btp/oneP/Countries.java | 145 ++++++++++++++++++++ src/btp/oneP/Lists.java | 113 +++++++++++++++ src/btp/oneP/PDFTest.java | 189 ++++++++++++++++++++++++++ src/btp/oneP/SetFillList.java | 22 +++ src/btp/oneP/Unsupported.java | 67 +++++++++ 10 files changed, 703 insertions(+), 2 deletions(-) create mode 100644 Study.iml create mode 100644 src/btp/oneP/CollectionMethod.java create mode 100644 src/btp/oneP/CountingIntegerList.java create mode 100644 src/btp/oneP/CountingMapData.java create mode 100644 src/btp/oneP/Countries.java create mode 100644 src/btp/oneP/Lists.java create mode 100644 src/btp/oneP/PDFTest.java create mode 100644 src/btp/oneP/SetFillList.java create mode 100644 src/btp/oneP/Unsupported.java diff --git a/Study.iml b/Study.iml new file mode 100644 index 0000000..b8db988 --- /dev/null +++ b/Study.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/src/btp/oneP/ABtpTest.java b/src/btp/oneP/ABtpTest.java index be23f00..36bdcce 100644 --- a/src/btp/oneP/ABtpTest.java +++ b/src/btp/oneP/ABtpTest.java @@ -3,6 +3,8 @@ import java.io.PrintStream; import java.util.ArrayList; import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; import java.util.Scanner; public class ABtpTest { @@ -11,13 +13,17 @@ public static void main(String[] args) { PrintStream p = System.out; Scanner sc =new Scanner(System.in); try{ - ArrayList as = returnArray(); + /*ArrayList as = returnArray(); ArrayList ass = (ArrayList)as; p.println(ass); as = returnArrayNew(); p.println(as); ass = (ArrayList)as; - p.println(ass); + p.println(ass);*/ + + List myIntList = new LinkedList();//1 + myIntList.add(new Integer(0));//2 + Integer x = (Integer) myIntList.iterator().next();//3 }catch(Exception e){ e.printStackTrace(); }finally{ diff --git a/src/btp/oneP/CollectionMethod.java b/src/btp/oneP/CollectionMethod.java new file mode 100644 index 0000000..f4b9778 --- /dev/null +++ b/src/btp/oneP/CollectionMethod.java @@ -0,0 +1,53 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +public class CollectionMethod { + + public static void main(String[] args) { + Collection c = new ArrayList(); + c.addAll(Countries.names(6)); + c.add("ten"); + c.add("eleven"); + System.out.println(c); + + Object[] array = c.toArray(); + String[] str = c.toArray(new String[0]); + + System.out.println(Arrays.toString(array)); + System.out.println(Arrays.toString(str)); + + System.out.println("Collections.max(c) = "+Collections.max(c)); + System.out.println("Collections.min(c) = "+Collections.min(c)); + + Collection c2 = new ArrayList(); + c2.addAll(Countries.names(6)); + c.addAll(c2); + System.out.println(c); + c.remove(Countries.DATA[0][0]); + System.out.println(c); + c.removeAll(c2); + System.out.println(c); + c.addAll(c2); + System.out.println(c); + String val = Countries.DATA[3][0]; + System.out.println("c.contains("+val+")="+c.contains(val)); + System.out.println("c.containsAll(c2)="+c.containsAll(c2)); + + Collection c3 = ((List)c).subList(3, 5); + c2.retainAll(c3); + System.out.println(c2); + c2.removeAll(c3); + System.out.println("c2.isEmpty()="+c2.isEmpty()); + c = new ArrayList(); + c.addAll(Countries.names(6)); + System.out.println(c); + c.clear(); + System.out.println("after c.clear():"+c); + } + +} diff --git a/src/btp/oneP/CountingIntegerList.java b/src/btp/oneP/CountingIntegerList.java new file mode 100644 index 0000000..5eae6da --- /dev/null +++ b/src/btp/oneP/CountingIntegerList.java @@ -0,0 +1,33 @@ +package btp.oneP; + +import java.util.AbstractList; + +public class CountingIntegerList extends AbstractList{ + + public static void main(String[] args) { + // TODO Auto-generated method stub + //构造函数构造对象时里面还没有值，都是null，在调用toString函数的时候， + //toString函数内使用Iterator遍历集合，next()时调用了get(index) + //所以是边赋值边打印 + System.out.println(new CountingIntegerList(30)); + } + + + private int size; + public CountingIntegerList(int size){ + this.size = size<0?0:size; + } + + @Override + public Integer get(int index) { + // TODO Auto-generated method stub + return Integer.valueOf(index); + } + + @Override + public int size() { + // TODO Auto-generated method stub + return size; + } + +} diff --git a/src/btp/oneP/CountingMapData.java b/src/btp/oneP/CountingMapData.java new file mode 100644 index 0000000..23c8df8 --- /dev/null +++ b/src/btp/oneP/CountingMapData.java @@ -0,0 +1,61 @@ +package btp.oneP; + +import java.util.AbstractMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; + +public class CountingMapData extends AbstractMap{ + + public static void main(String...args){ + System.out.println(new CountingMapData(60)); + } + + private int size; + private static String[] chars = "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z".split(" "); + public CountingMapData(int size){ + this.size = size<0?0:size; + } + + private static class Entry implements Map.Entry{ + int index; + Entry(int index){ + this.index = index; + } + public boolean equals(Object o){ + return Integer.valueOf(index).equals(o); + } + @Override + public Integer getKey() { + // TODO Auto-generated method stub + return index; + } + + @Override + public String getValue() { + // TODO Auto-generated method stub + return chars[index%chars.length]+Integer.toString(index/chars.length); + } + + @Override + public String setValue(String value) { + // TODO Auto-generated method stub + return null; + } + + public int hashCode(){ + return Integer.valueOf(index).hashCode(); + } + } + + @Override + public Set> entrySet() { + // TODO Auto-generated method stub + Set> entries = new LinkedHashSet>(); + for(int i=0;i(capitals(3))); + System.out.println(new LinkedHashMap(capitals(3))); + System.out.println(new TreeMap(capitals(3))); + System.out.println(new Hashtable(capitals(3))); + System.out.println(new HashSet(names(6))); + System.out.println(new LinkedHashSet(names(6))); + System.out.println(new TreeSet(names(6))); + System.out.println(new ArrayList(names(6))); + System.out.println(new LinkedList(names(6))); + System.out.println(capitals().get("ALGERIA")); + } + + public static final String[][] DATA = { + {"ALGERIA","Algiers"},{"CHINA","Beijing"}, + {"Japan","Tokoy"},{"America","Washington"} + }; + private static class FlyweightMap extends AbstractMap{ + private static class Entry implements Map.Entry{ + int index; + Entry(int index){ + this.index = index; + } + public boolean equals(Object o){ + return DATA[index][0].equals(o); + } + @Override + public String getKey() { + // TODO Auto-generated method stub + return DATA[index][0]; + } + + @Override + public String getValue() { + return DATA[index][1]; + } + + @Override + public String setValue(String value) { + // TODO Auto-generated method stub + return null; + } + + public int hashCode(){ + return DATA[index][0].hashCode(); + } + } + + static class EntrySet extends AbstractSet>{ + private int size; + EntrySet(int size){ + if(size < 0){ + this.size = 0; + }else if(size > DATA.length){ + this.size = DATA.length; + }else{ + this.size = size; + } + } + public int size(){ + return size; + } + + @Override + public Iterator> iterator() { + // TODO Auto-generated method stub + return new Iter(); + } + + private class Iter implements Iterator>{ + private Entry entry = new Entry(-1); + @Override + public boolean hasNext() { + // TODO Auto-generated method stub + return entry.index < size - 1; + } + + @Override + public java.util.Map.Entry next() { + entry.index++; + return entry; + } + + } + } + + private static Set> entries = new EntrySet(DATA.length); + @Override + public Set> entrySet() { + return entries; + } + + } + + + + + + + static Map select(final int size){ + return new FlyweightMap(){ + public Set> entrySet(){ + return new EntrySet(size); + } + }; + } + + static Map map = new FlyweightMap(); + public static Map capitals(){ + return map; + } + public static Map capitals(int size){ + return select(size); + } + static List names = new ArrayList(map.keySet()); + + public static List names(){ + return names; + } + public static List names(int size){ + return new ArrayList(select(size).keySet()); + } +} diff --git a/src/btp/oneP/Lists.java b/src/btp/oneP/Lists.java new file mode 100644 index 0000000..d57237e --- /dev/null +++ b/src/btp/oneP/Lists.java @@ -0,0 +1,113 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.ListIterator; + +public class Lists { + + private static boolean b; + private static String s; + private static int i; + private static Iterator it; + private static ListIterator lit; + public static void basicTest(List a){ + a.add(1,"x"); + a.add("x"); + a.addAll(Countries.names(25)); + a.addAll(3,Countries.names(25)); + b = a.contains("1"); + b = a.containsAll(Countries.names(25)); + s = a.get(1); + i = a.indexOf("1"); + b = a.isEmpty(); + it = a.iterator(); + lit = a.listIterator(); + lit = a.listIterator(3); + i = a.lastIndexOf("1"); + a.remove(1); + a.remove("3"); + a.set(1, "y"); + + a.retainAll(Countries.names(25)); + a.removeAll(Countries.names(25)); + i = a.size(); + a.clear(); + } + + public static void iterMotion(List a){ + ListIterator it = a.listIterator(); + b = it.hasNext(); + b = it.hasPrevious(); + s = it.next(); + i = it.nextIndex(); + s = it.previous(); + i = it.previousIndex(); + } + + public static void iterManipulation(List a){ + ListIterator it = a.listIterator(); + it.add("47"); + it.next(); + it.remove(); + it.next(); + it.set("47"); + } + + public static void testVisual(List a){ + System.out.println(a); + List b = Countries.names(25); + System.out.println("b = "+b); + a.addAll(b); + a.addAll(b); + System.out.println(a); + + ListIterator x = a.listIterator(a.size()/2); + x.add("one"); + System.out.println(a); + System.out.println(x.next()); + x.remove(); + System.out.println(x.next()); + x.set("47"); + System.out.println(a); + x = a.listIterator(a.size()); + while(x.hasPrevious()){ + System.out.println(x.previous() + " "); + } + System.out.println(); + System.out.println("testVisual finished"); + } + + public static void testLinkedList(){ + LinkedList ll = new LinkedList(); + ll.addAll(Countries.names(25)); + System.out.println(ll); + ll.addFirst("one"); + ll.addFirst("two"); + System.out.println(ll); + System.out.println(ll.getFirst()); + System.out.println(ll.removeFirst()); + System.out.println(ll.removeFirst()); + System.out.println(ll.removeLast()); + System.out.println(ll); + } + + public static void main(String[] args) { + /*basicTest(new LinkedList(Countries.names(25))); + basicTest(new ArrayList(Countries.names(25))); + iterMotion(new LinkedList(Countries.names(25))); + iterMotion(new ArrayList(Countries.names(25))); + iterManipulation(new LinkedList(Countries.names(25))); + iterManipulation(new ArrayList(Countries.names(25))); + testVisual(new LinkedList(Countries.names(25))); + testLinkedList();*/ + List list = new ArrayList(); + list.add("A"); + list.add("B"); + list.set(0, "C"); + System.out.println(list); + } + +} diff --git a/src/btp/oneP/PDFTest.java b/src/btp/oneP/PDFTest.java new file mode 100644 index 0000000..ca4b7d8 --- /dev/null +++ b/src/btp/oneP/PDFTest.java @@ -0,0 +1,189 @@ +package btp.oneP; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.PrintWriter; + +public class PDFTest { + public static void main(String...args){ + Pdf2htmlEXUtil.pdf2html("C:\\Users\\dell\\Desktop\\pdf转html\\pdf2htmlEX-v1.0\\pdf2htmlEX.exe","C:\\Users\\dell\\Desktop\\匹配确认书.pdf","C:\\Users\\dell\\Desktop\\pdf转html","my.html"); + } + +} + + + + + + +/** + * @author liuzhengyong + * @version 1.0 时间：2013-12-30 下午2:24:10 pdf文件转html工具类 + */ +class Pdf2htmlEXUtil { + /** + * 调用pdf2htmlEX将pdf文件转换为html文件 + * + * @param exeFilePath + * pdf2htmlEX.exe文件路径 + * @param pdfFile + * pdf文件绝对路径 + * @param [destDir] 生成的html文件存放路径 + * @param htmlName + * 生成的html文件名称 + * @return + */ + public static boolean pdf2html(String exeFilePath, String pdfFile, + String destDir, String htmlFileName) { + if (!(exeFilePath != null && !"".equals(exeFilePath) && pdfFile != null + && !"".equals(pdfFile) && htmlFileName != null && !"" + .equals(htmlFileName))) { + System.out.println("传递的参数有误！"); + return false; + } + Runtime rt = Runtime.getRuntime(); + StringBuilder command = new StringBuilder(); + command.append(exeFilePath).append(" "); + if (destDir != null && !"".equals(destDir.trim()))// 生成文件存放位置,需要替换文件路径中的空格 + command.append("--dest-dir ").append(destDir.replace(" ", "\" \"")) + .append(" "); + command.append("--optimize-text 1 ");// 尽量减少用于文本的HTML元素的数目 (default: 0) + command.append("--zoom 1.4 "); + command.append("--process-outline 0 ");// html中显示链接：0——false，1——true + command.append("--font-format woff ");// 嵌入html中的字体后缀(default ttf) + // ttf,otf,woff,svg + command.append(pdfFile.replace(" ", "\" \"")).append(" ");// 需要替换文件路径中的空格 + if (htmlFileName != null && !"".equals(htmlFileName.trim())) { + command.append(htmlFileName); + if (htmlFileName.indexOf(".html") == -1) + command.append(".html"); + } + try { + System.out.println("Command：" + command.toString()); + Process p = rt.exec(command.toString()); + StreamGobbler errorGobbler = new StreamGobbler(p.getErrorStream(), + "ERROR"); + // 开启屏幕标准错误流 + errorGobbler.start(); + StreamGobbler outGobbler = new StreamGobbler(p.getInputStream(), + "STDOUT"); + // 开启屏幕标准输出流 + outGobbler.start(); + int w = p.waitFor(); + int v = p.exitValue(); + if (w == 0 && v == 0) { + return true; + } + } catch (Exception e) { + e.printStackTrace(); + } + return false; + } + + public static boolean pdf2html_linux(String pdfFile, String destDir, + String htmlFileName) { + if (!(pdfFile != null && !"".equals(pdfFile) && htmlFileName != null && !"" + .equals(htmlFileName))) { + System.out.println("传递的参数有误！"); + return false; + } + Runtime rt = Runtime.getRuntime(); + StringBuilder command = new StringBuilder(); + command.append("pdf2htmlEX").append(" "); + if (destDir != null && !"".equals(destDir.trim()))// 生成文件存放位置,需要替换文件路径中的空格 + command.append("--dest-dir ").append(destDir.replace(" ", "\" \"")) + .append(" "); + command.append("--optimize-text 1 ");// 尽量减少用于文本的HTML元素的数目 (default: 0) + command.append("--process-outline 0 ");// html中显示链接：0——false，1——true + command.append("--font-format woff ");// 嵌入html中的字体后缀(default ttf) + // ttf,otf,woff,svg + command.append(pdfFile.replace(" ", "\" \"")).append(" ");// 需要替换文件路径中的空格 + if (htmlFileName != null && !"".equals(htmlFileName.trim())) { + command.append(htmlFileName); + if (htmlFileName.indexOf(".html") == -1) + command.append(".html"); + } + try { + System.out.println("Command：" + command.toString()); + Process p = rt.exec(command.toString()); + StreamGobbler errorGobbler = new StreamGobbler(p.getErrorStream(), + "ERROR"); + // 开启屏幕标准错误流 + errorGobbler.start(); + StreamGobbler outGobbler = new StreamGobbler(p.getInputStream(), + "STDOUT"); + // 开启屏幕标准输出流 + outGobbler.start(); + int w = p.waitFor(); + int v = p.exitValue(); + if (w == 0 && v == 0) { + return true; + } + } catch (Exception e) { + e.printStackTrace(); + } + return false; + } + + +} + + + +/** + * 用于处理Runtime.getRuntime().exec产生的错误流及输出流 + * + * @author shaojing + * + */ +class StreamGobbler extends Thread { + InputStream is; + String type; + OutputStream os; + + public StreamGobbler(InputStream is, String type) { + this(is, type, null); + } + + StreamGobbler(InputStream is, String type, OutputStream redirect) { + this.is = is; + this.type = type; + this.os = redirect; + } + + public void run() { + InputStreamReader isr = null; + BufferedReader br = null; + PrintWriter pw = null; + try { + if (os != null) + pw = new PrintWriter(os); + isr = new InputStreamReader(is); + br = new BufferedReader(isr); + String line = null; + while ((line = br.readLine()) != null) { + if (pw != null) + pw.println(line); + System.out.println(type + ">" + line); + } + if (pw != null) + pw.flush(); + } catch (IOException ioe) { + ioe.printStackTrace(); + } finally { + try { + if (pw != null) + pw.close(); + if (br != null) + br.close(); + if (isr != null) + isr.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } +} \ No newline at end of file diff --git a/src/btp/oneP/SetFillList.java b/src/btp/oneP/SetFillList.java new file mode 100644 index 0000000..483f3a8 --- /dev/null +++ b/src/btp/oneP/SetFillList.java @@ -0,0 +1,22 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public class SetFillList { + + public static void main(String[] args) { + List c = Collections.nCopies(5, new String("hello")); + Set s = new HashSet(c); + System.out.println(s); + List l = new ArrayList(s); + System.out.println(l); + Collections.fill(l, new String("world")); + s = new HashSet(l); + System.out.println(s); + } + +} diff --git a/src/btp/oneP/Unsupported.java b/src/btp/oneP/Unsupported.java new file mode 100644 index 0000000..8f6d6fa --- /dev/null +++ b/src/btp/oneP/Unsupported.java @@ -0,0 +1,67 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +public class Unsupported { + + static void test(String msg,List list){ + System.out.println("--- "+msg+" ---"); + Collection c = list; + Collection sublist = list.subList(1, 8); + Collection c2 = new ArrayList(sublist); + + try{ + c.retainAll(c2); + }catch(Exception e){ + System.out.println("retainAll():"+e); + } + + try{ + c.removeAll(c2); + }catch(Exception e){ + System.out.println("removeAll():"+e); + } + + try{ + c.clear(); + }catch(Exception e){ + System.out.println("clear():"+e); + } + + try{ + c.add("X"); + }catch(Exception e){ + System.out.println("add():"+e); + } + + try{ + c.addAll(c2); + }catch(Exception e){ + System.out.println("addAll():"+e); + } + + try{ + c.remove("C"); + }catch(Exception e){ + System.out.println("remove():"+e); + } + + try{ + list.set(0, "X"); + }catch(Exception e){ + System.out.println("List.set():"+e); + } + } + public static void main(String[] args) { + // TODO Auto-generated method stub + List list = Arrays.asList("A B C D E F G H I J K L".split(" ")); + test("Modifiable Copy",new ArrayList(list)); + test("Arrays.asList()",list); + test("unmodifiableList()",Collections.unmodifiableList(new ArrayList(list))); + } + +} From 430fb6e63fd78b5456136d9265f0acf0fc6eae69 Mon Sep 17 00:00:00 2001 From: btp <842297171@qq.com> Date: Tue, 11 Jul 2017 21:10:08 +0800 Subject: [PATCH 07/15] Chapter 17 collections btp170711 --- src/btp/oneP/TypesForSets.java | 72 ++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 src/btp/oneP/TypesForSets.java diff --git a/src/btp/oneP/TypesForSets.java b/src/btp/oneP/TypesForSets.java new file mode 100644 index 0000000..4a3a6ac --- /dev/null +++ b/src/btp/oneP/TypesForSets.java @@ -0,0 +1,72 @@ +package btp.oneP; + +import java.util.HashSet; +import java.util.Set; + +public class TypesForSets { + static Set fill(Set set,Class type){ + try{ + for(int i=0;i<10;i++){ + set.add(type.getConstructor(int.class).newInstance(i)); + } + }catch(Exception e){ + throw new RuntimeException(e); + } + return set; + } + + static void test(Set set,Class type){ + fill(set,type);fill(set,type);fill(set,type); + System.out.println(set); + } + public static void main(String[] args) { + test(new HashSet(),HashType.class); + test(new HashSet(),HashType.class); + test(new HashSet(),HashType.class); + test(new HashSet(),HashType.class); + test(new HashSet(),HashType.class); + test(new HashSet(),HashType.class); + test(new HashSet(),HashType.class); + } + +} + +class SetType{ + int i; + public SetType(int n){ + i = n; + } + public boolean equals(Object o){ + return o instanceof SetType && (i == ((SetType)o).i); + } + public String toString(){ + return Integer.toString(i); + } +} + +class HashType extends SetType{ + + public HashType(int n) { + super(n); + // TODO Auto-generated constructor stub + } + + public int hashCode(){ + return i; + } +} + +class TreeType extends SetType implements Comparable{ + + public TreeType(int n) { + super(n); + // TODO Auto-generated constructor stub + } + + @Override + public int compareTo(TreeType o) { + // TODO Auto-generated method stub + return (o.i Date: Sat, 22 Jul 2017 23:17:58 +0800 Subject: [PATCH 08/15] Chapter 17 collections btp170722 --- src/btp/oneP/AssociativeArray.java | 57 ++++++++ src/btp/oneP/Bits.java | 67 +++++++++ src/btp/oneP/CanonicalMapping.java | 26 ++++ src/btp/oneP/ChangeCollectionTest.java | 19 +++ src/btp/oneP/CountedString.java | 53 +++++++ src/btp/oneP/DequeTest.java | 60 ++++++++ src/btp/oneP/Element.java | 20 +++ src/btp/oneP/Enumerations.java | 20 +++ src/btp/oneP/FailFast.java | 21 +++ src/btp/oneP/Individual.java | 48 +++++++ src/btp/oneP/Key.java | 10 ++ src/btp/oneP/LinkedHashMapDemo.java | 22 +++ src/btp/oneP/ListPerformance.java | 188 +++++++++++++++++++++++++ src/btp/oneP/ListSortSearch.java | 39 +++++ src/btp/oneP/MapEntry.java | 47 +++++++ src/btp/oneP/Maps.java | 49 +++++++ src/btp/oneP/PriorityQueueTst.java | 38 +++++ src/btp/oneP/QueueBehavior.java | 41 ++++++ src/btp/oneP/ReadOnly.java | 40 ++++++ src/btp/oneP/References.java | 57 ++++++++ src/btp/oneP/SimpleHashMap.java | 72 ++++++++++ src/btp/oneP/SlowMap.java | 78 ++++++++++ src/btp/oneP/SortedMapDemo.java | 33 +++++ src/btp/oneP/SortedSetDemo.java | 35 +++++ src/btp/oneP/SpringDetector.java | 68 +++++++++ src/btp/oneP/Stacks.java | 30 ++++ src/btp/oneP/Synchronization.java | 22 +++ src/btp/oneP/TestCollection.java | 9 ++ src/btp/oneP/TestParam.java | 26 ++++ src/btp/oneP/Tester.java | 79 +++++++++++ src/btp/oneP/TypesForSets.java | 25 +++- src/btp/oneP/Utilities.java | 62 ++++++++ src/btp/oneP/Value.java | 10 ++ src/btp/oneP/VeryBig.java | 16 +++ 34 files changed, 1481 insertions(+), 6 deletions(-) create mode 100644 src/btp/oneP/AssociativeArray.java create mode 100644 src/btp/oneP/Bits.java create mode 100644 src/btp/oneP/CanonicalMapping.java create mode 100644 src/btp/oneP/ChangeCollectionTest.java create mode 100644 src/btp/oneP/CountedString.java create mode 100644 src/btp/oneP/DequeTest.java create mode 100644 src/btp/oneP/Element.java create mode 100644 src/btp/oneP/Enumerations.java create mode 100644 src/btp/oneP/FailFast.java create mode 100644 src/btp/oneP/Individual.java create mode 100644 src/btp/oneP/Key.java create mode 100644 src/btp/oneP/LinkedHashMapDemo.java create mode 100644 src/btp/oneP/ListPerformance.java create mode 100644 src/btp/oneP/ListSortSearch.java create mode 100644 src/btp/oneP/MapEntry.java create mode 100644 src/btp/oneP/Maps.java create mode 100644 src/btp/oneP/PriorityQueueTst.java create mode 100644 src/btp/oneP/QueueBehavior.java create mode 100644 src/btp/oneP/ReadOnly.java create mode 100644 src/btp/oneP/References.java create mode 100644 src/btp/oneP/SimpleHashMap.java create mode 100644 src/btp/oneP/SlowMap.java create mode 100644 src/btp/oneP/SortedMapDemo.java create mode 100644 src/btp/oneP/SortedSetDemo.java create mode 100644 src/btp/oneP/SpringDetector.java create mode 100644 src/btp/oneP/Stacks.java create mode 100644 src/btp/oneP/Synchronization.java create mode 100644 src/btp/oneP/TestCollection.java create mode 100644 src/btp/oneP/TestParam.java create mode 100644 src/btp/oneP/Tester.java create mode 100644 src/btp/oneP/Utilities.java create mode 100644 src/btp/oneP/Value.java create mode 100644 src/btp/oneP/VeryBig.java diff --git a/src/btp/oneP/AssociativeArray.java b/src/btp/oneP/AssociativeArray.java new file mode 100644 index 0000000..fb4213a --- /dev/null +++ b/src/btp/oneP/AssociativeArray.java @@ -0,0 +1,57 @@ +package btp.oneP; + +public class AssociativeArray{ + + public static void main(String[] args) { + AssociativeArray map = new AssociativeArray(6); + map.put("sky", "blue"); + map.put("grass", "green"); + map.put("ocean", "dancing"); + map.put("tree", "tall"); + map.put("earth", "brown"); + map.put("sun", "warm"); + try{ + map.put("extra", "object"); + }catch(Exception e){ + System.out.println(e); + } + System.out.println(map); + System.out.println(map.get("ocean")); + } + + private Object[][] pair; + private int index; + public AssociativeArray(int length){ + pair = new Object[length][2]; + } + + public void put(K key,V value){ + if(index >= pair.length){ + throw new ArrayIndexOutOfBoundsException(); + } + pair[index++] = new Object[]{key,value}; + } + + @SuppressWarnings("unchecked") + public V get(K key){ + for(int i=0;i=0;i--){ + if(((1 << i)&bt) != 0){ + bb.set(i); + }else{ + bb.clear(i); + } + } + System.out.println("byte value: "+bt); + printBitSet(bb); + + short st = (short)rand.nextInt(); + BitSet bs = new BitSet(); + for(int i = 15;i>=0;i--){ + if(((1 << i)&st) != 0){ + bs.set(i); + }else{ + bs.clear(i); + } + } + System.out.println("short value: "+st); + printBitSet(bs); + + int it = rand.nextInt(); + BitSet bi = new BitSet(); + for(int i = 31;i>=0;i--){ + if(((1 << i)&bt) != 0){ + bi.set(i); + }else{ + bi.clear(i); + } + } + System.out.println("int value: "+it); + printBitSet(bi); + + BitSet b127 = new BitSet(); + b127.set(127); + System.out.println("set bit 127: "+b127); + BitSet b255 = new BitSet(65); + b255.set(255); + System.out.println("set bit 255: "+b255); + + BitSet b1023 = new BitSet(512); + b1023.set(1023); + b1023.set(1024); + System.out.println("set bit 1023: "+b1023); + } + +} diff --git a/src/btp/oneP/CanonicalMapping.java b/src/btp/oneP/CanonicalMapping.java new file mode 100644 index 0000000..3743bd6 --- /dev/null +++ b/src/btp/oneP/CanonicalMapping.java @@ -0,0 +1,26 @@ +package btp.oneP; + +import java.util.WeakHashMap; + +public class CanonicalMapping { + + public static void main(String[] args) { + int size = 1000; + if(args.length > 0){ + size = new Integer(args[0]); + } + + Key[] keys = new Key[size]; + WeakHashMap map = new WeakHashMap(); + for(int i = 0;i < size; i++){ + Key k = new Key(Integer.toString(i)); + Value v = new Value(Integer.toString(i)); + if(i % 3 == 0){ + keys[i] = k; + } + map.put(k, v); + } + System.gc(); + } + +} diff --git a/src/btp/oneP/ChangeCollectionTest.java b/src/btp/oneP/ChangeCollectionTest.java new file mode 100644 index 0000000..f68b4e3 --- /dev/null +++ b/src/btp/oneP/ChangeCollectionTest.java @@ -0,0 +1,19 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public class ChangeCollectionTest { + + public static void main(String[] args) { + List list = new ArrayList(); + list.add("hh"); + Iterator it = list.iterator(); + //list.add("hh"); + while(it.hasNext()){ + it.remove(); + } + } + +} diff --git a/src/btp/oneP/CountedString.java b/src/btp/oneP/CountedString.java new file mode 100644 index 0000000..614a00a --- /dev/null +++ b/src/btp/oneP/CountedString.java @@ -0,0 +1,53 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class CountedString { + + private static List created = new ArrayList(); + private String s; + private int id = 0; + public CountedString(String str){ + s = str; + created.add(s); + for(String s2:created){ + if(s2.equals(s)){ + id++; + } + } + } + + public int hashCode(){ + int result = 17; + result = 37*result+s.hashCode(); + result = 37*result+id; + return result; + } + + public boolean equals(Object o){ + return o instanceof CountedString && s.equals(((CountedString)o).s) && id==((CountedString)o).id; + } + + @Override + public String toString() { + return "CountedString [s=" + s + ", id=" + id + "hashCode():"+hashCode()+"]"; + } + + public static void main(String[] args) { + Map map = new HashMap(); + CountedString[] cs = new CountedString[5]; + for(int i=0;i deque){ + for(int i = 20;i < 27;i++){ + deque.addFirst(i); + } + for(int i = 50;i < 55;i++){ + deque.addLast(i); + } + } + public static void main(String[] args) { + Deque di = new Deque(); + fillTest(di); + System.out.println(di); + + while(di.size() != 0){ + System.out.print(di.removeFirst()+" "); + } + System.out.println(); + + fillTest(di); + while(di.size() != 0){ + System.out.print(di.removeLast()+" "); + } + System.out.println(); + } + +} + + +class Deque{ + private LinkedList deque = new LinkedList(); + public void addFirst(T t){ + deque.add(t); + } + public void addLast(T t){ + deque.addLast(t); + } + public T getFirst(){ + return deque.getFirst(); + } + public T getLast(){ + return deque.getLast(); + } + public T removeFirst(){ + return deque.removeFirst(); + } + public T removeLast(){ + return deque.removeLast(); + } + public int size(){ + return deque.size(); + } + public String toString(){ + return deque.toString(); + } +} \ No newline at end of file diff --git a/src/btp/oneP/Element.java b/src/btp/oneP/Element.java new file mode 100644 index 0000000..f2f1467 --- /dev/null +++ b/src/btp/oneP/Element.java @@ -0,0 +1,20 @@ +package btp.oneP; + +public class Element { + private String ident; + public Element(String id){ + ident = id; + } + public String toString(){ + return ident; + } + public int hashCode(){ + return ident.hashCode(); + } + public boolean equals(Object r){ + return r instanceof Element && ident.equals(((Element)r).ident); + } + protected void finalize(){ + System.out.println("Finalizing "+this.getClass().getSimpleName()+" "+ident+":"+(Integer.parseInt(ident)%3==0)); + } +} diff --git a/src/btp/oneP/Enumerations.java b/src/btp/oneP/Enumerations.java new file mode 100644 index 0000000..5fb98dd --- /dev/null +++ b/src/btp/oneP/Enumerations.java @@ -0,0 +1,20 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Enumeration; +import java.util.Vector; + +public class Enumerations { + + public static void main(String[] args) { + Vector v = new Vector(Countries.names(10)); + Enumeration e = v.elements(); + while(e.hasMoreElements()){ + System.out.println(e.nextElement()+", "); + } + e = Collections.enumeration(new ArrayList()); + + } + +} diff --git a/src/btp/oneP/FailFast.java b/src/btp/oneP/FailFast.java new file mode 100644 index 0000000..604e610 --- /dev/null +++ b/src/btp/oneP/FailFast.java @@ -0,0 +1,21 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.ConcurrentModificationException; +import java.util.Iterator; + +public class FailFast { + + public static void main(String[] args) { + Collection c = new ArrayList(); + Iterator it = c.iterator(); + c.add("An object"); + try{ + String s = it.next(); + }catch(ConcurrentModificationException e){ + System.out.println(e); + } + } + +} diff --git a/src/btp/oneP/Individual.java b/src/btp/oneP/Individual.java new file mode 100644 index 0000000..fb20acf --- /dev/null +++ b/src/btp/oneP/Individual.java @@ -0,0 +1,48 @@ +package btp.oneP; + +public class Individual implements Comparable { + private static long counter = 0; + private final long id = counter++; + private String name; + public Individual(String name){ + this.name = name; + } + public Individual(){} + public String toString(){ + return this.getClass().getSimpleName()+(name == null?"":" "+name); + } + public long id(){ + return id; + } + public boolean equals(Object o){ + return o instanceof Individual && id == ((Individual)o).id; + } + public int hashCode(){ + int result = 17; + if(name != null){ + result = 37*result+name.hashCode(); + } + result = 37*result+(int)id; + return result; + } + @Override + public int compareTo(Individual o) { + String first = getClass().getSimpleName(); + String argFirst = o.getClass().getSimpleName(); + int firstCompare = first.compareTo(argFirst); + if(0 != firstCompare){ + return firstCompare; + } + if(name != null && o.name != null){ + int secondCompare = name.compareTo(o.name); + if(secondCompare != 0){ + return secondCompare; + } + } + return (o.id linkedMap = new LinkedHashMap(new CountingMapData(9)); + System.out.println(linkedMap); + //false:基于插入顺序 true:基于访问顺序 LRU：最近最少访问，默认是false + linkedMap = new LinkedHashMap(16,0.75f,true); + linkedMap.putAll(new CountingMapData(9)); + System.out.println(linkedMap); + for(int i = 0;i<6;i++){ + linkedMap.get(i); + } + System.out.println(linkedMap); + linkedMap.get(0); + System.out.println(linkedMap); + } + +} diff --git a/src/btp/oneP/ListPerformance.java b/src/btp/oneP/ListPerformance.java new file mode 100644 index 0000000..4024bd4 --- /dev/null +++ b/src/btp/oneP/ListPerformance.java @@ -0,0 +1,188 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.ListIterator; +import java.util.Random; + +import javax.annotation.Generated; + +public class ListPerformance { + + static Random rand = new Random(); + static int reps = 1000; + static List>> tests = new ArrayList>>(); + static List>> qTests = new ArrayList>>(); + + static{ + tests.add(new TestCollection>("add"){ + @Override + int test(List list, TestParam tp) { + int loops = tp.loops; + int listSize = tp.size; + for(int i=0;i>("get"){ + @Override + int test(List list, TestParam tp) { + int loops = tp.loops * reps; + int listSize = list.size(); + for(int i=0;i>("set"){ + @Override + int test(List list, TestParam tp) { + int loops = tp.loops * reps; + int listSize = list.size(); + for(int i=0;i>("iteradd"){ + @Override + int test(List list, TestParam tp) { + final int LOOPS = 1000000; + int half = list.size()/2; + ListIterator it = list.listIterator(half); + for(int i=0;i>("insert"){ + @Override + int test(List list, TestParam tp) { + int loops = tp.loops; + for(int i=0;i>("remove"){ + @Override + int test(List list, TestParam tp) { + int loops = tp.loops; + int size = tp.size; + for(int i=0;i 5){ + list.remove(5); + } + } + return loops*size; + } + }); + + qTests.add(new TestCollection>("addFirst"){ + @Override + int test(LinkedList list, TestParam tp) { + int loops = tp.loops; + int size = tp.size; + for(int i=0;i>("addLast"){ + @Override + int test(LinkedList list, TestParam tp) { + int loops = tp.loops; + int size = tp.size; + for(int i=0;i>("rmFirst"){ + @Override + int test(LinkedList list, TestParam tp) { + int loops = tp.loops; + int size = tp.size; + for(int i=0;i0){ + list.removeFirst(); + } + } + return loops * size; + } + }); + + qTests.add(new TestCollection>("rmLast"){ + @Override + int test(LinkedList list, TestParam tp) { + int loops = tp.loops; + int size = tp.size; + for(int i=0;i0){ + list.removeLast(); + } + } + return loops * size; + } + }); + } + + static class ListTester extends Tester>{ + + public ListTester(List container, List>> tests) { + super(container, tests); + // TODO Auto-generated constructor stub + } + + protected List initialize(int size){ + container.clear(); + container.addAll(new CountingIntegerList(size)); + return container; + } + + public static void run(List list, List>> tests){ + new ListTester(list,tests).timedTest(); + } + } + public static void main(String[] args) { + if(args.length > 0){ + Tester.defaultParams = TestParam.array(args); + Tester> arrayTest = new Tester>(null,tests.subList(1, 3)){ + + }; + } + } + +} diff --git a/src/btp/oneP/ListSortSearch.java b/src/btp/oneP/ListSortSearch.java new file mode 100644 index 0000000..e31b5d6 --- /dev/null +++ b/src/btp/oneP/ListSortSearch.java @@ -0,0 +1,39 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.ListIterator; +import java.util.Random; + +public class ListSortSearch { + + public static void main(String[] args) { + List list = new ArrayList(Utilities.list); + list.addAll(Utilities.list); + System.out.println(list); + Collections.shuffle(list,new Random(47)); + System.out.println("Shuffled:"+list); + ListIterator it = list.listIterator(10); + while(it.hasNext()){ + System.out.print(it.next()+" "); + it.remove(); + } + System.out.println(); + System.out.println("Trimmed:"+list); + Collections.sort(list); + System.out.println("Sorted:"+list); + + String key = list.get(7); + int index = Collections.binarySearch(list, key); + System.out.println("Location of "+key+" is "+index+",list.get("+index+") = "+list.get(index)); + + Collections.sort(list, String.CASE_INSENSITIVE_ORDER); + System.out.println("Case-insensitive soretd:"+list); + key = list.get(7); + index = Collections.binarySearch(list, key,String.CASE_INSENSITIVE_ORDER); + System.out.println("Location of "+key+" is "+index+",list.get("+index+") = "+list.get(index)); + + } + +} diff --git a/src/btp/oneP/MapEntry.java b/src/btp/oneP/MapEntry.java new file mode 100644 index 0000000..5a75fe6 --- /dev/null +++ b/src/btp/oneP/MapEntry.java @@ -0,0 +1,47 @@ +package btp.oneP; + +import java.util.Map; + +public class MapEntry implements Map.Entry{ + private K key; + private V value; + public MapEntry(K key,V value){ + this.key = key; + this.value = value; + } + @Override + public K getKey() { + // TODO Auto-generated method stub + return key; + } + + @Override + public V getValue() { + return value; + } + + @Override + public V setValue(V value) { + //返回的不是类的属性 + V result = value; + this.value = value; + return result; + } + + public int hashCode(){ + return (key == null ? 0 :key.hashCode()) ^ (value == null ? 0 :value.hashCode()); + } + + public boolean equals(Object o){ + if(!(o instanceof MapEntry)) return false; + MapEntry me = (MapEntry)o; + return + (key == null?me.getKey() == null:key.equals(me.getKey())) + && + (value == null?me.getValue() == null:value.equals(me.getValue())); + } + + public String toString(){ + return key+"="+value; + } +} diff --git a/src/btp/oneP/Maps.java b/src/btp/oneP/Maps.java new file mode 100644 index 0000000..7a7ae7f --- /dev/null +++ b/src/btp/oneP/Maps.java @@ -0,0 +1,49 @@ +package btp.oneP; + +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.TreeMap; +import java.util.WeakHashMap; +import java.util.concurrent.ConcurrentHashMap; + +public class Maps { + + public static void main(String[] args) { + test(new HashMap()); + test(new TreeMap()); + test(new LinkedHashMap()); + test(new IdentityHashMap()); + test(new ConcurrentHashMap()); + test(new WeakHashMap()); + } + public static void printKeys(Map map){ + System.out.print("Size = "+map.size()+","); + System.out.println("Keys: "); + System.out.println(map.keySet()); + } + + public static void test(Map map){ + System.out.println(map.getClass().getSimpleName()); + map.putAll(new CountingMapData(25)); + map.putAll(new CountingMapData(25)); + printKeys(map); + System.out.println("Values: "); + System.out.println(map.values()); + System.out.println(map); + System.out.println("map.containsKey(11):"+map.containsKey(11)); + System.out.println("map.get(11):"+map.get(11)); + System.out.println("map.containsValue(\"F0\"):"+map.containsValue("F0")); + Integer key = map.keySet().iterator().next(); + System.out.println("First key in map:"+key); + map.remove(key); + printKeys(map); + map.clear(); + System.out.println("map.isEmpty():"+map.isEmpty()); + map.putAll(new CountingMapData(25)); + map.keySet().removeAll(map.keySet()); + System.out.println("map.isEmpty():"+map.isEmpty()); + System.out.println("---------------"); + } +} diff --git a/src/btp/oneP/PriorityQueueTst.java b/src/btp/oneP/PriorityQueueTst.java new file mode 100644 index 0000000..62f7087 --- /dev/null +++ b/src/btp/oneP/PriorityQueueTst.java @@ -0,0 +1,38 @@ +package btp.oneP; + +import java.util.PriorityQueue; +import java.util.Random; + +public class PriorityQueueTst { + + public static void main(String[] args) { + PriorityQueue pq = new PriorityQueue(); + for(int i=0;i<10;i++){ + pq.add(new IntegerPriority()); + } + System.out.println(pq); + while(!pq.isEmpty()){ + System.out.println(pq.poll()); + System.out.println(pq); + } + } + + static class IntegerPriority implements Comparable{ + Integer i; + private Random rd = new Random(); + public IntegerPriority(){ + i = rd.nextInt(100); + } + @Override + public int compareTo(IntegerPriority o) { + if(this.i>o.i){ + return -1; + }else if(this.i < o.i){ + return 1; + }else return 0; + } + public String toString(){ + return Integer.toString(i); + } + } +} diff --git a/src/btp/oneP/QueueBehavior.java b/src/btp/oneP/QueueBehavior.java new file mode 100644 index 0000000..c9d8b22 --- /dev/null +++ b/src/btp/oneP/QueueBehavior.java @@ -0,0 +1,41 @@ +package btp.oneP; + +import java.util.LinkedList; +import java.util.PriorityQueue; +import java.util.Queue; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.PriorityBlockingQueue; + +public class QueueBehavior { + private static int count = 10; + static void test(Queue queue,GeneratorN gen){ + for(int i=0;i{ + String[] s = ("one two three four five six seven eight nine ten").split(" "); + int i; + @Override + public String next() { + return s[i++]; + } + + } + + public static void main(String[] args) { + test(new LinkedList(),new Gen()); + test(new PriorityQueue(),new Gen()); + test(new ArrayBlockingQueue(count),new Gen()); + test(new ConcurrentLinkedQueue(),new Gen()); + test(new LinkedBlockingQueue(),new Gen()); + test(new PriorityBlockingQueue(),new Gen()); + } + +} diff --git a/src/btp/oneP/ReadOnly.java b/src/btp/oneP/ReadOnly.java new file mode 100644 index 0000000..2cce919 --- /dev/null +++ b/src/btp/oneP/ReadOnly.java @@ -0,0 +1,40 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; +import java.util.Set; +import java.util.TreeMap; +import java.util.TreeSet; + +public class ReadOnly { + static Collection data = new ArrayList(Countries.names(5)); + public static void main(String[] args) { + Collection c = Collections.unmodifiableCollection(new ArrayList(data)); + System.out.println(c); + //c.add("one");//error + + List a = Collections.unmodifiableList(new ArrayList(data)); + ListIterator lit = a.listIterator(); + System.out.println(lit.next()); + //lit.add("one");//error + + Set s = Collections.unmodifiableSet(new HashSet(data)); + System.out.println(s); + //s.add("one");//error + + Set ss = Collections.unmodifiableSortedSet(new TreeSet(data)); + + Map m = Collections.unmodifiableMap(new HashMap(Countries.capitals(6))); + System.out.println(m); + + Map sm = Collections.unmodifiableSortedMap(new TreeMap(Countries.capitals(6))); + System.out.println(sm); + } + +} diff --git a/src/btp/oneP/References.java b/src/btp/oneP/References.java new file mode 100644 index 0000000..976c875 --- /dev/null +++ b/src/btp/oneP/References.java @@ -0,0 +1,57 @@ +package btp.oneP; + +import java.lang.ref.PhantomReference; +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.lang.ref.SoftReference; +import java.lang.ref.WeakReference; +import java.util.LinkedList; + +public class References { + + private static ReferenceQueue rq = + new ReferenceQueue(); + public static void checkQueue(){ + Reference inq = rq.poll(); + if(null != inq){ + System.out.println("In queue: "+inq.get()); + } + } + + public static void main(String[] args) { + int size = 10; + if(args.length > 0){ + size = new Integer(args[0]); + } + + LinkedList> sa = new LinkedList>(); + + for(int i=0;i(new VeryBig("Soft "+i),rq)); + System.out.println("Just created: "+sa.getLast()); + checkQueue(); + } + System.out.println("--------------------"); + + LinkedList> wa = new LinkedList>(); + + for(int i=0;i(new VeryBig("Weak "+i),rq)); + System.out.println("Just created: "+wa.getLast()); + checkQueue(); + } + System.out.println("--------------------"); + + SoftReference s = new SoftReference(new VeryBig("Soft")); + WeakReference w = new WeakReference(new VeryBig("Weak")); + System.gc(); + LinkedList> pa = + new LinkedList>(); + for(int i=0;i(new VeryBig("Phantom "+i),rq)); + System.out.println("Just created: "+pa.getLast()); + checkQueue(); + } + } + +} diff --git a/src/btp/oneP/SimpleHashMap.java b/src/btp/oneP/SimpleHashMap.java new file mode 100644 index 0000000..61eb305 --- /dev/null +++ b/src/btp/oneP/SimpleHashMap.java @@ -0,0 +1,72 @@ +package btp.oneP; + +import java.util.AbstractMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.ListIterator; +import java.util.Map; +import java.util.Set; + +public class SimpleHashMap extends AbstractMap{ + + static final int size = 997; + @SuppressWarnings("unchecked") + LinkedList>[] buckets = new LinkedList[size]; + + public V put(K key,V value){ + V oldValue = null; + int index = Math.abs(key.hashCode())%size; + if(buckets[index] == null){ + buckets[index] = new LinkedList>(); + } + LinkedList> bucket = buckets[index]; + MapEntry pair = new MapEntry(key,value); + boolean found = false; + ListIterator> it = bucket.listIterator(); + while(it.hasNext()){ + MapEntry ipair = it.next(); + if(ipair.getKey().equals(key)){ + oldValue = ipair.getValue(); + it.set(pair); + found = true; + break; + } + } + if(!found){ + buckets[index].add(pair); + } + return oldValue; + } + + public V get(Object key){ + int index = Math.abs(key.hashCode())%size; + if(buckets[index] == null)return null; + for(MapEntry ipair:buckets[index]){ + if(ipair.getKey().equals(key)){ + return ipair.getValue(); + } + } + return null; + } + + + @Override + public Set> entrySet() { + Set> set = new HashSet>(); + for(LinkedList> bucket:buckets){ + if(bucket == null) continue; + for(MapEntry mpair:bucket){ + set.add(mpair); + } + } + return set; + } + + public static void main(String[] args) { + SimpleHashMap m = new SimpleHashMap(); + m.putAll(Countries.capitals(25)); + System.out.println(m); + System.out.println(m.get("CHINA")); + System.out.println(m.entrySet()); + } +} diff --git a/src/btp/oneP/SlowMap.java b/src/btp/oneP/SlowMap.java new file mode 100644 index 0000000..6b53a71 --- /dev/null +++ b/src/btp/oneP/SlowMap.java @@ -0,0 +1,78 @@ +package btp.oneP; + +import java.util.AbstractMap; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class SlowMap extends AbstractMap{ + private List keys = new ArrayList(); + private List values = new ArrayList(); + public V put(K key,V value){ + V oldValue = get(key); + if(!keys.contains(key)){ + keys.add(key); + values.add(value); + }else{ + values.set(keys.indexOf(key), value); + } + return oldValue; + } + + public V get(Object key){ + if(!keys.contains(key)){ + return null; + }else{ + return values.get(keys.indexOf(key)); + } + } + + @Override + public Set> entrySet() { + // TODO Auto-generated method stub + Set> set = new HashSet>(); + Iterator ki = keys.iterator(); + Iterator vi = values.iterator(); + while(ki.hasNext()){ + set.add(new Map.Entry() { + K k = ki.next(); + V v = vi.next(); + @Override + public K getKey() { + // TODO Auto-generated method stub + return k; + } + + @Override + public V getValue() { + // TODO Auto-generated method stub + return v; + } + + @Override + public V setValue(V value) { + v = value; + return v; + } + + public String toString(){ + return k+"="+v; + } + }); + } + return set; + } + + public static void main(String...args){ + SlowMap m = new SlowMap(); + m.putAll(Countries.capitals()); + System.out.println(m); + System.out.println(m.get("Japan")); + //不按插入顺序打印，set + System.out.println(m.entrySet()); + } + +} diff --git a/src/btp/oneP/SortedMapDemo.java b/src/btp/oneP/SortedMapDemo.java new file mode 100644 index 0000000..3cb4532 --- /dev/null +++ b/src/btp/oneP/SortedMapDemo.java @@ -0,0 +1,33 @@ +package btp.oneP; + +import java.util.Iterator; +import java.util.SortedMap; +import java.util.TreeMap; + +public class SortedMapDemo { + + public static void main(String[] args) { + SortedMap sortedMap = new TreeMap(new CountingMapData(10)); + System.out.println(sortedMap); + Integer low = sortedMap.firstKey(); + Integer high = sortedMap.lastKey(); + System.out.println(low); + System.out.println(high); + Iterator it = sortedMap.keySet().iterator(); + for(int i=0;i<=6;i++){ + if(i == 3){ + low = it.next(); + } + if(i == 6){ + high = it.next(); + } + else it.next(); + } + System.out.println(low); + System.out.println(high); + System.out.println(sortedMap.subMap(low, high)); + System.out.println(sortedMap.headMap(high)); + System.out.println(sortedMap.tailMap(low)); + } + +} diff --git a/src/btp/oneP/SortedSetDemo.java b/src/btp/oneP/SortedSetDemo.java new file mode 100644 index 0000000..9691b15 --- /dev/null +++ b/src/btp/oneP/SortedSetDemo.java @@ -0,0 +1,35 @@ +package btp.oneP; + +import java.util.Collections; +import java.util.Iterator; +import java.util.SortedSet; +import java.util.TreeSet; + +public class SortedSetDemo { + + public static void main(String[] args) { + SortedSet sortedSet = new TreeSet(); + Collections.addAll(sortedSet, "one two three four five six seven eight".split(" ")); + System.out.println(sortedSet); + + String low = sortedSet.first(); + String high = sortedSet.last(); + System.out.println(low); + System.out.println(high); + + Iterator it = sortedSet.iterator(); + for(int i = 0;i<=6;i++){ + if(i == 3) low = it.next(); + if(i == 6)high = it.next(); + else it.next(); + } + + System.out.println(low); + System.out.println(high); + + System.out.println(sortedSet.subSet(low, high)); + System.out.println(sortedSet.headSet(high)); + System.out.println(sortedSet.tailSet(low)); + } + +} diff --git a/src/btp/oneP/SpringDetector.java b/src/btp/oneP/SpringDetector.java new file mode 100644 index 0000000..adf10a0 --- /dev/null +++ b/src/btp/oneP/SpringDetector.java @@ -0,0 +1,68 @@ +package btp.oneP; + +import java.lang.reflect.Constructor; +import java.util.HashMap; +import java.util.Map; +import java.util.Random; + +public class SpringDetector { + + public static void detectSpring(Class type) throws Exception{ + Constructor ghog = type.getConstructor(Integer.TYPE); + Map map = new HashMap(); + for(int i = 0;i<10;i++){ + map.put(ghog.newInstance(i), new Prediction()); + } + System.out.println("map = "+map); + Groundhog gh = ghog.newInstance(3); + System.out.println("Looking up prediction for "+gh); + if(map.containsKey(gh)){ + System.out.println(map.get(gh)); + }else{ + System.out.println("key not found:"+gh); + } + } + + public static void main(String[] args) throws Exception{ + //detectSpring(Groundhog.class); + SpringDetector.detectSpring(Groundhog2.class); + } + +} + +class Groundhog{ + protected int number; + public Groundhog(int n){ + number = n; + } + public String toString(){ + return "Groundhog #"+number; + } +} + +class Prediction{ + private static Random rand = new Random(47); + private boolean shadow = rand.nextDouble()>0.5; + public String toString(){ + if(shadow){ + return "Six more weeks of winter!"; + }else{ + return "Early Spring!"; + } + } +} + +class Groundhog2 extends Groundhog{ + + public Groundhog2(int n) { + super(n); + } + public int hashCode(){ + return number; + } + public boolean equals(Object o){ + //return o instanceof Groundhog2 && (number == ((Groundhog2)o).number); + return o instanceof Groundhog2 && (this.hashCode() == ((Groundhog2)o).hashCode()); + } + +} diff --git a/src/btp/oneP/Stacks.java b/src/btp/oneP/Stacks.java new file mode 100644 index 0000000..5ded04a --- /dev/null +++ b/src/btp/oneP/Stacks.java @@ -0,0 +1,30 @@ +package btp.oneP; +import java.util.*; +public class Stacks { + + public static void main(String[] args) { + java.util.Stack stack = new java.util.Stack(); + for(Month m:Month.values()){ + stack.push(m.toString()); + } + stack.addElement("The last line"); + System.out.println("element 5 = "+stack.elementAt(5)); + System.out.println("popping elements:"); + while(!stack.empty()){ + System.out.println(stack.pop()+" "); + } + LinkedList lstack = new LinkedList(); + for(Month m : Month.values()){ + lstack.addFirst(m.toString()); + } + System.out.println("lstack = "+lstack); + while(!lstack.isEmpty()){ + System.out.println(lstack.removeFirst() + " "); + } + } + +} + +enum Month{ + JANUARY,FEBRUARY,MARCH,APRIL,MAY,JUNE,JULY,AUGUST,SEPTEMBER,OCTOBER,NOVEMBER +} diff --git a/src/btp/oneP/Synchronization.java b/src/btp/oneP/Synchronization.java new file mode 100644 index 0000000..50945e9 --- /dev/null +++ b/src/btp/oneP/Synchronization.java @@ -0,0 +1,22 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeMap; +import java.util.TreeSet; + +public class Synchronization { + public static void main(String...args){ + Collections.synchronizedCollection(new ArrayList()); + List list = Collections.synchronizedList(new ArrayList()); + Set s = Collections.synchronizedSet(new HashSet()); + Set ss = Collections.synchronizedSortedSet(new TreeSet()); + Map m = Collections.synchronizedMap(new HashMap()); + Map sm = Collections.synchronizedSortedMap(new TreeMap()); + } +} diff --git a/src/btp/oneP/TestCollection.java b/src/btp/oneP/TestCollection.java new file mode 100644 index 0000000..2cbd09e --- /dev/null +++ b/src/btp/oneP/TestCollection.java @@ -0,0 +1,9 @@ +package btp.oneP; + +public abstract class TestCollection { + String name; + public TestCollection(String name){ + this.name = name; + } + abstract int test(C container,TestParam tp); +} diff --git a/src/btp/oneP/TestParam.java b/src/btp/oneP/TestParam.java new file mode 100644 index 0000000..37989fb --- /dev/null +++ b/src/btp/oneP/TestParam.java @@ -0,0 +1,26 @@ +package btp.oneP; + +public class TestParam { + public final int size; + public final int loops; + public TestParam(int size,int loops){ + this.size = size; + this.loops = loops; + } + public static TestParam[] array(int...values){ + int size = values.length/2; + TestParam[] result = new TestParam[size]; + int n = 0; + for(int i = 0;i { + public static int fieldWidth = 8; + public static TestParam[] defaultParams = TestParam.array(10,5000,100,5000,1000,5000,10000,500); + protected C initialize(int size){ + return container; + } + protected C container; + private String headline = ""; + private List> tests; + private static String stringFiled(){ + return "%"+fieldWidth+"s"; + } + private static String numberFiled(){ + return "%"+fieldWidth+"d"; + } + private static int sizeWidth = 5; + private static String sizeFiled = "%"+sizeWidth+"s"; + private TestParam[] paramList = defaultParams; + + public Tester(C container,List> tests){ + this.container = container; + this.tests = tests; + if(container != null){ + headline = container.getClass().getSimpleName(); + } + } + public Tester(C container,List> tests,TestParam[] paramList){ + this(container,tests); + this.paramList = paramList; + } + public void setHeadline(String newHeadline){ + this.headline = newHeadline; + } + public static void run(C cntnr,List> tests){ + new Tester(cntnr,tests).timedTest(); + } + public static void run(C cntnr,List> tests,TestParam[] paramList){ + new Tester(cntnr,tests,paramList).timedTest(); + } + private void displayHeader(){ + int width = fieldWidth * tests.size()+sizeWidth; + int dashLength = width-headline.length()-1; + StringBuilder head = new StringBuilder(width); + for(int i=0;i test:tests){ + C kontainer = initialize(param.size); + long start = System.nanoTime(); + int reps = test.test(kontainer, param); + long duration = System.nanoTime()-start; + long timePerRep = duration/reps; + System.out.format(numberFiled(), timePerRep); + } + System.out.println(); + } + } +} diff --git a/src/btp/oneP/TypesForSets.java b/src/btp/oneP/TypesForSets.java index 4a3a6ac..b36285f 100644 --- a/src/btp/oneP/TypesForSets.java +++ b/src/btp/oneP/TypesForSets.java @@ -1,7 +1,9 @@ package btp.oneP; import java.util.HashSet; +import java.util.LinkedHashSet; import java.util.Set; +import java.util.TreeSet; public class TypesForSets { static Set fill(Set set,Class type){ @@ -21,12 +23,23 @@ static void test(Set set,Class type){ } public static void main(String[] args) { test(new HashSet(),HashType.class); - test(new HashSet(),HashType.class); - test(new HashSet(),HashType.class); - test(new HashSet(),HashType.class); - test(new HashSet(),HashType.class); - test(new HashSet(),HashType.class); - test(new HashSet(),HashType.class); + test(new LinkedHashSet(),HashType.class); + test(new TreeSet(),TreeType.class); + test(new HashSet(),SetType.class); + test(new HashSet(),TreeType.class); + test(new LinkedHashSet(),SetType.class); + test(new LinkedHashSet(),TreeType.class); + try{ + test(new TreeSet(),SetType.class); + }catch(Exception e){ + System.out.println(e.getMessage()); + } + + try{ + test(new TreeSet(),HashType.class); + }catch(Exception e){ + System.out.println(e.getMessage()); + } } } diff --git a/src/btp/oneP/Utilities.java b/src/btp/oneP/Utilities.java new file mode 100644 index 0000000..f934aef --- /dev/null +++ b/src/btp/oneP/Utilities.java @@ -0,0 +1,62 @@ +package btp.oneP; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Enumeration; +import java.util.List; +import java.util.Random; +import java.util.Vector; + +public class Utilities { + static List list = Arrays.asList("one two three four five six one".split(" ")); + public static void main(String[] args) { + System.out.println(list); + System.out.println("'list' disjoint (Four)?:"+Collections.disjoint(list, Collections.singletonList("four"))); + System.out.println("max:"+Collections.max(list)); + System.out.println("min:"+Collections.min(list)); + System.out.println("max w/ comparator:"+Collections.max(list,String.CASE_INSENSITIVE_ORDER)); + System.out.println("min w/ comparator:"+Collections.min(list,String.CASE_INSENSITIVE_ORDER)); + + List sublist = Arrays.asList("four five six".split(" ")); + System.out.println("indexOfSublist:"+Collections.indexOfSubList(list, sublist)); + System.out.println("lastIndexOfSublist:"+Collections.lastIndexOfSubList(list, sublist)); + + Collections.replaceAll(list, "one", "yo"); + System.out.println("replaceAll:"+list); + Collections.reverse(list); + System.out.println("reverse:"+list); + Collections.rotate(list, 3); + System.out.println("rotate:"+list); + + List source = Arrays.asList("in the matrix".split(" ")); + Collections.copy(list, source); + System.out.println("copy:"+list); + + Collections.swap(list, 0, list.size()-1); + System.out.println("swap:"+list); + + Collections.shuffle(list, new Random(47)); + System.out.println("shuffled:"+list); + + Collections.fill(list, "pop"); + System.out.println("fill:"+list); + + System.out.println("frequency of 'pop':"+Collections.frequency(list, "pop")); + + List dups = Collections.nCopies(3, "snap"); + System.out.println("dups:"+dups); + + System.out.println("'list' disjoint 'dups'?:"+Collections.disjoint(list, dups)); + + Enumeration e = Collections.enumeration(dups); + Vector v = new Vector(); + while(e.hasMoreElements()){ + v.addElement(e.nextElement()); + } + + ArrayList arrayList = Collections.list(v.elements()); + System.out.println("arrayList:"+arrayList); + } + +} diff --git a/src/btp/oneP/Value.java b/src/btp/oneP/Value.java new file mode 100644 index 0000000..a57c2fa --- /dev/null +++ b/src/btp/oneP/Value.java @@ -0,0 +1,10 @@ +package btp.oneP; + +public class Value extends Element { + + public Value(String id) { + super(id); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/btp/oneP/VeryBig.java b/src/btp/oneP/VeryBig.java new file mode 100644 index 0000000..ba449aa --- /dev/null +++ b/src/btp/oneP/VeryBig.java @@ -0,0 +1,16 @@ +package btp.oneP; + +public class VeryBig { + private static final int SIZE = 10000; + private long[] la = new long[SIZE]; + private String ident; + public VeryBig(String id){ + this.ident = id; + } + public String toString(){ + return ident; + } + protected void finalize(){ + System.out.println("Finalizing "+ident); + } +} From 5966cb080610971eefa3a818fac88b4a0bb03d5e Mon Sep 17 00:00:00 2001 From: btp <842297171@qq.com> Date: Wed, 2 Aug 2017 10:00:02 +0800 Subject: [PATCH 09/15] Chapter 18 IO/NIO btp170802 --- .settings/org.eclipse.core.resources.prefs | 2 + src/Data/IO.jpg | Bin 0 -> 51281 bytes src/btp/oneP/AvailableCharSets.java | 29 +++++ src/btp/oneP/BasicFileOutput.java | 24 +++++ src/btp/oneP/BinaryFile.java | 38 +++++++ src/btp/oneP/BufferToText.java | 51 +++++++++ src/btp/oneP/BufferedInputFile.java | 23 ++++ src/btp/oneP/ChangeSystemOut.java | 14 +++ src/btp/oneP/ChannelCopy.java | 24 +++++ src/btp/oneP/DirList.java | 38 +++++++ src/btp/oneP/DirList2.java | 43 ++++++++ src/btp/oneP/Directory.java | 82 ++++++++++++++ src/btp/oneP/DirectoryDemo.java | 32 ++++++ src/btp/oneP/Echo.java | 17 +++ src/btp/oneP/Endians.java | 23 ++++ src/btp/oneP/FileLocking.java | 22 ++++ src/btp/oneP/FileOutputShortcut.java | 25 +++++ src/btp/oneP/FormattedMemoryInput.java | 22 ++++ src/btp/oneP/GetChannel.java | 30 ++++++ src/btp/oneP/GetData.java | 46 ++++++++ src/btp/oneP/IntBufferDemo.java | 21 ++++ src/btp/oneP/LargeMappedFiles.java | 22 ++++ src/btp/oneP/LockingMappedFiles.java | 50 +++++++++ src/btp/oneP/MakeDirectories.java | 55 ++++++++++ src/btp/oneP/MappedIO.java | 118 +++++++++++++++++++++ src/btp/oneP/MemoryInput.java | 16 +++ src/btp/oneP/OSExecute.java | 32 ++++++ src/btp/oneP/OSExecuteDemo.java | 9 ++ src/btp/oneP/OSExecuteException.java | 7 ++ src/btp/oneP/PPrint.java | 30 ++++++ src/btp/oneP/ProcessFiles.java | 56 ++++++++++ src/btp/oneP/ProcessTest.java | 24 +++++ src/btp/oneP/Redirecting.java | 31 ++++++ src/btp/oneP/SameFather.java | 38 +++++++ src/btp/oneP/StoringAndRecoveringData.java | 29 +++++ src/btp/oneP/TestEOF.java | 18 ++++ src/btp/oneP/TextFile.java | 83 +++++++++++++++ src/btp/oneP/TransferTo.java | 20 ++++ src/btp/oneP/UsingBuffers.java | 28 +++++ src/btp/oneP/UsingRandomAccessFile.java | 33 ++++++ src/btp/oneP/ViewBuffers.java | 58 ++++++++++ 41 files changed, 1363 insertions(+) create mode 100644 .settings/org.eclipse.core.resources.prefs create mode 100644 src/Data/IO.jpg create mode 100644 src/btp/oneP/AvailableCharSets.java create mode 100644 src/btp/oneP/BasicFileOutput.java create mode 100644 src/btp/oneP/BinaryFile.java create mode 100644 src/btp/oneP/BufferToText.java create mode 100644 src/btp/oneP/BufferedInputFile.java create mode 100644 src/btp/oneP/ChangeSystemOut.java create mode 100644 src/btp/oneP/ChannelCopy.java create mode 100644 src/btp/oneP/DirList.java create mode 100644 src/btp/oneP/DirList2.java create mode 100644 src/btp/oneP/Directory.java create mode 100644 src/btp/oneP/DirectoryDemo.java create mode 100644 src/btp/oneP/Echo.java create mode 100644 src/btp/oneP/Endians.java create mode 100644 src/btp/oneP/FileLocking.java create mode 100644 src/btp/oneP/FileOutputShortcut.java create mode 100644 src/btp/oneP/FormattedMemoryInput.java create mode 100644 src/btp/oneP/GetChannel.java create mode 100644 src/btp/oneP/GetData.java create mode 100644 src/btp/oneP/IntBufferDemo.java create mode 100644 src/btp/oneP/LargeMappedFiles.java create mode 100644 src/btp/oneP/LockingMappedFiles.java create mode 100644 src/btp/oneP/MakeDirectories.java create mode 100644 src/btp/oneP/MappedIO.java create mode 100644 src/btp/oneP/MemoryInput.java create mode 100644 src/btp/oneP/OSExecute.java create mode 100644 src/btp/oneP/OSExecuteDemo.java create mode 100644 src/btp/oneP/OSExecuteException.java create mode 100644 src/btp/oneP/PPrint.java create mode 100644 src/btp/oneP/ProcessFiles.java create mode 100644 src/btp/oneP/ProcessTest.java create mode 100644 src/btp/oneP/Redirecting.java create mode 100644 src/btp/oneP/SameFather.java create mode 100644 src/btp/oneP/StoringAndRecoveringData.java create mode 100644 src/btp/oneP/TestEOF.java create mode 100644 src/btp/oneP/TextFile.java create mode 100644 src/btp/oneP/TransferTo.java create mode 100644 src/btp/oneP/UsingBuffers.java create mode 100644 src/btp/oneP/UsingRandomAccessFile.java create mode 100644 src/btp/oneP/ViewBuffers.java diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..5e64050 --- /dev/null +++ b/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding//src/btp/oneP/BufferToText.java=UTF-8 diff --git a/src/Data/IO.jpg b/src/Data/IO.jpg new file mode 100644 index 0000000000000000000000000000000000000000..71e5e494538bedc79232beaa03191738226179c2 GIT binary patch literal 51281 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