您的位置: 首页  >  文章  >  java知识网络梳理

java知识网络梳理

分类: 文章 • 2025-03-24 10:47:34

Java知识点汇总

一、基本数据类型

        Java共有8种原生类型，分别是byte, short, int, long, float, double, char, boolean，不包含字符串String。在Java中，所有整型都是有符号数，没有unsigned关键字。特别注意char是两个字节的，范围是0～65535，存的是Unicode编码。short是两个字节，int是四个字节，long是八个字节，类型大小是固定的，与平台无关。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-27. 
  5.  */  
  6. public class BasicTypeDemo {  
  7.     public static void main(String[] args){  
  8.         System.out.println("Byte");  
  9.         System.out.println(Byte.MIN_VALUE); // -128  
  10.         System.out.println(Byte.MAX_VALUE); // 127  
  11.   
  12.         System.out.println("Short");  
  13.         System.out.println(Short.MIN_VALUE); // -32768  
  14.         System.out.println(Short.MAX_VALUE); // 32767  
  15.   
  16.         System.out.println("Character");  
  17.         System.out.println((int)Character.MIN_VALUE); // 0  
  18.         System.out.println((int)Character.MAX_VALUE); // 65535  
  19.   
  20.         System.out.println("Integer");  
  21.         System.out.println(Integer.MIN_VALUE); // -2147483648  
  22.         System.out.println(Integer.MAX_VALUE); // 2147483647  
  23.   
  24.         System.out.println("Long");  
  25.         System.out.println(Long.MIN_VALUE); // -9223372036854775808  
  26.         System.out.println(Long.MAX_VALUE); // 9223372036854775807  
  27.   
  28.         System.out.println("Float");  
  29.         System.out.println(Float.MIN_VALUE); // 1.4E-45, 最小精度值，而不是最小值(-Float.MAX_VALUE)  
  30.         System.out.println(Float.MAX_VALUE); // 3.4028235E38  
  31.   
  32.         System.out.println("Double");  
  33.         System.out.println(Double.MIN_VALUE); // 4.9E-324，最小精度值，而不是最小值(-Double.MAX_VALUE)  
  34.         System.out.println(Double.MAX_VALUE); // 1.7976931348623157E308  
  35.     }  
  36. }  

        这些基本类型有对应的包装类。int->Integer称为装包，Integer->int称为拆包。而且会自动装包和自动拆包，是由编译器支持的，会自动插入指令，虚拟机不知。前六个基本类型的包装类都继承自Number。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. import java.util.ArrayList;  
  4. /** 
  5.  * Created by gzx on 16-12-27. 
  6.  */  
  7. public class WrapperDemo {  
  8.     public static void main(String[] args){  
  9.         ArrayList<Integer> arrayList = new ArrayList<Integer>();  
  10.   
  11.         // 自动装箱，int转化为Integer  
  12.         int data = 10;  
  13.         arrayList.add(data);  
  14.   
  15.         // 自动拆箱，Integer转化为int  
  16.         int ret = arrayList.get(0);  
  17.   
  18.         // 自动装包，本质是new Integer(a)。-128 ～ 127都相等，有唯一的对象  
  19.         Integer a = 127;  
  20.         Integer b = 127;  
  21.         System.out.println(a == b); // true  
  22.   
  23.         // 手动生成新的实例  
  24.         Integer c = new Integer(1);  
  25.         Integer d = new Integer(1);  
  26.         System.out.println(c == d); // false  
  27.   
  28.     }  
  29. }  

二、字符串

        String底层使用char[]存储，Unicode编码，而且所有需要改变字符串状态的方法都通过创建新的字符串实例返回，不会改变字符串的底层数据，即状态不可变，线程安全。另String用了final修饰，即不可以再被继承。如果字符串需要频繁修改，使用StringBuilder，主要有append方法。String比较有用的方法有：

substring(int beginIndex,int endIndex)：获得两个索引之间的子串，不包含endIndex

charAt(int index)：某个位置的char

compareTo(String other) :实现了Comparable<String>接口

indexOf(String str)：子串首次出现的位置

trim():去除字符串前后的空白

toLowerCase()

toUpperCase()

静态方法：

String.format(String fmt, Object… ) :格式化字符串，后跟不定参数

[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-27. 
  5.  */  
  6. public class StringDemo {  
  7.     public static void main(String[] args){  
  8.         /* 
  9.             String相关方法 
  10.          */  
  11.         String str = "hello world";  
  12.         for(int i = 0; i < str.length(); i++){  
  13.             System.out.printf("'%c' ", str.charAt(i));  
  14.         }  
  15.         System.out.println();  
  16.         System.out.println(str.substring(3, 7)); // lo w  
  17.         System.out.println(str.compareTo("you are here")); // -17, h - y  
  18.         System.out.println(str.indexOf("wo")); // 6  
  19.         System.out.println(str.toUpperCase()); // HELLO WORLD  
  20.         System.out.println(str); // hello world  
  21.   
  22.         /* 
  23.             字符串格式化 
  24.          */  
  25.         String format = "you are %s";  
  26.         System.out.println(String.format(format, str)); // you are hello world  
  27.     }  
  28. }  

    正则表达式的使用：

先编译模式Pattern，再匹配文本，得到matcher，最后通过matcher.find()寻找所有结果，以及匹配的模式中的所有加括号的组。
[java] view plain copy
  1. import java.util.regex.Matcher;  
  2. import java.util.regex.Pattern;  
  3.   
  4. /** 
  5.  * Created by jessin on 17-2-26. 
  6.  */  
  7. public class PatternDemo {  
  8.     public static void main(String[] args){  
  9.         // 预先编译  
  10.         String str = "\\$(\\w+)\\((\\d+)\\)";  
  11.         Pattern pattern = Pattern.compile(str);  
  12.         String text = "hello $natureOrder(123) if you like this ,please use $indexOrder(99);";  
  13.         // 生成编译类  
  14.         Matcher matcher = pattern.matcher(text);  
  15.         // 得到所有的匹配结果  
  16.         while(matcher.find()){  
  17.             // 整个匹配的字符串：$function(argument)  
  18.             System.out.println(matcher.group());  
  19.             // 第一个()的内容：函数名function  
  20.             System.out.println(matcher.group(1));  
  21.             // 第二个括号的内容：数字argument  
  22.             System.out.println(matcher.group(2));  
  23.             // 将所有的匹配项删除，必须赋值才能起作用  
  24.             text = text.replace(matcher.group(), "field");  
  25. //            $natureOrder(123)  
  26. //            natureOrder  
  27. //            123  
  28. //            $indexOrder(99)  
  29. //            indexOrder  
  30. //            99  
  31.         }  
  32.         System.out.println(text);  
  33.         // hello field if you like this ,please use field;  
  34.     }  
  35. }  


三、标准输入和格式化输出

        这里主要是从键盘和文件读入数据，将数据格式化输出到控制台或者文件。

java.util.Scanner提供了标准输入，比较有用的方法有

Scanner(InputStream input) :初始化一个Scanner实例

String nextLine() : 读入一行，不论是否有空格

String hasNext() :是否还有字符串

String next() :以空格作为分隔符

String hasNextInt()

String nextInt() :读入一个整数

String hasNextDouble()

String nextDouble()：读入一个double

标准输入：new Scanner(System.in)

从文件输入：new Scanner(new File(filename))

格式化输出到控制台：System.out.printf(fmt, object...)

格式化输出到文件：PrintWriter(new File(filename))

printer.printf(fmt, object...)

printer.close()

[java] view plain copy
  1. package knowledge;  
  2. import java.io.FileNotFoundException;  
  3. import java.io.PrintWriter;  
  4. import java.util.Scanner;  
  5. import java.io.File;  
  6. /** 
  7.  * Created by gzx on 16-12-27. 
  8.  */  
  9. public class ScannerDemo {  
  10.     public static void main(String[] args) throws FileNotFoundException{  
  11.         /* 
  12.              从文件格式化输入 
  13.          */  
  14.         Scanner in = new Scanner(new File("/home/gzx/hello.txt")); // 将参数改为System.in可以从键盘输入  
  15.         // 文件内容：hello 123 31313.111  
  16.         while(in.hasNext()){  
  17.             System.out.println(in.next()); // hello  
  18.             System.out.println(in.nextInt()); // 123  
  19.             System.out.println(in.nextDouble()); //31313.111  
  20.         }  
  21.         /* 
  22.              格式化输出到控制台 
  23.          */  
  24.         int data = 1234;  
  25.         double hello = -1234.13214134;  
  26.         System.out.printf("整数是%d\n", data); // 1234  
  27.         System.out.printf("浮点数是%7.3f\n", hello); // -1234.132  
  28.         /* 
  29.              格式化输出到文件 
  30.          */  
  31.         String outName = "out.txt"; // 保存hello : world  
  32.         File outFile = new File(outName);  
  33.         System.out.println(outFile.getAbsolutePath());  
  34.           
  35.         PrintWriter printer = new PrintWriter(outFile); // FileNotFoundException  
  36.         printer.printf("%s : %s\n", "hello", "world");  
  37.         printer.close();  
  38.     }  
  39. }  

四、数组

        数组创建(new)时的元素是默认值，数字是0，布尔是false，对象是null。也可以在创建数组时初始化，但不能指定数组的大小，大小将由初始值的个数确定。数组是对象，有length属性，可以赋值给另一个数组。数组有对应的工具类Arrays。

数组转化为字符串：

Arrays.toString(type[] arr)

二维数组快速输出：

Arrays.deepToString(type[][] arr)

数组拷贝：

newArr= Arrays.copyOf(type[] arr, int len) :不管数组大小，生成新的数组，与原来数组没有任何关系。

数组排序：

Arrays.sort(type[] arr)

数组二分查找，检查是否有该元素，没有则返回-1：

Arrays.binarySearch(type[] arr, int v)

数组整体赋值：

Arrays.fill(type[] arr, type v)

[java] view plain copy
  1. package knowledge;  
  2.   
  3. import java.util.Arrays;  
  4.   
  5. /** 
  6.  * Created by gzx on 16-12-27. 
  7.  */  
  8. public class ArrayDemo{  
  9.     public static void main(String[] args) {  
  10.         /* 
  11.             默认值为null，在堆中，接下来需要一一赋值 
  12.          */  
  13.         int [] intArr = new int[10];  
  14.         System.out.println(intArr[0]); // 0  
  15.         double[] doubleArr = new double[10];  
  16.         System.out.println(doubleArr[0]); // 0.0  
  17.         String[] stringArr = new String[10];  
  18.         System.out.println(stringArr[0]); // null  
  19.   
  20.         // 数组初始化，数组是对象，有length属性，可以相互赋值  
  21.         int[] intArr2 = {1, 3, 5, 7};  
  22.         System.out.println(intArr2.length); // 4  
  23.         // 匿名数组赋值，不能指定大小，可以把new int[]去掉变为数组初始化  
  24.         int[] intArr3 = new int[] {1, 2, 3, 4, 5};  
  25.         System.out.println(intArr3.length); // 5  
  26.   
  27.         /* 
  28.             二维数组 
  29.          */  
  30.         int[][] intArr4 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};  
  31.         for(int i = 0; i < intArr4.length; i++){  
  32.             for(int j = 0; j < intArr4[i].length; j++){  
  33.                 System.out.printf(intArr4[i][j] + " ");  
  34.             }  
  35.             System.out.println();  
  36.         }  
  37.   
  38.         int size = 10;  
  39.         int[][] intArr5 = new int[size][size];  
  40.         System.out.println(intArr5[0][0]); // 0  
  41.   
  42.         String[] stringArr2 = new String[]{"hello", "world", "long", "int", "string", "turn"};  
  43.         /* 
  44.             Arrays.sort 
  45.          */  
  46.         Arrays.sort(stringArr2);  
  47.         for(int i = 0; i < stringArr2.length; i++){  
  48.             System.out.print(stringArr2[i] + " "); // hello int long string turn world  
  49.         }  
  50.         System.out.println();  
  51.   
  52.         System.out.println(Arrays.binarySearch(stringArr2, "turn")); // 4  
  53.         /* 
  54.             Arrays.toString 
  55.          */  
  56.         System.out.println(Arrays.toString(stringArr2)); // [hello, int, long, string, turn, world]  
  57.         /* 
  58.             Arrays.deepToString : 二维数组 
  59.          */  
  60.         System.out.println(Arrays.deepToString(intArr4)); // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]  
  61.         /* 
  62.             Arrays.copyOf : 获得新的数组，并返回，新增加的空间填null 
  63.          */  
  64.         String[] copyStringArr2 = Arrays.copyOf(stringArr2, stringArr2.length * 2);  
  65.         // [hello, int, long, string, turn, world, null, null, null, null, null, null]  
  66.         System.out.println(Arrays.toString(copyStringArr2));  
  67.   
  68.         /* 
  69.             Arrays.fill 
  70.          */  
  71.         String[] stringArr3 = new String[3];  
  72.         Arrays.fill(stringArr3, "no");  
  73.         System.out.println(Arrays.toString(stringArr3)); // [no, no, no]  
  74.     }  
  75. }  

五、类

       因为对象在堆中创建，类的成员变量默认有初始值。而局部变量一般在栈中，必须在操作前明确初始化，否则编译不通过。Java中的类是要加上包名的，构成的全名才是类名（运行时用java 全名）。当有冲突时，用全名就可以了。包之间没有任何关系。类有三个特性：封装、继承、多态。封装最主要体现在权限上，Java中有四种权限：private,default,protected,public。其中修饰类只能是public或者default。private只能在本类可见，default是包权限，protected是包权限+子类权限（子类成员方法可以直接使用，而静态方法中可以通过生成子类的实例来访问，但不可以使用父类实例来访问，见下面代码），public是所有权限。继承的话会继承所有成员，包括私有成员，当然子类可以有和父类同名成员，但是父类的成员会被隐藏。子类可以覆盖父类的方法。多态主要体现在覆盖上。覆盖方法时权限不能缩小，抛出的异常不能增多，子类中的返回值可以是父类返回值的子类型，其他如形参都必须保持一致。多态的实现机制是每个类维护一张方法表，如果有覆盖，则表里的方法被替换掉。具体要看引用指向的类型，这一点非常重要，赋值给的类型只是在操作时有些方法可能不能调用。

5.1测试继承自Object的方法和保护权限

[java] view plain copy
  1. package knowledge2;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-27. 
  5.  */  
  6. public class Worker {  
  7.     private int data;  
  8.     // 测试不同包下的保护权限  
  9.     protected int getData(){  
  10.         return data;  
  11.     }  
  12. }  

[java] view plain copy
  1. package knowledge;  
  2.   
  3. import knowledge2.Worker;  
  4.   
  5. /** 
  6.  * Created by gzx on 16-12-27. 
  7.  */  
  8. public class DefaultClass extends Worker{  
  9.     public int getD(){ // 将方法名改为getData，而方法体改为super.getData()，可以实现权限的扩大。  
  10.         return getData();  
  11.     }  
  12.     // 默认继承Object的hashCode equals toString方法  
  13.     public static void main(String[] args){  
  14.         Worker worker = new Worker();  
  15.         // 下面注释的语句出错：保护属性不能用  
  16.         // worker.getData();  
  17.         Worker dc1 = new DefaultClass();  
  18.         DefaultClass dc2 = new DefaultClass();  
  19.         System.out.printf("%x\n", dc1.hashCode()); // 36baf30c  
  20.         // 不管怎样，引用对应的类型是不会变的，尽管受到所赋予对象能调用方法的限制  
  21.         System.out.println(dc1.equals((DefaultClass)dc1)); // true  
  22.         System.out.println(dc1.equals(dc2)); // false  
  23.         // toString  
  24.         System.out.println(dc1); // [email protected]  
  25.         // 向下转型  
  26.         System.out.println(((DefaultClass)dc1).getD()); // 0  
  27.         // 子类可以使用  
  28.         System.out.println(dc2.getData()); // 0  
  29.     }  
  30. }  

        Object是所有类的超类，也就是所有类都继承Object的方法:equals，toString，hashCode，clone。equals默认是比较变量的地址(实际编程时所有变量的状态相同，就可以认为两个实例相等)。equals相等时，则hashCode必须相等。toString默认返回类名@哈希值。clone是protected权限，必须在子类扩大为public权限，这样才能实现对象拷贝。对于数组整体输出，可以使用Arrays.toString()，但是集合类可以直接输出，这两个都要求具体类覆盖其toString()方法。

[java] view plain copy
  1. public class Object {  
  2.     private static native void registerNatives();  
  3.     static {  
  4.         registerNatives();  
  5.     }  
  6.     public native int hashCode();  
  7.   
  8.     public boolean equals(Object obj) {  
  9.         return (this == obj);  
  10.     }  
  11.     protected native Object clone() throws CloneNotSupportedException;  
  12.   
  13.     public final native Class<?> getClass();  
  14.   
  15.     public String toString() {  
  16.         return getClass().getName() + "@" + Integer.toHexString(hashCode());  
  17.     }  
  18. }  

5.2测试覆盖

[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-29. 
  5.  */  
  6. public class OverrideDemo {  
  7.     public static void main(String[] args){  
  8.   
  9.     }  
  10. }  
  11.   
  12. class Parent1{  
  13.     private int data = 1;  
  14.     protected Parent2 get(Parent2 c){  
  15.         return ;  
  16.     }  
  17. }  
  18. class Child1 extends Parent1{  
  19.     private int data = 2; // 还有继承自父类的属性data，这里不可见  
  20.     // 将参数类型Parent2改为Child2将不是覆盖，而是重载  
  21.     @Override  
  22.     public Child2 get(Parent2 d){  
  23.         return ;  
  24.     }  
  25. }  
  26. class Parent2{  
  27. }  
  28. class Child2 extends Parent2{  
  29. }  

5.3 final关键字

       final修饰的类不能被继承，修饰的方法不能被覆盖。对于全局成员，final必须在定义时初始化，与默认值和static无关。而对于方法中的final，在操作前必须初始化。final修饰的变量只能被赋值一次。final的语义其实就是不可以改变引用的指向，但其指向的对象的状态仍然可以改变。这点与C++的顶层const类似。状态不改变的类称为不可变类。注意两者的区别。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-29. 
  5.  */  
  6. // final类，不可以继承，所有方法均为final  
  7. public final class FinalDemo {  
  8.     // 全局final成员必须初始化  
  9.     private final static int finalData = 1;  
  10.     private int data;  
  11.   
  12.     public void setData(final int data){  
  13.         // 传值时已经初始化了，不可以再改变data  
  14.         // data = 2;  
  15.         this.data = data;  
  16.     }  
  17.     // 不可以覆盖  
  18.     public final int getData(){  
  19.         return data;  
  20.     }  
  21.   
  22.     // 方法中的final局部变量  
  23.     public static void main(String[] args){  
  24.         final int hello;  
  25.        // System.out.println(hello); // 只要不操作hello，就可以不用初始化，与局部变量类似  
  26.         final FinalDemo finalDemo = new FinalDemo();  
  27.         // 只能赋值一次，但可以改变对象的状态  
  28.        // finalDemo = new FinalDemo();  
  29.         int data = 2;  
  30.         finalDemo.setData(data);  
  31.         System.out.println(finalDemo.getData()); // 2  
  32.     }  
  33.   
  34. }  

5.4类的初始化顺序

        有几个原则。静态成员和成员属性一开始都有默认值，如0,false,null，这是在定义初始化之前的。静态成员是类级别的，所以在类加载时就已经初始化了，先定义初始化，然后运行静态块，且只初始化一次。数据成员定义时先初始化，然后才是构造函数。父类先于子类。某个实例是子类的实例，必然是父类的实例，这是instanceof的语义。如果子类覆盖了父类的方法，然后在父类的构造函数中调用，这时调用的是子类的覆盖方法，但是方法中有多个父子都有的同名的数据成员，则使用子类的，方法体在哪个类中，就使用哪个类的属性，即使存在隐藏，且与权限无关。
        初始化的顺序：
        父类静态数据成员
        父类静态块
        静态数据成员
        静态数据块  // 上述四个在类第一次加载时初始化， 且只初始化一次，构造子类实例会自动加载父类静态
        父类数据成员定义时初始化
        父类构造函数 // 如果这时调用了子类的覆盖函数，则由于未初始化，为默认值
        子类数据成员定义时初始化
        子类构造函数
[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-30. 
  5.  */  
  6. public class InitDemo {  
  7.     public static void main(String[] args){  
  8.         Parent parent = new Parent();  
  9.         System.out.println("------------------------------------------------");  
  10.         Parent child = new Child();  
  11.         /* 
  12.                 运行结果： 
  13.                 parent static block staticData = 2 
  14.                 parent constructor data = 1 name = parent name 
  15.                 parent getData name = parent name staticData = 2 
  16.                 1 
  17.                 true 
  18.                 false 
  19.                 ------------------------------------------------ 
  20.                 child static block staticData = 3 
  21.                 parent constructor data = 1 name = parent name 
  22.                 child getData name = null staticData = 3 
  23.                 0 
  24.                 true 
  25.                 true 
  26.                 child constructor data = 2 name = child name 
  27.          */  
  28.     }  
  29. }  
  30. class Parent{  
  31.     private int data = 1;  
  32.     private String name = "parent name";  
  33.     private static int staticData = 2;  
  34.     static {  
  35.         System.out.println("parent static block staticData = " + staticData);  
  36.     }  
  37.     public Parent(){  
  38.         System.out.println("parent constructor data = " + data + " name = " + name);  
  39.         System.out.println(getData()); // 子类引用时，调用的是子类的方法  
  40.         System.out.println(this instanceof Parent);  
  41.         System.out.println(this instanceof Child);  
  42.     }  
  43.     public int getData(){  
  44.         System.out.println("parent getData name = " + name + " staticData = " + staticData);  
  45.         return data;  
  46.     }  
  47. }  
  48. class Child extends Parent{  
  49.     private int data = 2;  
  50.     private String name = "child name";  
  51.     private static int staticData = 3;  
  52.     static {  
  53.         System.out.println("child static block staticData = " + staticData);  
  54.     }  
  55.     public Child(){  
  56.         System.out.println("child constructor data = " + data + " name = " + name);  
  57.     }  
  58.     public int getData(){  
  59.         System.out.println("child getData name = " + name + " staticData = " + staticData);  
  60.         return data;  
  61.     }  
  62. }  

5.5 命令行编译和运行

        javac 中的-d选项用于指定生成的类放在哪个文件夹下，并在该文件夹下生成包目录。如果不指定，则class文件与java源码文件在同一个目录，不会生成包目录。javac和java都有-cp选项。这个选项用于指定class字节码文件的目录（这个目录下有完整的类包目录），或者指定对应的jar库（必须指定到具体的jar，不能只指定到jar所在的目录）。当然，这个选项可以通过设置一个环境变量CLASSPATH替代，对于Linux，分隔符为:。有一个区别，javac会自动查找当前目录，而java则只认定指定的cp选项，没有设置当前目录(.)，则可能会出错。-cp使得在任何目录下都可以运行java程序。javac编译的文件以.java为后缀。java 运行的类必须给出是全名，且有正确的main函数，类是public。
新建两个类：
/home/gzx/test/src/a/A.java
[java] view plain copy
  1. package a;  
  2. import b.B;  
  3. public class A{  
  4.     public static void main(String[] args){  
  5.         new B().print();  
  6.     }  
  7. }  
/home/gzx/test/src/b/B.java : 这个类用到了guava-17.0.jar里面的类
[java] view plain copy
  1. package b;  
  2. import com.google.common.base.Joiner;  
  3. public class B{  
  4.     public void print(){  
  5.         StringBuilder stringBuilder = new StringBuilder("hello");  
  6.             // 字符串连接器，以|为分隔符，同时去掉null元素  
  7.             Joiner joiner1 = Joiner.on("|").skipNulls();  
  8.             // 构成一个字符串foo|bar|baz并添加到stringBuilder  
  9.             stringBuilder = joiner1.appendTo(stringBuilder, "foo", "bar", , "baz");  
  10.             System.out.println(stringBuilder);  
  11.     }  
  12. }  

同时在test目录下新建bin和lib文件夹，将jar包放到lib中，最终test目录结构如下：
java知识网络梳理

5.5.1 逐个文件编译

        由于类A用到了类B(import)，存在依赖关系。这里先生成类B：
[plain] view plain copy
  1. javac -d bin -cp lib/guava-17.0.jar src/b/B.java  
再编译类A：
[plain] view plain copy
  1. javac -d bin  -cp bin src/a/A.java  
结果如下：
java知识网络梳理
在bin目录下生成了完整的类目录结构
运行命令：
[plain] view plain copy
  1. java -cp bin:lib/guava-17.0.jar a.A  
结果：
java知识网络梳理

5.5.2 多个依赖文件同时编译

        也可以同时编译有依赖关系的类
[plain] view plain copy
  1. javac -d bin -cp lib/guava-17.0.jar src/a/A.java src/b/B.java  
运行：
[plain] view plain copy
  1. java -cp bin:lib/guava-17.0.jar a.A  

5.5.3 将jar移动到自动查找的路径

        由于javac和java命令会自动查找jre/lib/ext下的jar包，因而把guava-17.0.jar移动到jre/lib/ext下，则不需要引用这个jar包。不推荐这种方法。
java知识网络梳理

六、抽象类和接口

        抽象类，主要是类中有实现不了的抽象方法，加abstract，不用写出方法体。或者所有方法都实现了，还可以添加abstract关键字，形成抽象类，希望被扩展。接口有public接口和default接口，成员属性默认全部是public final static，方法全部是public。接口主要是使得实现类符合某一规范，如要进行排序，则必须实现Comparable接口，或者提供Comparator比较器。有些接口没有任何内容，称为标记接口。接口之间可以存在继承关系，用extends，表示扩展一个接口。不实现抽象方法或者接口的方法，则还是抽象类。抽象类不可以实例化，但可以用匿名类实例化。

[java] view plain copy
  1. public interface Comparable<T> {  
  2.     public int compareTo(T o);  
  3. }  
  4. public interface Comparator<T> {  
  5.     int compare(T o1, T o2);  
  6. }  

        上面是两个常用的易混淆的接口。通常第一个是在类实现时实现的，作为类的默认排序方式。但由于一个类可能有多种排序标准，故可以在排序时提供比较器。两个接口待实现的方法原型也不一样。第一个有To，加上this，仅仅需要一个参数，第二个要两个参数。Comparator的实现者通常又称为函数对象，因为里面只有函数，没有任何成员属性。

[java] view plain copy
  1. public interface Cloneable {  
  2. }  

        要实现对象的拷贝，则必须实现Clonable接口，这是个标记接口，不然调用clone时会抛出异常。同时我们需要覆盖Object类的clone()方法，且由于该方法是protected，我们必须将其权限扩大为public，这样才能在其他包下使用。在覆盖方法中直接调用super.clone()就可以了，这种拷贝默认是浅拷贝，即直接复制所有成员。如果是不可变类或者成员属性都是原始类型则没事，但如果有引用类型的成员属性，则需要对这些引用类型分别调用其clone()方法，实现深度拷贝，从而得到两个独立的副本。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-27. 
  5.  */  
  6. // 必须实现cloneable标记接口，否则clone时会抛出异常  
  7. public class CloneDemo implements Cloneable{  
  8.     private int data;  
  9.     private int next;  
  10.     public CloneDemo(){  
  11.         data = 1;  
  12.         next = 2;  
  13.     }  
  14.   
  15.     void setData(int data){  
  16.         this.data = data;  
  17.     }  
  18.     void setNext(int next){  
  19.         this.next = next;  
  20.     }  
  21.     @Override  
  22.     public String toString(){  
  23.         return "data = " + data + " next = " + next;  
  24.     }  
  25.   
  26.     // 重载Object的方法，权限扩大为public，并调用父类的clone方法，如果有引用，则要一一clone  
  27.     @Override  
  28.     public Object clone() throws CloneNotSupportedException{  
  29.         return super.clone();  
  30.     }  
  31.   
  32.     public static void main(String[] args){  
  33.         CloneDemo cloneDemo = new CloneDemo();  
  34.         CloneDemo cloneDemo2 = ;  
  35.         try {  
  36.             cloneDemo2 = (CloneDemo)cloneDemo.clone();  
  37.         } catch (CloneNotSupportedException e) {  
  38.             e.printStackTrace();  
  39.         }  
  40.         System.out.println(cloneDemo == cloneDemo2); // false  
  41.         cloneDemo2.setData(2);  
  42.         System.out.println(cloneDemo); // data = 1 next = 2  
  43.         System.out.println(cloneDemo2); // data = 2 next = 2  
  44.     }  
  45. }  


[java] view plain copy
  1. import java.io.*;  
  2. import java.util.HashMap;  
  3. import java.util.Map;  
  4.   
  5. /** 
  6.  * Created by jessin on 17-2-26. 
  7.  */  
  8. abstract class AbstractLineProcessor {  
  9.     protected abstract void processLine(String line);  
  10.     public abstract int getAns();  
  11.     public void processFile(String filename){  
  12.         BufferedReader bf = ;  
  13.         try {  
  14.              bf = new BufferedReader(new FileReader(filename));  
  15.             String line = ;  
  16.             while((line = bf.readLine()) != ){  
  17.                 processLine(line);  
  18.             }  
  19.         } catch (IOException e) {  
  20.             e.printStackTrace();  
  21.         }  
  22.         finally{  
  23.             if(bf != ){  
  24.                 try {  
  25.                     bf.close();  
  26.                 } catch (IOException e) {  
  27.                     e.printStackTrace();  
  28.                 }  
  29.             }  
  30.         }  
  31.     }  
  32. }  
  33. class NumberLineProcessor extends AbstractLineProcessor{  
  34.     private int ans;  
  35.     protected void processLine(String line) {  
  36.         for(char aChar : line.toCharArray()){  
  37.             if(Character.isDigit(aChar)){  
  38.                 ans++;  
  39.             }  
  40.         }  
  41.     }  
  42.   
  43.     public int getAns() {  
  44.         return ans;  
  45.     }  
  46. }  
  47.   
  48. class LetterLineProcessor extends AbstractLineProcessor{  
  49.     private int ans;  
  50.     protected void processLine(String line) {  
  51.         for(char aChar : line.toCharArray()){  
  52.             if(aChar >= 'a' && aChar <= 'z' || aChar >= 'A' && aChar <= 'Z'){  
  53.                 ans++;  
  54.             }  
  55.         }  
  56.     }  
  57.   
  58.     public int getAns() {  
  59.         return ans;  
  60.     }  
  61. }  
  62. public class Main{  
  63.     public static void main(String[] args){  
  64.         final Map<String, AbstractLineProcessor> map = new HashMap<String, AbstractLineProcessor>();  
  65.         map.put("number", new NumberLineProcessor());  
  66.         map.put("letter", new LetterLineProcessor());  
  67.   
  68.         // 匿名内部类，实现对一行进行所有的行处理，最后得到结果  
  69.         AbstractLineProcessor all = new AbstractLineProcessor(){  
  70.   
  71.             protected void processLine(String line) {  
  72.                 for(AbstractLineProcessor lineProcessor : map.values()){  
  73.                     lineProcessor.processLine(line);  
  74.                 }  
  75.             }  
  76.   
  77.             public int getAns() {  
  78.                 return 0;  
  79.             }  
  80.         };  
  81.         all.processFile("hello.txt");  
  82.         for(AbstractLineProcessor lineProcessor : map.values()){  
  83.             System.out.println(lineProcessor.getAns());  
  84.         }  
  85.     }  
  86. }  

七、内部类

        除了静态内部类以外，内部类可以访问外部类的成员属性，与其权限无关。这也是编译器的杰作。编译器会把外部类作为内部类的构造函数的一个参数，并在内部类的实例化处传递外部类的this，这样内部类内部会有这个this的final成员属性。

7.1全局内部类

        全局内部类编译后得到一个叫做外部类名$内部类名的文件。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. import java.awt.event.ActionEvent;  
  4. import java.awt.event.ActionListener;  
  5. import java.util.Date;  
  6. import javax.swing.Timer;  
  7.   
  8. /** 
  9.  * Created by gzx on 16-12-27. 
  10.  */  
  11. public class TalkingClock {  
  12.     private int interval;  
  13.     private boolean beep;  
  14.     public TalkingClock(int interval, boolean beep){  
  15.         this.interval = interval;  
  16.         this.beep = beep;  
  17.     }  
  18.     public void start(){  
  19.         ActionListener printer = new TimePrinter();  
  20.         Timer timer = new Timer(interval, printer);  
  21.         timer.start();  
  22.     }  
  23.       
  24.     public class TimePrinter implements ActionListener {  
  25.         // 内部类可以直接使用外部类的属性beep  
  26.         @Override  
  27.         public void actionPerformed(ActionEvent e) {  
  28.             // 这里其实是TalkingClock.this.beep  
  29.             if(!beep){  
  30.                 return;  
  31.             }  
  32.             // this 出现在这里，则是TimePrinter的实例  
  33.             Date now = new Date();  
  34.             System.out.println("time : " + now);  
  35.         }  
  36.     }  
  37.   
  38.     /* 
  39.         每隔一秒，打印出日期，无限循环 
  40.         time : Thu Dec 29 14:36:35 CST 2016 
  41.         time : Thu Dec 29 14:36:36 CST 2016 
  42.         time : Thu Dec 29 14:36:37 CST 2016 
  43.      */  
  44.     public static void main(String[] args){  
  45.         new TalkingClock(1000, true).start();  
  46.         while(true){  
  47.         }  
  48.     }  
  49. }  

7.2局部内部类

         局部内部类定义在方法中，包含匿名内部类。这里有一个约束，也就是方法中的局部变量被局部内部类访问时，一般要用final修饰，因为方法结束后局部变量也被释放掉了，内部类中会有该属性。如果不用final修饰，则方法体中不能出现任何改变变量的方法，否则编译出错。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. import javax.swing.*;  
  4. import java.awt.event.ActionEvent;  
  5. import java.awt.event.ActionListener;  
  6. import java.util.Date;  
  7.   
  8. /** 
  9.  * Created by gzx on 16-12-27. 
  10.  */  
  11. public class TalkingClock2 {  
  12.     // 局部类不能改变beep  
  13.     public void start(int interval, boolean beep){  
  14.         Timer timer = ;  
  15.         // 类必须放在前面，否则下面语句会提示找不到类  
  16.         class TimerPrinter implements ActionListener {  
  17.             @Override  
  18.             public void actionPerformed(ActionEvent e) {  
  19.                 if(!beep){  
  20.                     return;  
  21.                 }  
  22.                 // 出错  
  23.                 // beep = false;  
  24.                 System.out.println("time : " + new Date());  
  25.             }  
  26.         }  
  27.         // 出错  
  28.         //beep = true;  
  29.         timer = new Timer(interval, new TimerPrinter());  
  30.         timer.start();  
  31.     }  
  32.   
  33.     public static void main(String[] args){  
  34.         new TalkingClock2().start(1000, true);  
  35.         while(true){}  
  36.     }  
  37. }  

7.3匿名内部类

        匿名内部类，没有类名，不能有构造函数，且必须将实参在实现时给出，只能有一个实例，类似Lambda表达式，闭包。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. import javax.swing.*;  
  4. import java.awt.event.ActionEvent;  
  5. import java.awt.event.ActionListener;  
  6. import java.util.Date;  
  7. import java.util.HashSet;  
  8. import java.util.Hashtable;  
  9. import java.util.TreeSet;  
  10.   
  11. /** 
  12.  * Created by gzx on 16-12-27. 
  13.  */  
  14. public class TalkingClock3 {  
  15.     public void start(int interval, boolean beep){  
  16.         Timer timer = ;  
  17.         // 匿名内部类，这里不需要出现类名，同时不能有构造函数。对于接口，用默认的无参构造函数。对于抽象类，可以是带实参的构造函数，且在()里面提供  
  18.         // 出错  
  19.         //beep = true;  
  20.         timer = new Timer(interval, new  ActionListener(){  
  21.                                     @Override  
  22.                                     public void actionPerformed(ActionEvent e) {  
  23.                                         if(!beep){  
  24.                                             return;  
  25.                                         }  
  26.                                         // 出错  
  27.                                         // beep = false;  
  28.                                         System.out.println("time : " + new Date());  
  29.                                     }  
  30.                                 }  
  31.         );  
  32.         timer.start();  
  33.     }  
  34.     public static void main(String[] args){  
  35.         new TalkingClock3().start(1000, true);  
  36.         while(true){}  
  37.     }  
  38. }  

7.4静态内部类

         静态内部类，没有外部类实例的this，不能访问任何外部类非静态成员或方法。静态内部类的好处是可以避免与其他类命名冲突。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-27. 
  5.  */  
  6. public class StaticClassDemo {  
  7.     public static Pair minmax(double[] data){  
  8.         double min = Double.MAX_VALUE;  
  9.         double max = Double.MIN_VALUE;  
  10.         for(double tmp : data){  
  11.             if(min > tmp){  
  12.                 min = tmp;  
  13.             }  
  14.             else if(max < tmp){  
  15.                 max = tmp;  
  16.             }  
  17.         }  
  18.         return new Pair(min, max);  
  19.     }  
  20.       
  21.     // 静态内部类不能访问实例属性，没有外部类实例的this  
  22.     public static class Pair{  
  23.         private double min, max;  
  24.         public Pair(double min, double max){  
  25.             this.min = min;  
  26.             this.max = max;  
  27.         }  
  28.         public double getMin() {  
  29.             return min;  
  30.         }  
  31.         public double getMax() {  
  32.             return max;  
  33.         }  
  34.     }  
  35.       
  36.     public static void main(String[] args){  
  37.         double[] data = {10, 1324.12, 2134.11, -132.32};  
  38.         StaticClassDemo.Pair pair = StaticClassDemo.minmax(data);  
  39.         System.out.println(pair.getMin());  
  40.         System.out.println(pair.getMax());  
  41.     }  
  42. }  

八、异常体系

        所有异常都是Throwable(不是接口，也不是抽象类，是普通类，可以直接使用)的子类，有两个派系：Error和Exception。Exception可以分为RuntimeException和IOException。Error一般是系统级别的错误，这种错误是我们无法解决的，而RuntimeException是程序的逻辑错误，一般是可以解决的，例如数组越界，空指针，错误类型转换等，这类错误我们无需显式处理。RuntimeException和Error称为未检查异常，而其他异常称为检查异常。

        可以使用throw new Exception(message)抛出异常。当一个方法抛出检查异常时，如果当前方法可以解决，用try-catch-finally捕获。否则使用throws向其他调用者继续抛出。未检查异常可以不用做任何处理，直接抛出。

[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-29. 
  5.  */  
  6. public class ExceptionDemo {  
  7.     // 运行时异常（继承RuntimeException）不用处理  
  8.     public static void main(String[] args){  
  9.         throw new NullPointerException("just test"); // 直接抛出异常  
  10.     }  
  11. }  

九、泛型

        泛型类似C++中的模板。但是Java中的泛型是在编译器层面实现的，在虚拟机中不管具体的参数如何，都只有一个对应的类，参数会被擦掉，变成Object。泛型分为泛型类和泛型方法。泛型类在类名后加<T>，而对于泛型方法则在返回类型前加<T>。

泛型类：

[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-27. 
  5.  */  
  6. // 泛型类  
  7. public class GenericDemo<T> {  
  8.     private T first;  
  9.     private T second;  
  10.   
  11.     public T getFirst() {  
  12.         return first;  
  13.     }  
  14.   
  15.     public void setFirst(T first) {  
  16.         this.first = first;  
  17.     }  
  18.   
  19.     public T getSecond() {  
  20.         return second;  
  21.     }  
  22.   
  23.     @Override  
  24.     public String toString() {  
  25.         return "GenericDemo{" +  
  26.                 "first=" + first +  
  27.                 ", second=" + second +  
  28.                 '}';  
  29.     }  
  30.   
  31.     public void setSecond(T second) {  
  32.         this.second = second;  
  33.     }  
  34.   
  35.     public static void main(String[] args){  
  36.         GenericDemo<Integer> pair = new GenericDemo<Integer>(); // 后面尖括号的类型可以去掉，类型自动推导  
  37.         pair.setFirst(100);  
  38.         pair.setSecond(100);  
  39.         System.out.println(pair); // GenericDemo{first=100, second=100}  
  40.     }  
  41. }  
泛型方法：
[java] view plain copy
  1. package knowledge;  
  2.   
  3. /** 
  4.  * Created by gzx on 16-12-27. 
  5.  */  
  6. public class MethodDemo {  
  7.     public <T> T getData(T data){  
  8.         return data;  
  9.     }  
  10.     public static void main(String[] args){  
  11.         // 自动推导类型  
  12.         System.out.println(new MethodDemo().getData(10)); // 10  
  13.     }  
  14. }  

? extends classA表示classA或classA的子类

? super classA表示classA或classA的父类

对于某些函数，对于泛型参数有一些约束，如

public static<T extends Comparable<? super T> > T min(T[] data)

表示T必须实现Comparable<K>接口，且K是T的父类。也就是父类K implements Comparable<K>，然后T extends K，从而T extends Comparable<K>

而且对于有关系的子类subclass和父类superclass，ArrayList<subclass>和ArrayList<superclass>没有任何关系，不能赋值。但是List<subclass>= ArrayList<subclass>是成立的。

十、集合框架

        集合主要有两大派系：Collection和Map。其中Collection包含List、Queue、Set。List包含ArrayList和LinkedList，有序集合。Queue包含PriorityQueue，有序集合。Set包含HashSet和TreeSet，无序集合。Collection实现了Iterable接口。用add/get(index)添加元素，用set(index,value)设置元素，用remove删除元素。而Map包含HashMap和TreeMap。集合体系提供了接口和抽象类，抽象类主要给类库扩展者使用，而接口提供给用户使用。遍历Collection可以用iterator方法，返回Iterator接口的实例，或者for each。而Map使用put和get添加获取值，一般使用keySet和entrySet方法遍历，进而获得key-value。

        LinkedList用链表实现的。ArrayList用动态数组实现的，当达到一定程度时，会重新分配新的数组，并拷贝旧的数组值。HashSet/HashMap使用拉链法实现，底层是数组头加链表实现，使用hashCode映射到对应的数组（应当尽量减少碰撞，减少链表的长度）。TreeSet/TreeMap使用红黑树实现，是一种高效的排序树状结构。PriorityQueue使用堆实现，默认是小根堆。如果不要求有序则使用Hash更加高效。哈希要注意对象的hashCode和equals方法，而排序要注意实现Comparable接口，或者提供Comparator比较器。

        所有的集合类都直接保存引用，无论从集合处（内部）还是从数组处（外部）改变集合中对象的状态都将引起变化，因为引用是一样的，其结果对于集合的语义而言是不可预知的。所以不要改变集合中对象的状态，尽量用匿名构造，这样就不会有问题。但可以整体替换对象，把对象看成一个原子。

        Collections提供了一些算法和集合的常用操作：

        Collections.sort(list)：主要对List类型进行排序，可以指定比较器

        Collections.binarySearch(list, key, comparrator)：二分查找元素

        Collections.copy(list to, list from) : 复制列表

        Collections.min(colleciton, comparator)

Collections.max(colleciton, comparator)

        除此之外，还有早期的位于上述架构之外的集合，如Vector，HashTable，Properties，Stack等集合。Vector和HashTable都进行了同步。如果是单线程，用ArrayList等会更高效。

[java] view plain copy
  1. public interface Collection<E> extends Iterable<E> {  
  2.     int size();  
  3.     boolean isEmpty();  
  4.     boolean contains(Object o);  
  5.     Iterator<E> iterator();  
  6.     Object[] toArray();  
  7.     <T> T[] toArray(T[] a);  
  8.     boolean add(E e);  
  9.     boolean remove(Object o);  
  10.     boolean addAll(Collection<? extends E> c);  
  11.     boolean removeAll(Collection<?> c);  
  12.     void clear();  
  13. }  

[java] view plain copy
  1. public interface Map<K,V> {  
  2.     int size();  
  3.     boolean isEmpty();  
  4.     boolean containsKey(Object key);  
  5.     boolean containsValue(Object value);  
  6.     V get(Object key);  
  7.     V put(K key, V value);  
  8.     V remove(Object key);  
  9.     void putAll(Map<? extends K, ? extends V> m);  
  10.     void clear();  
  11.     Set<K> keySet();  
  12.     Collection<V> values();  
  13.     Set<Map.Entry<K, V>> entrySet();  
  14. }  

        显然Collection和Map所拥有的方法是不一样的，如add对应put，contians对应containsKey和containsValue，iterator对应keySet和entrySet。

[java] view plain copy
  1. package knowledge;  
  2. import java.util.*;  
  3.   
  4. /** 
  5.  * Created by gzx on 16-12-28. 
  6.  */  
  7. public class CollectionDemo {  
  8.     public static void main(String[] args){  
  9.         /* 
  10.             所有集合初始化 
  11.          */  
  12.         ArrayList<Person> arrayList = new ArrayList<Person>();  
  13.         LinkedList<Person> linkedList = new LinkedList<Person>();  
  14.         PriorityQueue<Person> pq = new PriorityQueue();  
  15.         HashMap<Person, Integer> hashMap = new HashMap<Person, Integer>();  
  16.         TreeMap<Person, Integer> treeMap = new TreeMap<Person, Integer>();  
  17.         HashSet<Person> hashSet = new HashSet<Person>();  
  18.         TreeSet<Person> treeSet = new TreeSet<Person>();  
  19.   
  20.         /* 
  21.             测试数据 
  22.          */  
  23.         Person[] persons = {  
  24.                 new Person("B13080128", "gzx", 23, "2013"),  
  25.                 new Person("B13080127", "qqy", 23, "2013"),  
  26.                 new Person("B13080129", "lcq", 24, "2013"),  
  27.                 new Person("B13080126", "gjj", 23, "2013"),  
  28.                 new Person("B13080130", "xt", 23, "2013")  
  29.         };  
  30.         int[] scores = {88, 76, 99, 92, 70};  
  31.   
  32.         for(int i = 0; i < persons.length; i++){  
  33.             arrayList.add(persons[i]);  
  34.             linkedList.add(persons[i]);  
  35.   
  36.             // 添加到队尾，满时返回false  
  37.             boolean flag = pq.offer(persons[i]);  
  38.             if(!flag){  
  39.                 System.out.println("full");  
  40.             }  
  41.   
  42.             hashMap.put(persons[i], scores[i]);  
  43.             treeMap.put(persons[i], scores[i]);  
  44.             hashSet.add(persons[i]);  
  45.             treeSet.add(persons[i]);  
  46.         }  
  47.         /* 
  48.          所有的集合类都直接使用引用，从集合处还是从数组处改变集合中对象的状态将引起变化， 
  49.          其结果对于集合的语义而言是不可预知的，所以不要改变集合中对象的状态 
  50.          可以整体替换对象 
  51.           */  
  52.        // persons[1].setId("Number0");  
  53.   
  54.         /* 
  55.             ArrayList 
  56.          */  
  57.         System.out.println("ArrayList");  
  58.         arrayList.remove(0);  
  59.         // 数组访问不能越界 抛出IndexOutOfBoundsException  
  60.         // System.out.println(arrayList.get(5));  
  61.         Iterator<Person> arrayListIterator = arrayList.iterator();  
  62.         // 检查当前指针是否有元素，开始时指向第一个元素  
  63.         while(arrayListIterator.hasNext()){  
  64.             // 输出当前指针指向的元素，并移动到下一个元素  
  65.             System.out.println(arrayListIterator.next());  
  66.             /* 
  67.                   Person{id='B13080127', name='qqy', age=23, grade='2013'} 
  68.                   Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  69.                   Person{id='B13080126', name='gjj', age=23, grade='2013'} 
  70.                   Person{id='B13080130', name='xt', age=23, grade='2013'} 
  71.              */  
  72.         }  
  73.         System.out.println("sort arraylist");  
  74.         // collections.sort(list)：专门用来对list进行排序  
  75.         Collections.sort(arrayList);  
  76.         for(Person p : arrayList){  
  77.             System.out.println(p);  
  78.             /* 
  79.                 Person{id='B13080126', name='gjj', age=23, grade='2013'} 
  80.                 Person{id='B13080127', name='qqy', age=23, grade='2013'} 
  81.                 Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  82.                 Person{id='B13080130', name='xt', age=23, grade='2013'} 
  83.              */  
  84.         }  
  85.         /* 
  86.             链表 LinkedList：操作对应的iteartor能够起变化 
  87.          */  
  88.         System.out.println("LinkedList");  
  89.         Iterator<Person> linkedListIterator = linkedList.listIterator();  
  90.         // 指向第二项  
  91.         linkedListIterator.next();  
  92.         // 指向第三项  
  93.         linkedListIterator.next();  
  94.         // 删除当前指针的前一项，即第二项  
  95.         linkedListIterator.remove();  
  96.         for(Person person : linkedList){  
  97.             System.out.println(person);  
  98.             /* 
  99.                     Person{id='B13080126', name='gjj', age=23, grade='2013'} 
  100.                     Person{id='B13080128', name='gzx', age=23, grade='2013'} 
  101.                     Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  102.                     Person{id='B13080130', name='xt', age=23, grade='2013'} 
  103.              */  
  104.         }  
  105.         // equals  
  106.         Person p1 = new Person("B13080133", "xt", 23, "2013");  
  107.         System.out.println(linkedList.contains(p1)); // true  
  108.         System.out.println("sort linkedlist");  
  109.         Collections.sort(linkedList);  
  110.         for(Person p : linkedList){  
  111.             System.out.println(p);  
  112.             /* 
  113.                 Person{id='B13080126', name='gjj', age=23, grade='2013'} 
  114.                 Person{id='B13080127', name='qqy', age=23, grade='2013'} 
  115.                 Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  116.                 Person{id='B13080130', name='xt', age=23, grade='2013'} 
  117.              */  
  118.         }  
  119.   
  120.         /* 
  121.             PriorityQueue : 底层用queue数组实现，contains使用equals比较 
  122.          */  
  123.         System.out.println("PriorityQueue");  
  124.         // 两个方法为空时，都返回null  
  125.         // 获得队头元素并删除  
  126.         System.out.println(pq.poll()); // Person{id='B13080126', name='gjj', age=23, grade='2013'}  
  127.         // 获得队头元素，不删除  
  128.         System.out.println(pq.peek()); // Person{id='B13080127', name='qqy', age=23, grade='2013'}  
  129.         try {  
  130.             Person tmp = (Person)persons[0].clone();  
  131.             tmp.setId("setId");  
  132.             // 用equals()比较  
  133.             // tmp.setAge(13);  
  134.             System.out.println(pq.contains(tmp)); // true  
  135.             // 按照compare(To)排序，允许有相等的元素  
  136.             pq.offer(tmp);  
  137.             while(!pq.isEmpty()){  
  138.                 System.out.println(pq.poll());  
  139.                 /* 
  140.                     Person{id='B13080127', name='qqy', age=23, grade='2013'} 
  141.                     Person{id='B13080128', name='gzx', age=23, grade='2013'} 
  142.                     Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  143.                     Person{id='B13080130', name='xt', age=23, grade='2013'} 
  144.                     Person{id='setId', name='gzx', age=23, grade='2013'} 
  145.                  */  
  146.             }  
  147.         } catch (CloneNotSupportedException e) {  
  148.             e.printStackTrace();  
  149.         }  
  150.   
  151.         /* 
  152.             HashMap：看hashCode和equals起作用的数据成员，以此来判重 
  153.          */  
  154.         System.out.println("HashMap");  
  155.         try {  
  156.             Person tmp = (Person)persons[0].clone();  
  157.             tmp.setId("newId");  
  158.             // 键不替换，覆盖值，因为哈希值与ID无关  
  159.             hashMap.put(tmp, 59);  
  160.             Set<Map.Entry<Person, Integer> > keyValue = hashMap.entrySet();  
  161.             for(Map.Entry<Person, Integer> it : keyValue){  
  162.                 System.out.println(it.getKey() + " : " + it.getValue());  
  163.                 //it.getKey().setAge(1000);  
  164.                 /* 
  165.                     Person{id='B13080128', name='gzx', age=23, grade='2013'} : 59 
  166.                     Person{id='B13080127', name='qqy', age=23, grade='2013'} : 76 
  167.                     Person{id='B13080130', name='xt', age=23, grade='2013'} : 70 
  168.                     Person{id='B13080129', name='lcq', age=24, grade='2013'} : 99 
  169.                     Person{id='B13080126', name='gjj', age=23, grade='2013'} : 92 
  170.                  */  
  171.             }  
  172.         } catch (CloneNotSupportedException e) {  
  173.             e.printStackTrace();  
  174.         }  
  175.   
  176.         /* 
  177.                TreeMap：看比较器Comparable(Comparator)中的数据成员，以此来去重 
  178.          */  
  179.         System.out.println("TreeMap");  
  180.         try {  
  181.             Person tmp = (Person)persons[0].clone();  
  182.             tmp.setName("kitty");  
  183.             // 键不替换，覆盖，只和ID有关，不管名字是否其变化  
  184.             treeMap.put(tmp, 100);  
  185.             // 改变已经存在的实例的键，结果不可知，下面注释去掉将出现部分值为null  
  186.             // persons[0].setId("AAAA");  
  187.             for(Person person : treeMap.keySet()){  
  188.                 System.out.println(person + " : " + treeMap.get(person));  
  189.                 /* 
  190.                     Person{id='B13080126', name='gjj', age=23, grade='2013'} : 92 
  191.                     Person{id='B13080127', name='qqy', age=23, grade='2013'} : 76 
  192.                     Person{id='B13080128', name='gzx', age=23, grade='2013'} : 100 
  193.                     Person{id='B13080129', name='lcq', age=24, grade='2013'} : 99 
  194.                     Person{id='B13080130', name='xt', age=23, grade='2013'} : 70 
  195.                  */  
  196.             }  
  197.         } catch (CloneNotSupportedException e) {  
  198.             e.printStackTrace();  
  199.         }  
  200.   
  201.         /* 
  202.             HashSet/TreeSet 有两种遍历方法：for each 和 iterator 
  203.             分别与HashMap和TreeMap去重方法类型 
  204.          */  
  205.         System.out.println("HashSet");  
  206.         Iterator<Person> it2 = hashSet.iterator();  
  207.         while(it2.hasNext()){  
  208.             System.out.println(it2.next());  
  209.             /* 
  210.                 Person{id='B13080128', name='gzx', age=23, grade='2013'} 
  211.                 Person{id='B13080127', name='qqy', age=23, grade='2013'} 
  212.                 Person{id='B13080130', name='xt', age=23, grade='2013'} 
  213.                 Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  214.                 Person{id='B13080126', name='gjj', age=23, grade='2013'} 
  215.              */  
  216.         }  
  217.   
  218.         try {  
  219.             Person tmp = (Person)persons[0].clone();  
  220.             tmp.setId("changeId");  
  221.             System.out.println(hashSet.contains(tmp)); // true  
  222.             hashSet.remove(tmp);  
  223.             System.out.println(hashSet.contains(persons[0])); // false  
  224.             Iterator<Person> it3 = hashSet.iterator();  
  225.             while(it3.hasNext()){  
  226.                 System.out.println(it3.next());  
  227.                 /* 
  228.                     Person{id='B13080127', name='qqy', age=23, grade='2013'} 
  229.                     Person{id='B13080130', name='xt', age=23, grade='2013'} 
  230.                     Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  231.                     Person{id='B13080126', name='gjj', age=23, grade='2013'} 
  232.                  */  
  233.             }  
  234.         } catch (CloneNotSupportedException e) {  
  235.             e.printStackTrace();  
  236.         }  
  237.   
  238.         /* 
  239.             TreeSet 
  240.          */  
  241.         System.out.println("TreeSet");  
  242.         Iterator<Person> it4 = treeSet.iterator();  
  243.         for(Person p : treeSet){  
  244.             System.out.println(p);  
  245.             /* 
  246.                 Person{id='B13080126', name='gjj', age=23, grade='2013'} 
  247.                 Person{id='B13080127', name='qqy', age=23, grade='2013'} 
  248.                 Person{id='B13080128', name='gzx', age=23, grade='2013'} 
  249.                 Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  250.                 Person{id='B13080130', name='xt', age=23, grade='2013'} 
  251.              */  
  252.         }  
  253.         try {  
  254.             Person tmp = (Person)persons[0].clone();  
  255.             tmp.setAge(50);  
  256.             // 如果改变ID，则不会被删除掉  
  257.            // tmp.setId("newId");  
  258.             System.out.println(treeSet.contains(tmp)); // true  
  259.             treeSet.remove(tmp);  
  260.             System.out.println(treeSet.contains(persons[0])); // false  
  261.             Iterator<Person> it5 = treeSet.iterator();  
  262.             while(it5.hasNext()){  
  263.                 System.out.println(it5.next());  
  264.                 /* 
  265.                     Person{id='B13080126', name='gjj', age=23, grade='2013'} 
  266.                     Person{id='B13080127', name='qqy', age=23, grade='2013'} 
  267.                     Person{id='B13080129', name='lcq', age=24, grade='2013'} 
  268.                     Person{id='B13080130', name='xt', age=23, grade='2013'} 
  269.                  */  
  270.             }  
  271.         } catch (CloneNotSupportedException e) {  
  272.             e.printStackTrace();  
  273.         }  
  274.     }  
  275. }  
  276. class Person implements Comparable<Person>, Cloneable{  
  277.     private String id;  
  278.     private String name;  
  279.     private int age;  
  280.     private String grade;  
  281.   
  282.     public Person(String id, String name, int age, String grade){  
  283.         this.id = id;  
  284.         this.name = name;  
  285.         this.age = age;  
  286.         this.grade = grade;  
  287.     }  
  288.   
  289.     public String getId() {  
  290.         return id;  
  291.     }  
  292.   
  293.     public void setId(String id) {  
  294.         this.id = id;  
  295.     }  
  296.   
  297.     public String getName() {  
  298.         return name;  
  299.     }  
  300.   
  301.     public void setName(String name) {  
  302.         this.name = name;  
  303.     }  
  304.   
  305.     public int getAge() {  
  306.         return age;  
  307.     }  
  308.   
  309.     public void setAge(int age) {  
  310.         this.age = age;  
  311.     }  
  312.   
  313.     public String getGrade() {  
  314.         return grade;  
  315.     }  
  316.   
  317.     public void setGrade(String grade) {  
  318.         this.grade = grade;  
  319.     }  
  320.   
  321.     @Override  
  322.     public Object clone() throws CloneNotSupportedException {  
  323.         return super.clone();  
  324.     }  
  325.   
  326.     // equals 和 hashCode要保持一致  
  327.     // 不比较id  
  328.     @Override  
  329.     public boolean equals(Object o) {  
  330.         if(o == ){  
  331.             return false;  
  332.         }  
  333.         if (this == o) return true;  
  334.         if (!(o instanceof Person)) return false;  
  335.   
  336.         Person person = (Person) o;  
  337.         return Objects.equals(name, person.name) && Objects.equals(age, person.age) && Objects.equals(grade, person.grade);  
  338.     }  
  339.   
  340.     @Override  
  341.     public int hashCode() {  
  342.         // Object...  
  343.         int result = Objects.hash(name, age, grade);  
  344.         return result;  
  345.     }  
  346.   
  347.     // 只比较id  
  348.     @Override  
  349.     public int compareTo(Person o) {  
  350.         return id.compareTo(o.id);  
  351.     }  
  352.   
  353.     @Override  
  354.     public String toString() {  
  355.         return "Person{" +  
  356.                 "id='" + id + '\'' +  
  357.                 ", name='" + name + '\'' +  
  358.                 ", age=" + age +  
  359.                 ", grade='" + grade + '\'' +  
  360.                 '}';  
  361.     }  
  362. }  

        从上述例子可以看出，TreeSet和TreeMap去重的关键是看比较器的compare方法，影响contains或者containsKey的结果。而HashSet和HashMap去重主要看equals方法。其他集合包含某元素看equals。实现这些方法时注意选好相关属性。建议查看源码的相关方法。注意equals为true时，hashCode必须相等。

十一、多线程

        未完待续。。。


相关推荐