您的位置: 首页  >  文章  >  Java 8新特性

Java 8新特性

分类: 文章 • 2024-07-22 10:20:10

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

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


Java 8新特性

Java 8新特性


 Java 8新特性


Java 8新特性

Java 8新特性


  

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

  

Java 8新特性

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


Java 8新特性


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有多条语句的时候需要用大括号括起来：只有一条语句的时候


Java 8新特性


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));

输出：

Java 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);
}

Java 8新特性

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

Java 8新特性


Lambda需要函数式接口的支持

Java 8新特性


Java 8新特性

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


Java 8新特性


案例：

接口

@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);
}

输出：

Java 8新特性


带泛型的接口：

@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));
}


结果输出：

Java 8新特性

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


Java 8新特性

Java 8新特性


案例：

消费型接口

    @Test
    public void testConsumer(){
         consummer(10000,(m) -> System.out.println("消费"+m+"元"));

    }
//消费型接口
    public void consummer(double money,Consumer<Double> conm){
         //传过去参数
         conm.accept(money);

    }

输出：

Java 8新特性


供给型接口：

@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;

}

输出：

Java 8新特性

函数型接口：

@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);

}

输出：

Java 8新特性


断言型接口：返回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;
}


输出：

Java 8新特性

Java 8新特性


Java 8新特性

Java 8新特性

Java 8新特性


Java 8新特性


Java 8新特性

Java 8新特性


Java 8新特性

Java 8新特性

Java 8新特性



Java 8新特性


Java 8新特性

案例：

@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);
}

输出：

Java 8新特性



Java 8新特性


@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);


}

输出：

Java 8新特性





Java 8新特性


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

输出结果：

Java 8新特性




Java 8新特性

@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);
}


结果输出：


Java 8新特性


Java 8新特性


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



}

结果输出：

Java 8新特性



Java 8新特性


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


输出：

Java 8新特性


@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);
}

结果：

Java 8新特性




Java 8新特性


Java 8新特性




Java 8新特性


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


结果：


Java 8新特性

Java 8新特性

Java 8新特性


Java 8新特性






Java 8新特性

Java 8新特性

Java 8新特性


Java 8新特性

       

Java 8新特性

Java 8新特性

Java 8新特性

Java 8新特性

Java 8新特性


Java 8新特性

Java 8新特性


Java 8新特性


其他的特性：

Java 8新特性


Java 8新特性




相关推荐