Java 8新特性

末蓝、 2022-05-26 01:50 228阅读 0赞

java8中 HashMap的数据结构由数组+链表 新增加了红黑树   这样 查找、删除产，修改的效率变高，新增的效率变慢。

堆区，栈区，方法区，方法区是堆区的一部分，位于永久区PremGen

![70][]

![70 1][]

![70 2][]

![70 3][]

![70 4][]

Runnable runnable=() -> System.out.println("hello"+i);
    runnable.run();//输出hello0

![70 5][]

左侧是接口方法的参数    右侧是接口要实现的功能

![70 6][]

Consumer<String> con=(x) -> System.out.println(x);
    con.accept("ok");   //把ok传给上面输出
    
    Consumer<String> con1=x -> System.out.println(x);
    con1.accept("ok");   //把ok传给上面输出

Lambda有多条语句的时候需要用大括号括起来：只有一条语句的时候

![70 7][]

Comparator<Integer> com=(x,y) ->{
        System.out.println("ok"); //输出ok
        return Integer.compare(x,y);
    };
    
    Comparator<Integer> com2=(x,y) ->  Integer.compare(x,y);
    
    int value=com.compare(1,2); //1比2大
    System.out.println(value);
    
    System.out.println(com2.compare(1,2));

输出：

![70 8][]

Stream API 和Lambda表达式：

List<Employee> employees= Arrays.asList(
           new Employee("a",1,1000),
           new Employee("b",24,8888),
           new Employee("b",31,9999),
           new Employee("b",77,11111)
       );
    
       //获取薪水小于10000的员工
       employees.stream().filter((e) -> e.getSalary()<10000)
               .forEach(System.out::println);
    
       //获取所有员工的名字
       employees.stream()
               .map(Employee::getName)
               .forEach(System.out::println);
    }

![70 9][]

参数的数据类型可以省略不写：

![70 10][]

Lambda需要函数式接口的支持

![70 11][]

![70 12][]

MyFunction是一个泛型的接口  里面有一个String getValue()方法 返回String类型的值

![70 13][]

案例：

接口

@FunctionalInterface  //有这个注解的接口  只能有一个方法
    public interface EmployeeDao {
    
         String  say(String x);
    
    
    }

测试类：

@Test
    public void test1(){
            /*String saying=say("hello",str -> str+"world");*/
        String saying=say("hello",(String str) -> str+"world");
        //(String str) 就是接口里面方法的参数形式
    
            System.out.println(saying);
    }
    
    public String say(String s,EmployeeDao employeeDao){
       return employeeDao.say(s);
    }

输出：

![70 14][]

带泛型的接口：

@FunctionalInterface  //有这个注解的接口  只能有一个方法
    public interface EmployeeDao<T,R> {
             //T 是参数  R是返回值
          R say(T t,R r);
    
    
    }

测试类

@Test
    public void test1(){
         say("hello","world",(x,y) -> x+y);
        
    }
    
    public void say(String str1,String str2,EmployeeDao<String,String> employeeDao){
         System.out.println(employeeDao.say(str1,str2));
    }

结果输出：

![70 15][]

前面需要自定义接口 才能使用Lambdab表达式太麻烦  下面使用java8中自定义的接口

![70 16][]

![70 17][]

案例：

消费型接口

@Test
        public void testConsumer(){
             consummer(10000,(m) -> System.out.println("消费"+m+"元"));
    
        }
    //消费型接口
        public void consummer(double money,Consumer<Double> conm){
             //传过去参数
             conm.accept(money);
    
        }

输出：

![70 18][]

供给型接口：

@Test
    public void testSuply(){
        //下面产生的整数是100以内的随机数
        List<Integer> list=suply(5,() -> (int)(Math.random()*100));
        for(Integer i:list){
            System.out.println(i);
        }
    
    }
    //供给型接口
    //需求 产生指定的个数的整数，并且放入集number合中
    public List<Integer> suply(int number,Supplier<Integer> conm){
        //传过去参数
        List<Integer> list=new ArrayList<>();
        for(int i=0;i<number;i++){
            //产生一个整数
            Integer value=conm.get();
            list.add(value);
        }
    
         return list;
    
    }

输出：

![70 19][]

函数型接口：

@Test
    public void testFunction(){
       String newStr=function("hello",(str) -> str+"world");
       System.out.println(newStr);
    
    }
    //函数型接口
    public String function(String str, Function<String,String> f){
        //(String,String) 前面是参数类型  后面是返回值类型
         return f.apply(str);
    
    }

输出：

![70 20][]

断言型接口：返回boolean值

@Test
    public void testPredicate(){
    
         List<String> list=Arrays.asList("tom","jack","picke");
         list=predicate(list,(str) -> str.startsWith("t"));
         for(int i=0;i<list.size();i++){
             System.out.println(list.get(i));
         }
    
    }
    //断言型接口
    //需求  将满足条件的字符串加入带集合中
    public List<String> predicate(List<String> list ,Predicate<String> predicate){
         List<String> list1=new ArrayList<>();
        for(String s:list){
            if (predicate.test(s)){
                list1.add(s);
            }
        }
    
      return list1;
    }

输出：

![70 21][]

![70 22][]

![70 23][]

![70 24][]

![70 25][]

![70 26][]

![70 27][]

![70 28][]

![70 29][]

![70 30][]

![70 31][]

![70 32][]

![70 33][]

案例：

@Test
    public void test1(){
    
         //collection集合創建流
         List<String> list=new ArrayList<>();
         Stream<String> srtream=list.stream();
    
         //数组创建流
        Integer integer[]=new Integer[12];
        Stream<Integer> stream=Arrays.stream(integer);
    
        //Stream的静态方法 of()创建流
        Stream<String> stream1=Stream.of("a","b","c");
    
        //创建无限流  迭代的方式
        Stream<String> stream2=Stream.iterate("hello",(x) -> x+"world");
        stream2.limit(10).forEach(System.out::println);
    
        //创建无限流  生成的方式
        Stream<Double> stream3=Stream.generate(() -> Math.random()*100);
        stream3.limit(10).forEach(System.out::println);
    }

输出：

![70 34][]

![70 35][]

@Test
    public void test2(){
        List<Employee> employees= Arrays.asList(
                new Employee("a",1,1000),
                new Employee("b",24,8888),
                new Employee("b",31,9999),
                new Employee("b",77,11111)
        );
    
         //中间操作  不会执行任何内容  只有在终止操作的时候一次性执行全部的内容
         //filter  传入lambda表达式  获取salay大于1000的employee
         Stream<Employee> stream=employees.stream().filter((x) -> x.getSalary()>1000);
         //终止操作
         stream.forEach(System.out::println);
        //跳过前一个
        Stream<Employee> stream1=employees.stream().filter((x) -> x.getSalary()>1000).skip(1);
        //终止操作
        stream1.forEach(System.out::println);
    
    
    }

输出：

![70 36][]

![70 37][]

@Test
    public void test3(){
       List<String> list=Arrays.asList("aaa","bbb","ccc");
       //将list中的值变成大写
        Stream<String> stream=list.stream().map((str) -> str.toUpperCase());
        stream.forEach(System.out::println);
         //list.stream()方法操做的是里面的元素
        //提取employee的名字
        List<Employee> employees= Arrays.asList(
                new Employee("a",1,1000),
                new Employee("b",24,8888),
                new Employee("b",31,9999),
                new Employee("b",77,11111)
        );
        employees.stream().map((e) -> e.getSalary()).forEach(System.out::println);
    
        /*//得到的结果是流里面套流
        Stream<Stream<Character>> stream1=list.stream().map(Note::filterCharacter);
        stream1.forEach((stream2) -> {
                stream2.forEach(System.out::println);
        });*/
        //使用  优化上面的流套流
        System.out.println("......");
        list.stream().flatMap(Note::filterCharacter).forEach(System.out::println);
    
    
    }
    
     //提供一个函数供给上面使用  注意返回的是流
    public static Stream<Character> filterCharacter(String str){
        List<Character> list=new ArrayList<>();
        for(Character character:str.toCharArray()){
            list.add(character);
        }
        return list.stream();
    }

输出结果：

![70 38][]

![70 39][]

@Test
    public void test4(){
        List<String> list=Arrays.asList("tom","jack","picke");
        list.stream().sorted().forEach(System.out::println);
    
        List<Employee> employees= Arrays.asList(
                new Employee("a",1,1000),
                new Employee("b",24,8888),
                new Employee("b",31,9999),
                new Employee("b",77,11111)
        );
        employees.stream().sorted((e1,e2) ->{
              if (e1.getName().equalsIgnoreCase(e2.getName())){
                  return e1.getAge().compareTo(e2.getAge());
              }else {
                  return e1.getAge().compareTo(e2.getAge());
              }
    
        }).forEach(System.out::println);
    }

结果输出：

![70 40][]

![70 41][]

@Test
    public void test5(){
        List<Employee> employees= Arrays.asList(
                new Employee("a",1,1000),
                new Employee("b",24,8888),
                new Employee("b",31,9999),
                new Employee("b",77,11111)
        );
    
        //是不是所有的name=“b”
       boolean flag= employees.stream().allMatch((e) -> "b".equalsIgnoreCase(e.getName()));
       System.out.println(flag);
    
       //至少匹配一个元素 name="b"
        boolean flag2= employees.stream().anyMatch((e) -> "b".equalsIgnoreCase(e.getName()));
        System.out.println(flag2);
    
        //检查没有一个匹配name="b"
        boolean flag3= employees.stream().noneMatch((e) -> "b".equalsIgnoreCase(e.getName()));
        System.out.println(flag3);
    
        //找到第一个元素 返回一个容器类
        Optional<Employee> optional=employees.stream().sorted((e1, e2) -> e1.getAge().compareTo(e2.getAge())).findFirst();
        System.out.println(optional.get());
    
    
        //找到任何一个元素 返回一个容器类
        Optional<Employee> optional2=employees.stream().filter((e) -> "b".equalsIgnoreCase(e.getName())).findAny();
        System.out.println(optional2.get());
    
    
    
    }

结果输出：

![70 42][]

![70 43][]

@Test
    public void test6(){
        List<Employee> employees= Arrays.asList(
                new Employee("a",1,1000),
                new Employee("b",24,8888),
                new Employee("b",31,9999),
                new Employee("b",77,11111)
        );
    
        //返回流中总数
        Long count=employees.stream().count();
        System.out.println(count);
    
        //最大工资的employee
        Optional<Employee> optional=employees.stream().max((e1,e2) -> e1.getSalary().compareTo(e2.getSalary()));
        System.out.println(optional.get());
    
        //的带最大employee的工资是多少
        Optional<Integer> salary=employees.stream().map(Employee::getSalary).max((salarye1, salarye2) -> salarye1.compareTo(salarye2));
        System.out.println(salary.get());
    }

输出：

![70 44][]

@Test
    public void test7(){
        List<Employee> employees= Arrays.asList(
                new Employee("a",1,1000),
                new Employee("b",24,8888),
                new Employee("b",31,9999),
                new Employee("b",77,11111)
        );
    
        //计算employee的总工资    总工资从2开始累加
        //先把远编程工资  使用reduce
        //employees.stream().reduce(2,(x,y) -> x+y) 这种方式是错误的  stream得到的是employee的流
        Integer sum=employees.stream().map(Employee::getSalary).reduce(2,(x,y) -> x+y);
        System.out.println(sum);
    }

结果：

![70 45][]

![70 46][]

![70 47][]

![70 48][]

@Test
    public void test8(){
    
        List<Employee> employees= Arrays.asList(
                new Employee("a",1,1000),
                new Employee("b",24,8888),
                new Employee("b",31,9999),
                new Employee("b",77,11111)
        );
    
        //收集所有员工的名字
        List<String> list=employees.stream().map(Employee::getName).collect(Collectors.toList());
        list.forEach(System.out::println);
        //收集到自发定义的集合中
        HashSet<String> set=employees.stream().map(Employee::getName).collect(Collectors.toCollection(() -> new HashSet<>()));
        //上面的等同于HashSet<String> set=employees.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));
        set.forEach(System.out::println);
    
        //总数
        Long count=employees.stream().collect(Collectors.counting());
        //平均值
        Double avg=employees.stream().collect(Collectors.averagingInt(Employee::getSalary));
    
        //总和
        Double sun=employees.stream().collect(Collectors.averagingInt(Employee::getSalary));
    
        //最大薪水 返回的是员工
        Optional<Employee> optional=employees.stream().collect(Collectors.maxBy((e1,e2) -> e1.getSalary().compareTo(e2.getSalary())));
        System.out.println(optional.get());
    
    
        //最大薪水 返回的工资的值
        Optional<Integer> optional2=employees.stream().map(Employee::getSalary).collect(Collectors.maxBy((x,y) ->x.compareTo(y)));
        System.out.println(optional2.get());
    
        //分组  按姓名分组
         Map<String,List<Employee>> employeeMap=employees.stream().collect(Collectors.groupingBy(Employee::getName));
         System.out.println(employeeMap);
    
         System.out.println("........");
    
         //多级分组
        Map<String,Map<String,List<Employee>>> em=employees.stream().collect(Collectors.groupingBy(Employee::getName,Collectors.groupingBy(
                (e) ->{
                    if (e.getSalary()<3500){
                        return "低工资";
                    }else if (e.getSalary() <8000){
                        return "中等工资";
                    }else {
                        return "高工资";
    
                    }
                }
        )));
    
    
         System.out.println(em);
    
         //分区  按工资分区
        Map<Boolean,List<Employee>> booleanListMap=employees.stream().collect(Collectors.partitioningBy((e) -> e.getSalary() <5000));
        System.out.println(booleanListMap);
    
        //所有的name的值用逗号,连接在一起
        String name=employees.stream().map(Employee::getName).collect(Collectors.joining(","));
        System.out.println(name);
    
    }

结果输出：

a  
b  
b  
b  
a  
b  
Employee\{name='b', age=77, salary=11111\}  
11111  
\{a=\[Employee\{name='a', age=1, salary=1000\}\], b=\[Employee\{name='b', age=24, salary=8888\}, Employee\{name='b', age=31, salary=9999\}, Employee\{name='b', age=77, salary=11111\}\]\}  
........

\{a=\{低工资=\[Employee\{name='a', age=1, salary=1000\}\]\}, b=\{高工资=\[Employee\{name='b', age=24, salary=8888\}, Employee\{name='b', age=31, salary=9999\}, Employee\{name='b', age=77, salary=11111\}\]\}\}

\{false=\[Employee\{name='b', age=24, salary=8888\}, Employee\{name='b', age=31, salary=9999\}, Employee\{name='b', age=77, salary=11111\}\], true=\[Employee\{name='a', age=1, salary=1000\}\]\}

a,b,b,b  
  
  
Process finished with exit code 0

练习：

@Test
    public void test9(){
    
         //给定一个数字列表，如何返回每个数字的平方
         Integer num[]={
      1,2,3,4,5};
         Arrays.stream(num).map((x) -> x*x).forEach(System.out::println);
    
         //用map和reduce计算有数组里有多少个数字
         Optional<Integer> count=Arrays.stream(num).map((x) -> 1).reduce(Integer::sum);
         System.out.println(count.get());
    
    
         List<Employee> employees= Arrays.asList(
                 new Employee("a",1,1000),
                 new Employee("b",24,8888),
                 new Employee("b",31,8888),
                 new Employee("b",77,11111)
         );
    
        //找到name="b"的employee并且按照age 排序
         employees.stream().filter((e) -> e.getName().equalsIgnoreCase("b"))
                 //.sorted((e1,e2) -> Integer.compare(e1.getAge(),e2.getAge()));
                 .sorted((e1,e2) ->e1.getAge().compareTo(e2.getAge()))
                 .forEach(System.out::println);
    
         //员工的工资分别是多少 不重复
         employees.stream().map(Employee::getSalary).distinct()
                 .forEach(System.out::println);
    
         //返回所有employee的姓名并且按照字母排序
         employees.stream().map(Employee::getName)
                 .sorted((name1,name2) -> name1.compareTo(name2))
                 .forEach(System.out::println);
    
         //有没employe name="c"
         Boolean flag=employees.stream().allMatch((e) -> e.getName().equalsIgnoreCase("c"));
         System.out.println(flag);
    
         //employee的工资
         Optional<Integer> optional=employees.stream().map(Employee::getSalary)
                 .reduce(Integer::sum);
         System.out.println(optional.get());
    
         //employee的最高工资
         optional=employees.stream().map(Employee::getSalary).reduce((x,y) ->Integer.max(x,y));
         System.out.println(optional.get());
    
         //最小工资的employee
         Optional<Employee> o= employees.stream().collect(Collectors.minBy((e1,e2) -> e1.getSalary().compareTo(e2.getSalary())));
         System.out.println(o.get());
     }

结果：

![70 49][]

![70 50][]

![70 51][]

![70 52][]

![70 53][]

![70 54][]

![70 55][]

![70 56][]

![70 57][]

![70 58][]

![70 59][]

![70 60][]

![70 61][]

![70 62][]

![70 63][]

![70 64][]

其他的特性：

![70 65][]

![70 66][]

[70]: /images/20220526/b970e99e4c7d40bebf049496e42dc6b4.png
[70 1]: /images/20220526/93ad5d824d63479cafb05aced03b7aee.png
[70 2]: /images/20220526/7a6d0fdc324545efb49d577064c6d103.png
[70 3]: /images/20220526/0730ab84844f4eb7bfc7094a79aa7e7b.png
[70 4]: /images/20220526/98d8766827fa4eefa79ed3562180d91c.png
[70 5]: /images/20220526/fe70047111d2426f902eea1c96fc03b4.png
[70 6]: /images/20220526/a7da1f92b80c41ad863cf7496aa71327.png
[70 7]: /images/20220526/78c4eaa2d4864bfcaaf77040bc7e62ec.png
[70 8]: /images/20220526/82dd30c7caf24177b3494083daab7bb1.png
[70 9]: /images/20220526/cecc228d058942f28007a0d34a6fc873.png
[70 10]: /images/20220526/b4d63677d98e4b3f83efd6ce9f2abb5e.png
[70 11]: /images/20220526/bfbcab4c9fef4cd9adc470dd693bfa57.png
[70 12]: /images/20220526/0dcf72ade3e04579ab1c1812003ce6fb.png
[70 13]: /images/20220526/9e730337f81f4ed8853f06ef7baa9807.png
[70 14]: /images/20220526/3f28560eae8d4ac781c036d4caef0747.png
[70 15]: /images/20220526/f7d6a44bd4f24bbb8075dc182c903dcb.png
[70 16]: /images/20220526/b22712e85bda4cfaa2c2399061b958a0.png
[70 17]: /images/20220526/bdba822d120749558c4bd46508a70fc0.png
[70 18]: /images/20220526/8a220f5de61a4aecad79378af710ae93.png
[70 19]: /images/20220526/6281dbff16fb40f0a59c49fd805cf453.png
[70 20]: /images/20220526/f34ad3ef91d141dc8e9508a3ad62cef9.png
[70 21]: /images/20220526/14801f0be01546c5a6bb289f989e8738.png
[70 22]: /images/20220526/a84426cf56d445df8a950be1506e4c41.png
[70 23]: /images/20220526/9d5de512788a4057a11acc26a654a8a3.png
[70 24]: /images/20220526/68c23d4c856a4e2cad0ea3c5976f3922.png
[70 25]: /images/20220526/641e4530da3d4478805b67ab6b6d90d7.png
[70 26]: /images/20220526/8767cc6a334a40459890926c86f4947c.png
[70 27]: /images/20220526/78c567be76314c40bebeadccd58fd8bc.png
[70 28]: /images/20220526/fcddaba8d56c4783b6c85a9fa72fbccb.png
[70 29]: /images/20220526/e6d76bb4d5594022b6ebcb0992eb552f.png
[70 30]: /images/20220526/f0a1a65044294ef680c1476dd40f1822.png
[70 31]: /images/20220526/77a133dcd1af48f0b4ee51ea57fa9973.png
[70 32]: /images/20220526/448d26c8e41e490eb0de9aac54813b57.png
[70 33]: /images/20220526/1c5365ee2fe148d7a2fb3e89dfca5700.png
[70 34]: /images/20220526/f10047311e754633a439539985315e82.png
[70 35]: /images/20220526/bd50387b7c864b28bf66ef9e65326339.png
[70 36]: /images/20220526/0dfb6a1fff4c4790a73a3c192920ff82.png
[70 37]: /images/20220526/b4c6a953b9f144168742bf74a71cdf1e.png
[70 38]: /images/20220526/dcea10d411e642e9abe508a6cde527e9.png
[70 39]: /images/20220526/fe15c6e04b9340fa91fd24bf0c5ad526.png
[70 40]: /images/20220526/820bfcf8eb4b4e5f9e7701585bf74f82.png
[70 41]: /images/20220526/906cffd178d744bdac1c0125a0a63db5.png
[70 42]: /images/20220526/bbf71aa281384c03806087ac0142c52e.png
[70 43]: /images/20220526/99ed30fe6ecd437c9bdaf85399248782.png
[70 44]: /images/20220526/a0b29470280d4f14a31ba73c9ac3704c.png
[70 45]: /images/20220526/59488266d1e64892ba0c8dcbecbd1dff.png
[70 46]: /images/20220526/b0180f9b37cf482ea086e1e8bc91276e.png
[70 47]: /images/20220526/90eddbc2c8d74787b82158782b93fc0f.png
[70 48]: /images/20220526/83d49b7b84874e7ebe7ccf17049f9b51.png
[70 49]: /images/20220526/46af089920444cce996ebc976c23e566.png
[70 50]: /images/20220526/32e82fcbf3cd4ca98de82169f65f501d.png
[70 51]: /images/20220526/a2dc52fec0b948c6afeff8ae2d77c268.png
[70 52]: /images/20220526/514e4c85b72e458097eedc8775e639ae.png
[70 53]: /images/20220526/4612138c70e14051be8fbbc62060caa6.png
[70 54]: /images/20220526/dbd80a78ac784460b7b1ebdfafc91c32.png
[70 55]: /images/20220526/94e3e8ae4817498faf8e4304b1c570b3.png
[70 56]: /images/20220526/83551f59fa6c404d91a5b29b45db04ab.png
[70 57]: /images/20220526/64c5c94db7994187bbf06ef93cb2eeeb.png
[70 58]: /images/20220526/141e818829df47f4a08387f5ea166c30.png
[70 59]: /images/20220526/82c2b6cce5c94836b4724dd9efeb3152.png
[70 60]: /images/20220526/85870892bd2e4440b2228172c5a59676.png
[70 61]: /images/20220526/b5ae65112b5048de8af229e017e676e9.png
[70 62]: /images/20220526/855892c684f44f3f89d75e0021a47aa8.png
[70 63]: /images/20220526/f49de8e5154442caabe18599c3344b89.png
[70 64]: /images/20220526/806500e5e79444d99c39ce133be1fab4.png
[70 65]: /images/20220526/f757f33f539941c3a0e0b0915e73a305.png
[70 66]: /images/20220526/8eef54db1d434349ad823e5d20c7fae0.png

Java 8新特性

发表评论取消回复

还没有评论，来说两句吧...

相关阅读