java8常用特性

桃扇骨 2022-01-20 04:09 192阅读 0赞

**注意 : 一个 Stream 只可以使用一次**  
获取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，重复时采用后面的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;}));
        }

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

@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(","));

将对象集合变为map

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

校验集合中数据：  
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.forEach(e ->{ 
                log.info(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<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);
        }