什么是泛型

  1. public class ArrayList<T> {
  2.     private T[] array;
  3.     private int size;
  4.     public void add(T e) {...}
  5.     public void remove(int index) {...}
  6.     public T get(int index) {...}
  7. }
  9. // T可以是任何class
  11. // 创建可以存储String的ArrayList:
  12. ArrayList<String> strList = new ArrayList<String>();
  13. // 创建可以存储Float的ArrayList:
  14. ArrayList<Float> floatList = new ArrayList<Float>();
  15. // 创建可以存储Person的ArrayList:
  16. ArrayList<Person> personList = new ArrayList<Person>();
  18. // 总结
  20. /*
  21. 泛型就是编写模板代码来适应任意类型；
  23. 泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查；
  25. 注意泛型的继承关系：可以把ArrayList<Integer>向上转型为List<Integer>（T不能变！），但不能把ArrayList<Integer>向上转型为ArrayList<Number>（T不能变成父类）。
  26. */

使用泛型

  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  4. // 使用泛型
  5. public class Main {
  6.     public static void main(String[] args) {
  7.         ArrayList<String> list = new ArrayList<String>();
  8.         list.add("hello");
  9.         list.add("world");
  11.         String first = list.get(0);
  12.         String second = list.get(1);
  14.         System.out.println(first + second);
  16.     }
  17. }
  19. public class Main {
  20.     public static void main(String[] args) {
  21.         ArrayList<Number> list = new ArrayList<>();
  22.         list.add(new Integer(123));
  23.         list.add(new Double(123.12));
  25.         Number first = list.get(0);
  26.         Number second = list.get(1);
  28.         System.out.println(first);
  29.         System.out.println(second);
  31.     }
  32. }
  34. // ArrayList<Number> list = new ArrayList<>();后面的<>里面的Number可以省略，会自动识别出Number
  37. // 泛型接口
  38. public class Main{
  39.     public static void main(String[] args) {
  40.         String[] ss = new String[]{"xiaoshuai","shaoshuai","shuai"};
  41.         Arrays.sort(ss);
  42.         System.out.println(Arrays.toString(ss));
  43.     }
  44. }
  45. // String本身已经实现了Comparable<String>接口，所以可以进行排序
  48. // 换成我们自定义的Person类型就需要写Comparable<Person>接口
  49. public class Main{
  50.     public static void main(String[] args) {
  51.         Person[] ps = new Person[]{
  52.             new Person("shuai",99),
  53.             new Person("shaoshuai",88),
  54.             new Person("xiaoshuai",77),
  55.         };
  56.         Arrays.sort(ps);
  57.         System.out.println(Arrays.toString(ps));
  58.     }
  59. }
  61. class Person implements Comparable<Person>{
  62.     String name;
  63.     int score;
  65.     Person(String name, int score){
  66.         this.name = name;
  67.         this.score = score;
  68.     }
  70.     public int compareTo(Person other){
  71.         return this.name.compareTo(other.name);
  72.     }
  74.     public String toString(){
  75.         return this.name + "," + this.score;
  76.     }
  77. }