java-List集合初始化的几种方式与一些常用操作-持续更新

目录

list集合初始化

map初始化

获取list集合中的最大最小值

list排序

list对象时间排序

treeMap 中（基于key的排序）

TreeMap的按value排序

Map按value排序2

去掉一个list中包含的另一个list数据

String数组转换成List

list对象转对象某属性的list

list对象转成Map

map转list

JSON中string转List

list集合从前面追加数据

list与list互转

将list集合，元素随机打乱

根据下标替换元素

stream api对象过滤空

list使用 stream api去重

List根据某属性删除对象

List获取某属性重复的对象

List根据某属性去重

list根据某属性分组

List分割数据, 例每次请求500条数据 

List转map重复key报错java.lang.IllegalStateException: Duplicate key 0

list求交集

---

list集合初始化

• 常用的

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: szw
 * @Date: 2020/6/3 9:23
 */
public class ListTest {

    public static void main(String[] args) {
        List languages = new ArrayList<>();
        languages.add("Java");
        languages.add("List");
        languages.add("ArrayList");
    }
}

• 匿名内部类，

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: szw
 * @Date: 2020/6/3 9:23
 */
public class ListTest {

    static String str = "112233";

    // {{}} 双括号, 外层的 {} 定义了一个匿名内部类。内层的 {} 的定义了一个实例初始化代码块
    static List list = new ArrayList() {
        { // 这个大括号 就是 构造代码块 会在构造函数前 调用
            this.add("11"); //this 可以省略
            add("21");
            add("31");
            add(str);
        }
    };

    public static void main(String[] args) {
        System.out.println(list);
    }
}

• Arrays 工具类和Collections 工具类，不可变的 List

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

/**
 * @Author: szw
 * @Date: 2020/6/3 9:23
 */
public class ListTest {

    public static void main(String[] args) {
        List list = Arrays.asList("Java", "Jdk", "Jre");

        List list2 = Collections.nCopies(3, "apple");
    }
}

这种得到的是不可变的 List, 不能增删，如果要可变，那就使用 ArrayList 再包装一下 

List list = new ArrayList<>(Arrays.asList("1", "2", "3"));

List dogs = new ArrayList<>(Collections.nCopies(3, "dog"));

• JDK8 Stream，以下都是不常用的了

List colors = Stream.of("blue", "red", "yellow").collect(toList());

• JDK 9 List.of

List cups = List.of("A", "B", "C");

• guava

// 不可变集合
List list = ImmutableList.of("Hollis", "hollis", "HollisChuang", "H");

map初始化

    public final static Map DUANWEN_MAP_MINGYAN = new HashMap() {
        {
            put("1","励志名言");
            put("2","爱情名言");
            put("3","爱国名言");
        }
    };

获取list集合中的最大最小值

Collections.min(list);//获取最小值
Collections.max(list);//获取最大值

list排序

// JDK1.8以前的老用法，之前一直这样写
Collections.sort(books,new Comparator() {

            @Override
            public int compare(Book o1, Book o2) {
                // TODO Auto-generated method stub
                
                return o1.getBookPrice() - o2.getBookPrice();
                
            }
        });

// JDK1.8
Collections.sort(books,(Book a, Book b) -> { return a.getBookPrice()-b.getBookPrice(); });

// 简写1
Collections.sort(books,(Book a, Book b) ->  a.getBookPrice()-b.getBookPrice()); // 正序
Collections.sort(books,(Book a, Book b) ->  b.getBookPrice()-a.getBookPrice()); // 倒序
// 简写2
Collections.sort(list, Comparator.comparingInt(Channel::getChnumber)); // 正序

list.sort(Comparator.comparing(User::getSex)); // 正序
list.sort(Comparator.comparing(User::getSex, Comparator.reverseOrder()) // 倒叙
    .thenComparing(User::getLevel, Comparator.reverseOrder())); // 倒叙

list对象时间排序

    static void getSort(List totalList) {
        Collections.sort(totalList, (StatisticsVo a, StatisticsVo b) -> {

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date aParse = null;
            Date bParse = null;
            try {
                aParse = sdf.parse(a.getDayTimeString());
                bParse = sdf.parse(b.getDayTimeString());
            } catch (ParseException e) {
                e.printStackTrace();
            }

            return bParse.compareTo(aParse); // 倒叙
        });
    }

treeMap 中（基于key的排序）

treeMap默认的是基于key的从小到大 的排列
自定义排序也是基于key的，如果key object类型 可以自定义各种排序

TreeMap treeMap = new TreeMap<>((String a,String b)-> b.compareTo(a));//降序
TreeMap treeMap = new TreeMap<>((String a,String b)-> a.compareTo(b));//升序

TreeMap的按value排序

（转换成entry list 然后排序）汉字是按ascii码排序的，不是汉语拼音

User p1 = new User(1, "A小红");
User p2 = new User(5, "D赵明");
User p3 = new User(2, "W孙宇");
User p4 = new User(9, "C黎明");

TreeMap treeMap = new TreeMap<>();

treeMap.put("45", p1);
treeMap.put("12", p2);
treeMap.put("85", p3);
treeMap.put("33", p4);


List> entries = new ArrayList<>(treeMap.entrySet());

Collections.sort(entries,
        (Map.Entry e1, Map.Entry e2) -> ((User) e1.getValue()).getUserName()
                .compareTo(((User) e2.getValue()).getUserName()));
System.out.println("按名字顺序排列");
for (Entry entry : entries) {
    System.out.println(entry.getValue());

}

Map按value排序2

JSONObject parse = (JSONObject) JSONObject.parse(data.getOptionName());
            Map innerMap = parse.getInnerMap();
            List> entries = new ArrayList<>(innerMap.entrySet());
            Collections.sort(entries, Comparator.comparing((Map.Entry e) -> (Integer.valueOf((String) e.getValue()))));

去掉一个list中包含的另一个list数据

HashSet h1 = new HashSet<>(list);
HashSet h2 = new HashSet<>(list2);
h1.removeAll(h2);
list.clear();
list.addAll(h1);

String数组转换成List

List list= Arrays.asList((Integer[]) ConvertUtils.convert(stringArray, Integer.class));

// 将String数组转成Integer数组
Integer[] interArray = (Integer[])ConvertUtils.convert(stringArray, Integer.class);

// String数组转int数组
int[] array = Arrays.asList(strings).stream().mapToInt(Integer::parseInt).toArray();
int[] array = Arrays.stream(strings).mapToInt(Integer::parseInt).toArray();

list对象转对象某属性的list

List ids = list.stream()
        .map(User::getId)
        .collect(Collectors.toList());

list对象转成Map

    public static Map getListToObjectMap(List list) {
        Map map = list.stream().collect(Collectors.toMap(Student::getStuId, student -> student));
        map.forEach((key, value) -> {
            System.out.println("key:" + key + ",value:" + value);
        });
        return map;
    }

map转list

Map map = new HashMap<>();
// Convert all Map keys to a List
List result = new ArrayList(map.keySet());
// Convert all Map values to a List
List result2 = new ArrayList(map.values());
// Java 8, Convert all Map keys to a List
List result3 = map.keySet().stream()
	.collect(Collectors.toList());
// Java 8, Convert all Map values  to a List
List result4 = map.values().stream()
	.collect(Collectors.toList());
// Java 8, seem a bit long, but you can enjoy the Stream features like filter and etc.
List result5 = map.values().stream()
	.filter(x -> !"apple".equalsIgnoreCase(x))
	.collect(Collectors.toList());

JSON中string转List

List pList = JSON.parseArray(svcCont4PlaceHolderReq.getMarksList(),String.class);

list集合从前面追加数据

    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("1111");
        list.add("2222");
        System.out.println(list); // [1111, 2222]
        list.add(0, "qqqqq");
        System.out.println(list); // [qqqqq, 1111, 2222]
    }

list与list互转

List stringList = intList.stream().map(String::valueOf).collect(Collectors.toList());
      
List codesInteger = codes.stream().map(Integer::parseInt).collect(Collectors.toList());

将list集合，元素随机打乱

2021-07-14更新

• static void shuffle(List list)  使用默认随机源对列表进行置换，所有置换发生的可能性都是大致相等的。
• static void shuffle(List list, Random rand) 使用指定的随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的，假定随机源是公平的。

Collections.shuffle(list); 

Random rand=new Random(47);
Collections.shuffle(list,rand);

根据下标替换元素

jsonArray.set(i, jsonObject);

stream api对象过滤空

Set collect = list.stream().map(DO::getMainId).filter(Objects::nonNull).collect(Collectors.toSet());

Set collect = list.stream().filter(Objects::nonNull).collect(Collectors.toSet());

Objects::nonNull, 或filter(StringUtils::isNotBlank)判断字符串(import org.apache.commons.lang.StringUtils;)

list使用 stream api去重

常用的去重list转set, stream也有对应的api, 注意对象的话需要重写equals and hashcode0

List newList = list.stream().distinct().collect(Collectors.toList());

2022-06-30更新

List根据某属性删除对象

jdk 1.8 的集合类 removeIf() 方法用于删除所有满足特定条件的数组元素。语法; arraylist.removeIf(Predicate filter)

        List newList = userList.stream().collect(Collectors.collectingAndThen(
            Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getCode))), ArrayList::new));

userList.removeIf(user -> user.age > 50);

List获取某属性重复的对象

根据名字分组统计, 获取到名字重复数大于1的名字列表(groupingBy的值不能为空)

         List userNameList = userList.stream().filter(f -> StringUtils.isNotBlank(f.getName()))
                 .collect(Collectors.groupingBy(User::getName, Collectors.counting())).entrySet().stream()
                 .filter(e -> e.getValue() > 1).map(Map.Entry::getKey)
                 .collect(Collectors.toList());

过滤一下

List list = userList.stream().filter(f -> userNameList.contains(f.getName())).collect(Collectors.toList());

List根据某属性去重

        List newList = userList.stream().collect(Collectors.collectingAndThen(
            Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getCode))), ArrayList::new));

2022-12-13补充

list根据某属性分组

Map> map = students.stream().collect(Collectors.groupingBy(Student::getName));

更多java常用知识点整理：java常用知识点整理_瑶山的博客-CSDN博客_java知识点整理

2023-2补充

List分割数据, 例每次请求500条数据 

import com.google.common.collect.Lists;
// 代码模拟

List> partition = Lists.partition(idList, 500);

    for (List list : partition) {
        query.setUserIds(list);
        response = queryList(query);
    }

2023-4补充

List转map重复key报错java.lang.IllegalStateException: Duplicate key 0

        Map totalBindMap = list.stream()
                .collect(Collectors.toMap(StatisticsDO::getCode, StatisticsDO::getMoney, (entity1, entity2) -> entity2));

(entity1, entity2) -> entity2中，如果entity1与entity2的key值相同，选择entity2作为那个key所对应的value值。这里的箭头函数，当出现了重复key的数据时，会回调这个方法，可以在这个方法里处理重复Key数据问题

list求交集

List list1 = new ArrayList<>();
        list1.add("03");
        list1.add("02");
        list1.add("01");

        List list2 = new ArrayList<>();
        list2.add("02");
        list2.add("03");

        // list1 只保留在 lists2 中的元素
        list1.retainAll(list2);

        System.out.println(list1);
        ->> ["03, 02]

// 并集
listA.removeAll(listB);
listA.addAll(listB);