方法的引用

     类名::静态方法名

interface StaticMethodInterface { 							// 测试接口
    int method(int a, int b);  								// 抽象方法
}
public class StaticMethodDemo {
    static int add(int x, int y) {								// 静态方法，返回两个参数相加的结果
        return x + y;                         				//返回相加结果
    }

    public static void main(String[] args) {
        StaticMethodInterface sm = StaticMethodDemo::add; 		//引用StaticMethodDemo类的静态方法
        int result = sm.method(15, 16);						//直接调用接口方法获取结果
        System.out.println("接口方法结果：" + result); 			//输出结果
    }
}

     接口方法结果：31

     对象名::成员方法名

import java.text.SimpleDateFormat;
import java.util.Date;
interface InstanceMethodInterface {                    // 创建测试接口
    String method(Date date);                           // 带参数的抽象方法
}
public class InstanceMethodDemo {
    public String format(Date date) {                  // 格式化方法
        // 创建日期格式化对象，并指定日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(date);                       // 返回格式化结果
    }

    public static void main(String[] args) {
        // 创建类对象
        InstanceMethodDemo demo = new InstanceMethodDemo();
        // 引用类对象的方法
        InstanceMethodInterface im = demo::format;
        Date date = new Date();                       // 创建日期对象
        System.out.println("默认格式：" + date);     // 输出日期对象默认格式
        // 输出经过接口方法处理过的格式
        System.out.println("接口输出的格式：" + im.method(date));
    }
}

     默认格式：Thu Jan 19 09:22:19 CST 2023
     接口输出的格式：2023-01-19

import java.util.HashSet;
interface ParadigmInterface<T> {                           // 测试接口
    int method(T[] t);                                      // 抽象方法
}

public class ParadigmDemo {// 测试类
    // 静态方法，使用泛型参数，在方法名之前定义泛型。此方法用于查找数组中的重复元素个数
    static public <T> int repeatCoount(T[] t) {
        int arrayLength = t.length;                     	// 记录数组长度
        java.util.HashSet<T> set = new HashSet<>(); 		// 创建哈希集合
        for (T tmp : t) {                        			// 遍历数组
            set.add(tmp);  							// 将数组元素放入集合中
        }
        return arrayLength - set.size();                    // 返回数组长度与集合长度的差
    }

    public static void main(String[] args) {
        Integer a[] = {1, 1, 2, 3, 1, 5, 6, 1, 8, 8};   			// 整数数组
        
        String s[] = {"王", "李", "赵", "陈", "李", "孙", "张"};		// 字符串数组
        // 创建接口对象，Integer作为泛型，引入ParadigmDemo类的静态方法,方法名要定义泛型
        ParadigmInterface<Integer> p1 = ParadigmDemo::<Integer> repeatCoount;
        // 调用接口方法
        System.out.println("整数数组重复元素个数：" + p1.method(a));
        // 创建接口对象，String作为泛型，引入ParadigmDemo类的静态方法
 		// 方法名若不定义泛型，则默认使用接口已定义好的的泛型
        ParadigmInterface<String> p2 = ParadigmDemo::repeatCoount;
        // 调用接口对象方法
        System.out.println("字符串数组重复元素个数：" + p2.method(s));
    }
}

     整数数组重复元素个数：4
     字符串数组重复元素个数：1

import java.util.function.Function;

public class FunctioinDemo {
	// 创建Function接口对象，参数类型是Integer[]，返回值类型是String
	Function<Integer[], String> function = (n) -> {
		StringBuilder str = new StringBuilder(); // 创建字符序列
		for (Integer num : n) { // 遍历参数数组
			str.append(num); // 字符序列添加数组元素
			str.append('.'); // 字符序列添加字符'.'
		}
		str.deleteCharAt(str.length() - 1); // 删除末尾的'.'
		return str.toString(); // 返回字符串
	};

	public static void main(String[] args) {
		Integer[] ip = { 192, 168, 1, 1 }; // 待处理的数组
		FunctioinDemo demo = new FunctioinDemo();
		System.out.println(demo.function.apply(ip)); // 输出处理结果
	}
}

     192.168.1.1

void sort(int arr[]);