java集合框架笔记(2)ArrayList

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

利用get()、add()、set()、remove()实现 增删改查操作，配合size()获取数组大小辅助遍历。

java中有两种数据类型：基本类型和引用类型。泛型一般使用的是引用类型。
基本类型有8个：
整数类型 byte、short、int、long
浮点数类型 float、double
字符型 char
布尔类型 boolean
引用类型包括三种：
类 Class
接口 Interface
数组 Array

在java中，8种基本类型在java中都有对应的封装类型，也就是引用类型：
整数类型 Byte、Short、Integer、Long
浮点数类型 Float、Double
字符型 Character
布尔类型 Boolean

有时候我们会看到这样的语句 Integer num = 3;Boolean b = true;这样定义也能行得通，其实这里面有一个自动装箱的问题，即java自动把 3 这个字面常量封装成了Integer对象，同理也有自动拆箱。

利用 Collections.sort() 对继承了 Collections 类的对象进行排序（A-Z,1-9） 默认升序。

public class Test03 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(9);
        list.add(1);

        Collections.sort(list);
        for (Integer i : list) {
            System.out.println(i);
        }
    }
}

1
2
9

removeAll() 和 clear() 方法功能都是一样都。但是 clear() 方法的比 removeAll() 更常被用到，因为 clear() 比 removeAll() 更快，更高效。

没有找到 removeRange() …

lambda 表达式可以作为参数传入函数，格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

以下是lambda表达式的重要特征:

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

package test;

import java.sql.Types;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @Description: TODO
 * @author: HardyDragon
 * @date: 2021年06月07日 15:37
 */
public class Test03 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        ArrayList<Integer> list2 = new ArrayList<Integer>();

        list.add(2);
        list.add(9);
        list.add(1);

        System.out.println("addAll()----------------");

        list2.addAll(list);
        for (Integer i : list2) {
            System.out.println(i);
        }

        System.out.println("clear()----------------");

        list2.clear();
        System.out.println("list2.size = " + list2.size());

        System.out.println("clone()----------------");

        ArrayList<Integer> clone = (ArrayList<Integer>) list.clone();

        for (Integer i : clone) {
            System.out.println(i);
        }

        if (list.contains(2)) {
            System.out.println("list contains 2");
        } else {
            System.out.println("list not contains 2");
        }

        System.out.println("2 index = " + list.indexOf(2));

        clone.removeAll(clone);
        System.out.println("After clone.removeAll(clone); clone.size() = " + clone.size());

        if (clone.isEmpty()) {
            System.out.println("list is empty.");
        } else {
            System.out.println("list isn't empty.");
        }

        List<Integer> subList = list.subList(0, 1);
        for (Integer i : subList) {
            System.out.println("subList:" + i);
        }

        Object[] toArray = list.toArray();
        for (Object o : toArray) {
            System.out.println("Object[]=" + o);
        }

        System.out.println("After add 2");
        list.add(2);
        for (Integer i : list) {
            System.out.println(i);
        }
        System.out.println("lastIndexOf(2) = " + list.lastIndexOf(2));

        System.out.println("retain()--------------------");
        ArrayList<Integer> list3 = new ArrayList<Integer>();
        list3 = (ArrayList<Integer>) list.clone();

        list.set(0, 89);
        list.set(1, 77);
        for (Integer i : list) {
            System.out.println("list:" + i);
        }
        System.out.println("____________________________");
        list.retainAll(list3);
        System.out.println("retain 保留两个列表重复的元素。");
        for (Integer i : list3) {
            System.out.println("list3:" + i);
        }
        System.out.println("___________________________");
        for (Integer i : list) {
            System.out.println("list:" + i);
        }

        System.out.println("replaceAll()----------------");
        System.out.println("对每个元素+10");
        list3.replaceAll(integer -> integer + 10);
        for (Integer i : list3) {
            System.out.println("list3:" + i);
        }

        System.out.println("removeIf()----------------");
        list3.removeIf(integer -> integer == 12 || integer == 11);
        for (Integer i : list3) {
            System.out.println("list3:" + i);
        }

        System.out.println("foreach()----------------");
        list3.add(1);
        list3.add(2);
        // lambda 表达式 作为参数
        list3.forEach(integer -> {
            integer = integer * 10;
            System.out.println(integer);
        });


    }
}

result:

addAll()----------------
2
9
1
clear()----------------
list2.size = 0
clone()----------------
2
9
1
list contains 2
2 index = 0
After clone.removeAll(clone); clone.size() = 0
list is empty.
subList:2
Object[]=2
Object[]=9
Object[]=1
After add 2
2
9
1
2
lastIndexOf(2) = 3
retain()--------------------
list:89
list:77
list:1
list:2
____________________________
retain 保留两个列表重复的元素。
list3:2
list3:9
list3:1
list3:2
___________________________
list:1
list:2
replaceAll()----------------
对每个元素+10
list3:12
list3:19
list3:11
list3:12
removeIf()----------------
list3:19
foreach()----------------
190
10
20