最好的方法引用文章【转载】

标签：String int void 引用 文章 转载 方法 public

https://developer.aliyun.com/article/1324717?spm=a2c6h.12873639.article-detail.19.3b172f69wPEsWf

https://developer.aliyun.com/article/1315631

 

简介： Java方法四种引用

1 Java的四种引用，强弱软虚

1.1 强引用

强引用是平常中使用最多的引用，强引用在程序内存不足（ OOM ）的时候也不会被回收，使用方式：

String str = new String("str");

1.2 软引用

软引用在程序内存不足时，会被回收，使用方式：

可用场景： 创建缓存的时候，创建的对象放进缓存中，当内存不足时， JVM 就会回收早先创建的对象。

// 注意：wrf这个引用也是强引用，它是指向SoftReference这个对象的， 
// 这里的软引用指的是指向new String("str")的引用，也就是SoftReference类中T 
 
SoftReference<String> wrf = new SoftReference<String>(new String("str"));

 

没人指向的就是软引用

1.3 弱引用

弱引用就是只要 JVM 垃圾回收器发现了它，就会将之回收，使用方式：

WeakReference<String> wrf=new WeakReference<String>(str);

可用场景： Java 源码中的 java.util.WeakHashMap 中的 key 就是使用弱引用，我的理解就是，

一旦我不需要某个引用， JVM 会自动帮我处理它，这样我就不需要做其它操作。

1.4 虚引用

虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入 ReferenceQueue 中。

注意哦，其它引用是被 JVM 回收后才被传入

ReferenceQueue 中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有

ReferenceQueue ，使用

例子：

PhantomReference<String> prf=new PhantomReference<String>(new String("str"),new ReferenceQueue<>());

可用场景： 对象销毁前的一些操作，比如说资源释放等。 ** Object.fifinalize() 虽然也可以做这类动作，但是这个方式即不安全又低效

上诉所说的几类引用，都是指对象本身的引用，而不是指 Reference 的四个子类的引用

( SoftReference 等 ) 。

2 体验方法引用

方法引用的出现原因

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

那么考虑一种情况：如果我们在 Lambda 中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再

写重复逻辑呢？答案肯定是没有必要

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

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

代码演示

 

public interface Printable {
    void printString(String s);
}
public class PrintableDemo {
    public static void main(String[] args) {
//在主方法中调用usePrintable方法
// usePrintable((String s) -> {
// System.out.println(s);
// });
//Lambda简化写法
        usePrintable(s -> System.out.println(s));
//方法引用
        usePrintable(System.out::println);
    }
    private static void usePrintable(Printable p) {
        p.printString("爱生活爱Java");
    }
}

3 方法引用符

方法引用符

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

推导与省略

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

它们都将被自动推导

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

方法引用是 Lambda 的孪生兄弟

4 引用类方法

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

格式

类名 :: 静态方法

范例

Integer::parseInt

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

练习描述

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

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

一个方法是： useConverter(Converter c)

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

代码演示

public interface Converter {
    int convert(String s);
}
public class ConverterDemo {
    public static void main(String[] args) {
//Lambda写法
        useConverter(s -> Integer.parseInt(s));
//引用类方法
        useConverter(Integer::parseInt);
    }
    private static void useConverter(Converter c) {
        int number = c.convert("666");
        System.out.println(number);
    }
}

 

使用说明

 

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

5 引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法

格式

对象 :: 成员方法

范例

"HelloWorld"::toUpperCase

String 类中的方法： public String toUpperCase() 将此 String 所有字符转换为大写

练习描述

定义一个类 (PrintString) ，里面定义一个方法

public void printUpper(String s) ：把字符串参数变成大写的数据，然后在控制台输出

定义一个接口 (Printer) ，里面定义一个抽象方法

void printUpperCase(String s)

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

一个方法是： usePrinter(Printer p)

一个方法是主方法，在主方法中调用 usePrinter 方法

代码演示

public class PrintString {
    //把字符串参数变成大写的数据，然后在控制台输出
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}
public interface Printer {
    void printUpperCase(String s);
}
public class PrinterDemo {
    public static void main(String[] args) {
//Lambda简化写法
        usePrinter(s -> System.out.println(s.toUpperCase()));
//引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);
    }
    private static void usePrinter(Printer p) {
        p.printUpperCase("HelloWorld");
    }
}

 

使用说明

 

Lambda 表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

6 引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

格式

类名 :: 成员方法

范例

String::substring

public String substring(int beginIndex,int endIndex)

从 beginIndex 开始到 endIndex 结束，截取字符串。返回一个子串，子串的长度为 endIndex-beginIndex

练习描述

定义一个接口 (MyString) ，里面定义一个抽象方法：

String mySubString(String s,int x,int y);

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

一个方法是： useMyString(MyString my)

一个方法是主方法，在主方法中调用 useMyString 方法

代码演示

public interface MyString {
    String mySubString(String s,int x,int y);
}
public class MyStringDemo {
    public static void main(String[] args) {
//Lambda简化写法
        useMyString((s,x,y) -> s.substring(x,y));
//引用类的实例方法
        useMyString(String::substring);
    }
    private static void useMyString(MyString my) {
        String s = my.mySubString("HelloWorld", 2, 5);
        System.out.println(s);
    }
}

 

使用说明

 

Lambda 表达式被类的实例方法替代的时候

第一个参数作为调用者

后面的参数全部传递给该方法作为参数

7 引用构造器

引用构造器，其实就是引用构造方法

l 格式

类名 ::new

范例

Student::new

练习描述

定义一个类 (Student) ，里面有两个成员变量 (name,age)

并提供无参构造方法和带参构造方法，以及成员变量对应的 get 和 set 方法

定义一个接口 (StudentBuilder) ，里面定义一个抽象方法

Student build(String name,int age);

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

一个方法是： useStudentBuilder(StudentBuilder s)

一个方法是主方法，在主方法中调用 useStudentBuilder 方法

代码演示

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 interface StudentBuilder {
    Student build(String name,int age);
}
public class StudentDemo {
    public static void main(String[] args) {
//Lambda简化写法
        useStudentBuilder((name,age) -> new Student(name,age));
//引用构造器
        useStudentBuilder(Student::new);
    }
    private static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("林青霞", 30);
        System.out.println(s.getName() + "," + s.getAge());
    }
}

使用说明

Lambda 表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

标签：String,int,void,引用,文章,转载,方法,public
From： https://www.cnblogs.com/simba1984/p/17700748.html