java8知识点总结

最新推荐文章于 2022-04-12 15:05:15 发布
最新推荐文章于 2022-04-12 15:05:15 发布
阅读量539 收藏 1
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011676795/article/details/87527174
版权

      学了尚硅谷老师java8视频之后，本人一点一滴的对代码做了如下总结。仅供学习。

1、lambda表达式过渡：（优化方式1-优化方式4，追层优化，简化代码开发，可读性增强）

package com.example.demo.java8_1_lambda表达式过渡;

import com.example.demo.domain.Employee;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 体验lambda表达式
 */
public class Test0 {
    @Test
    public  void test1(){
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

        TreeSet<Integer> ts = new TreeSet<>(comparator);
        ts.add(1);
        ts.add(3);
        ts.add(2);
        System.out.println(ts);
    }

    @Test
    public void test2(){
        Comparator<Integer> comparator = (o1,o2) -> Integer.compare(o1,o2);

        TreeSet<Integer> ts = new TreeSet<>(comparator);
        ts.add(1);
        ts.add(3);
        ts.add(2);
        System.out.println(ts);
    }

    @Test
    public  void test3(){
        Comparator<Integer> comparator = Integer::compareTo;

        TreeSet<Integer> ts = new TreeSet<>(comparator);
        ts.add(1);
        ts.add(3);
        ts.add(2);
        System.out.println(ts);
    }


    /**
     * =======================================================================
     */
    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",38,5555.99),
            new Employee("王五",50,6666.66),
            new Employee("赵六",16,3333.33),
            new Employee("田七",8,7777.77)
    );
    //需求1：获取当前公司员工中年龄大于35的员工信息
    public List<Employee> filterEmployees(List<Employee> employees){
        List<Employee> emps = new ArrayList<>();
        for (Employee employee : employees) {
            if(employee.getAge() > 35){
                emps.add(employee);
            }
        }
        return  emps;
    }
    @Test
    public  void test4(){
        System.out.println(filterEmployees(employees));
    }


    /**
     * =======================================================================
     */
    //需求2：获取当前公司员工中工资大于5000的员工信息
    // 里边的方法跟需求1 差不多，再写一遍累赘，冗余代码
    //早先优化用设计模式  ，现在不需要了
    /**
     * 优化方式1 ，策略设计模式
     */
    public List<Employee> filterEmployee(List<Employee> employees,MyPredicate<Employee> myPredicate){
        List<Employee> emps = new ArrayList<>();
        for (Employee employee : employees) {
            if(myPredicate.test(employee)){
                emps.add(employee);
            }
        }
        return  emps;
    }
    @Test
    public  void test5(){
        System.out.println(filterEmployee(employees,new FilterEmployeeByAge()));
        System.out.println("-----------------------------");
        System.out.println(filterEmployee(employees,new FilterEmployeeBySalary()));
        System.out.println("-----------------------------");
    }

    //优化方式2：  每次都要实现MyPredicate接口，只写一点，多余。。。---匿名内部类优化
    @Test
    public  void test6(){
        List<Employee> employees = filterEmployee(this.employees, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary() <= 5000;
            }
        });
        System.out.println(employees);
    }

    //优化方式3  lambda表达式
    @Test
    public  void test7(){
        List<Employee> employees = filterEmployee(this.employees, (employee -> employee.getSalary() <= 5000));
        System.out.println(employees);
    }

    //优化方式4  MyPredicate接口,以及一切继承类都不再需要  stream api优化
    @Test
    public  void test8(){
        List<Employee> collect = employees
                .stream()
                .filter((employee -> employee.getSalary() >= 5000))
                .limit(2)  //取前两个数据
                .collect(Collectors.toList());
        System.out.println(collect);

        System.out.println("----------------");

        //把集合中所有名字提取出来
        List<String> collect1 = employees.stream().map(Employee::getName).collect(Collectors.toList());
        System.out.println(collect1);
    }
}

2、Lambda表达式基本语法

package com.example.demo.java8_2_lambda表达式;
import org.junit.Test;
import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * 一、Lambda表达式基本语法   (列表参数) -> lambda体
 *
 * 语法格式1：无参数，无返回值
 *         （） -> System.out.println("hello lambda");
 *
 * 语法格式2： 有一个参数，并且无返回值
 *          (x) -> System.out.println(x);
 *
 * 语法格式3： 若只有一个参数，小括号可以省略不写
 *
 * 语法格式4： 两个以上的参数，有返回值，并且lambda体中有多条语句
 *          Comparator<Integer> com = (x,y) -> {
 *             System.out.println("函数式接口");
 *             return  Integer.compare(x,y);
 *         };
 *
 * 语法格式5：若lambda体只有一条语句，return和大括号都可以省略不写
 *
 * 语法格式6：参数类型可以不写，jvm推断出参数类型
 *
 * 二、Lambda表达式需要函数式接口的支持
 *
 */
public class TestLambda {
    @Test
    public  void test1(){
        //语法格式1： 无参，无返回值  demo
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello lambda");
            }
        };
        r1.run();

        System.out.println("=================================");
        Runnable r2 = () -> System.out.println("hello lambda");
        r2.run();
    }

    @Test
    public  void  test2(){
        //语法格式2：有一个参数，并且无返回值
        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("我大中国威武");
    }

    @Test
    public  void test4(){
        //语法格式4： 两个以上的参数，有返回值，并且lambda体中有多条语句
        Comparator<Integer> com = (x,y) -> {
            System.out.println("函数式接口");
            return  Integer.compare(x,y);
        };
        System.out.println(com.compare(3,2));
    }

    //需求：对一个数进行运算
    @Test
    public  void  test5(){
        System.out.println(operation(10, x -> x* x));
    }
    public  Integer operation(Integer num, Function<Integer,Integer> fun){
        return fun.apply(num);
    }

}

3、Lambda表达式基本语法练习

package com.example.demo.java8_2_lambda表达式;

import com.example.demo.domain.Employee;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class TestLambdaPractise {
    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",38,5555.99),
            new Employee("王五",50,6666.66),
            new Employee("赵六",16,3333.33),
            new Employee("田七",8,7777.77),
            new Employee("阿八",8,7777.77)
    );

    //一、调用Collections.sort() 方法，通过定制排序比较两个Employee(先按年龄比，年龄相同按姓名比)，使用Lambda作为参数传递
    @Test
    public  void test1(){
        Collections.sort(employees,(e1,e2)-> {
            if(e1.getAge() == e2.getAge()){
                return -e1.getName().compareTo(e2.getName());
            }else {
                return  Integer.compare(e1.getAge(),e2.getAge());
            }
        });
        employees.forEach(System.out::println);
    }

    //二、1、声明函数式接口，接口中声明抽象方法， public String getValue(String str);
    //二、2、声明类TestLambda,类中编写方法使用接口作为参数，将一个字符串转换为大写，并作为方法的返回值
    @Test
    public  void test2(){
        System.out.println(getStr("adsada",String::toUpperCase));
    }

    public  String getStr(String str,MyInterface myInterface){
        return myInterface.getValue(str);
    }

    //二、3、再讲一个字符串的第二个和第四个索引位置进行截取子串
    @Test
    public  void test3(){
        System.out.println(getStr("dasdsaddvcs",x -> x.substring(1,4)));
    }

    //三、1、声明一个带两个泛型的函数式接口，泛型类型为<T,R>,T为参数，R为返回值
    //三、2、接口中声明对应抽象方法
    //三、3、在TestLambda类中声明方法，使用接口作为参数，计算两个long参数的和
    @Test
    public  void test4(){
        System.out.println(getSalary(1000,2000,(x,y) -> x+y));
    }
    public  double getSalary(double money1,double money2,MyInterface2<Double,Double> myInterface2){
        return  myInterface2.getTh(money1,money2);
    }

    //三、4、再计算两个long参数的乘积
    @Test
    public  void test5(){
        System.out.println(getSalary(100,300,(x,y) -> x*y));
    }

}

4、四大内置核心函数式接口

package com.example.demo.java8_3_四大内置核心函数式接口;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 内置的四大核心函数式接口
 * 1、Consumer<T> :消费型接口
 *       void accept(T t)
 *
 * 2、Supplier<T> :供给型接口
 *       T get()
 *
 * 3、Function<T,R> :函数型接口
 *      R apply(T t)
 *
 * 4、Predicate<T> :断言型接口
 *     boolean  test(T t)
 *
 * */
public class TestLambda {
    //1、Consumer<T> :消费型接口
    @Test
    public  void test1(){
        happy(1000,m -> System.out.println("消费"+m));
    }
    public  void happy(double money, Consumer<Double> con){
        con.accept(money);
    }

    //2、Supplier<T> :供给型接口
    //产生指定个数的整数，并放入集合中
    @Test
    public  void test2(){
        //随机产生10个整数放到集合中
        System.out.println(getNumList(10,()-> (int)(Math.random()*100)));
    }
    public List<Integer> getNumList(int num , Supplier<Integer> sup){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(sup.get());
        }
        return  list;
    }

    //Function<T,R> :函数型接口
    //需求：用于处理字符串
    @Test
    public  void test3(){
        System.out.println(strHandler("dasd",String::toUpperCase));
    }
    public  String strHandler(String str, Function<String,String> fun){
        return fun.apply(str);
    }

    //Predicate<T> :断言型接口
    //需求：将满足条件的字符串放入结合中，并返回
    @Test
    public  void test4(){
        List<String> list = Arrays.asList("hello","lambda","wwwww","ok");
        System.out.println(filterStr(list, s -> s.length()> 3));
    }
    public  List<String> filterStr(List<String> list, Predicate<String> pre) {
        List<String> strList = new ArrayList<>();
        for (String str : list) {
            if(pre.test(str)){
                strList.add(str);
            }
        }
        return  strList;
    }
}

5、方法引用与构造器引用

package com.example.demo.java8_4_方法引用与构造器引用;

import com.example.demo.domain.Employee;
import org.junit.Test;
import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 方法引用：若Lambda体中的内容有方法已经实现了，我们可以使用“方法引用”
 *          （可以理解为方法引用是Lambda表达式的另外一种表现形式）
 *
 *  语法格式：
 *  1、对象：：实例方法名
 *
 *  2、类：：静态方法名
 *
 *  3、类：：实例方法名
 *
 *  构造器引用：ClassName::new
 *
 *  数组引用：Type::new
 */
public class TestMethodRef {

    @Test
    public  void test1(){
        Consumer<String> con = x -> System.out.println(x);
        //对象：：实例方法名
        PrintStream ps = System.out;
        Consumer<String> con1 = ps::println;

        con1.accept("dasdasd");
    }

    @Test
    public  void test2(){
        //对象：：实例方法名
        Employee emp = new Employee();
        Supplier<String> sup = () -> emp.getName();
        System.out.println(sup.get());

        System.out.println("----------------------");
        Supplier<Integer> sup1 = emp::getAge;
        System.out.println(sup1.get());
    }

    @Test
    public  void test3(){
        //类：：静态方法名
        Comparator<Integer> con = (x, y) -> Integer.compare(x,y);
        System.out.println(con.compare(3,4));

        System.out.println("-----------------");
        Comparator<Integer> con1 = Integer::compare;
        System.out.println(con1.compare(1,5));
    }

    @Test
    public  void test4(){
        //类：：实例方法名
        BiPredicate<String,String> bp1 = (x,y) -> x.equals(y);
        System.out.println("-----------------");
        BiPredicate<String,String> bp2 = String::equals;
        System.out.println( bp2.test("x","x"));
    }

    @Test
    public  void test5(){
        //构造器引用：ClassName::new
        Supplier<Employee> sup1 = () -> new Employee();
        Supplier<Employee> sup2 = Employee::new; //注意：一定调用的是无参构造，
    }

    @Test
    public  void test6(){
        //数组引用：Type::new
        Function<Integer,String[]> fun1 = x -> new String[x];
        System.out.println(fun1.apply(10).length);
        System.out.println("--------------------");
        Function<Integer,String[]> fun2 = String[]::new;
        System.out.println(fun2.apply(10).length);
    }
}

6、练习再做

package com.example.demo.java8_4_练习再做;

import com.example.demo.domain.Employee;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;

public class TestPractise {
    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",38,5555.99),
            new Employee("王五",50,6666.66),
            new Employee("赵六",16,3333.33),
            new Employee("田七",8,7777.77),
            new Employee("阿八",8,7777.77)
    );

    //一、调用Collections.sort() 方法，通过定制排序比较两个Employee(先按年龄比，年龄相同按姓名比)，使用Lambda作为参数传递
    @Test
    public  void test1(){
        employees.sort((x,y) -> {
            if(x.getAge() == y.getAge()){
                return x.getName().compareTo(y.getName());
            }else{
                return Integer.compare(x.getAge(),y.getAge());
            }
        });
        employees.forEach(System.out::println);
    }

    //二、1、声明函数式接口，接口中声明抽象方法， public String getValue(String str);
    //二、2、声明类TestLambda,类中编写方法使用接口作为参数，将一个字符串转换为大写，并作为方法的返回值
    @Test
    public  void test2(){
        Function<String,String> fun = String::toUpperCase;
        System.out.println(fun.apply("zhansgan"));
    }

    //二、3、再讲一个字符串的第二个和第四个索引位置进行截取子串
    @Test
    public  void test3(){
        Function<String,String> fun = x -> x.substring(1,4);
        System.out.println(fun.apply("zhangsan"));
    }

    //三、1、声明一个带两个泛型的函数式接口，泛型类型为<T,R>,T为参数，R为返回值
    //三、2、接口中声明对应抽象方法
    //三、3、在TestLambda类中声明方法，使用接口作为参数，计算两个long参数的和
    @Test
    public  void test4(){
        BiFunction<Long,Long,Long> biFunction = (x,y) -> x+y;
        System.out.println(biFunction.apply(111l,222l));
    }

    //三、4、再计算两个long参数的乘积
    @Test
    public  void test5(){
        BiFunction<Long,Long,Long> biFunction = (x,y) -> x*y ;
        System.out.println(biFunction.apply(100l,900l));
    }
}

7、stream api

 

 

 

许八点半
关注
专栏目录
Java8 知识点
05-31
知识点总结 参考 Java: The Complete Reference, Tenth Edition explains how to develop, compile, debug, and run Java programs. Bestselling programming author Herb Schildt covers the entire Java language, including its syntax, keywords, and fundamental programming principles. You'll also find information on key portions of the Java API library, such as I/O, the Collections Framework, the stream library, and the concurrency utilities. Swing, JavaFX, JavaBeans, and servlets are examined and numerous examples demonstrate Java in action. Of course, the new module system added by Java SE 9 is discussed in detail. This Oracle Press resource also offers an introduction to JShell, Java’s new interactive programming tool.
Java知识点总结
Leo的博客
10-27 1639
1，final类型的变量一定要初始化，因为final变量的值不能改变；final修饰的方法不允许被重写，但可以被重载；final修饰的类不能被继承；final修饰的引用类型，不能在指向别的东西，但可改变其中的内容。 2，Java在编译时将源文件编译成字节码文件，在运行时把字节码文件变成机器码文件，C/C++在编译时直接编译成机器码。 3，创建servlet实例是由servlet容器完成，并且在...
JAVA8知识点概览
及时雨的csdn
12-28 265
行为参数化（Lambda 以及方法引用） Java 8通过借鉴函数式编程，提供了一种新的方式——通过向方法传递代码片段来解决这一问题。这种新的方法非常方便地提供了两种变体。 传递一个Lambda表达式，即一段精简的代码片段，比如 apple -> apple.getWeight() > 150 传递一个方法引用，该方法引用指向了一个现有的方法，比如这样的代码： Apple::isHeavy 这些值具有类似 Function<T, R> 、 Predicate<T..
【读书笔记】《写给大忙人看的Java SE 8》——Java8新特性总结
a61140502935的博客
10-23 424
接口中的默认方法和静态方法 先考虑一个问题，如何向Java中的集合库中增加方法？例如在Java 8中向Collection接口中添加了一个forEach方法。 如果在Java 8之前，对于接口来说，其中的方法必须都为抽象方法，也就是说接口中不允许有接口的实现，那么就需要对每个实现Collection接口的类都需要实现一个forEach方法。 但这就会造成在给接口添加新方法的同时影响...
Java基础知识点总结.docx
04-03
以下是对这些知识点的详细说明： 一、Java概述： Java是由Sun Microsystems开发的一种跨平台的编程语言，它具有“一次编写，到处运行”的特性，通过Java虚拟机（JVM）实现平台无关性。Java有丰富的类库支持，适用于...
JAVA核心知识点总结.pdf
10-02
《JAVA核心知识点总结》 Java作为一款广泛应用的编程语言，其核心知识点对于开发者来说至关重要。本资料旨在为准备面试或者系统学习Java的人员提供一个全面的复习框架。以下是对其中部分关键知识点的详细阐述： **...
java集合知识点总结.doc
12-21
Java 集合知识点总结 Java 集合知识点总结是指在 Java编程语言中对集合的知识点的总结。集合是 Java 编程语言中的一种数据结构，用于存储和操作数据。 Java 集合知识点总结包括集合的定义、集合的分类、集合的操作...
JAVA反射知识点总结
12-22
使用反射的基本步骤四.Class类讲解（1）Class类是反射机制的起源和入口（2）Class类存放类的结构信息（3）获取 Class对象的方式（4）获取类的...对象（6）动态执行方法（7）反射动态操作属性值（8）反射技术的优点和缺点...
Java基础知识点总结
最新发布
10-24
Java基础知识点总结 Java基础知识点总结是一篇关于Java基础知识的总结，涵盖了Java的概述、Java技术架构、JDK、JRE、环境变量配置、classpath配置、javac命令和java命令、Java语法基础等内容。 一、Java概述 Java...
Java8相关知识点汇总(上)
HardyZhan的博客
04-12 313
Java8相关知识点汇总(上) 一、行为参数化 行为参数化就是一个方法接受多个不同的行为作为参数，并在内部使用它们，完成不同行为的能力。 二、Lambda表达式 可以把Lambda表达式理解为一种简洁的可传递匿名函数：它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。 只有在接受函数式接口的地方才可以使用Lambda表达式。 1. 匿名 说它是匿名的，因为它不像普通的方法那样有一个明确的名称：写的少想得多。 2. 函数 说它是一种函数，是因为Lambda函数不像方法那样属于某个
（一）Java8基础知识
余笙的博客
05-10 312
一、Java8基础概念 1、流处理 流是一系列数据项，一次只生成一项。程序可以从输入流中一个一个读取数据项，然后利用同样的方式将数据项写入输出流。一个程序的输出流很可能是另一个程序的输入流。 举例：比如在Unix或Linux中，很多程序都从标准输入（Java中的System.in）来读取数据，然后把结果写入标准输出流（System.out）。 2、方法引用 方法引用通过方法的名字来指向一个方法，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。 语法：方法引用使用一对冒号:: 传统方式筛选一个目录中
Java8基础知识点梳理
qq_27416233的博客
11-30 462
最近可能是自己的原因导致对Java8的学习落入的下乘,我们就来抽个时间将Java8的知识点进行梳理下吧 ###常用的函数(函数式接口) 1.function 根据我的记忆是function里面有个apply方法,apply方法是接受一个参数，并不返回值,我们去看下源码 那么就比较明显了,我记错了，在我看来这个是一个好事,下面我们去写个代码去测试一下这个方法 import java.ut...
Java8总结
人过留名 雁过留声
04-16 587
Java8（部分内容来自Java实战一书） 零.Lambda表达式 1. 为什么需要Lambda表达式 在Java中，我们无法将函数作为参数传递给一个方法，也无法声明返回一个函数的方法。 在JS中，函数参数是一个函数，返回值是另一个函数是常见的，所以JS是一门非常典型的函数式语言 2. 什么是Lambda表达式：维基百科：函数式编程（英语：functional programming）或称函数...
Java8 总结
大鹏小站的博客
03-11 168
过年期间在家里陆陆续续把张龙的Java8看了一遍，老师讲解的非常好，简洁易懂，今天做一个总结 深入理解 Java8+jdk8 源码级思想 （完） 参考文章： Java8 JAVA8新特性 ...
JAVA知识点总结
carolineme的博客
03-03 199
一、JavaSE面试题 1、自增变量 public static void main(String[] args){ int i = 1; i = i++; int j = i++; int k = i + ++i * i++; System.out.println("i=" + i); System.out.println("j=" + j); System.out.println("k=" + k); } 输出结果：i=4 j=1 k=11
精品资料：JAVA基础知识点总结【推荐】
JAVA基础知识点总结精品资料是一份吐血推荐的学习资料，涵盖了Java程序设计的概述、开发Java语言的公司、以及开发Java的三个版本：J2SE(Java2 Standard Edition)、J2EE(Java 2 Platform,Enterprise Edition)、J2ME...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值