Java集合框架（包装类、泛型）

前言：

        本篇文章我们来讲解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);

总结：

        本篇作者其实有些敷衍，并没有考虑到小白，可以说这是一篇笔记，但是相信对于一些人还是有帮助的，也希望各位体谅。