ArrayList

ArrayList

Class ArrayList

表示泛型，泛型简单来说就是装入集合中的所有元素全部是统一的什么类型，而且泛型只能是引用类型，不能是基本类型。

有关泛型的定义和使用可阅读 ：java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一

在图形化理解Java中的形参和实参中我们知道Java中八大基本数据类型，同样也知道了它们各自的取值范围和默认的初始值。那么既然有基本数据类型使用，为什么还要使用包装类呢？Java是一门面向对象的编程语言，而基本数据类型并不具备面向对象的特点，因此包装类的引入是为了让基本类型具有对象的特点；另一方面包装类也方便了泛型的使用。

例如：如果希望向ArrayList当中存储基本数据类型，必须使用基本数据类型对应的包装类：

例如Integer在ArrayList中的使用如下所示：

import java.util.ArrayList;
public class ArrayListTest1 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        System.out.println(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

装箱和拆箱：基本数据类型和包装类型之间的相互转换

• 装箱：基本类型 -> 包装类型

  • 构造方法，以Integer为例，主要有如下两个构造方法：

    • Integer(int value)：构造新的Integer对象用于表示指定的int值，已过时
    • Integer(String s)：构造新的Integer对象用于表示指定的同String表示int值，已过时

  • 静态方法：

    • static Integer valueOf(int i)
    • static Integer valueOf(String s)

• 拆箱：包装类型 -> 基本数据类型

  • int intValue()
  • 其他类型原理类似

```java package IntegerClass;

public class IntegerMain { public static void main(String[] args) { // 构造方法 Integer i = new Integer(24); System.out.println(i); // 24

    Integer i1 = new Integer("24");
    System.out.println(i1);  // 24
    // 静态方法
    Integer i2 = Integer.valueOf(24);
    Integer i3 = Integer.valueOf("24");
    System.out.println(i2); // 24
    System.out.println(i3); // 24
    // 拆箱
    int number= i.intValue();
    System.out.println(number);  // 24
}

}

基本数据类型和包装类之间的自动转换就称为自动装箱和自动拆箱：

- 
自动装箱：基本类型 ---> 包装类型
```java
public class Test {
    public static void main(String[] args) {
        // 自动装箱
        int number = 8;
        Integer x = new Integer(number);
        System.out.println(x);  // 8
        System.out.println(x.getClass());  // class java.lang.Integer
    }
}

如上所示，我们首先定义一个int型的变量并赋值8，然后new一个Integer对象并将number传入，通过输入可以看出：x的值和number的值相等，并且此时x的类就是int对应的包装类Integer。其他基本类型数据到对应包装类的转换同理，都可以通过自动装箱实现。

• 自动拆箱：包装类型 —-> 基本类型

  public class Test {
    public static void main(String[] args) {
        // 自动拆箱
        Integer y = new Integer(24);
        System.out.println(y);
        System.out.println(y.getClass());
        int n = y;
        System.out.println(n);
  
    }
  }
  

自动拆箱流程和上面的自动装箱相逆，即将包装类转换为对应的基本数据类型。

以Integer为例，自动装箱机制是调用了Integer的valueOf()实现：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

而自动拆箱调用intValue方法实现：

public int intValue() {
    return value;
}

基本数据类型和包装类的区别：

• 基本类型不能使用new关键字来创建，而包装类作为类处理，那么包装类型必须使用new关键字来创建
• 存储的位置不同，基本类型存储在栈区，包装类型存储在堆区
• 初始值不同。基本类型中的int初始值为0，boolean初始值为false。包装类型初始值都为null。因此在进行自动装拆箱时一定要避免空指针异常
• 使用场景不同，基本类型主要用于计算和赋值，包装类型用于泛型
• 基本类型是值传递，包装类型是引用传递

Java基本数据类型及其包装类型

ArrayList是一个其容量能够动态增长的动态数组，但又和数组不一样，它继承了AbstractList，实现了List、RandomAccess, Cloneable, java.io.Serializable。

常用方法：**

• boolean add(E e){}：向集合中添加元素，参数类型和泛型一致。ArrayList的添加操作一定成功，故返回值可选择使用，其他类型类型不一定成功
• E get(int index){}：从集合中获取元素，参数是索引编号，返回值就是对应位置元素
• E remove(int index){}：从集合中删除元素，参数是索引编号，返回值就是要被删掉的元素
• int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        // 右侧的<>中可以不写内容但必须有
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list); // []

        // add(E e)
        list.add("Forlogen");
        boolean k = list.add("Kobe");
        System.out.println(list); // [Forlogen, Kobe]

        // size()
        System.out.println(list.size()); // 2

        // get(int index)
        System.out.println(list.get(0)); // Forlogen

        // 遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        for(String ele: list){
            System.out.println(ele);
        }

        // remove(int index)
        list.remove(0);
        System.out.println(list); // [Kobe]

        //remove(object 0)
        list.remove("Kobe");
        System.out.println(list); // []

    }
}

• void clear()：移除list中的所有元素
• boolean isEmpty()：判断list是否为空
• boolean contains()：判断元素是否存在
• object [] toArray()：将内容放入数组中
• void sort(Comparator<? super E> c)：升序排列

package collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Random;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Forlogen");
        boolean k = list.add("Kobe");
        System.out.println(list); // [Forlogen, Kobe]

        // contains
        System.out.println(list.contains("Kobe"));  // true
        System.out.println(list.contains("James")); // false

        // isEmpty
        System.out.println(list.isEmpty()); // false

        // toArray
        Object [] array = list.toArray();
        System.out.println(array); // java.lang.Object;@1b6d3586

        // clear
        list.clear();
        System.out.println(list); // []

        // sort
        ArrayList<Integer> list1 = new ArrayList<>();
        Random r = new Random(1);
        for (int i = 0; i < 5; i++) {
            list1.add(r.nextInt(10));
        }
        System.out.println(list1); // [5, 8, 7, 3, 4]

        Collections.sort(list1);
        System.out.println(list1); // [3, 4, 5, 7, 8]

    }
}