[List] 1.单值不可变List 2.排序 3.Array和List互转 4.差集 5.带泛型的空List做返回值 6.addAll 7.逆序

1)Collections.singletonList(x) // 只有1个值的不可变List，修改将抛出异常

package org.example.testSingletonList;

import com.google.common.collect.Lists;

import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 可变的list
        List<Integer> list = Lists.newArrayList(1, 2, 3);

        // 不可变，修改将会抛出异常，且是这个列表只有一个值
        List<Integer> list1 = Collections.singletonList(1);
        list1.add(1);

    }
}

/*
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.AbstractList.add(AbstractList.java:153)
	at java.base/java.util.AbstractList.add(AbstractList.java:111)
	at org.example.testSingletonList.Main.main(Main.java:12)
 */

2)对list指定排序规则

Collections.sort(list, (v1, v2)->{
  ...

})

3)List和Array互转

List转Array

package org.example.intArrToList;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Integer[] arr = list.toArray(new Integer[0]);

        for (int n : arr) {
            System.out.print(n + " ");
        }
    }
}

/*
1 2 3 4 5 
 */

 Array转List // Arrays.stream(xx).boxed(), 因为策划的配置是数组需要转下

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        // 这样子转
        List<Integer> list = Arrays.stream(arr)
                                .boxed()
                                .collect(Collectors.toList());
        System.out.println(list);
    }
}

/*
[1, 2, 3, 4, 5]
 */

4)removeAll实现2个List的差集(注意一定要用guava的，用Arrays.asList 会有异常)

package org.example;
 
import com.google.common.collect.Lists;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
 
/**
 * @author jianan
 * @date 2021/7/8 12:13:05
 */
public class TestArrayList {
	public static void main(String[] args) {
		List<Integer> list = Lists.newArrayList(1, 2, 3);
		System.out.println(list);
 
		List<Integer> list2 = Lists.newArrayList(1, 2, 3);
		list2.removeAll(list);
 
		System.out.println(list2);
	}
}
 
/*
[1, 2, 3]
[]
 */

5.带有泛型的List函数返回值  // 其实我更倾向于Lists.newArrayList()了

return Collections.emptyList();
 
而不要写: return Lists.newArrayList(); 之类的写法了

6.addAll() 实现 一个List直接初始化另外一个List

/**
 * @author jianan
 * @date 2021/6/9 12:01:39
 */
public class TestList {
    public static void main(String[] args) {
        ArrayList<Integer> arr = Lists.newArrayList();
        arr.add(1);
        arr.add(2);
 
        // 子数组
        ArrayList<Integer> arr1 = Lists.newArrayList();
        arr1.add(3);
        arr1.add(4);
        // end
 
        arr.addAll(arr1);
 
        System.out.println(arr);
    }
}
 
/*
[1, 2, 3, 4]
 */

7)Comparator.comparingInt(e -> (int) e).reversed() // 主要对一个类排序，逆序

package org.example.basic;

import com.google.common.collect.Lists;

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class TestReadOnlyList {
    public static void main(String[] args) {
        List<Integer> list = Lists.newArrayList(1, 4, 3, 2, 5, 6, 2);
        list = list.stream()
                .sorted(Comparator.comparingInt(e -> (int) e).reversed())
                .collect(Collectors.toList());

        System.out.println(list);
    }
}

/*
[6, 5, 4, 3, 2, 2, 1]
 */