Java——比较器，接口

Java——比较器，接口

可以通过自定义指定比较 规则，比较引用数据类型的数据

• Arrays.sort() 对 数组中的多个数据进行升序排序
• 当对自定义 引用数据类型数组排序的时候，通过2中方式实现：要求数据需要实现： 内部比较器|外部比较器
• Comparable 内部比较器|自然排序|默认排序规则
• 使用类去实现Comparable接口，重写内部的compareTo方法，方法中自定义比较规则
• 与类的耦合度太高，不便于后期维护
• 推荐使用自定义比较器|自定义排序
• 实现Comparator接口，重写compare方法，方法内部自定义比较规则

函数式接口

java8 四大内置核心函数式接口

• 消费型接口 Consumer

•  void accept(T t)
  

• 供给型接口 Supplier

•  T	 get()
  

• 函数型接口 Function<T,R>

•  R	 apply(T t)
  

• 段言型接口 Predicate

•  boolean test(T t)
  

1. Consumer 消费,有去无回

public static void happy(double money,Consumer<Double> con) {
		con.accept(money);
		}
	}

• 段言型接口 Predicate : 做一些操作 判断,是否满足条件
• 需要 : 将满足条件的字符串放入集合
• 返回值: 返回集合
• 参数: ArrayList集合,结合中放入字符串 判断操作Lambda

public static ArrayList<String> filter(ArrayList<String> ls,Predicate<String> pre){
	ArrayList<String> flterStr = new ArrayList<String>(); //容器中存储满足条件的字符串
	
	//遍历参数容器,拿出的每一个数据进行判断,满足条件放入flterStr容器
	for(String str:ls) {
		if(pre.test(str)) {
			flterStr.add(str);
		}
	}
	return flterStr;
}

• 函数型接口 Function<T,R>
• 需求: 对字符串进行某种操作

public static String strHandler(String str, Function<String,String> fun) {
		return  fun.apply(str);
	}

• 供给型接口 Supplier : 产生一些对象|数据供你使用,所以名字为供给型
• 需求: 产生指定个正数数据,放入数组中
• num: 个数
• sup: 执行生产的的规则
• int–>对应的引用数据类型–>Integer
• 泛型: 只能为引用数据类型

public static ArrayList<Integer> getNumList(int num,Supplier<Integer> sup){
		ArrayList<Integer> list= new ArrayList<Integer>();
		for(int i=1;i<=num;i++) {
			int n=sup.get();  //调用指定规则生成一个正数Integer,因为泛型,int也可以
			list.add(n);  //把生成的数据放入list集合
		}
		return list;
	}
	

java8 四大内置核心函数式接口

• 消费型接口 Consumer
• void accept(T t)
• 供给型接口 Supplier
• T get()
• 函数型接口 Function<T,R>
• R apply(T t)
• 段言型接口 Predicate
• boolean test(T t)

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

import com.shsxt.bean.Student;
public class FunctionalInterfaceDemo01 {
	public static void main(String[] args) {
		happy(10000,(e)->{System.out.println("给托马托马斯刷火箭消费"+e);});
		happy(100,(e)->{System.out.println("日常午餐消费"+e);});
		
		ArrayList<Integer> list = getNumList(10,()->{return (int)(Math.random()*(50-3)+3);});
		System.out.println(list);
		
		Supplier<Student> s=()->new Student();
		System.out.println(s.get());;
		
		System.out.println(strHandler("  匆匆那年 ",(str)->str.trim()));;
		
		ArrayList<String> list2 = new ArrayList<String>(); 
		list2.add("张三");
		list2.add("张三风");
		list2.add("张三雨");
		//断言型接口
		System.out.println(filter(list2,(str)->str.length()>2));
	}
	/*
	 * 段言型接口 Predicate<T> : 做一些操作 判断,是否满足条件
	 * 	需要 : 将满足条件的字符串放入集合 
	 * 	返回值: 返回集合
	 *  参数: ArrayList集合,结合中放入字符串     判断操作Lambda
	 */
	public static ArrayList<String> filter(ArrayList<String> ls,Predicate<String> pre){
		ArrayList<String> flterStr = new ArrayList<String>(); //容器中存储满足条件的字符串
		
		//遍历参数容器,拿出的每一个数据进行判断,满足条件放入flterStr容器
		for(String str:ls) {
			if(pre.test(str)) {
				flterStr.add(str);
			}
		}
		return flterStr;
	}
	
	/*
	 * 函数型接口   Function<T,R> 
	 * 	需求: 对字符串进行某种操作
	 */
	public static String strHandler(String str, Function<String,String> fun) {
		return  fun.apply(str);
	}

	/*
	 * 供给型接口 Supplier<T> : 产生一些对象|数据供你使用,所以名字为供给型
	 * 	需求: 产生指定个正数数据,放入数组中
	 * 
	 * num: 个数
	 * sup: 执行生产的的规则
	 * 
	 * int-->对应的引用数据类型-->Integer
	 * 泛型: 只能为引用数据类型 
	 */
	public static ArrayList<Integer> getNumList(int num,Supplier<Integer> sup){
		ArrayList<Integer> list= new ArrayList<Integer>();
		for(int i=1;i<=num;i++) {
			int n=sup.get();  //调用指定规则生成一个正数Integer,因为泛型,int也可以
			list.add(n);  //把生成的数据放入list集合
		}
		return list;
	}
	//Consumer<T> 消费,有去无回
	public static void happy(double money,Consumer<Double> con) {
		con.accept(money);
	}
}

方法引用:简化Lambda表达式

• 若Lambda体中的功能,已经有方法提供了实现,就可以使用方法引用(调用那个方法)
• 方法引用
• 1.对用的引用::成员方法名
• 2.类名::静态方法名
• 3.类名::实例方法名
• 构造器引用
• 类型名::new

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

import com.shsxt.bean.Employee;
import com.shsxt.bean.Student;
public class Demo02 {
	public static void main(String[] args) {
		//test1();
		test4();
	}
	
	/**
	 * 4.构造器引用
	 * 
	 */
	public static void test4() {
		//Supplier<Employee> sup = ()->new Employee();
		Supplier<Employee> sup = Employee::new;
		
		//Function<String,Employee> sup2 = (s)-> new Employee(s);
		Function<String,Employee> sup2 = Employee::new;
		System.out.println(sup2.apply("wangwu"));;
	}
	
	
	/**
	 * 3.类名::实例方法名
	 *  当抽象方法的参数列表中,第一个参数匹配内部所引用的方法的调用对象,第二个参数开始匹配引用方法的参数列表
	 */
	public static void test3() {
		//BiPredicate<String,String> bp = (s1,s2)->s1.equals(s2);
		BiPredicate<String,String> bp = String::equals;
		System.out.println(bp.test("abc", "abcd"));
		
		Student s = new Student(001,"zhangsan",18);
		
		//Consumer<Student> con = (student)->{student.show();};
		Consumer<Student> con = Student::show;
		con.accept(s);
	}
	
	
	
	/**
	 * 2.类名::静态方法名 
	 */
	public static void test2() {
		//2个正数 中最大的
		Comparator<Integer> com = (i1,i2)->Math.max(i1,i2);
		Comparator<Integer> com2 =Math::max;
		System.out.println(com2.compare(1, 4));
	}
	
	/*
	 * 1.对用的引用::成员方法名
	 * 	需要函数型接口中抽象方法的参数列表和返回值类型 与 引用的方法的参数列表和返回值类型一一对应
	 */
	public static void test1() {
		PrintStream ps = System.out;
		//打印参数字符串
		Consumer<String> con = (s)->{ps.println(s);};
		Consumer<String> con2 =ps::println;
		
		//只能够存储String类型的容器,个数大小没有限制
		ArrayList<String> ls = new ArrayList<String>();
		//往容器中添加String数据
		ls.add("董晖");
		ls.add("李松宝");
		ls.add("姜首航");
		ls.add("姜云英");
		//forEach 遍历拿出容器中每一个数据 拿出数据做什么,看参数定义的消费方式
		ls.forEach(System.out::println);
		
	}
}

下一篇，接口