java8常用特性

小馒头味豆浆

已于 2025-04-21 14:41:39 修改

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java

于 2019-06-10 17:05:00 首次发布

本文链接：https://blog.youkuaiyun.com/qq_43639296/article/details/91385671

java 专栏收录该内容

61 篇文章

订阅专栏

注意 : 一个 Stream 只可以使用一次

List<List<Integer>> groups = Lists.partition(Arrays.asList(1,2,3,4,5),2);

对象集合非空过滤后遍历

List<User> userList = new ArrayList();
userList.stream.filter(Objects::nonNull).foreach(user ->{})

集合遍历，携带索引

List<User> userList = new ArrayList();
List<User> finalInfos = IntStream.range(0, userList.size()).mapToObj(x -> {
                userList.get(x).setSortCode(x);
                return userList.get(x);
            }).collect(Collectors.toList());

用于int、double、long等基本类型上，用来统计结果

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
 
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
 
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

筛选数据后拼接

@Test
public void test18() {
    List<String>strings = Arrays.asList("我", "", "爱", "中", "国","", "!");
    String collect = strings.parallelStream().filter(s -> !s.isEmpty()).collect(Collectors.joining());
    System.out.println(collect);
}

获取list对象中某个字段最大值的对象

 @Test
    public void test15() {  
		List<User> userList = new ArrayList<>();
		User user = userList.stream().max(Comparator.comparingLong(User::getAge)).get();
    }

将对象list按照某个字段求和

//集合中该字段都不为空
Float aFloat = ljMtRefundOrderECDTOList.stream().map(LjMtRefundOrderECDTO::getMoney).reduce(Float::sum).get();
//求和过程中出现空字段处理
Float sumRefund = ljMtRefundOrderECDTOList.stream().map(ecdto -> {
											           if (Objects.isNull(ecdto.getMoney())) {
											               return 0F;
											           } else {
											               return ecdto.getMoney();
											           }
											       }).reduce(Float::sum).get();

list转化为map

    @Test
    public void test20() {
        List<String> strList = Arrays.asList("a", "ba", "bb", "abc", "cbb", "bba", "cab");
        Map<Integer, String> strMap = new HashMap<Integer, String>();

        strMap = strList.stream()
                .collect( Collectors.toMap( str -> strList.indexOf(str), str -> str ) );

        strMap.forEach((key, value) -> {
            System.out.println(key+"::"+value);
        });
    }

将list转化为map，重复时采用后面的value2 覆盖value1

 @Test
    public void test14() {  
		List<User> userList = new ArrayList<>();
		Map<String, String> userMap = userList.stream().collect(Collectors.toMap(User::getName, User::getPassword, (value1, value2 )->{return value2;}));
    }

将对象集合变为map

List<Order> orders = new ArrayList<>();
final Map<String, Order> orderMap = orders.stream().collect(Collectors.toMap(Order::getOrderCode, order -> order));

将集合中字段已逗号拼接成字符串

    @Test
    public void test13() {
        List<User> users = new ArrayList<>();
        final String username = users.stream().map(User::getUsername).collect(Collectors.joining(","));
        System.out.println(username);
    }

将对象集合按指定字段分组，并指定字段求和

    @Test
    public void test12() {
        User tom2 = new User("Tom", 1);
        User tom1 = new User("Tom", 2);
        User tom = new User("Tom", 3);
        User dick2 = new User("Dick", 3);
        User dick1 = new User("Dick", 3);
        User dick = new User("Dick", 3);
        List<User> users = new ArrayList<>();
        users.add(tom);
        users.add(tom2);
        users.add(tom1);
        users.add(dick);
        users.add(dick2);
        users.add(dick1);
        Map<String, Integer> dotMap = users.stream().collect(Collectors.groupingBy(User::getUsername, Collectors.summingInt(User::getAge)));
        System.out.println(JSONObject.toJSONString(dotMap));
    }

将对象集合中的指定字段用逗号分割，并返回字符串。

List<Order> orders = new ArrayList<>();
final String activityIds = orders.stream().map(Order::getOrderCode).collect(Collectors.joining(","));

校验集合中数据：
anyMatch表示，判断的条件里，任意一个元素成功，返回true
allMatch表示，判断条件里的元素，所有的都是，返回true
noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

List<String> strs = Arrays.asList("a", "a", "a", "a", "b");
boolean aa = strs.stream().anyMatch(str -> str.equals("a"));
boolean bb = strs.stream().allMatch(str -> str.equals("a"));
boolean cc = strs.stream().noneMatch(str -> str.equals("a"));
long count = strs.stream().filter(str -> str.equals("a")).count();
System.out.println(aa);// TRUE
System.out.println(bb);// FALSE
System.out.println(cc);// FALSE
System.out.println(count);// 4

将strem中数据求和

@Test
    public void testJava8(){
        Stream<BigDecimal> bigDecimalStream = Stream.of(new BigDecimal(1), new BigDecimal(2), new BigDecimal(3));
        BigDecimal bigDecimal = bigDecimalStream.reduce(BigDecimal.ZERO, BigDecimal::add);
        //也可以这样写
//        BigDecimal bigDecimal = bigDecimalStream.reduce(BigDecimal::add).get();
        Stream<Integer> integerStream = Stream.of(1, 2, 3);
        Integer integer = integerStream.reduce(0, Integer::sum);
        //也可以这样写
//        Integer integer = integerStream.reduce(Integer::sum).get();
        System.out.println(bigDecimal + "," + integer);
    }

将对象集合按照某个字段排序

@Test
    public void testJava8() throws IOException {
        ArrayList<User> list = new ArrayList<>();
        list.add(new User("tom",0));
        list.add(new User("xiao",1));
        list.add(new User("li",2));
        list.add(new User("dick",3));
        //未处理空值
        list.sort(Comparator.comparing(User::getAge).reversed());
        //加入空值处理
        list.sort((User u1, User u2) -> {
            final Integer a1 = u1.getAge();
            final Integer a2 = u2.getAge();
            if(a1 == null) {
                if(a2 == null) {
                    return 0;
                }
                return 1;
            }
            if(a2 == null) {
                return -1;
            }
            return a1 - a2;
        });
        list.forEach(System.out::println);
    }

提取对象集合的某一字段值

@Test
    public void testJava8() throws IOException {
        ArrayList<User> list = new ArrayList<>();
        list.add(new User("tom",0));
        list.add(new User("xiao",1));
        list.add(new User("li",2));
        list.add(new User("dick",3));

        List<String> collect = list.stream().map(User::getUsername).collect(Collectors.toList());
        collect.forEach(e -> {
            System.out.println(e.toString());
        });
    }

过滤对象集合中符合条件的对象

@Test
    public void testJava8() throws IOException {
        ArrayList<User> list = new ArrayList<>();
        list.add(new User("tom",0));
        list.add(new User("xiao",1));
        list.add(new User("li",2));
        list.add(new User("dick",3));

        List<User> users = list.stream().filter(e -> (e.getUsername().equals("tom"))).collect(Collectors.toList());
        users.forEach(e ->{
            System.out.println(e.toString());
        });

将对象集合按照某一字段分组

@Test
    public void testJava8() throws IOException {
        ArrayList<User> list = new ArrayList<>();
        list.add(new User("tom",0));
        list.add(new User("tom",1));
        list.add(new User("li",2));
        list.add(new User("dick",3));

		Map<String, List<User>> map = list.stream().collect(Collectors.groupingBy(User::getUsername));
		
        Set<String> strings = map.keySet();
        strings.forEach(e ->{
            List<User> returnOrderEntries = map.get(e);
            System.out.println(returnOrderEntries);
        });

**
将数组中数据进行类型转换

    public static void main(String[] args) {
        String[] dd = {"1","2","3"};
        Stream<String> stream = Arrays.stream(dd);
        stream.map(str -> Integer.valueOf(str)).forEach(str -> {
            System.out.println(str);
            System.out.println(str.getClass());
        });
    }

将集合按条件筛选

    public static void main(String[] args) {
        List<String> includeList = new ArrayList<>();
        includeList.add("aa");
        includeList.add("bb");
        //替换aa为cc
        List<String> maplist = includeList.stream().map(s -> s.equals("aa")?"cc":s).collect(Collectors.toList());
        maplist.forEach(System.out::println);
        //过滤出aa
        List<String> filterlist = includeList.stream().filter(s -> s.equals("aa")).collect(Collectors.toList());
        filterlist.forEach(System.out::println);
    }

将数组转化stream

    public static void main(String[] args) {
        String [] strArray = new String[] {"a", "b", "c"};
        //方式一
        List<String> list = Arrays.asList(strArray);
        Stream stream = list.stream();
        stream.forEach(System.out::println);
        //方式二
        Stream<String> stream2 = Arrays.stream(strArray);
        stream2.forEach(System.out::println);
        //方式三
        stream3 = Stream.of(strArray);
        stream3.forEach(System.out::println);
    }

将数组转集合

    public static void main(String[] args) {
        String[] dd = { "a","b","c" };
        Stream<String> stream = Arrays.stream(dd);
        List<String> list = stream.collect(Collectors.toList());
        Set<String> set = stream.collect(Collectors.toSet());
        Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
        String str = stream.collect(Collectors.joining(","));
        System.out.println(str);
    }

获取集合中某个范围内的值

    public static void main(String[] args) {
        List<Tes> list = Arrays.asList(new Tes("红二"), new Tes("王三"), new Tes("刘四"));
        List<String> personList2 = list.stream().map(Tes::getName).limit(2).skip(2).collect(Collectors.toList());
        System.out.println(personList2);
    }

    public static class Tes {
        private String name;

        public Tes(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

获取集合中以特定值开头的数据

    public static void main(String[] args) {
        ArrayList<String> stringList = new ArrayList<>();
        stringList.add("aa");
        stringList.add("bb");
        stringList.add("adc");
        stringList.stream().filter((s) -> s.startsWith("a")).forEach(System.out::println);
    }

获取第一条数据，使用 findAny() 和 findFirst()

List<User> userList = UserService.getUserList();
//获取用户信息，如果没有找到则返回null
User user = userList.stream().filter(u -> u.getName().equals("小红")).findAny().orElse(null);
User user = userList.stream().filter(u -> u.getName().equals("小红")).findFirst().get();

合并list集合

public static<T> List<T> merge5(List<T> list1, List<T> list2){
    List<T> list = new ArrayList<>();
    Stream.of(list1, list2).forEach(list::addAll);
    return list;
}