        int i = 10;
        //装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
        //①
        Integer ii = Integer.valueOf(i);
        //②
        Integer ij = new Integer(i);

        //拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
        int j = ii.intValue();
        int jj = ij.intValue();

可以看到，在使用包装类时装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，java 提供了自动机制。

包装类的自动装箱(autoboxing)和自动拆箱(autounboxing)

        int i = 10;
        Integer ii = i;	// 自动装箱
        Integer ij = (Integer)i;// 自动装箱
        int j = ii;	// 自动拆箱
        int k = (int)ii;	// 自动拆箱

List类的自动装箱拆箱

        List<Integer>list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        int sum = 0;
        for (int i:list) {
            sum += i;
        }
        System.out.println(sum);

我们通过反编译方便观察：

自动装箱、拆箱的陷阱

自动装箱没有想象中的那么难，但也没有那么简单，看下面这段代码：

        Integer a = 1;
        Integer b = 2;
        Integer c = 2;
        Integer d = 128;
        Integer e = 128;
        Integer f = 129;
        System.out.println(a==b);
        System.out.println(b==c);
        System.out.println(d==e);
        System.out.println(e==f);

结果：

因为自动装箱使我们没有注意到装箱方法valueOf的范围，容易犯错。

我们可以看到valueOf如果给定的值再[-128,127]之间是直接返回一个缓存数组里的对象，如果超出这个范围则会重写new一个对象，而我们知道new对象，那么引用是会改变的，所以造成了结果不同。

List的使用

因为List是一个接口，还是不能直接new一个对象，因此我们借用底下的实现类来使用，继续使用ArrayList吧。

基本方法：

我们注意到ArrayList有三种构造方法，分别使用看看：

        //无参构造
        List<Integer>list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        System.out.println(list1);

        //初始容量构造
        List<Integer>list2 = new ArrayList<>(20);
        list2.add(1);
        list2.add(2);
        list2.add(3);
        System.out.println(list2);

        //其他集合构造
        List<Integer>list3 = new ArrayList<>(list2);
        System.out.println(list3);

第三种泛型集合的返回值如果不知道可以戳这：泛型上下边界符。

ArrayList的五种遍历方式：

        //五种遍历方式
        List<Integer>list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        //底层重写了toString方法实现了遍历
        //①
        System.out.println(list1);
        //②
        System.out.println("======for循环遍历============");
        for (int i = 0; i < list1.size(); i++) {
            System.out.print(list1.get(i)+" ");
        }
        System.out.println();
        //③
        System.out.println("========for-each循环遍历===========");
        for (int i: list1) {
            System.out.print(i + " ");
        }
        //④
        System.out.println();
        System.out.println("========迭代器打印=======");
        Iterator<Integer>it = list1.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
        System.out.println("========List迭代器打印=======");
        ListIterator<Integer> it1 = list1.listIterator();
        while(it1.hasNext()){
            System.out.print(it1.next()+" ");
        }

上面的方法就不一一演示了。

我们前面讲了ArrayList的三种构造方法，其中有一种是没有初始容量，另一种是有初始容量的，但问题是他们都能插入元素，这又得从源码角度分析：

如果ArrayList调用不带参数的构造方法，那么顺序表的大小是0，当第一次add的时候，整个顺序表才变为了10，而不是默认容量是10，当10放满了，开始1.5倍扩容。

iterator 和 Listiterator

两种迭代器接口的方法：可以逐一去试试，这里就不多说了，接口这么多，只需记住几个常用的就ok。

iterator 和 Listiterator两种接口有些方法我们可以使用，但要注意：

当我们在迭代的同时删除元素时，首先需要使用next方法迭代出集合中的元素，然后才能调用remove方法，否则集合可能会因为对同一个Iterator remove了多次而造成这个异常。

我们这样写后才不会报错，有点类似于java的scanner必须接收掉一行空格一样，不然会造成下一行输入变成空。

这样我们里面的东西删完了，第二次迭代器打印就为空。

add方法：

发现它插入的位置是it移动的下一位。

简单模拟ArrayList

模拟集中ArrayList里的方法

import java.util.Arrays;

public class MyArrayList<E> {
    private E[]element;
    public static int usedSize;

    public MyArrayList(){
        //不推荐这种写法，现在只是简单模拟一下
        this.element = (E[]) new Object[10];
    }

    public void add(E e){//增添元素
        if(isFull()){
            this.element = Arrays.copyOf(element,element.length * 2);//2倍扩容
        }
        this.element[usedSize] = e;
        usedSize++;
    }
    public boolean isEmpty(){
        return usedSize > element.length;
    }
    public boolean isFull(){
        return usedSize == element.length;
    }
    public void remove(int index){//删除第n个元素
        if(index < 0 || index > usedSize)return;
        for(int i = index; i < usedSize; i++){
            element[i - 1] = element[i];
        }
        if(usedSize > 0) {
            usedSize--;
        }
    }

    public E search(int index){//查找第n个元素值
        if(index < 0 || index > usedSize){
            return null;
        }
        return element[index];
    }


    public String toString() {//重写toString方法
        StringBuilder stringBuilder = new StringBuilder("[");
        for (int i = 0; i < usedSize - 1; i++) {
            stringBuilder.append(element[i]);
            stringBuilder.append(",");
        }
        stringBuilder.append(element[usedSize-1]);
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

测试：

   public static void main(String[] args) {
        MyArrayList<Integer>list1 = new MyArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        System.out.println(list1);
        list1.remove(1);
        System.out.println(list1);
        list1.remove(2);
        list1.remove(3);
        list1.remove(4);
        list1.remove(5);
        System.out.println(usedSize);
        list1.remove(1);
        System.out.println(list1);
        System.out.println(list1.search(3));
    }

结果：

熟练ArrayList-斗牛扑克牌

事先说明只能看牌，玩牌的逻辑还没有写，后续可能会出。写好玩牌逻辑后就是一个斗地主或者另外的扑克牌游戏。

public class Card {//牌类
    public String suit;//花色
    public String rank;//点数

    public Card(String suit, String rank) {
        this.suit = suit;
        this.rank = rank;
    }

    @Override
    public String toString() {
        return "[" + suit + ":" + rank+"]";
    }
}

import demo2.Card;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

public class Test {
    static String suit[] = {"♠","♥","♣","♦"};
    static String rank[] = {"1","2","3","4","5","6","7","8","9","10","J","Q","K"};
    //没有大小王
    //牌为 1,2,3,4,5,6，……J,Q,K
    public static void buyCard(List<Card>list){//买牌
        for(int i = 0; i < 4; i++){
            for (int j = 0; j < 13; j++) {
                Card card = new Card(suit[i],rank[j]);
                list.add(i,card);
            }
        }
        System.out.println("买来的牌"+list);
    }

    public static void swap(List<Card>list,int i ,int j){//洗牌交换顺序
        Card tmp = list.get(i);
        list.set(i,list.get(j));
        list.set(j,tmp);
    }

    public static void shuffle(List<Card>list){//洗牌
        //著名 的 洗牌代码，可以去搜搜，这里改长了点
        int size = list.size();
        Random random = new Random();
        for(int i = size - 1; i > 0; i--){
            int j = random.nextInt(i);
            swap(list,i,j);
        }
        System.out.println("洗好的牌" + list);
    }
    //三个人轮流发五张牌
    public static void lookCard(List<Card>list){//看牌
        List<List<Card>>list1 = new ArrayList<>();
        List<Card>list2 = new ArrayList<>();
        List<Card>list3 = new ArrayList<>();
        List<Card>list4 = new ArrayList<>();
        list1.add(list2);
        list1.add(list3);
        list1.add(list4);
        for(int i = 0; i < 5; i++){
            for (int j = 0; j < 3; j++){
                list1.get(j).add(list.remove(0));
            }
        }
        System.out.println("第1个人的牌"+list1.get(0));
        System.out.println("第2个人的牌"+list1.get(1));
        System.out.println("第3个人的牌"+list1.get(2));
    }

    public static void play(){
        List<Card>list = new ArrayList<>();
        buyCard(list);
        shuffle(list);
        int i = 1;
        while(list.size() > 15) {
            System.out.println("============第"+i+"局的牌=============");
            lookCard(list);
            i++;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        boolean game[] = {true,false};
        while(true){
            System.out.println("是否要进行斗牛游戏:0>是 1>否");
            int i = scanner.nextInt();
            if(game[i]){
                play();
            }else{
                break;
            }
        }
    }
}

测试：