02Java8 List集合 和 Map集合使用

 

 

List新特性使用

List分组功能使用

• 创建对象

/**
 * @author mazhiyuan
 * @date 2022/01/07
 */
@Data
@AllArgsConstructor
class User {
    private String name;
    private String sex;
    private String grade;
}

• 测试分组功能

    /**
     *groupingList
     */
    private static void groupingList() {

        //1.模拟数据
        List<User> users = new ArrayList<>();
        users.add(new User("小明", "男", "1班"));
        users.add(new User("小红", "女", "1班"));
        users.add(new User("小张", "男", "2班"));
        users.add(new User("小兰", "女", "1班"));
        users.add(new User("小紫", "女", "2班"));

        //2.根据性别进行分组
        // 核心代码（返回Map集合，key就是分组的属性，value就是分组后的集合）
        Map<String, List<User>> userMap = users.stream().collect(Collectors.groupingBy(User::getSex));
        System.out.println(userMap);
    }

嵌套分组

    /**
     *ingInnerList
     */
    private static void ingInnerList() {
        //1.模拟数据
        List<User> users = new ArrayList<>();
        users.add(new User("小明", "男", "1班"));
        users.add(new User("小红", "女", "1班"));
        users.add(new User("小张", "男", "2班"));
        users.add(new User("小兰", "女", "1班"));
        users.add(new User("小紫", "女", "2班"));

        //2.根据性别进行分组
        // 核心代码（返回Map集合，也是嵌套的，最外层key就是sex，内层map的key是grade）
        Map<String,Map<String,List<User>>> userMap = users.stream().collect(Collectors.groupingBy(User::getSex,Collectors.groupingBy(User::getGrade)));
        System.out.println(userMap);

    }

List排序

• 简单的排序方法

    private static void simpleSort() {

        //1.数据模拟(Integer继承了比较接口)
        List<Integer> list = new ArrayList<Integer>();
        list.add(new Integer(3));
        list.add(new Integer(14));
        list.add(new Integer(6));
        list.add(new Integer(10));

        //2.使用Collections进行排序
        Collections.sort(list);
        System.out.println(list.toString());
    }

• 继承Comparable接口

//用户类
@Data
@AllArgsConstructor
class User implements Comparable<User>{
    private String name;
    private String sex;
    private String grade;
    private Integer age;

    @Override
    public int compareTo(User user) {
    // 重写Comparable接口的compareTo方法，根据年龄升序排列，降序修改相减顺序即可
    return this.age - user.getAge();
    }
}

    /**
     *继承comparable接口
     */
    private static void comparableSort() {

        //1.模拟数据
        List<User> users = new ArrayList<>();
        users.add(new User("小兰", "女", "1班", 4));
        users.add(new User("小紫", "女", "2班", 5));
        users.add(new User("小明", "男", "1班", 1));
        users.add(new User("小红", "女", "1班", 2));
        users.add(new User("小张", "男", "2班", 3));

        //2.使用Collections进行排序
        Collections.sort(users);
        System.out.println(users.toString());
    }

• 使用匿名内部类重写Comparator方法实现排序

    private static void newComparatorSort() {

        //1.模拟数据
        List<User> users = new ArrayList<User>();
        users.add(new User("小兰", "女", "1班", 4));
        users.add(new User("小紫", "女", "2班", 5));
        users.add(new User("小明", "男", "1班", 1));
        users.add(new User("小红", "女", "1班", 2));
        users.add(new User("小张", "男", "2班", 3));

        //2.排序
        Collections.sort(users, new Comparator<User>() {
            @Override
            public int compare(User u1, User u2) {
                int diff = u1.getAge() - u2.getAge();
                if (diff > 0) {
                    return 1;
                } else if (diff < 0) {
                    return -1;
                }
                return 0; //相等为0
            }
        }); // 按年龄排序
        System.out.println(users.toString());
    }

• 使用Comparator.comparing简单排序

    private static void comparingSort() {
        //1.模拟数据
        List<User> users = new ArrayList<User>();
        users.add(new User("小兰", "女", "1班", 4));
        users.add(new User("小紫", "女", "2班", 5));
        users.add(new User("小明", "男", "1班", 1));
        users.add(new User("小红", "女", "1班", 2));
        users.add(new User("小张", "男", "2班", 3));

        //2.排序
        users.sort(Comparator.comparing(User::getAge));
        System.out.println(users.toString());

    }

• 使用Comparator.comparing升序/降序 以及多字段排序

  单字段

List<类> list; 代表某集合
 
//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));
 
/**
* 返回 对象集合以类属性一降序排序 注意两种写法
**
//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一).reversed());
//以属性一降序 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));

​ 多字段

// 返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
 

//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
 list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));
 
//先以属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));
 
/**
* 返回 对象集合以类属性一降序 属性二降序 注意两种写法
**/
 
//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));
//先以属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));
 
/**
* 返回 对象集合以类属性一升序 属性二降序 注意两种写法
**/
 
//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序 
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());
 
//先以属性一升序,再进行属性二降序 
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));

升序/降序

        List<User> users = new ArrayList<User>();
        users.add(new User("小兰", "女", "1班", 4));
        users.add(new User("小紫", "女", "2班", 5));
        users.add(new User("小明", "男", "1班", 1));
        users.add(new User("小红", "女", "1班", 2));
        users.add(new User("小张", "男", "2班", 3));
//        users.sort(Comparator.comparing(User::getAge).reversed());
        users.sort(Comparator.comparing(User::getAge, Comparator.reverseOrder()));
        System.out.println(users.toString());

注意点：

写法一： Comparator.comparing(类::属性一).reversed();

写法二： Comparator.comparing(类::属性一,Comparator.reverseOrder());

两种排序是完全不一样的,一定要区分开来。

写法一是得到排序结果后再排序；

写法二是直接进行排序,很多人会混淆导致理解出错,但写法二更好理解,建议使用写法二

==排序总结:==

排序算法本质使用的是

• 希尔排序(插入排序的改进算法)

• 归并排序

---

基本数组类型转换Lits集合

代码实现

package com.arithmetic;

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

public class Solution {
    public static void main(String[] args) {
        // int 类型
        int[] ints = {1, 2, 3, 4, 5};
        List<Integer> list1 = Arrays.stream(ints).boxed().collect(Collectors.toList());
        System.out.println(list1);
        // double 类型
        double[] doubles = {1.0, 2.0, 3.0, 4.0, 5.0};
        List<Double> list2 = Arrays.stream(doubles).boxed().collect(Collectors.toList());
        System.out.println(list2);
        // String 类型
        String[] strs = {"1", "2", "3", "4", "5"};
        List<String> list3 = Arrays.stream(strs).collect(Collectors.toList());
        System.out.println(list3);
        System.out.println(Arrays.asList(strs));

    }
}