Java里的引用详解

已于 2024-07-18 10:45:39 修改
阅读量395 收藏 24
点赞数 11
分类专栏： JAVA 文章标签： java 开发语言
于 2024-07-18 10:42:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65752158/article/details/140499850
版权

1.体验方法引用

  • 方法引用的出现原因

    在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

    那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要

    那我们又是如何使用已经存在的方案的呢？

    这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

package yingyong;

import java.util.Arrays;
import java.util.Comparator;

public class demo1 {
    public static void main(String[] args) {
        //需求：创建一个数组，进行倒序排列
        Integer[] arr = {3, 5, 4, 1, 6, 2};
        //匿名内部类
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
      

        //lambda表达式
        //因为第二个参数的类型Comparator是一个函数式接口
        Arrays.sort(arr, (Integer o1, Integer o2)-> {
                return o2 - o1;
            }
        );
        
        //lambda表达式简化格式
        Arrays.sort(arr, ( o1,  o2)-> o2 - o1);

        //方法引用
        //1.引用处需要是函数式接口
        //2.被引用的方法需要已经存在
        //3.被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
        //4.被引用方法的功能需要满足当前的要求
        Arrays.sort(arr,demo1::mySort);
        //表示引用demo1类里面的mySort方法
        //把这个方法当做抽象方法的方法体
        

      
    }
    public static int mySort(int o1, int o2) {
        return o2 - o1;
        
    }
}

2.方法引用符

  • 方法引用符

    :: 该符号为引用运算符，而它所在的表达式被称为方法引用

  • 推导与省略

    • 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导

    • 如果使用方法引用，也是同样可以根据上下文进行推导

    • 方法引用是Lambda的孪生兄弟

3.引用类方法

引用类方法，其实就是引用类的静态方法

  • 格式

    类名::静态方法

  • 范例

    Integer::parseInt

    Integer类的方法：public static int parseInt(String s) 将此String转换为int类型数据

  • 练习描述

    • 定义一个接口(Converter)，里面定义一个抽象方法 int convert(String s);

    • 定义一个测试类(ConverterDemo)，在测试类中提供两个方法

      • 一个方法是：useConverter(Converter c)

      • 一个方法是主方法，在主方法中调用useConverter方法

package yingyong;

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

public class demo2 {
    public static void main(String[] args) {
        /*
        需求：
        集合里一下的数字，把他们变成Int类型
        "1","2","3","4","5"

         */
        //1.常规方法
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1, "1", "2", "3", "4", "5");
        ArrayList<Integer> list2 = new ArrayList<>();
        for (String s : list1) {
            int i = Integer.parseInt(s);
            list2.add(i);
        }
        System.out.println(list2);
        System.out.println("---------------");
        //2.stream流
        list1.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int i = Integer.parseInt(s);
                return i;
            }
        }).forEach(s-> System.out.println(s));
        System.out.println("---------------");
        //简化lambda表达式
        list1.stream().map( s-> Integer.parseInt(s)).forEach(s-> System.out.println(s));
        System.out.println("---------------");
        //3.引用类方法
        list1.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));

    }
}

  • 使用说明

    Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

4.引用对象的实例方法

引用其他类的成员方法

package yingyong;

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

/*
       方法引用（引用成员方法）
       格式
               其他类：其他类对象::方法名
               本类：this::方法名(引用处不能是静态方法)
               父类：super::方法名(引用处不能是静态方法)
       需求：
           集合中有一些名字，按照要求过滤数据
           数据："张无忌","周芷若","赵敏","张强","张三丰"
           要求：只要以张开头，而且名字是3个字的

      */
public class demo3 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
        //1.stream()流方法
        //  要求：只要以张开头，而且名字是3个字的
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));

        //引用类方法  ---其他类

        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张") && s.length() == 3;
            }
        }).forEach(s -> System.out.println(s));
        System.out.println("-----------------");

        //我们现在就在其他类自己写一个这个接口的实现类方法
        // 其他类：其他类对象::方法名
        list.stream().filter(new Mytest()::test).forEach(s -> System.out.println(s));

    }
}


package yingyong;

public class Mytest {
    public boolean test(String s) {
        return   s.startsWith("张") && s.length()==3;
    }
}

引用本类成员方法：this::方法名(引用处不能是静态方法)

public class demo4 {
    public static void main(String[] args) {

          new test();
    }


}
package yingyong;

import java.util.ArrayList;
import java.util.function.Predicate;

public class test {
    public test(){

        method01();
    }

    private void method01() {
        //创建集合 初始化集合数据
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        //调用方法过滤奇数的数字
        method02(list);
    }

    private void method02(ArrayList<Integer> list) {
        list.stream().filter(this::fun).forEach(s->System.out.println(s));

    }
    public boolean fun(int i) {
        return i % 2 == 0;
    }
}

5.引用构造器

为他专门写一个构造方法 

public class Student {
    private String name;
    private int age;

    public Student() {


    }
    public Student(String str) {
        String[] arr = str.split(",");
        this.name = arr[0];
        this.age = Integer.parseInt(arr[1]);
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
package yingyong;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

/*
       方法引用（引用构造方法）
       格式
               类名::new

       目的：
               创建这个类的对象

       需求：
            集合里面存储姓名和年龄，要求封装成Student对象并收集到List集合中

       方法引用的规则：
           1.需要有函数式接口
           2.被引用的方法必须已经存在
           3.被引用方法的形参和返回值，需要跟抽象方法的形参返回值保持一致
           4.被引用方法的功能需要满足当前的需求
      */
public class demo5 {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三,18", "李四,22", "王五,25");
        //1.匿名内部类方法
        list.stream().map(new Function<String, Student>() {
            @Override
            public Student apply(String s) {
                String name = s.split(",")[0];
                int age = Integer.parseInt(s.split(",")[1]);
                return new Student(name, age);
            }
        }).forEach(s -> System.out.println(s));
        System.out.println("---------------");
        //2.lambda方法
        list.stream().map(s-> new Student(s.split(",")[0],Integer.parseInt(s.split(",")[1]))).forEach(s -> System.out.println(s));
        System.out.println("---------------");
        // 3.方法引用（引用构造方法）
      /*  格式
        类名::new*/
        List<Student> newlist = list.stream().map(Student::new).collect(Collectors.toList());
        System.out.println(newlist);
    }
}

6.类名引用成员方法

源码里的String里的把字符串变大写的方法 

    public String toUpperCase() {
        return toUpperCase(Locale.getDefault());
    }

 

为什么形参的参数没有对应上呢

下面来解释 

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

第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

局限性：
    不能引用所有类中的成员方法。
    是跟抽象方法的第一个参数有关，这个参数是什么类型的，那么就只能引用这个类中的方法。

package yingyong;

import java.util.ArrayList;
import java.util.Collections;

/*

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

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

      第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

      局限性：
          不能引用所有类中的成员方法。
          是跟抽象方法的第一个参数有关，这个参数是什么类型的，那么就只能引用这个类中的方法。

     */
public class demo6 {
    public static void main(String[] args) {
       /* 方法引用（类名引用成员方法）
        格式
        类名::成员方法
        需求：
        集合里面一些字符串，要求变成大写后进行输出*/
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "abc", "bba", "ccd");
        //拿着流里面的每一个数据，去调用String类中的toUpperCase方法，方法的返回值就是转换之后的结果。
        list.stream().map(String::toUpperCase).forEach(s->System.out.println(s));
    }
}

7.引用数组的构造方法


 

package yingyong;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
/*
方法引用（数组的构造方法）
格式
        数据类型[]::new
目的：
        创建一个指定类型的数组
需求：
     集合中存储一些整数，收集到数组当中

细节：
    数组的类型，需要跟流中数据的类型保持一致。

*/
public class demo7 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        /*格式
        数据类型[]::new*/
       /* 需求：
        集合中存储一些整数，收集到数组当中*/

        Integer[] arr = list.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr));
       /* //收集到数组里
        Integer[] arr = list.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });
        System.out.println(Arrays.toString(arr));*/

        //
    }

}

练习

ublic class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Student(String str) {
        String[] arr = str.split(",");
        this.name = arr[0];
        this.age = Integer.parseInt(arr[1]);
        //张无忌,15
    }
}

package lx;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
/*
      需求：
           集合中存储一些字符串的数据，比如：张三,23。
           收集到Student类型的数组当中
     */
public class demo1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三,23","李四,24");
       //由于集合是String类型的所以要强制转换
        Student[] arr = list.stream().map(Student::new).toArray(Student[]::new);
        System.out.println(Arrays.toString(arr));
    }
}

练习2方法一

package lx;

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

/*
 *   技巧：
 *       1.现在有没有一个方法符合我当前的需求
 *       2.如果有这样的方法，这个方法是否满足引用的规则
 *       静态   类名：：方法名
 *       成员方法
 *       构造方法  类名：：new
 * */
public class demo2 {
    public static void main(String[] args) {
       /* 需求：
 *      创建集合添加学生对象
      学生对象属性：name，age
        要求：
 *      获取姓名并放到数组当中
        使用方法引用完成*/
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 28);
        ArrayList<Student> list = new ArrayList<>();
        Collections.addAll(list, s1, s2, s3);
        //先获取每一个流 ,把每一个流转换成String 类型的name
        String[] arr = list.stream().map(new Function<Student, String>() {
            @Override
            public String apply(Student student) {
                return student.getName();
            }
        }).toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

方法2

package lx;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

/*
 *   技巧：
 *       1.现在有没有一个方法符合我当前的需求
 *       2.如果有这样的方法，这个方法是否满足引用的规则
 *       静态   类名：：方法名
 *       成员方法
 *       构造方法  类名：：new
 * */
public class demo3 {
    public static void main(String[] args) {
          /* 需求：
 *      创建集合添加学生对象
      学生对象属性：name，age
        要求：
 *      获取姓名并放到数组当中
        使用方法引用完成*/
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 28);
        ArrayList<Student> list = new ArrayList<>();
        Collections.addAll(list, s1, s2, s3);
        String[] arr = list.stream().map(Student::getName).toArray(String[]::new);
        System.out.println(Arrays.toString(arr));
    }
}
抽象方法形参的详解：
第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法
            在Stream流当中，第一个参数一般都表示流里面的每一个数据。
            假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String这个类中的方法

第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

对象名引用方法名只能---被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致。

类名引用方法名,由于引用的方法没有第二个参树,说明被引用的方法是需要无参的成员方法刚好满足

题目3

package lx;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

/*
 *   需求：
 *       创建集合添加学生对象
 *       学生对象属性：name，age
 *   要求：
 *       把姓名和年龄拼接成：张三-23的字符串，并放到数组当中
 *       使用方法引用完成
 * */
public class demo4 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 19);
        Student s3 = new Student("王五", 28);
        ArrayList<Student> list = new ArrayList<>();
        Collections.addAll(list, s1, s2, s3);
        String[] arr = list.stream().map(Student::pj).toArray(String[]::new);
        System.out.println(Arrays.toString(arr));

    }
}

 public String pj(){
        return name+"-"+age;
    }

林的快手
关注
  • 11
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解JAVA 虚引用
08-18
JAVA 虚引用详解 JAVA 虚引用是一种特殊的引用类型，它是使用PhantomReference创建的引用，也称为幽灵引用或者幻影引用，是所有引用类型中最弱的一个。虚引用对对象的生命周期没有影响，也无法通过虚引用获得对象...
详解JAVA 强引用
08-18
JAVA 强引用详解 JAVA 强引用是JAVA 中最基本的引用类型，也是我们在编程中最常用的引用方式。强引用是使用最普遍的引用类型，如果一个对象具有强引用，那么垃圾回收器宁愿抛出OOM（OutOfMemoryError）也不会回收它...
java集合超详解
热门推荐
feiyan的博客
08-03 45万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
java引用详解
qq_41854911的博客
12-25 1万+
文章目录一、关于对象与引用之间的一些基本概念new Vehicle Vehicle veh1二、Java对象及引用三、只有理解了对象和引用的关系，才能理解参数传递总结：什么是值传递，什么是引用传递。为什么说Java中只有值传递实参与形参值传递与引用传递Java中的值传递总结 学过C/C++的应该都知道，C/C++中存在 值传递、指针传递、引用传递。 在java中存在指针传递、引用传递。 这篇博客讲解一下java中的引用。 一、关于对象与引用之间的一些基本概念 为便于说明，先定义一个类： class Vehi
java 引用类型详解
lonely_baby的博客
02-24 1603
Java 还有一个特殊的引用类型，叫做虚引用（Phantom Reference），它主要用于跟踪对象被垃圾回收的状态，但不能通过虚引用来获取对象的实例。当系统内存不足时，垃圾回收器会优先回收软引用所指向的对象，如果仍然需要内存，才会回收弱引用或强引用所指向的对象。强引用是最常用的引用类型，它指向一个对象，只要强引用存在，对象就不会被垃圾回收器回收。软引用指向的对象在内存不足时会被垃圾回收器回收，而弱引用指向的对象在垃圾回收时会被立即回收。当内存不足时，垃圾回收器会回收软引用所指向的对象，从而释放内存。
java引用详解_Java四种引用详解
weixin_35974392的博客
02-13 1707
EndlessLethe原创文章，转载请注明： 转载自小楼吹彻玉笙寒前言Java中引用是一个最常用的Object，我们有必要对它有一个基本的理解。而且引用通常出现在一本Java书的开头，这导致，几乎没有Java书敢详细地叙述关于引用的复杂机制。本文剖析了Java的四种引用。注意，理解这四种引用需要明白：什么是对象，什么是引用。一定注意叙述中的“对象”和“引用”。本文没有涵盖的内容：JVM内存管理。...
java方法引用详解
qq_55278081的博客
10-02 2412
1.构造器引用和数组引用。
详解 JAVA 弱引用
08-18
"JAVA 弱引用详解" JAVA 弱引用是JAVA语言中的一种特殊的引用类型，它使用WeakReference类来实现。弱引用是一种非必需对象的描述，它比软引用更弱。在发生GC时，只要发现弱引用，不管系统堆空间是否足够，都会将...
Java值传递和引用传递详解
08-31
Java中的参数传递方式有两种，即值传递和引用传递，但需要注意的是，Java只支持值传递。下面我们将详细探讨这两种传递方式及其在实际编程中的表现。 1. 值传递（Value Passing） 值传递指的是在调用方法时，将变量...
java堆栈详解.pdf
11-13
在函数中定义的 一些基本类型的变量和对象的引用变量都是在函数 的栈内存中分配。当在一段代码块中定义一个变量时，java 就在栈中 为这个变量分配内存空间，当超过变量的作用域后，java 会自动释放 掉为该变量...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 831
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 904
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1025
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 834
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Java 线程池详解
qq_41591215的博客
07-13 966
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 162
【JAVA】相关程序组件
【Java算法】前缀和 下
最新发布
2302_79806056的博客
07-18 693
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 501
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 519
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值