JAVA 方法引用（十五）

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量324 收藏 11
点赞数 8
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljs__123/article/details/136007974
版权

方法引用（十五）

方法引用：把已存在的方法拿过来用，当做函数式接口中抽象方法的方法体。

注意：

  1. 引用处必须是函数式接口
  2. 被引用方法必须已经存在
  3. 被引用方法的形参和返回值需跟抽象方法保持一致
  4. 被引用方法的功能需要满足当前需求

方法引用符：

::

范例：

import java.util.Arrays;
import java.util.Comparator;
public class Test{
    public static void main(String[] args){
        Integer[] arr1={45,78,67,45,57,13};
        Integer[] arr2={45,78,67,45,57,13};
        Integer[] arr3={45,78,67,45,57,13};
        Integer[] arr4={45,78,67,45,57,13};
        Arrays.sort(arr1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }   
        });
        System.out.println(Arrays.toString(arr1));

        //lambda
        Arrays.sort(arr2,(Integer o1,Integer o2)->{
            return o2-o1;
        });
        System.out.println(Arrays.toString(arr2));

        //lambda省略
        Arrays.sort(arr3,(o1,o2)->o2-o1);
        System.out.println(Arrays.toString(arr3));

        //方法引用
        Arrays.sort(arr4,Test::subtraction);
        System.out.println(Arrays.toString(arr4));
    }
    public static int subtraction(int num1,int num2){
        return num2-num1;
    }
}
/*
[78, 67, 57, 45, 45, 13]
[78, 67, 57, 45, 45, 13]
[78, 67, 57, 45, 45, 13]
[78, 67, 57, 45, 45, 13]
*/

分类

  1. 引用静态方法
  2. 引用成员方法
    1. 引用其他类的成员方法
    2. 引用本类的成员方法
    3. 引用父类的成员方法
  3. 引用构造方法
  4. 其他调用方式
    1. 使用类名引用成员方法
    2. 引用数组的构造方法

引用静态方法

格式：

类名::静态方法

范例:

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"1","2","3","4");
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        }).forEach(s-> System.out.print(s+" "));
        System.out.println();
        list.stream().map(Integer::parseInt).forEach(s-> System.out.print(s+" "));
    }
}
/*
1 2 3 4 
1 2 3 4 
*/

引用成员方法

格式：对象::对象方法

  1. 其他类：其他类对象::方法名
  2. 本类：this::方法名
    • 引用处不能是静态方法，静态方法中没有this
  3. 父类：super::方法名
    • 引用处不能是静态方法，静态方法中没有super
引用其他类的成员方法
//只打印集合中以“路”开头并且长度为3的字符串
//Test.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张三","路人甲","李四","路人乙","路丙");
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("路")&&s.length()==3;
            }
        }).forEach(s-> System.out.print(s+" "));

        //方法引用
        System.out.println();
        list.stream().filter(new StringController()::StringJudge).forEach(s-> System.out.print(s+" "));
    }
}
/*
路人甲 路人乙 
路人甲 路人乙 
*/
//StringController.java
public class StringController {
    public boolean StringJudge(String s) {
        return s.startsWith("路")&&s.length()==3;
    }
}
引用本类的成员方法
//Test.java
public class Test{
    public static void main(String[] args){
        new StringController();
    }
}

//StringController.java
import java.util.ArrayList;
import java.util.Collections;
public class StringController {
    public StringController(){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"aaa","ccc","vbb","ddd");
        list.stream().forEach(this::print);
    }
    public void print(String s){
        System.out.println(s);
    }
}
/*
aaa
ccc
vbb
ddd
*/
获取父类的成员方法
//Test.java
public class Test{
    public static void main(String[] args){
        new StringController();
    }
}

//Father.java
public class Father {
    public void print(String s){
        System.out.println(s);
    }
}

//StringController.java
import java.util.ArrayList;
import java.util.Collections;
public class StringController extends Father{
    public StringController(){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"aaa","ccc","vbb","ddd");
        list.stream().forEach(super::print);
    }
}
/*
aaa
ccc
vbb
ddd
*/

引用构造方法

格式：

类名::new

范例：

//Test.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list, "zhangsan,23","lisi,24","wangwu,25");
        List<Student> list1=list.stream().map(Student::new).collect(Collectors.toList());
        System.out.println(list1);
    }
}

//Student.java
public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String str){
        this.name=str.split(",")[0];
        this.age=Integer.parseInt(str.split(",")[1]);

    }
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}
/*
[Student{name = zhangsan, age = 23}, Student{name = lisi, age = 24}, Student{name = wangwu, age = 25}]
*/

类名引用成员方法

格式：类名::成员方法

该方法引用的规则：（该规则仅限于类名引用成员方法）

  1. 需要有函数式接口
  2. 被引用的方法已经存在
  3. 被引用方法的形参，需跟抽象方法的第二个形参到最后一个形参一致，返回值需保持一致
  4. 被引用的方法需要满足当前的需求

抽象方法形参的详解：

第一个参数：表示被引用方法的调用者，决定了可以引用那些类的方法，比如：在Stream流中，第一个参数一般都表示流里面的每一个数据，假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String类里的方法。

第二个参数到最后一个参数：跟被引用方法的形参保持一致，若无第二个参数，则该被引用的方法需要是无参的成员方法。

范例：

//将集合中字符串以大写的形式输出
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list, "zhangsan","lisi","wangwu");
        list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        }).forEach(s-> System.out.print(s+" "));
        System.out.println();

        //类名引用成员方法
        list.stream().map(String::toUpperCase).forEach(s-> System.out.print(s+" "));
    }
}

引用数组的构造方法

格式：

数据类型::new

目的：创建一个指定类型的数组。

注：数组的类型需跟流中的类型保持一致。

范例：

//集合存取一些整数，收集到数组中
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.IntFunction;

public class Test{
    public static void main(String[] args){
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list, 1,2,3,4,5,6,7,8,9);
        Integer[] arr=list.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });
        System.out.println(Arrays.toString(arr));

        Integer[] arr2=list.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr2));
    }
}
/*
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
*/

范例

例1

/*
集合中存储一些字符串的数据，比如："张三,18","李四,19","王五,20"
使用引用方法收集到Student类型的数组中
*/
//Test.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张三,18","李四,19","王五,20");
        Student[] students=list.stream().map(Student::new).toArray(Student[]::new);
        System.out.println(Arrays.toString(students));
    }
}
//Student.java
public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String str){
        this.name=str.split(",")[0];
        this.age=Integer.parseInt(str.split(",")[1]);
    }

    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

例2

/*
创建集合添加学生对象，学生对象属性：name,age
只获取姓名并放到数组当中（使用方法引用完成）
*/
//Student.java
public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}
//Test.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test{
    public static void main(String[] args){
        ArrayList<Student> list=new ArrayList<>();
        Student stu1=new Student("张三",18);
        Student stu2=new Student("李四",19);
        Student stu3=new Student("王五",20);
        Collections.addAll(list,stu1,stu2,stu3);
        String[] s=list.stream().map(Student::getName).toArray(String[]::new);
        System.out.println(Arrays.toString(s));
    }
}
/*
[张三, 李四, 王五]
*/

例3

/*
创建集合添加学生对象，学生对象属性：name,age
把姓名和年龄拼接成：张三-23的字符串，并放到数组当中（使用方法引用完成）
*/
//Student.java
public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
    public String getAll(){
        return name+","+age;
    }
}
//Test.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test{
    public static void main(String[] args){
        ArrayList<Student> list=new ArrayList<>();
        Student stu1=new Student("张三",18);
        Student stu2=new Student("李四",19);
        Student stu3=new Student("王五",20);
        Collections.addAll(list,stu1,stu2,stu3);
        String[] s=list.stream().map(Student::getAll).toArray(String[]::new);
        System.out.println(Arrays.toString(s));
    }
}
/*
[张三,18, 李四,19, 王五,20]
*/
ljs__123
关注
  • 8
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java从入门到精通十五(方法引用)
jgdabc的博客
03-16 1212
我们的lambda的概要格式为（形式参数）->(代码块)。在简化操作的同时我们有时候也需要在lambda表达式进行调用方法。我们采用lambda调用的方法可能已经有了。这个方法可能存在我们的类中，或者接口中。于是我们可以采用方法引用来做进一步的简化。...
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
【Java 干货教程】Java方法引用详解
向上的"狼"的博客
01-08 2053
​Java方法引用是Java 8引入的一项重要特性，它提供了一种简洁、可读性高的方式来直接引用已经存在的方法。方法引用使得代码更加简洁、易懂，同时提高了代码的可维护性和重用性。本文将详细介绍Java方法引用的概念、语法和使用方法，并提供一些示例代码。
深入理解Java的五种引用类型
码到三十五
02-23 1098
Java的五种引用类型为开发者提供了灵活控制对象生命周期和内存管理的手段。强引用确保对象的可达性；软引用和弱引用允许在内存不足时回收对象；虚引用则提供了对象被回收时的通知机制。而终结器引用（即finalize()方法）虽然已经废弃，但了解其历史和替代方案对于全面理解Java的内存管理仍然是有益的。在实际开发中，合理利用这些引用类型可以帮助我们编写更高效、更稳定的代码。
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
java重复执行方法_重复java方法
weixin_42514005的博客
02-24 3174
Java删除ArrayList中的重复元素的2种方法ArrayList是Java中最常用的集合类型之一。它允许灵活添加多个null元素，重复的元素，并保持元素的插入顺序。在编码时我们经常会遇到那种必须从已建成的ArrayList中删除重复元素的要求。这篇文章将给出两种从ArrayList中删除重复元素的方法。方法1：使用HashSet删除A...文章行者武松2017-08-01895浏览量java...
java常用方法合集
qq_42121746的博客
01-11 4773
Arrays工具类 java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比 如排序和搜索）的各种方法。 方法 作用 boolean equals(int[] a,int[] b) 判断两个数组是否相等。 String toString(int[] a) 输出数组信息。 void fill(int[] a,int val) 将指定值填充到数组之中。 ...
java值传递与引用传递
weixin_43195187的博客
09-30 3310
一、java中没有引用传递，全部是值传递。 java中方法调用参数传递类型无非两种，一种是基本数据类型、另一种是应用数据类型。受到这两种数据类型的影响，让人误以为，参数传递方式是和数据类型有关的，其实不然。无论是基本数据类型还是引用数据类型。下面我将分类阐述基本类型变量，与引用类型变量传递过程。 二、基本类型与引用类型内存模型介绍,以及基本数据类型传递过程 1、基本类型。 执行结果为 ：1 这里...
Java基础知识总结（2021版）
热门推荐
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java | Java常用API方法总结
多氯环己烷的博客
08-29 1万+
个人总结的Java常用API手册汇总常用APIJavaAPI1 java.langStringStringBuilderIntegerparseXxxMathObjectSystemThrowableThreadRunnable/接口Class\*reflect反射相关FieldConstructor\MethodClassLoader2 java.utilScannerObectsDate(瞬时)Calendar(日历)Random*数据结构相关Collection/接口Iterator/接口List/接
50个关键字_3个直接量_JAVA的五十个关键词_
10-02
30. `native`：表示方法由非Java代码实现，通常与C/C++库交互。 31. `new`：创建对象，分配内存空间。 32. `package`：组织类和接口的命名空间，便于管理。 33. `private`：私有访问修饰符，仅限于本类内部访问。 34...
JAVA基础五十经典问答.docx
09-30
因此，方法可以改变对象的属性，返回的对象引用仍然是指向原来的对象，而不是副本。 以上是Java基础的一些核心知识点，涵盖了面向对象、内存管理、类型系统和线程等方面。理解并熟练掌握这些概念对于Java程序员来说...
java中DecimalFormat四舍五入用法详解
08-27
在本文中，我们详细介绍了 Java 中 DecimalFormat 的用法和四舍五入的实现方法。DecimalFormat 是一个功能强大且灵活的格式化工具，可以满足我们格式化数字的需求。同时，我们还可以使用不同的模式来实现不同的格式...
JAVA第十版部分答案
10-14
五、Java流程控制 * Java的switch语句：包括switch语句的语法、switch语句的使用等。 * Java的循环语句：包括for循环、while循环、do-while循环等。 六、Java字符串处理 * Java字符串的概念：包括字符串的定义、...
java语言程序设计第十版课后答案
12-26
《Java语言程序设计第十版》是一本深入浅出的编程教材，由梁勇编写，针对Java编程语言进行了全面且细致的讲解。这本书不仅涵盖了Java的基础语法，还涉及到面向对象编程、异常处理、集合框架、多线程、网络编程等多个...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 406
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 773
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java第十五章：理解String与StringBuilder应用
学习者将学会区分和使用`==`运算符和`equals()`方法来比较字符串，前者用于比较对象引用是否相同，后者则用于比较字符串内容是否相等。 `StringBuffer`类则是可变的字符串，提供了对字符串进行动态添加、删除和替换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值