JAVA实训第三天

已于 2022-11-25 00:35:59 修改
阅读量404 收藏 1
点赞数
分类专栏： JAVA实训 java 文章标签： java 开发语言 jvm
于 2022-11-25 00:33:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63202674/article/details/128029124
版权

目录

方法引用

示例

接口

类

测试类

Stream

​编辑 Stream 的操作三个步骤

 创建 Stream 的 4 种方法

 常见Stream接口的继承关系

Stream的中间操作

 中间操作常用方法

 Stream的终止操作

 Stream的终止操作-collect()

 示例代码演示

 作业

方法引用

        在Lamda新特性的支持下，JAVA8中可以使用lamda表达式来创建匿名方法。然而，有时候我们仅仅是需要调用一个已存在的方法（如java中已经定义好的方法），在这时候java8新特性“方法引用”将会进一步简化操作（注意：需要有Lamda的支持）。

• 方法引用的四种形式：
• 引用静态方法 --> 类名称 ::static 方法名称；
• 引用某个对象的实例的普通方法 --> 实例化对象 :: 普通方法；
• 引用 特定类型 的 任意对象 的实例方法 --> 特定类 :: 普通方法；
• 引用构造方法 --> 类名称 ::new

• 定义一个方法获取供给型接口类型的参数，调用 get 方法获取返回对象，并执行普通方法

 

 

示例

接口

package part4;

/**
 * @date : 2022/11/23 9:36
 */
@FunctionalInterface
public interface PersonInterface {
  public static  final   String name = "tidy";
  public static  final   Integer age =18;


  public void methodA();



}

类

package part4;

/**
 * @date : 2022/11/23 9:31
 */
public   class Person {

    String name;
    Integer age;

    public static int   method1() {
        System.out.println("static静态方法...");
        return 0;
    }

    public static int   method2(int a) {
        System.out.println("static静态方法..."+a);
        return 0;
    }



    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }


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

测试类

package part4;


import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;


/**
 * @date : 2022/11/23 9:29
 */
public class MethodReferenceDemo {

    public static void main(String[] args) {
     /*   方法引用的四种形式：
        引用静态方法-->类名称::static 方法名称；
        引用某个对象的实例的普通方法-->实例化对象::普通方法；
        引用特定类型的任意对象的实例方法-->特定类::普通方法；
        引用构造方法-->类名称::new
*/

//        1）引用构造方法-->类名称::new
        /*Person person = new Person();
        System.out.println(person);*/
//        注意事项1：方法引用 前提要使用lambda表达式--》功能性函数
//        Person person = Person::new;

//        注意事项2：接口中没有构造方法  调用不成
//        PersonInterface personInterface =  PersonInterface::new;

//        借助于供给型接口 实例化对象
        Supplier<Person> supplier = Person::new;
        Person person = supplier.get();
        System.out.println(person);


//        2) 引用静态方法-->类名称::static 方法名称；
        Supplier<Integer> method1 = Person::method1;
        Integer result = method1.get();
        System.out.println("result:"+result);

        System.out.println("==================");
//        调用静态方法时：选定和这个静态方法相匹配的功能性函数（是否匹配：是否有参数 是否有返回值--》使用哪个功能性函数）
        Function<Integer,Integer> function = Person::method2;
        Integer apply = function.apply(66);
        System.out.println("applay:"+apply);

        System.out.println("==================");
//        3)引用某个对象的实例的普通方法-->实例化对象::普通方法；
        Person person1 = new Person("tidy",18);
        Supplier<String> stringSupplier =person1::getName;
        String name = stringSupplier.get();
        System.out.println("name:"+name);


//        4)引用特定类型的任意对象的实例方法-->特定类::普通方法；
//        String equals方法  比较两个字符串是否相等  2个字符串
//        BiFunction
        BiFunction<String,String,Boolean> biFunction = String::equals;
        Boolean resultFlg = biFunction.apply("hello", "hello");
        System.out.println("resultFlg:"+resultFlg);

        System.out.println("6666666666666666666:");
        List<Integer> list = new ArrayList();
        list.add(10);
        list.add(30);
        list.add(30);
//        内部类
       /* Consumer<Integer> consumer = new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        };
        list.forEach(consumer);*/
        /*list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });*/

//        list.forEach(t-> System.out.println(t));
//        println(..):有参数没有返回值
       /*Consumer consumer =  System.out::println;
//        方法引用
        list.forEach(consumer);*/

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

Stream

 Stream 的操作三个步骤

创建 Stream ：一个数据源(如:集合、数组),获取一个流

中间操作 ：一个中间操作链，对数据源的数据进行处理

终止操作(终端操作) ：一个终止操作，执行中间操作链，并产生结果

 创建 Stream 的 4 种方法

•通过Collection中的steam()方法创建流
•通过Collection中的parallelSteam()方法创建流
•通过Arrays中的steam()方法创建流
•通过Stream中的of()静态方法创建流
•通过Stream中的iterate()方法创建流
•通过Steam中的generate()方法创建流

 常见Stream接口的继承关系

Stream的中间操作

       多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理而在终止操作时一次性全部处理，称为“惰性求值”。

 上面这个例子主要是对一组String数据进行操作，主要涉及到的中间操作方法有filter(),limit(),skip(),distinct()终止操作方法有forEach()，下面我们对这些常用方法进行简单介绍

 中间操作常用方法

分类

方法

描述

筛选和切片

filter(Predicate p)

接收Lambda,从流中排除某些元素

limit(long maxSize)

截断流，使其元素不超过给定数量

skip(long n)

跳过元素，返回一个跳过前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补

distinct()

筛选，通过流所生成元素的hashCode()和equals()去除重复元素

映射

map(Function f)

接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

mapToDouble(ToDoubleFunction f)

接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream

mapTolnt(ToIntFunction f)

同上

mapToLong(ToLongFunction f)

同上

flatMap(Function f)

接收一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有流连接成一个流

排序

sorted()

产生一个新流，其中按自然顺序排序

sorted(Comparator c)

产生一个新流，其中按比较器顺序排序

 Stream的终止操作

分类

方法

描述

查找与匹配

allMatch(Predicate p)

检查是否匹配所有元素

anyMatch(Predicate p)

检查是否至少匹配一个元素

findFirst()

检查是否没有匹配所有元素返回第一个元素

findAny()

返回当前流中的任意元素

count()

返回流中元素总数

max(Comparator c)

返回流中最大值

min(Comparator c)

返回流中最小值

forEach()

内部迭代

归约

reduce(T iden, BinaryOperator b)

可以将流中元素反复结合起来，得到一个值。返回T

reduce(BinaryOperator b)

可以将流中元素反复结合起来，得到一个值。返回 Optional

收集

collect(Collector c)

将流转换为其他形式。接收一个 Collector 接口的实现，用于给 Stream 中元素做汇总的方法

 演示

 Stream的终止操作-collect()

  Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set/Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

方法

返回类型

作用

toList

List

把流中元素收集到 List

toSet

Set

把流中元素收集到 Set

toCollection

Collection

把流中元素收集到 Collection

counting

Long

计算流中元素的个数

summingInt

Integer

对流中元素的整数属性求和

averagingInt

Double

计算流中元素Integer属性的平均值

summarizingInt

IntSummaryStatistics

收集流中Integer属性的统计值，如：平均值

joining

String

连接流中每个字符串

maxBy

Optional

根据比较器选择最大值

minBy

Optional

根据比较器选择最小值

reducing

归约产生的类型

收集流中Integer属性的统计值，如：平均值

collectingAndThen

转换函数返回的类型

包裹另一个收集器，对其结果转换函数

groupingBy

Map<K, List>

根据某属性值对流分组，属性为K，结果为V

partitioningBy

Map<Boolean, List>

根据true或false进行分区

 

 

 

 示例代码演示

package part5;

import org.junit.Test;

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

/**
 * @date : 2022/11/23 14:30
 */
public class JunitStream {


    /**
     * 数据源（集合、数组、变量、字符串。。。）---》Stream流对象
     * 1、创建Stream流对象
     */
    @Test
    public void createStream() {

//        list1数据源
        List<Integer> list1 = new ArrayList<>();
        list1.add(10);
        list1.add(30);
        list1.add(20);

//        1)集合对象中 stream()
        Stream<Integer> stream = list1.stream();
        stream.forEach(t -> System.out.println(t));

//         2)集合中方式2
        Stream<Integer> stream2 = list1.parallelStream();
        stream2.forEach(t -> System.out.println(t));

//        3)数组数据源--》Stream
        Integer[] arr = {1, 3, 5, 7};
        Stream<Integer> stream3 = Arrays.stream(arr);


//        4)Stream中的of方法
        Stream<Integer> stream4 = Stream.of(1, 2, 3, 4, 5);
        stream4.forEach(t-> System.out.println(t));


//        5)Stream中iterate
//        数据进行计算：从0开始 让他每次+2 :0 2 4 6 8 10.....
//         iterate无限流
//        Stream<Integer> stream5 = Stream.iterate(0, t -> t + 2);


        //        limit(3) 获取前3个数据
        Stream<Integer> stream6 = Stream.iterate(0, t -> t + 2).limit(3);
        stream6.forEach(t -> System.out.println(t));

        System.out.println("===================");
//        6）Stream.generate
//        Math.random()--double
//        Stream.generate(()->{return Math.random();});
//        Stream.generate(()-> Math.random());
//        Stream<Double> generate = Stream.generate(Math::random);
        Stream<Double> stream7 = Stream.generate(Math::random).limit(2);
        stream7.forEach(t -> System.out.println(t));
//        stream7.forEach(System.out::println);


    }


    /**
     * 2、流操作：
     * 中间操作
     */
    @Test
    public void operation() {
        Stream<String> stream = Stream.of("Tom", ",", "Hello", " ", "Hello", "World");

//      1)中间操作-->新Stream流
//      filter：过滤流  返回true条件都会添加到这个新流当中
        Stream<String> newStream = stream.filter(str -> {
            if (",".equals(str)) {
                return false;
            } else {
                return true;
            }
        });

        newStream.forEach(t -> System.out.println(t));

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

        Stream<String> stream2 = Stream.of("Tom", ",", "Hello", " ", "Hello", "World");

//        中间操作--limit  获取前X个数据
        Stream<String> newStream2 = stream2.limit(2);

        newStream2.forEach(t -> System.out.println(t));


        System.out.println("------1111111111----------------------------");
        Stream<String> stream3 = Stream.of("Tom", ",", "Hello", " ", "Hello", "World");

//        中间操作---skip跳过前多少个数据
        Stream<String> streamNew = stream3.skip(2);
        streamNew.forEach(t -> System.out.println(t));

        System.out.println("----distict:-----------------------------");
        Stream<Integer> streamDistinct = Stream.of(10, 20, 30, 10, 5);
//         中间操作去重--distinct
        Stream<Integer> newDistinctStream = streamDistinct.distinct();
        newDistinctStream.forEach(t -> System.out.println(t));


//        数组  1,3,7,8,9,2,4,7,2----去重后求其数据个数
        Integer[] arr2 = {1, 3, 7, 8, 9, 2, 4, 7, 2};
        Stream<Integer> stream1 = Arrays.stream(arr2);
        long count = stream1.distinct().count();
        System.out.println("count:" + count);


        Stream<String> stream4 = Stream.of("Tom", ",", "Hello", " ", "Hello", "World");
//        Stream<String> count1 = stream.filter(str -> !",".equals(str) ? true : false).limit(3).skip(1).distinct();
//        中间流  可以使用连续操作---链式编程
        long count1 = stream4.filter(str -> !",".equals(str) ? true : false).limit(3).skip(1).distinct().count();
        System.out.println("count1:" + count1);

        System.out.println("=========sorted=============");
        Integer[] arr = {1, 3, 7, 8, 9, 2, 4, 7, 2};
//        使用流的操作：数组去重  按照升序进行输出
        Stream<Integer> stream5 = Arrays.stream(arr);
//        按照升序进行输出
//        stream5.distinct().sorted().forEach(t-> System.out.println(t));
//        降序进行输出
        stream5.distinct().sorted((a1, a2) -> a2.compareTo(a1)).forEach(t -> System.out.println(t));


        System.out.println("flatMap:===================");
//        需求："e", "d", "c", "a", "f", "b"--->"edcafb"
        Stream<String> stream6 = Stream.of("e", "d", "c", "a", "f", "b");
        stream6.flatMap(t -> Stream.of(t)).forEach(t -> System.out.print(t));

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

        Integer[] arr66 = {1, 3, 7, 8, 9, 2, 4, 7, 2, 60, 70};
//        分类：>=10归为一类数据    ----》999      <10归为两类----》0
        Stream<Integer> stream66 = Arrays.stream(arr66);
        Stream<Integer> stream661 = stream66.map(t -> t >= 10 ? 999 : 0);
        stream661.forEach(t -> System.out.println(t));

    }


    /**
     * 流操作注意事项：
     * Stream 自己不会存储元素----》：数据源--》转换为流
     * Stream 不会改变源对象。相反,他们会返回一个持有结果的新 Stream
     * Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
     * Stream 只能被"消费"一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。
     */
    @Test
    public void operation2() {
        Integer[] arr = {1, 3, 7, 8, 9, 2, 4, 7, 2};
        Stream<Integer> stream = Arrays.stream(arr);
        /*Stream<Integer> stream = Arrays.stream(arr);

        Stream<Integer> newStream = stream.skip(2).distinct();

        long count = newStream.count();*/
//        Stream 只能被"消费"一次，一旦遍历过就会失效
        stream.forEach(t -> System.out.println(t));


//        java.lang.IllegalStateException: stream has already been operated upon or closed
        long count = stream.distinct().count();


    }


    /**
     * 2、流操作：
     * 终止操作
     */
    @Test
    public void operation3() {

//        Integer[] arr = {11, 3, 17};
//        Stream<Integer> stream = Arrays.stream(arr);

//        判断数组中至少含有一个大于10数据
//        anyMatch:至少含有一个
       /* boolean result1 = stream.anyMatch(t -> t > 10);
        System.out.println("result1:"+result1);*/

//        判断数组中所有的数据都大于5  true
       /* boolean resultALl = stream.allMatch(t -> t >5);
        System.out.println("resultALl:"+resultALl);*/


//   求 数组中所有元素之和
       /* Optional<Integer> reduce = stream.reduce((num1, num2) -> num1 + num2);
        Integer sum = reduce.get();
        System.out.println("sum:"+sum);*/


//        求 数组中所有数据乘积
        /*Optional<Integer> reduce2 = stream.reduce((num1, num2) -> num1 * num2);
        Integer result = reduce2.get();
        System.out.println("result:"+result);

        Stream<String> streamNew = Stream.of("a", "b", "c");

        Optional<String> reduce3 = streamNew.reduce((str1, str2) -> str1 + str2);
        String str = reduce3.get();
        System.out.println(str);*/

     /*   Integer[] arr1 = {1, 2, 3, 4, 5};
        Stream<Integer> stream1 = Arrays.stream(arr1);
//        求 数组中所有奇数和
        Optional<Integer> reduce7 = stream1.filter(t -> t % 2 != 0).reduce((a, b) -> a + b);
        Integer result77 = reduce7.get();
        System.out.println(result77);*/


//        System.out.println("=======collect:=流--》集合对象转换===============");

        /*Stream<String> stream2 = Stream.of("e", "d", "c", "a", "f", "b");    //把流中元素收集到


        List<String> list = stream2.collect(Collectors.toList());   // 调用终止操作的方法后需要重新定义


        Stream stream = Stream.of("e", "d", "c", "a", "f", "b");   // 把流中元素收集到

        Set<String> set = stream2.collect(Collectors.toSet());

        stream = Stream.of("e", "d", "c", "a", "f", "b");
//         把流中元素收集到 Collection(ArrayList)
//         ArrayList::new 等同于()->new ArrayList()
//         ArrayList::new 可以是list,set接口下的任意实现类
        ArrayList<String> alist = stream2.collect(Collectors.toCollection(ArrayList::new));
        System.out.println(list); // [e, d, c, a, f, b]
        System.out.println(set); // [a, b, c, d, e, f]
        System.out.println(alist); // [e, d, c, a, f, b]
*/

        System.out.println("====collect===Collectors:功能===============");


        Integer[] arr2 = {1, 2, 3, 4, 5};
        Stream<Integer> stream1 = Arrays.stream(arr2);
//        计数
        /*Long count = stream1.collect(Collectors.counting());
        System.out.println("count:"+count);*/

//   求和
        Integer sum = stream1.collect(Collectors.summingInt(t -> t));
        System.out.println("sum:"+sum);


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

//        groupingBy:   分班 java314 精英班  成绩要求都是80分（含）以上     80分以下分数---java00
        Integer[] scores = {85, 90, 100, 70, 80,75};
//        java314---》 85 90 100 80
//        java00--->70 75

        Stream<Integer> stream = Arrays.stream(scores);
        Map<String, List<Integer>> map = stream.collect(Collectors.groupingBy(t -> t >= 80 ? "java314" : "java00"));
        map.forEach((k,v)-> System.out.println(k+"----"+v));


    }


}

 作业

package part5;

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

/**
 * @author : cqq
 * @date : 2022/11/23 13:13
 */
public class Task {

    public static void main(String[] args) {

//        1.	给一个整数集合，分别求集合中偶数和与奇数和

        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        list1.add(6);
        list1.add(7);
        list1.add(8);
        list1.add(9);
        list1.add(10);

//        list1.stream().filter(t->t%2==0).forEach(a-> System.out.println(a));
        Optional<Integer> reduce = list1.stream().filter(t -> t % 2 == 0).reduce((x, y) -> x + y);
        Integer ou = reduce.get();
        System.out.println("ou和:"+ou);
//        list1.stream().filter(t->t%2!=0).forEach(a-> System.out.println(a));
        Optional<Integer> ji = list1.stream().filter(t -> t % 2 != 0).reduce((x, y) -> x + y);
        System.out.println("ji和:"+ji.get());
//
//
//
//
//
       System.out.println("---------------------");
//        2. 给一个整数集合，将集合分成偶数集合和奇数集合
        ArrayList<Integer> li = new ArrayList<>();
        li.add(1);
        li.add(2);
        li.add(3);
        li.add(4);
        li.add(5);
        li.add(6);
        List<Integer> ou1 = li.stream().filter(t->t%2==0).collect(Collectors.toList());
        System.out.println("ou:"+ou1);
        List<Integer> ji1 = li.stream().filter(t->t%2!=0).collect(Collectors.toList());
        System.out.println("ji:"+ji1);



/*//        List<Integer> list22 = list1.stream().filter(t -> t % 2 == 0).collect(Collectors.toList());
        List<String> list66 = list1.stream().map(t -> t + "").collect(Collectors.toList());
        System.out.println(list66);


        System.out.println("---------888888888888------------");
        List list7 = new ArrayList<>();
        list7.add("hello");
        list7.add(2);
        System.out.println(list7);

        System.out.println("===========999999999:=============");
//
//*/
//
//        3. 集合转换：[[1, 2, 3, 4, 5], [2, 1, 9, 3, 6, 7], [3, 1, 6]] -> ["1", "2", "4", "5", "2", …… "3", "1","6"]
        List<Integer> list4 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();

        Collections.addAll(list4,1,2,3,4,5);
        Collections.addAll(list2,3,1,6);
        Collections.addAll(list3,2,1,9,3,6,7);
        List<String> list = new ArrayList<>();
        list1.stream().map(t -> list.add("“"+t+"”")).collect(Collectors.toList());
        list2.stream().map(t -> list.add("“"+t+"”")).collect(Collectors.toList());
        list3.stream().map(t -> list.add("“"+t+"”")).collect(Collectors.toList());
        System.out.println(list);


/*        List<Integer> list99 = new ArrayList<>();
        list99.add(1);
        list99.add(2);
        list99.add(3);

        List<Integer> list5 = new ArrayList<>();
        list5.add(11);
        list5.add(21);
        list5.add(31);

        List<Integer> list88 = new ArrayList<>();
        list88.add(88);
        list88.add(99);

        list5.stream().map(t -> list99.add(t)).collect(Collectors.toList());
        System.out.println(list99);
        System.out.println("list................");

        list88.stream().map(t -> list99.add(t)).collect(Collectors.toList());
        System.out.println(list99);


//        Stream<String> stringStream = Stream.of("e", "d", "c", "a", "f", "b");
//        String st = stringStream.reduce("", (str1, str2) -> str1 = str1 + str2);
//        System.out.println(st);*/


    }
}

空景 Sadnes╰つ677
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java获取System.out输出内容
安迪的专栏
12-09 6958
ByteArrayOutputStream baoStream = new ByteArrayOutputStream(1024); PrintStream cacheStream = new PrintStream(baoStream); PrintStream oldStream = System.out; System.setOut(cacheStream);//不打印到控制台 Sy
引用构造器【应用】
Leon_Jinhai_Sun的博客
09-12 321
引用构造器，其实就是引用构造方法 l格式 类名::new 范例 Student::new 练习描述 定义一个类(Student)，里面有两个成员变量(name,age) 并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法 定义一个接口(StudentBuilder)，里面定义一个抽象方法 Student build(String name,int age); 定义一个测试类(StudentDemo)，
【Java】System.out.println
Ankie_的博客
04-08 1万+
System.out.println() System.out.println是一个Java语句，一般情况下是将传递的参数，打印到控制台 System是Java.lang包中的一个final类，该类提供的设施包括标准输入、标准输出和错误输出流、访问外部定义的属性和环境变量，一种加载文件和库的方法，以及用于加速复制数组等一部分的使用方法。 out是System类的静态成员字段，类型为PrintSt...
【Java 8 新特性】Java Stream通过generate()生成流数据
猫巳的博客
12-14 1万+
本页将介绍Stream.generate方法示例。generate方法返回一个无限连续的无序流，其中每个元素由提供的供应商(Supplier)生成。generate方法用于生成常量流和随机元素流。 从javadoc找到generate方法声明。 static <T> Stream<T> generate​(Supplier<? extends T> s) 参数：传递生成流元素的供应商(Supplier)。 返回：它返回一个新的无限顺序无序的流(Stream)。 示例1
System.out::println是什么 ? Lambda表达式和方法引用
最新发布
weixin_48011779的博客
01-02 1620
System.out::println的实现方式
java通过类对象调用方法名_Java 8方法引用特定类型的任意对象的实例方法
weixin_42570769的博客
02-24 516
为什么以下不起作用？import java.util.function.Function;public class MethodRefTest {public String passMeAround( String input ) {return input + " been passed to me";}public Function testReferences() {final Functi...
java8方法引用：特定类的任意对象的方法引用
EnjoyInwind的专栏
01-22 2267
在使用特定类的任意对象的方法引用时，总是莫名其妙报错：non-static method can not referenced from a static context。 解决方案：其实是类型匹配不正确，修改类型后不再报错； public class StreamTest { public static void main(String[] args){ Strea...
Java - System.out::println
A_bad_horse的专栏
03-02 98
public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("one"); list.add("two"); list.add("three"); list.add("four"); list.add("five"); list.forEach(System.out::println); } 控制台打印结.
JAVA 方法引用——静态方法引用、实例方法引用、特定类型方法引用
七七的博客
02-03 2597
方法引用： 在某些场景之下，Lambda表达式要做的事情，其实在另一个地方已经写过了。 那么此时如果通过Lambda表达式重发编写相同代码，就是浪费。 那么如何才能复用已经存在的方法逻辑呢？ 如果Lamda表达式需要做的事情，在另外一个类当中已经做过了，那么可以直接拿过来替换Lambda 一.通过 类名称 引用 静态方法 ： 类名称::静态方法名 事先存在一个Cook类： public cla...
引用对象的实例方法
o676448的博客
06-26 152
格式 ==对象::成员方法== * 范例 "HelloWorld"::toUpperCase String类中的方法:public String toUpperCase()将此String所有字符转换为大写
Java 8 方法引用(Method Reference)详解
SUMUP
09-25 1139
Java 8 方法引用(Method Reference)详解 文章目录Java 8 方法引用(Method Reference)详解概述方法引用分类引用静态方法对已存在对象的实例方法的引用引用特定类型的任意对象的实例方法引用构造器方法引用优点总结参考 概述 Java 8 引入了新特性lambda表达式。Lambda表达式是一种不隶属于任何类的匿名方法。其可以使用在函数接口(functional interface)定义的变量。函数接口是一种只包含一个抽象方法(abstract method)，同时可以包含
Java 8 - 05 方法引用
小工匠
05-17 9439
文章目录Pre方法引用 Pre 先来看段代码 Comparator<Enginner> enginnerComparator = new Comparator<Enginner>() { @Override public int compare(Enginner o1, Enginner o2) { return o1.getJob().compareTo(o2.getJob());
干货！Java8核心特性实战之四：方法的引用
LeZiJie的博客
08-08 100
Java8 中引入方法引用新特性，用于简化应用对象方法的调用， 方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。 方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。 计算时，方法引用会创建函数式接口的一个实例。 当 Lambda 表达式中只是执行一个方法调用时，不用 Lambda 表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的 Lambda 表达式。 一、语法 目标引用：方法名称 目标引用：类名、实例对象 方法名称：实例方法名、静
引用类的实例方法, 说的是引用 类的 实例的方法
出位控的博客
03-20 731
方法引用符：:: 方法引用符基于Lambda表达式，因为参数确定了,接口中方法只有一个, 所以这个方法体,只调用了一个方法, 那么直接就引用该方法就可以了. 引用类方法 范例: System.out::println // 将Lambda表达式替换成这个，这就代表引用了println方法. 因为参数已经确定, 所以方法不用写括号，且参数只有一个 引用对象实例的方法 // 假设有一个符合Lambda的接口 // 和一个将字符串变成大写字符的类PrintString // 和静态方法userPrint
java8方法引用-调用特定方法的Lambda的一种快捷写法
无怨无悔专栏
09-17 4028
下面的代码是实现同一功能时，使用Lambda表达式与方法引用的对比代码：   //使用Lambda表达式对重量排序 inventory.sort((Apple a1, Apple a2) -&gt; a1.getWeight().compareTo(a2.getWeight())); //使用方法引用和java.util.Comparator.comparing对重量排序： inve...
java中System.in和System.out快速学会使用
热门推荐
LYoungJ的博客
03-24 1万+
import java.io.*; /** * @author LiaoYangJun * @createTime 2018/3/23. */ public class Demo2 { /** * 因为用的是字节流所以 * 控制台 中文 字符串 数字都可以输入输出 * @param args */ public static voi...
java可以接受任意对象的写法_java-引用特定类型的任意对象的实例方法……无法与自定义类一起使用？...
weixin_32563347的博客
03-01 610
根据有关“方法参考”的文档,可以创建：Reference to an instance method of an arbitrary object of a particular type我写了以下代码：public class App {public static void main(String[] args) {Function f1 = String::toString;Function ...
Java 8 经常见到的双冒号:: 关键字是什么意思
Ddd_victory的博客
05-04 759
双冒号就是把方法当做参数传到stream内部，使stream的每个元素都传入到该方法里面执行一下，双冒号运算就是Java中的方法引用； Java 8 中我们可以通过 :: 关键字来访问类的构造方法、对象方法、静态方法 不使用:: public static void main(String[] args) { List<String> list = Arrays.asList("张三", "李四", "王五"); list.forEach(t -
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值