常用lambda表达式

怼烎@ 2022-05-14 02:05 113阅读 0赞

package othertest;
    
    import org.junit.Before;
    import org.junit.Test;
    import org.springframework.test.context.TestPropertySource;
    
    import java.util.*;
    import java.util.function.Function;
    import java.util.function.Predicate;
    import java.util.stream.Collectors;
    
    /**
     * Created by me on 2017/8/31.
     */
    public class LambdaTest {
    
        private List<Person> dataList = null;
    
        private Map<String, Person> map = null;
    
        @Before
        public void init() {
            dataList = new ArrayList<Person>() {
                {
                    add(new Person("tan1", 27));
                    add(new Person("jian2", 26));
                    add(new Person("wang3", 25));
                    add(new Person("tan1", 28));
                }
            };
            map = new HashMap<String, Person>() {
                {
                    put("1", new Person("tan1", 27));
                    put("2", new Person("jian2", 26));
                    put("3", new Person("wang3", 25));
                }
            };
        }
    
        @Test
        public void test1() {
            //循环遍历
            //dataList.forEach(p -> System.out.println(p.getName()));
            dataList.forEach(p -> {
                if (p.getAge() > 26) {
                    System.out.println(p.getName());
                }
            });
        }
    
        /**
         * map函数操作：将一个对象变为另一个对象,并返回该值
         */
        @Test
        public void test2() {
            //1.map处理:将一个对象变为另一个对象,并返回该值，获取所有年龄
            List<Integer> ages = dataList.stream().map(Person::getAge).collect(Collectors.toList());
            System.out.println(ages);
    
            //2.map处理，年龄+1
            List<Person> persons = dataList.stream().map(p -> {
                return new Person(p.getName(), p.getAge() + 1);
            }).collect(Collectors.toList());
            System.out.println(persons.toString());
    
            //3.filter处理,给一个过滤条件,过滤掉数据
            Predicate<Person> predicate = p -> p.getAge() > 26;//只处理年龄大于26的，对年龄大于26的+1
            List<Person> persons2 = dataList.stream().filter(predicate).map(p -> {
                return new Person(p.getName(), p.getAge() + 1);
            }).collect(Collectors.toList());
            System.out.println(persons2.toString());
        }
    
        /**
         * reduce函数操作: 将所有值通过计算合并为一个
         */
        @Test
        public void test3() {
            //1.利用reduce排序取出最大年龄的
            Person p1 = dataList.stream().reduce((a, b) -> {
                if (a.getAge() > b.getAge()) {
                    return a;
                }
                return b;
            }).get();
            System.out.println(p1);
            //2.利用reduce计算年龄和
            int result = dataList.stream().mapToInt(p -> p.getAge()).reduce((a, b) -> a + b).getAsInt();
            System.out.println(result);
            //3.利用reduce求平均
            double age = dataList.stream().mapToInt(p -> p.getAge()).average().getAsDouble();
            System.out.println(age);
        }
    
        /**
         * sorted排序
         */
        @Test
        public void test4() {
            dataList = dataList.stream().sorted((a, b) ->  b.getAge() - a.getAge()).collect(Collectors.toList()); //年龄大的在前，调整a,b顺序
            System.out.println(dataList);
        }
    
        /**
         * java map遍历
         */
        @Test
        public void test5() {
            map.keySet().stream().forEach(k -> System.out.println(map.get(k)));
            System.out.println("-------------------------------------------");
            map.entrySet().stream().forEach(p -> System.out.println(p.getKey() + ":" + p.getValue()));
        }
    
        /**
         * list转map：拿出name当key，并把相同key的值放入同一个list中
         */
        @Test
        public void test6() {
            Map<Object, List<Person>> map = dataList.stream().collect(Collectors.groupingBy(p -> p.getName()));
            map.keySet().stream().forEach(p -> System.out.println(p + ";" + map.get(p)));
        }
    
        /**
         * list转map，拿出name当key，相同key用后一个值覆盖前一个值
         */
        @Test
        public void test7() {
            Map<String, Person> map = dataList.stream().collect(Collectors.toMap(p -> p.getName(), Function.identity(), (k1, k2) -> k2, LinkedHashMap::new));
            System.out.println(map);
        }
    
        /**
         * 判断相同属性的出现了多少次
         */
        @Test
        public void test8() {
            Map<String, Long> map = dataList.stream().collect(Collectors.groupingBy(Person::getName, Collectors.counting()));
            System.out.println(map);
    
            List<String> list2 = new ArrayList<String>() {
                {
                    add("111");
                    add("111");
                    add("222");
                    add("333");
                    add("222");
                }
            };
            Map<String, Long> map2 = list2.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
            System.out.println(map2);
        }
    
    
    
    }
    
    class Person {
        private String name;
    
        private int age;
    
        public Person() {
    
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }