还是那句话，学习某个知识一定要想想为什么要学它，这方面的知识用来解决什么问题的，怎么用，并且要总结的体系化，不能散的到处都是，方便以后查看博客。
今天参考廖雪峰老师官网学习并总结下泛型廖老师官网
在讲解什么是泛型之前，我们先观察Java标准库提供的ArrayList，它可以看作“可变长度”的数组，因为用起来比数组更方便。
实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”：
public class ArrayList {
private Object[] array;
private int size;
public void add(Object e) {...}
public void remove(int index) {...}
public Object get(int index) {...}
}
如果用上述ArrayList存储String类型，会有这么几个缺点：
取出时需要强制转型(如(String),这样写)；
不方便，易出错。
例如，代码必须这么写：
ArrayList list = new ArrayList();
list.add("Hello");
// 获取到Object，必须强制转型为String:
String first = (String) list.get(0);
很容易出现ClassCastException，因为容易“误转型”：
list.add(new Integer(123));
// ERROR: ClassCastException:
String second = (String) list.get(1);
要解决上述问题，我们可以为String单独编写一种ArrayList：
public class StringArrayList {
private String[] array;
private int size;
public void add(String e) {...}
public void remove(int index) {...}
public String get(int index) {...}
}
这样一来，存入的必须是String，取出的也一定是String，不需要强制转型，因为编译器会强制检查放入的类型：
StringArrayList list = new StringArrayList();
list.add("Hello");
String first = list.get(0);
// 编译错误: 不允许放入非String类型:
list.add(new Integer(123));
问题暂时解决。
然而，新的问题是，如果要存储Integer，还需要为Integer单独编写一种ArrayList：
public class IntegerArrayList {
private Integer[] array;
private int size;
public void add(Integer e) {...}
public void remove(int index) {...}
public Integer get(int index) {...}
}
实际上，还需要为其他所有class单独编写一种ArrayList：
为了解决新的问题，我们必须把ArrayList变成一种模板：ArrayList
public class ArrayList<T> {
private T[] array;
private int size;
public void add(T e) {...}
public void remove(int index) {...}
public T get(int index) {...}
}
T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：
// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();
因此，泛型就是定义一种模板，例如ArrayList
ArrayList<String> strList = new ArrayList<String>();
由编译器针对类型作检查：
strList.add("hello"); // OK
String s = strList.get(0); // OK
strList.add(new Integer(123)); // compile error!
Integer n = strList.get(0); // compile error!
这样一来，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。
在Java标准库中的ArrayList
public class ArrayList<T> implements List<T> {
...
}
List<String> list = new ArrayList<String>();
//List引用指向了ArrayList这个子类对象，故称为向上转型
即类型ArrayList
要特别注意：不能把ArrayList
这是为什么呢？假设ArrayList
// 创建ArrayList<Integer>类型：
ArrayList<Integer> integerList = new ArrayList<Integer>();
// 添加一个Integer：
integerList.add(new Integer(123));
// “向上转型”为ArrayList<Number>：
ArrayList<Number> numberList = integerList;
// 添加一个Float，因为Float也是Number：
numberList.add(new Float(12.34));
// 从ArrayList<Integer>获取索引为1的元素（即添加的Float）：
Integer n = integerList.get(1); // ClassCastException!
我们把一个ArrayList
实际上，编译器为了避免这种错误，根本就不允许把ArrayList
ArrayList
同时思考下，廖老师并没有讲的向下转型，我想只要大家懂了向上转型。向下转型自然就理解了，也是不可以的。
泛型就是编写模板代码来适应任意类型；
泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查，将运行期的异常提前到了编译期，并避免了强制转换的出现，同时提高了代码的复用性；
注意泛型的继承关系：可以把ArrayList
再来一张图嘿嘿，黑马的，总结的不错也，定义更好，形参和实参方面去理解下再：
使用ArrayList时，如果不定义泛型类型时，泛型类型实际上就是Object，即你虽然支持写泛型，但是我就是不用现在：
// 编译器警告:
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = (String) list.get(0);
String second = (String) list.get(1);
此时，只能把
当我们定义泛型类型
// 无编译器警告:
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
// 无强制转型:
String first = list.get(0);
String second = list.get(1);
当我们定义泛型类型
List<Number> list = new ArrayList<Number>();
list.add(new Integer(123));
list.add(new Double(12.34));
Number first = list.get(0);
Number second = list.get(1);
编译器如果能自动推断出泛型类型，就可以省略后面的泛型类型，jdk1.7以后就支持了。例如，对于下面的代码：
List<Number> list = new ArrayList<Number>();
编译器看到泛型类型List
// 可以省略后面的Number，编译器可以自动推断泛型类型：
List<Number> list = new ArrayList<>();
除了ArrayList
public interface Comparable<T> {
/**
* 返回负数: 当前实例比参数o小
* 返回0: 当前实例与参数o相等
* 返回正数: 当前实例比参数o大
*/
int compareTo(T o);
}
可以直接对String数组进行排序：
// sort
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
String[] ss = new String[] { "Orange", "Apple", "Pear" };
Arrays.sort(ss);
System.out.println(Arrays.toString(ss));
}
}
运行结果：[Apple, Orange, Pear]
这是因为String本身已经实现了Comparable
// sort
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Person[] ps = new Person[] {
new Person("Bob", 61),
new Person("Alice", 88),
new Person("Lily", 75),
};
Arrays.sort(ps);
System.out.println(Arrays.toString(ps));
}
}
class Person {
String name;
int score;
Person(String name, int score) {
this.name = name;
this.score = score;
}
public String toString() {
return this.name + "," + this.score;
}
}
运行程序，我们会得到ClassCastException，即无法将Person转型为Comparable。我们修改代码，让Person实现Comparable
异常信息：Exception in thread "main" java.lang.ClassCastException: class Person cannot be cast to class java.lang.Comparable (Person is in unnamed module of loader com.sun.tools.javac.launcher.Main$MemoryClassLoader @52e677af;
// sort
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Person[] ps = new Person[] {
new Person("Bob", 61),
new Person("Alice", 88),
new Person("Lily", 75),
};
Arrays.sort(ps);
System.out.println(Arrays.toString(ps));
}
}
class Person implements Comparable<Person> {
String name;
int score;
Person(String name, int score) {
this.name = name;
this.score = score;
}
public int compareTo(Person other) {
return this.name.compareTo(other.name);
}
public String toString() {
return this.name + "," + this.score;
}
}
运行结果：[Alice,88, Bob,61, Lily,75]
运行上述代码，可以正确实现按name进行排序。
也可以修改比较逻辑，例如，按score从高到低排序。请自行修改测试。
使用泛型时，把泛型参数
可以省略编译器能自动推断出的类型，例如：List
不指定泛型参数类型时，编译器会给出警告，且只能将
可以在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型。
补充:如果对Java 中 Comparable 和 Comparator 还不太了解，可以看下此博客，写的很不错，Comparable 是针对单独一个类使其支持排序，Comparator为
原文：https://www.cnblogs.com/lovelywcc/p/13917383.html