Java List 常用操作记录

记录常用的List(ArrayList)操作， 包括

(1) 创建ArrayList
(2) List之间赋值
(3) 增
(4) 删
(5) 改
(6) 查
(7) 切片
(8) List合并
(9) 排序
(10) 去重
(11) 长度和判断是否为空
(12) 元素清除， 清空
(13) 统计List的最大值， 最小值， 均值， 和
(14) 返回对应值得元素
(15) 判断是否包含某元素
(16) List判断是否相等
(17) 循环
(18) 流操作
(19) List转字符串
(20) List转Array

创建ArrayList

// 创建List(ArrayList)
    public static void createList() {
        List<Integer> a = new ArrayList<>();
        a.add(1);
        a.add(2);
        System.out.println(a);

        List<Integer> b = new ArrayList<Integer>() {
            {
                add(1);
                add(2);
            }
        };
        System.out.println(b);

        List<Integer> c = Arrays.asList(1, 2, 3, 4);
        System.out.println(c);

        List<Integer> d = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        System.out.println(d);
    }

List之间赋值

// List之间的赋值
    public static void assignTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        List<Integer> b = new ArrayList<>(a);
        System.out.println(b);
        List<Integer> c = new ArrayList<>();
        c.addAll(a);
        System.out.println(c);
    }

增加元素

// 增加元素
    public static void addTest() {
        List<Integer> a = new ArrayList<>();
        a.add(1);
        a.addAll(Arrays.asList(2, 3, 4));
        System.out.println(a);
        a.add(0, 9);
        System.out.println(a);
    }

删除元素

// 删除元素
    public static void removeTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 4));
        a.remove(1);
        System.out.println(a);
        // removeALl中的元素会删除， 重复的也会删除
        a.removeAll(Arrays.asList(3, 4));
        System.out.println(a);  // [1]
    }

修改元素

// 修改
    public static void alterTest() {
        // Arrays.asList不可以add和remove， 但是可以set修改
        List<Integer> a = Arrays.asList(1, 2, 3);
        a.set(2, 9);
        System.out.println(a);
    }

查找元素

// 查
    public static void getTest() {
        List<Integer> a = Arrays.asList(1, 2, 3);
        int b = a.get(1);
        System.out.println(b);
    }

切片

// 切片
    public static void sliceTest() {
        List<Integer> a = Arrays.asList(1, 2, 3, 4);
        List<Integer> b = a.subList(1, 3);
        System.out.println(b);  // [2, 3]
        List<Integer> c = a.subList(1, a.size());
        System.out.println(c);  // [2, 3, 4]
        a.set(2, 6);
        System.out.println(b);  // [2, 6], subList返回是愿列表的视图， 会随着原来改变而改变
        b.set(0, 10);
        System.out.println(a);  // [1, 10, 6, 4], 操作subList视图， 结果也会反馈到原列表
    }

List合并

// 合并
    public static void concatTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        List<Integer> b = Arrays.asList(2, 3, 4, 5);
        a.addAll(b);
        System.out.println(a);
        List<Integer> c = new ArrayList<>();
        for (List<Integer> i : new List[] {a, b}) {
            c.addAll(i);
        }
        System.out.println(c);
    }

List排序

// 排序
    public static void sortTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4));
        Collections.sort(a);
        System.out.println(a);
        // 升序
        a.sort(Comparator.naturalOrder());
        System.out.println(a);
        // 降序
        a.sort(Comparator.reverseOrder());
        System.out.println(a);

        // 多重list
        List<List<Integer>> result = new ArrayList<>();
        result.add(Arrays.asList(9, 2, 3));
        result.add(Arrays.asList(2, 9, 4));
        result.add(Arrays.asList(3, 4, 9));
        System.out.println(result);

        Collections.sort(result, new Comparator<List<Integer>>() {
            @Override
            public int compare(List<Integer> o1, List<Integer> o2) {
                // 按照第一索引位置从小到大排序
                return o1.get(0).compareTo(o2.get(0));  // [[2, 9, 4], [3, 4, 9], [9, 2, 3]]
            }
        });
        System.out.println(result);
    }

List元素去重

// 去重
    public static void setTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        // 使用Set
        Set b = new HashSet<Integer>(a);
        a.clear();
        a.addAll(b);
        System.out.println(a);  // [1, 2, 4, 5]
        // 使用stream
        List<Integer> c = a.stream().distinct().collect(Collectors.toList());
        System.out.println(c);  // [1, 2, 4, 5]
    }

判断是否为空， 以及List长度

// List长度和判断是否为空
    public static void testLength() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        System.out.println(a.size());
        // isEmpty和size == 0是一样的
        if (!a.isEmpty()) {
            System.out.println("do something");
        }
        if (!(a.size() == 0)) {
            System.out.println("do something");
        }
        // 加一个判断list为null
        if (a != null && ! a.isEmpty()) {
            System.out.println("do something");
        }
    }

List清空

// list清空
    public static void clearTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        // 不能直接等于赋值， 要new一个新的出来
//        List<Integer> b = a;
        List<Integer> b = new ArrayList<>(a);
        a.clear();
        System.out.println(a);
        a.addAll(b);
        System.out.println(a);
    }

求和， 求均值， 求最大最小

// 求和， 求最大， 最小， 均值
    public static void calculateTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        // 使用stream
        // 将流转化为数值流
        int sum = a.stream().mapToInt(x -> x).sum();
        int sum2 = a.stream().reduce(Integer::sum).get();
        double mean = a.stream().mapToDouble(x -> x).average().getAsDouble();
        int max = a.stream().mapToInt(x -> x).max().getAsInt();
        int min = a.stream().mapToInt(x -> x).min().getAsInt();
        System.out.println(sum);
        System.out.println(sum2);
        System.out.println(mean);
        System.out.println(max);
        System.out.println(min);
    }

通过值查找索引

// 通过值查找索引
    public static void indexTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        int index = a.indexOf(4);
        System.out.println(index);  // 返回满足条件的第一个索引值
    }

判断是否存在某个元素

// 判断是否存在某个元素
    public static void containTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        if (a.contains(3)) {
            System.out.println("存在");
        }
    }

判断两个List是否相等

// 判断两个list是否能相等
    public static void equalsTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        List<Integer> b = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        System.out.println(a == b);  // 内存地址
        System.out.println(a.equals(b));  // 真正判断list内容是否相等
    }

List循环

// List的循环
    public static void loopTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        for (int i : a) {
            System.out.println(i + 1);
        }
        a.forEach(x -> System.out.println(x + 1));
        for (int i = 0; i < a.size(); i ++) {
            System.out.println(a.get(i) + 1);
        }
    }

流操作

// 流操作
    public static void streamTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        List<Integer> b = a.stream().map(x -> x + 1).collect(Collectors.toList());
        System.out.println(b);
        Map<Integer, Integer> c = new HashMap<>();
        c.put(1, 2);
        c.put(5, 2);
        List<Integer> d = a.stream().map(x -> x * c.getOrDefault(x, 0)).collect(Collectors.toList());
        System.out.println(d);
        // 求统计值
        // 将流转化为数值流
        int res = a.stream().mapToInt(x -> x).sum();
        System.out.println(res);
    }

List转字符串

// List转字符串
// import org.apache.commons.lang.StringUtils;
    public static void toStringTest() {
        List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 5, 4, 4, 2));
        String res = StringUtils.join(a, ";");
        System.out.println(res);
    }

List转Array

public static void toArrayTest() {
        List<String> a = new ArrayList<>(Arrays.asList("a", "b", "c"));
        // toArray不加参数转成Object[], String后面指定长度是1
        String[] c = a.toArray(new String[0]);
        System.out.println(Arrays.toString(c));
    }