Java8特性学习笔记

最新推荐文章于 2022-11-29 11:27:09 发布
最新推荐文章于 2022-11-29 11:27:09 发布
阅读量100 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37863891/article/details/120870838
版权

Java8特性

lambda表达式

这个东西很多编程语言都有，比如C++，python，java中的lambda表达式相当于创建一个函数式接口的实例（如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口）。

  1. 举例： (o1,o2) -> Integer.compare(o1,o2);
  2. 格式：
    -> :lambda操作符 或 箭头操作符
    ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
    ->右边：lambda体 （其实就是重写的抽象方法的方法体）
  3. Lambda表达式的使用
    ->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个参数，其一对()也可以省略
    ->右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字

lambda表达式使用

public class LambdaTest1 {
    //语法格式一：无参，无返回值
    @Test
    public void test1(){
//        Runnable r1 = new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("原匿名函数");
//            }
//        };
//        r1.run();

        Runnable r2 = () -> {
            System.out.println("lambda表达式");
        };
        r2.run();
    }

    //语法格式二：Lambda 需要一个参数，但是没有返回值。
    @Test
    public void test2(){

        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("原匿名函数");

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

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
//        省略数据类型
//        Consumer<String> con1 = (s) -> {
//            System.out.println(s);
//        };
//        可以省略参数类型和（）
//        Consumer<String> con1 = s -> {
//            System.out.println(s);
//        };
//        只有一条语句时{}也可以省
//        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("lambda表达式");
    }

    //语法格式三：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test6(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };

        System.out.println(com1.compare(12,21));

        System.out.println("*****************************");
        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };

        System.out.println(com2.compare(12,6));
    }

    //语法格式四：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
    @Test
    public void test7(){

        Comparator<Integer> com1 = (o1,o2) -> {
            return o1.compareTo(o2);
        };

        System.out.println(com1.compare(12,6));

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

        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);

        System.out.println(com2.compare(12,21));

    }
}

java内置的4大核心函数式接口

lambda本质时函数式接口，可以看下最常用的函数式接口

  1. 消费型接口 Consumer void accept(T t)
  2. 供给型接口 Supplier T get()
  3. 函数型接口 Function<T,R> R apply(T t)
  4. 断定型接口 Predicate boolean test(T t)
public class LambdaTest2 {
@Test
    public void test1(){

        doSomething(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("逛街购物花了：" + aDouble);
            }
        });

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

        // money是入参，因为是单参数省略类型和()
        doSomething(400,money -> System.out.println("逛街购物花了：" + money));
    }

    public void doSomething(double money, Consumer<Double> con){
        con.accept(money);
    }

    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京","南京","天津","东京","西京","普京");

        List<String> filterStrs = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });

        System.out.println(filterStrs);

        // 省略return
        List<String> filterStrs1 = filterString(list,s -> s.contains("京"));
        System.out.println(filterStrs1);
    }

    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre){

        ArrayList<String> filterList = new ArrayList<>();

        for(String s : list){
            if(pre.test(s)){
                filterList.add(s);
            }
        }

        return filterList;
    }
}

方法引用

  1. 使用情境：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
  2. 本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以方法引用，也是函数式接口的实例。
  3. 使用格式： 类(或对象) :: 方法名
  4. 具体分为如下的三种情况：
    情况1 对象 :: 非静态方法
    情况2 类 :: 静态方法
    情况3 类 :: 非静态方法
  5. 方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）

关于方法引用，虽然代码便简洁了，但是可读性会变得非常差，所以一般用lambda就可以，这里记录一下只做了解

  • 测试用例
package com.lujw.java;

public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

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

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Employee() {
		System.out.println("Employee().....");
	}

	public Employee(int id) {
		this.id = id;
		System.out.println("Employee(int id).....");
	}

	public Employee(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public Employee(int id, String name, int age, double salary) {

		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	@Override
	public String toString() {
		return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
	}

	@Override
	public boolean equals(Object o) {
		if (this == o)
			return true;
		if (o == null || getClass() != o.getClass())
			return false;

		Employee employee = (Employee) o;

		if (id != employee.id)
			return false;
		if (age != employee.age)
			return false;
		if (Double.compare(employee.salary, salary) != 0)
			return false;
		return name != null ? name.equals(employee.name) : employee.name == null;
	}

	@Override
	public int hashCode() {
		int result;
		long temp;
		result = id;
		result = 31 * result + (name != null ? name.hashCode() : 0);
		result = 31 * result + age;
		temp = Double.doubleToLongBits(salary);
		result = 31 * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
}

public class MethodRefTest {
    	// 情况一：对象 :: 实例方法
	// Consumer中的void accept(T t)
	// PrintStream中的void println(T t)
	@Test
	public void test1() {
		Consumer<String> con1 = str -> System.out.println(str);
		con1.accept("哇哈哈");

		System.out.println("*******************");
		PrintStream ps = System.out;
		// println的作用和 str -> System.out.println(str)一样，且入参和出参也一致，直接使用方法引用
		Consumer<String> con2 = ps::println;
		con2.accept("beijing");
	}

	// 情况二：类 :: 静态方法
	//Comparator中的int compare(T t1,T t2)
	//Integer中的int compare(T t1,T t2)
	@Test
	public void test3() {
		Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
		System.out.println(com1.compare(12,21));
		System.out.println("*******************");
		// Integer中的静态方法compare作用与(t1,t2) -> Integer.compare(t1,t2)一致;
		Comparator<Integer> com2 = Integer::compare;
		System.out.println(com2.compare(12,3));
	}

	// 情况三：类 :: 实例方法  (有难度)
	// Comparator中的int comapre(T t1,T t2)
	// String中的int t1.compareTo(t2)
	@Test
	public void test5() {
		Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
		System.out.println(com1.compare("abc","abd"));

		System.out.println("*******************");
        // 虽然compareTo的入参和comapre不一致，但是compareTo是由t1调用的，也可以替换
		Comparator<String> com2 = String :: compareTo;
		System.out.println(com2.compare("abd","abm"));
	}
}

Stream

  1. Stream关注的是对数据的运算，与CPU打交道，相当于是对数据的运算。只要作用与集合，可以看成作用于集合的算法
  2. Stream 自己不会存储元素。
    Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
    Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
  3. Stream 执行流程
    3.1 Stream的实例化
    3.2 一系列的中间操作（过滤、映射、…) : 一个中间操作链，对数据源的数据进行处理
    3.3 终止操作 : 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

Stream的实例化

  • 测试用例
public class EmployeeData {
	public static List<Employee> getEmployees(){
		List<Employee> list = new ArrayList<>();
		list.add(new Employee(1001, "甲1", 34, 6000.38));
		list.add(new Employee(1002, "甲2", 12, 9876.12));
		list.add(new Employee(1003, "甲3", 33, 3000.82));
		list.add(new Employee(1004, "甲4", 26, 7657.37));
		list.add(new Employee(1005, "甲5", 65, 5555.32));
		list.add(new Employee(1006, "甲6", 42, 9500.43));
		list.add(new Employee(1007, "甲7", 26, 4333.32));
		list.add(new Employee(1008, "甲8", 35, 2500.32));
		return list;
	}
}
  • 创建方式
public class StreamAPITest {
    //创建 Stream方式一：通过集合
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
    //        default Stream<E> stream() : 返回一个顺序流，按集合顺序取出数据给溜
        Stream<Employee> stream = employees.stream();
    //        default Stream<E> parallelStream() : 返回一个并行流，多线程并发取数据给流
        Stream<Employee> parallelStream = employees.parallelStream();
    }

    //创建 Stream方式二：通过数组
    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee e1 = new Employee(1001,"Tom");
        Employee e2 = new Employee(1002,"Jerry");
        Employee[] arr1 = new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }

    //创建 Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    }

    //创建 Stream方式四：创建无限流
    @Test
    public void test4(){

        //      迭代
        //      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //0是初始值，每次加2，遍历前10个偶数，进行打印
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);


    //      生成随意流，中间操作：限制10个，终止操作：forEach
    //      public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}

Stream中间操作

方法描述
filter(Predicate p)接收 Lambda ， 从流中排除某些元素。
limit(n)截断流，使其元素不超过给定数量。
skip(n)跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
distinct()筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
map(Function f)接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
sorted()自然排序
sorted(Comparator com)定制排序
public class StreamAPITest1 {
    //1-筛选与切片
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
//        filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
        Stream<Employee> stream = list.stream();
        //练习：查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);

        System.out.println();
//        limit(n)——截断流，使其元素不超过给定数量。
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();

//        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        list.stream().skip(3).forEach(System.out::println);

        System.out.println();
//        distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",41,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));

//        System.out.println(list);

        list.stream().distinct().forEach(System.out::println);
    }

    @Test
    public void test2(){
//        map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

        //获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
        System.out.println();

        // map与flatMap的理解方式可以对比list里面的add与addall方法
        // 该情况下map生成一个流的流
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });
        System.out.println();
        // flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        // 该情况下只生成Character的流
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
    }

    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){//aa
        ArrayList<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()){
            list.add(c);
        }
       return list.stream();
    }

    //3-排序
    @Test
    public void test4(){
        // sorted()——自然排序，该方法需要实现Comparable接口，否则异常
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);

        //        sorted(Comparator com)——定制排序

        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted( (e1,e2) -> {

           int ageValue = Integer.compare(e1.getAge(),e2.getAge());
           if(ageValue != 0){
               return ageValue;
           }else{
               return -Double.compare(e1.getSalary(),e2.getSalary());
           }

        }).forEach(System.out::println);
    }
}

Stream终止操作

方法描述
allMatch(Predicate p)检查是否匹配所有元素
anyMatch(Predicate p)检查是否至少匹配一个元素
noneMatch(Predicate p)检查是否没有匹配的元素
findFirst()返回第一个元素
findAny()返回当前流中的任意元素,该方法只适用于parallelStream()方法创建的流
count()返回流中元素的总个数
max(Comparator c)返回流中最大值
min(Comparator c)返回流中最小值
forEach(Consumer c)内部迭代处理
reduce(T identity, BinaryOperator)可以将流中元素反复结合起来，得到一个值。返回 T
reduce(BinaryOperator)可以将流中元素反复结合起来，得到一个值。返回 Optional
collect(Collector c)将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
public class StreamAPITest2 {

    //1-匹配与查找
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();

        // allMatch(Predicate p)——检查是否匹配所有元素。
        // 是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

        // anyMatch(Predicate p)——检查是否至少匹配一个元素。
        // 是否存在员工的工资大于 10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

        // noneMatch(Predicate p)——检查是否没有匹配的元素。
        // 是否存在员工姓“甲”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("甲"));
        System.out.println(noneMatch);
        // findFirst——返回第一个元素
        Optional<Employee> employee = employees.stream().findFirst();
        System.out.println(employee);
        // findAny——返回当前流中的任意元素，只对parallelStream方法创建的流有用，否正只返回第一个
        Optional<Employee> employee1 = employees.parallelStream().findAny();
        System.out.println(employee1);

    }

    @Test
    public void test2(){
        List<Employee> employees = EmployeeData.getEmployees();
        // count——返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);
        // max(Comparator c)——返回流中最大值
        // 返回最高的工资：
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compare);    //此处为方法引用
        System.out.println(maxSalary);
        // min(Comparator c)——返回流中最小值
        // 返回最低工资的员工
        Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee);
        System.out.println();
        // forEach(Consumer c)——内部迭代
        employees.stream().forEach(System.out::println);

        // 使用集合的遍历操作
        employees.forEach(System.out::println);
    }

    //2-归约
    @Test
    public void test3(){
        // reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
        // 计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);


        // reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
        // 计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
        // Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
        Optional<Double> sumMoney = salaryStream.reduce((d1,d2) -> d1 + d2);
        System.out.println(sumMoney.get());
    }

    //3-收集
    @Test
    public void test4(){
        // collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
        // 查找工资大于6000的员工，结果返回为一个List或Set
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        employeeList.forEach(System.out::println);
        System.out.println();
        Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        employeeSet.forEach(System.out::println);
    }
}

Optional

Optional主要是为了处理空指针异常的新增的特性，主要了解下几个常用的方法

方法描述
Optional.of(T t)创建一个 Optional 实例，t必须非空；
Optional.empty()创建一个空的 Optional 实例
Optional.ofNullable(T t)t可以为null
orElse(T t1)如果单前的Optional内部封装的t是非空的，则返回内部的t.
心如镜止于水
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java8新特性学习笔记.rar
07-07
但是我们实际开发中真正用到的新特性并不多，大多数人也仅仅用用lambda，而对于其他的特性，比如：多重注解、Date API、函数式接口等等并没有使用起来，本资源包含作者的学习java8新特性的笔记，笔记中有讲解和代码...
常见的函数式接口介绍
技术积累，技术分享
06-17 1326
了解常见的函数式接口
Java基础 - 第十一章 - JDK8新特性
SongYu的博客
08-29 1万+
新特性 一、Java8新特性 1.Lambda表达式 Lambda表达式的使用 1.举例： (o1,o2) -> Integer.compare(o1,o2); 2.格式： -> :lambda操作符 或 箭头操作符 ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表） ->右边：lambda体 （其实就是重写的抽象方法的方法体） 3.Lambda表达式的使用：（分为6种情况介绍） 总结： ->左边：lambda形参
函数式接口
weixin_43541103的博客
02-13 129
一、函数式接口 1、概述：函数式接口就是有且仅有一个抽象方法的接口。Java中的函数式编程体现就是Lambda表达式所以函数式接口就是适用于Lambda表达式使用的接口，只有确保接口中有且仅有一个抽象方法，Java中的Lambda表达式才能顺利地进行推导 2、如何检测一个接口是否为函数式接口？ 函数式接口有个关键字注解：@FunctionalInterface 该注解放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败 3、注意：定义函数式接口的时候，@FunctionalInterfac
Java--函数式接口(java.util.function包)
IT利刃出鞘的博客
02-26 1988
其他网址 JDK8函数式接口Function、Consumer、Predicate、Supplier_酒肉猿-CSDN博客Java8中Function函数式接口详解及使用_Life is for sharing的博客-CSDN博客JAVA8的java.util.function包讲解 (方便的函数式编程)_我是guyue，guyue就是我O(∩_∩)O-CSDN博客 简介 原理 其他网址 【Java8】Function 讲解_sowhat-CSDN博客 ...
JAVA8 Function＜T,R＞ 和 BiFunction＜T,U,R＞ 接口
xjj1314的专栏
08-11 2147
Function是名字一般是一个函数接口，是JDK 1.8 新增加的函数式接口。 public interface Function<T, R> { /** * 将此函数应用于给定参数 * 真正执行函数接口的方法 */ R apply(T t); /** * 函数链，before执行的结果做根函数为参数 */ default <V> Function<V, R> compose.
JDK8新特性（Lambda、Stream、Optional）
星海IT学习之路
07-11 859
1.Lambda表达式 Lambda表达式的使用 1.举例： (o1,o2) -> Integer.compare(o1,o2); 2.格式： -> :lambda操作符 或 箭头操作符。 ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）。 ->右边：lambda体 （其实就是重写的抽象方法的方法体）。 3.Lambda表达式的使用：（分为6种情况介绍） 总结： ->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个
Java8之Function函数、BiFunction函数详解
qq_43842093的博客
11-23 8020
它也是一个函数式接口，它是Function 的 另一种形式，它接收两个参数（T，U），返回一个参数（R）。那么接下来我们看看这个接口里面有哪些方法吧。
Java8之function函数详解
qq_27416233的博客
12-05 5万+
1. function 我们来看下function这个函数式接口里面都有什么方法 下面,我们来仔细研究下以下的方法 1.R apply(T t) 按照以往的逻辑,我们先来看下原始接口是怎么说的 翻译过来就是：将给定的参数应用到这个函数上,传入的参数类型为T返回类型为R import java.util.function.Function; /** * @author Zerox *...
Java8新特性：（二）四大内置函数式接口
zx_1305769448的博客
08-10 221
1、消费型接口：void accept(T t); public class ConsumerTest{ /** * 消费性接口：接收一个参数，无返回值 */ @Test public void consumerTest() { Consumer<String> consumer = s -> System.out.println(s); consumer.accept("参数值"); } } 2、供
JAVA8的新特性学习笔记
03-01
该笔记主要记录了学习Java8新增特性的全部信息，包含概念讲解及代码示例，主要针对Lambda表达式、函数式接口、方法引用及构造器引用、Stream API、Optional类几个模块深入浅出的介绍了各个模块的使用。希望对大家的...
java jdk8 学习笔记
08-14
8.JVM让Java可以跨平台，不同的系统平台有不同的JVM,它们都认识.class文件。Java编译语言将Java代码编译成.class文件（只有一种形式），而C/C++语言将代码编译成01码，不同的操作系统的01码指令不同，这造成了不能跨...
java深入学习笔记.pdf
11-29
"java深入学习笔记.pdf" java是一种广泛应用的编程语言，具有平台独立性、...以上知识点只是java深入学习笔记.pdf中的一部分，java语言有很多其他的特性和应用领域，本文只是对java语言的基本概念和知识点进行了概述。
Java并发编程学习笔记
04-11
2、可重入锁与 Synchronized 的其他特性 3、ThreadLocal 的底层实现与使用 4、ReentrantLock底层实现和如何使用 5、Condition源码分析 6、ReentrantReadWriteLock底层实现原理 7、并发工具类CountDownLatch 、...
Java8新特性内置的四大核心函数式接口
Angela_L的博客
07-18 401
在前面几篇简单介绍了一些Lambda表达式得好处与语法，我们知道使用Lambda表达式是需要使用函数式接口得，那么，岂不是在我们开发过程中需要定义许多函数式接口，其实不然，java8其实已经为我们定义好了4类内置函数式接口，这4类接口其实已经可以解决我们开发过程中绝大部分的问题，只有一小部分比较特殊得情况需要我们自己去定义函数式接口，本文就简单来学习一下java8内置得4大核心函数式接口。 /*...
Function 源码解析与实践
京东科技开发者
11-29 581
Function 函数式接口是 java 8 新加入的特性，可以和 lambda 表达式完美结合，是非常重要的特性,可以极大的简化代码。
Java8新特性学习笔记
a_letter的博客
05-11 187
Java8新特性 1、Lambda表达式 1.1 语法格式 格式： (parameters参数) -> expression表达式或方法体 左侧：lambda表达式的参数列表 -> : 称为箭头操作符，或者lambda操作符 右侧 : lambda表达式中所需要执行的功能，即lambda函数体 //例1. @Test public void test01(){ Runnable r1 = new Runnable(){ @Override public v
Java8 Lambda表达式教程
热门推荐
io
10-16 26万+
Java8新特性，Lambda表达式与集合类bulk operation教程。迄今为止最全面的中文原创java lambda表达式教程。
java基础 学习笔记 markdownr版
最新发布
09-06
Java基础学习笔记 # 一、Java简介 Java是一种面向对象的编程语言，由Sun Microsystems（现在是Oracle）于1995年首次发布。它具有跨平台的特性，可以在不同的操作系统上运行。Java语言被广泛应用于开发各种类型的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值