前言：
本篇文章我们来讲解Java中的集合框架，就相当于车轮子。Java是面向对象的语言，所以相对于C语言有自身优势，就比如现成的数据结构（比如栈，队列，堆等）。Java的集合框架大家也不用想的很难，其实也就是这些内容。
在了解集合框架之前，还需要一些预备知识，比如泛型（当然本篇文章是基础泛型讲解，对于初学者绝对够用），包装类等。
集合框架：
Java集合框架Java Collection Framework，又称容器container，是定义在java.util包下的一组几口interfaces和其实现类classes。
这张图说明了Java中类与类，类与接口之间的关系。这只是部分重要常见的类。
我们可以看出，都是通过接口和类来使用的， 重要的有4个接口：List、Queue、Set、Map。其他类都是实现了这个接口。
这里我们都来粗略的了解一下都是些什么：Stack是栈，ArrayList底层是动态链表（顺序表），LinkedList底层是双向链表（队列），PriorityQueue底层是优先队列，TreeSet、TreeMap底层是红黑树，HashSet、HashMap底层是哈希表（数组+链表+红黑树）。
Set是集合，是一个接口。
包装类：
包装类：在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。
几乎所有类型对应的包装类都是首字母大写就是其包装类，有两个例外：int对应包装类为Integer；char对应包装类为Character。
拆箱和装箱：
装箱和拆箱也叫装包和拆包。
public static void main(String[] args) {
Integer a = 10;//装包
int i = 99;
Integer b = i;//也叫装包
//基本类型转换为 包装类型
System.out.println(a);
System.out.println(b);
} 我们执行完以后打开out目录并输入cmd，使用编辑模式观察。
此时我们就进入源码来观察。 点击Integer，并搜索valueOf。
装箱也分为自动装箱和显示装箱。
public static void main(String[] args) {
Integer a = 10;//装包 自动装箱
int i = 99;
Integer b = i;//也叫装包
//基本类型转换为 包装类型
System.out.println(a);
System.out.println(b);
Integer aa = Integer.valueOf(10);//显示装箱
}
我们再来举个例子：
public static void main(String[] args) {
Integer a= 10;//装箱
int i = a; //拆箱
System.out.println(i);
int aa = a.intValue();//显示拆箱
}此时我们再观察以下代码：
public static void main(String[] args) { Integer a = 100; Integer b = 100; System.out.println(a == b); Integer a1 = 200; Integer b1 = 200; System.out.println(a1 == b1); }两个都是包装类型，那么你肯定感觉结果都是为：true。
但是并不是，我们执行发现结果如下：
这个结果很奇怪，我们只能进入源码观察。发现是low <= i <= high，所以我们要观察这两个值。
所以high是127，low是-128。所以当我们的 i 在{-128,127}是不会新建对象的，而不在这个范围就会新建，而且直接比较对象是比较地址的，新建的话就会产生新的地址，从而不相等。
泛型：
泛型是一种语法。学过C语言的应该都知道（希望都学过，原谅作者但不影响阅读），我们可以定义数组，但是数组一定要明确里面存放的是什么类型的数据。比如我们创建一个栈（其实也就是数组），但是我们每次都要实现一个栈，必须明确这个栈里面存放的是什么类型的数据，这就很麻烦，于是Java中就引入了泛型的定义。
这里，请允许我举一个例子：比如此时我们引出一个类，类中包含一个数组成员，是的数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。
class MyArray {
public Object[] array = new Object[10];
public void setValue(int pos, Object val) {
array[pos] = val;
}
public Object getValue(int pos) {
return array[pos];
}
}
public class Test2 {
public static void main(String[] args) {
MyArray myArray = new MyArray();
//此时就可以存放任何数据类型了
myArray.setValue(0,10);
myArray.setValue(1,"hello");
String str = (String)myArray.getValue(1);
//此时我们知道下标 1 放的是 String 类型
}
}你可以把这个理解为泛型的雏形，因为你确实可以这样写，但是我们一眼就可以发现问题：这个弊端很大，我们要知道每一个下标放的是什么，但是自己写的自己知道，给别人就会迷糊。
所以我们引入了泛型，使用<>来指定存放的什么类型。比如：
此时我们还是要借助Object类：
//<T> 当前类 是一个泛型类 它只是一个占位符
class MyArray<T> {
//public T[] array = new T[10];
public Object[] array = new Object[10];
public void setValue(int pos, T val) {
array[pos] = val;
}
public T getValue(int pos) {
return (T)array[pos];
}
}
public class Test2 {
public static void main(String[] args) {
MyArray<Integer> myArray = new MyArray<Integer>();
myArray.setValue(0,10);
myArray.setValue(1,20);
int a = myArray.getValue(1);//不用进行强制类型转换
System.out.println(a);
MyArray<String> myArray1 = new MyArray<String >();
myArray1.setValue(0,"abcd");
myArray1.setValue(1,"efg");
String ret = myArray1.getValue(1);
System.out.println(ret);
}
}
我们就知道该使用Object时还是要使用，但是泛型还是方便了我们的使用，防止我们出错。此时我们也就明白了包装类的意义，因为我们不能直接传入整形。
MyArray<Integer> myArray = new MyArray<>();//此时就可以省略后面的泛型
myArray.setValue(0,10);
myArray.setValue(1,20);
int a = myArray.getValue(1);//不用进行强制类型转换
System.out.println(a);我们不能new泛型的对象(new T)。在编译时期泛型是存在的，当程序运行起来到JVM后，就没有泛型的概念了。
泛型在编译的时候如何编译？使用过擦除机制，擦除成了Object。Java中不允许直接返回泛型数组。
泛型注意事项：
class MyArray <T> {
public T[] ts1 = new T[2];//这样写不被允许
public T[] ts2 = (T[]) new Object[2];
}
当返回的是一个泛型的数组时，还是需要借助Object类来完成。
尖括号里面必须放引用类型。
<T extends Number>：
//T 一定是 Number 的子类
class TestGeneric<T extends Number> {
}
public class Test {
public static void main(String[] args) {
TestGeneric<Number> testGeneric1 = new TestGeneric<>();
TestGeneric<Integer> testGeneric2 = new TestGeneric<>();
TestGeneric<Double> testGeneric3 = new TestGeneric<>();
TestGeneric<String> testGeneric4 = new TestGeneric<>();
}
}泛型的上界， 泛型是没有下界的。
练习题：
写一个泛型类，求一个数组中的最大值。T一定是引用类型，最终被擦除为了Object类型。而Object类型没有实现Comparable接口。
class Alg<T> {
public T findMaxValue(T[] array) {
T max = array[0];
for (int i = 1; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
}
}
return max;
}
}
报错是因为我们没有指定一个类型作比较。 T类型一定是可以比较的，问题是怎么能够约束这个T一定是可以比较大小的？
class Alg<T extends Comparable<T>>这句不是说T继承Comparable，而是说将来指定传入的类一定实现了Comparable接口。
class Alg<T extends Comparable<T>> {
public T findMaxValue(T[] array) {
T max = array[0];
for (int i = 1; i < array.length; i++) {
if (max.compareTo(array[i]) < 0) {
max = array[i];
}
}
return max;
}
}
public class Test {
public static void main(String[] args) {
Alg<Integer> alg = new Alg<>();
Integer[] integers = {1, 2, 3, 4, 5, 6};
Integer ret = alg.findMaxValue(integers);
System.out.println(ret);
}
}包装类Integer实现了这个接口，所以我们可以传入整形数组。 传入数组是因为使用泛型本身就是要使用引用类型。
泛型方法：
class Alg2 {
public <T extends Comparable<T>> T findMaxValue(T[] array) {
T max = array[0];
for (int i = 1; i < array.length; i++) {
if (max.compareTo(array[i]) < 0) {
max = array[i];
}
}
return max;
}
}
public class Test {
public static void main(String[] args) {
Alg2 alg2 = new Alg2();
Integer[] integers = {1, 2, 3, 4, 5, 6};
Integer ret = alg2.findMaxValue(integers);
System.out.println(ret);//6
}
}此时发生了类型推导，根据实参传值，来推导此时的类型。也可以写上去：
Integer ret = alg2.<Integer>findMaxValue(integers);总结：
本篇作者其实有些敷衍，并没有考虑到小白，可以说这是一篇笔记，但是相信对于一些人还是有帮助的，也希望各位体谅。
