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)
- 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);
}
}