Java List转化判断是否包含，List使用Steam分组、转化成map

  • 博主： 牛宝宝
  • 发布时间：
  • 550 次浏览
  • 📚后端
  • Java

前端传入的list字符串转化成List对象并判断是否包含某些元素

  public static void main(String[] args) {
        String a = "[\"a\",\"b\"]";
        System.out.println(a);
        // 转化Json为指定格式对象
        List<String> strings = JSONObject.parseObject(a, new TypeReference<List<String>>() {
        });
        System.out.println(strings);
        // 去除字符串数组中的特殊字符
        a = a.replace("[","").replace("]","").replace("\"","");
        List<String> list = Arrays.asList(a.split(","));
        // 转化为ArrayList
        System.out.println(list);
        // 判断是否包含某个元素
        System.out.println(list.contains("a"));
        System.out.println(list.contains("c"));
    }

img_tc_1456311699599391237.png

使用stream对List按照元素当做key进行分组

package blog;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.TypeReference;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author niushuaikui
 * @description TODO
 * @date 2023/11/10
 */
public class TestExample {
    public static void main(String[] args) {
        // 转化list,注意直接使用asList转化的list是不可变的，使用new ArrayList<>(Arrays.asList())转化的list是可变的
        List<String> strList = new ArrayList<>(Arrays.asList("11","11", "12", "13", null, null));
        System.out.println(strList);
        Map<String, List<String>> map = strList.stream().collect(Collectors.groupingBy(x -> StringUtils.isEmpty(x) ? "null" : x));
        System.out.println(map);

        List<User> userList = Arrays.asList(new User("11", 11), new User("12", 12), new User("13", 13)
        ,new User("11", 111), new User("", 222), new User("", 333));
        System.out.println(userList);
        // 注意，使用  :: lambda表达式不能存在值为null的情况，否则会报空指针异常
        Map<String, List<User>> collect = userList.stream()
                .collect(Collectors.groupingBy(User::getName));
        System.out.println(collect);
        // 使用判断是否为空的方式
        List<User> userList2 = Arrays.asList(new User("11", 11), new User("12", 12), new User("13", 13)
                ,new User("11", 111), new User("", 222), new User("", 333));
        Map<String, List<User>> collect2 = userList2.stream()
                .collect(Collectors.groupingBy(user -> StringUtils.isEmpty(user.getName()) ? "null" : user.getName()));
        System.out.println(collect2);
        // 等同于以下
        Map<String, List<User>> collect3 = userList2.stream()
                .collect(Collectors.groupingBy((user) ->{
                  return  StringUtils.isEmpty(user.getName()) ? "null" : user.getName() ;
                }));
        System.out.println(collect3);
    }
}

@Data
@AllArgsConstructor
@ToString
class User{
    private String name;
    private Integer age;
}

img_tc_1516071699600567400.png

使用steam对吧List转化成Map对象，指定key和value

package blog;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.TypeReference;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author niushuaikui
 * @description TODO
 * @date 2023/11/10
 */
public class TestExample {
    public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("111","000"));
        users.add(new User("222","222"));
        users.add(new User("222","3333"));
        // 转化为map，如果有重复的key，取后面的value,  key为name，value为test
        Map<String, String> collect = users.stream()
                .collect(Collectors.toMap(User::getName, User::getTest,(before,behind)->behind));
        System.out.println(collect);
        // 转化成买个map，如果有重复的key，取后面的value,  key为name，value为user对象
        Map<String, User> collect2 = users.stream()
                .collect(Collectors.toMap(User::getName, Function.identity(),(before,behind)->behind));
        System.out.println(collect2);
    }

}
@Data
@AllArgsConstructor
@ToString
class User {
    private String name;
    private String test;

}

img_tc_1521201699600880130.png

steam过滤List,查找符合条件，

package blog;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.TypeReference;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author niushuaikui
 * @description TODO
 * @date 2023/11/10
 */
public class TestExample {
    public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("111","000"));
        users.add(new User("222","222"));
        users.add(new User("222","3333"));
        System.out.println(users);
        // 过滤name为222的
        List<User> collect = users.stream().filter(user -> StringUtils.equals(user.getName(), "222")).collect(Collectors.toList());
        System.out.println(collect);
        // 查找name为222的，如果没有则返回null
        User user1 = users.stream().filter(user -> StringUtils.equals(user.getName(), "222")).findAny().orElse(null);
        System.out.println(user1);
        // 查找name为222111的，如果没有则返回null
        User user2 = users.stream().filter(user -> StringUtils.equals(user.getName(), "222111")).findAny().orElse(null);
        System.out.println(user2);

    }

}
@Data
@AllArgsConstructor
@ToString
class User {
    private String name;
    private String test;

}

img_tc_1534131699601653025.png

List 利用steam排序,指定排序，也可以直接排序

package blog;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.TypeReference;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author niushuaikui
 * @description TODO
 * @date 2023/11/10
 */
public class TestExample {
    public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("113","113"));
        users.add(new User("111","111"));
        users.add(new User("111","131"));
        users.add(new User("111","121"));
        users.add(new User("122","122"));
        users.add(new User("333","333"));
        users.add(new User("121","121"));
        users.add(new User("222","222"));
        System.out.println("原列表"+users);
        // 按照name排序，大的在后面
        List<User> collect = users.stream().sorted(Comparator.comparing(User::getName))
                .collect(Collectors.toList());
        // 等同于 users.sort(Comparator.comparing(User::getName)); 
        System.out.println("按照name排序，大的在后面"+collect);
        // 按照name排序，大的在后面,然后按照test排序
        List<User> collect1 = users.stream().sorted(Comparator.comparing(User::getName).thenComparing(User::getTest)).collect(Collectors.toList());
        System.out.println("按照name排序，大的在后面,然后按照test排序"+collect1);
        // 按照name排序，大的在后面,然后翻转，大的在前面
        List<User> collect2 = users.stream().sorted(Comparator.comparing(User::getName).reversed())
                .collect(Collectors.toList());
        System.out.println("按照name排序，大的在后面,然后翻转，大的在前面"+collect2);
        users.add(new User(null,"444"));
        users.add(new User("444","444"));
        users.add(new User(null,"555"));
        // 按照想要的方式排序
        List<User> collect3 = users.stream().sorted(new Comparator<User>() {
                    @Override
                    public int compare(User o1, User o2) {
                        // 如果o1为空，o1排在前面
                        if (o1.getName() == null ){
                            return -1;
                        }
                        // 取name的最后一个字符，然后比较
                        return o1.getName().charAt(o1.getName().length()-1) - (o2.getName().charAt(o2.getName().length()-1));
                    }
                })
                .collect(Collectors.toList());
        System.out.println("按照想要的方式排序"+collect3);
        // 等价于上面的写法
        List<User> collect4 = users.stream().sorted((o1, o2) -> {
            // 如果o1为空，o1排在前面
            if (o1.getName() == null ){
                return -1;
            }
            // 取name的最后一个字符，然后比较
            return o1.getName().charAt(o1.getName().length()-1) - (o2.getName().charAt(o2.getName().length()-1));
        })
                .collect(Collectors.toList());
        System.out.println("按照想要的方式排序"+collect4);
        List<String> list = Arrays.asList("123","122","333","100","099");
        System.out.println("原列表"+list);
        list.sort(Comparator.comparing(Function.identity()));
        System.out.println("Function.identity()按照字符串排序"+list);
        list.sort(String::compareTo);
        System.out.println("String::compareTo按照字符串排序"+list);
        List<Integer> intList = Arrays.asList(123,122,111,333,321);
        System.out.println("原列表"+intList);
        intList.sort(Integer::compareTo);
        System.out.println("Integer::compareTo排序"+intList);

    }
    /*
    原列表[User(name=113, test=113), User(name=111, test=111), User(name=111, test=131), User(name=111, test=121), User(name=122, test=122), User(name=333, test=333), User(name=121, test=121), User(name=222, test=222)]
    按照name排序，大的在后面[User(name=111, test=111), User(name=111, test=131), User(name=111, test=121), User(name=113, test=113), User(name=121, test=121), User(name=122, test=122), User(name=222, test=222), User(name=333, test=333)]
    按照name排序，大的在后面,然后按照test排序[User(name=111, test=111), User(name=111, test=121), User(name=111, test=131), User(name=113, test=113), User(name=121, test=121), User(name=122, test=122), User(name=222, test=222), User(name=333, test=333)]
    按照name排序，大的在后面,然后翻转，大的在前面[User(name=333, test=333), User(name=222, test=222), User(name=122, test=122), User(name=121, test=121), User(name=113, test=113), User(name=111, test=111), User(name=111, test=131), User(name=111, test=121)]
    按照想要的方式排序[User(name=null, test=555), User(name=null, test=444), User(name=111, test=111), User(name=111, test=131), User(name=111, test=121), User(name=121, test=121), User(name=122, test=122), User(name=222, test=222), User(name=113, test=113), User(name=333, test=333), User(name=444, test=444)]
    按照想要的方式排序[User(name=null, test=555), User(name=null, test=444), User(name=111, test=111), User(name=111, test=131), User(name=111, test=121), User(name=121, test=121), User(name=122, test=122), User(name=222, test=222), User(name=113, test=113), User(name=333, test=333), User(name=444, test=444)]
    原列表[123, 122, 333, 100, 099]
    Function.identity()按照字符串排序[099, 100, 122, 123, 333]
    String::compareTo按照字符串排序[099, 100, 122, 123, 333]
    原列表[123, 122, 111, 333, 321]
    Integer::compareTo排序[111, 122, 123, 321, 333]
     */
}
@Data
@AllArgsConstructor
@ToString
class User {
    private String name;
    private String test;

}

img_tc_1553551699602835297.png
img_tc_1610421699603842320.png

包含对象的List提取指定属性，去重


package blog;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.TypeReference;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author niushuaikui
 * @description TODO
 * @date 2023/11/10
 */
public class TestExample {
    public static void main(String[] args) {
        ArrayList<User> users = new ArrayList<>();
        users.add(new User("113","113"));
        users.add(new User("111","111"));
        users.add(new User("111","131"));
        users.add(new User("111","121"));
        users.add(new User("122","122"));
        users.add(new User("333","333"));
        users.add(new User("121","121"));
        users.add(new User("222","222"));
        System.out.println("原列表"+users);
        // 提取属性
        List<String> collect = users.stream().map(User::getName).collect(Collectors.toList());
        System.out.println("提取属性"+collect);
        // 去重
        List<String> collect1 = users.stream().map(User::getName).distinct().collect(Collectors.toList());
        System.out.println("去重"+collect1);

    }
}
@Data
@AllArgsConstructor
@ToString
class User {
    private String name;
    private String test;

}

img_tc_1601011699603260891.png