以下博客是根据黑马视频写的Javase全集博客笔记：黑马程序员全套Java教程_Java基础入门视频教程，零基础小白自学Java必备教程
（一）Java语言基础
（二）Java面向对象编程
（三）Java核心类库之（常用API、字符串类、集合类、泛型）
（四） Java核心类库之（异常机制）
（五）Java核心类库之（字符集/编码集、File类、递归、IO流：字节流、字符流、特殊操作流）
（六）Java核心类库之（类加载器、反射机制、模块化）
（七）Java核心类库之（Lambda表达式）
（八）Java核心类库之（接口组成更新、方法引用、函数式接口）
（九）Java核心类库之（Stream流：生成、中间、终结、收集操作）
（十）Java核心类库之（多线程：实现多线程、线程同步）
（十一）Java核心类库之（网络编程：网络编程入门、UDP通信程序、TCP通信程序）
1 接口组成更新
1.1 接口组成更新概述
接口的组成
常量：public static final
抽象方法：public abstract
默认方法(Java 8)
静态方法(Java 8)
私有方法(Java 9)
1.2 接口中默认方法（JDK8）
接口中默认方法的定义格式：
格式：public default 返回值类型 方法名(参数列表){}
范例：public default void show(){}
接口中默认方法的注意事项：
默认方法不是抽象方法，所以不强制被重写。但是可以被重写,重写的时候去掉default关键字
public可以省略，default不能省略：default void show(){}
1.3 接口中静态方法（JDK8）
接口中静态方法的定义格式:
格式：public static 返回值类型 方法名(参数列表){}
范例：public static void show(){}
接口中静态方法的注意事项：
静态方法只能通过接口名调用, 不能通过实现类名或者对象名调用
public可以省略， static不能省略：static void show(){}
接口
package test; public interface Inter { void show(); default void method() { System.out.println("默认方法"); } // public static void test(){ // System.out.println("静态方法"); // } static void test(){ System.out.println("静态方法"); } }
实现类
package test; public class InterImpl implements Inter{ @Override public void show() { System.out.println("show方法"); } }
测试类
package test; public class Demo { public static void main(String[] args) { Inter i = new InterImpl(); i.show(); //show方法 i.method(); // // i.test(); //报错 Inter.test(); //静态方法,接口名调用静态方法 } }
1.4 接口中私有方法（JDK9）
接口中私有方法的定义格式：
格式1（非静态）：private 返回值类型 方法名(参数列表){}
范例1：private void show() {}
格式2（静态）：private static 返回值类型 方法名(参数列表){}
范例2：private static void method() {}
接口中私有方法的注意事项：
默认方法可以调用私有的静态方法和非静态方法
静态方法只能调用私有的静态方法
package test; public interface Inter { default void show1() { System.out.println("show1开始执行"); // System.out.println("初级工程师"); // System.out.println("中级工程师"); // System.out.println("高级工程师"); // show(); method(); System.out.println("show1结束"); } static void method1() { System.out.println("method1开始执行"); // System.out.println("初级工程师"); // System.out.println("中级工程师"); // System.out.println("高级工程师"); method(); System.out.println("method1结束"); } private void show(){ System.out.println("初级工程师"); System.out.println("中级工程师"); System.out.println("高级工程师"); } private static void method(){ System.out.println("初级工程师"); System.out.println("中级工程师"); System.out.println("高级工程师"); } }
2 方法引用
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作
那么考虑一种情况: 如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，没有必要再写重复逻辑，如usePrintable(s -> System.out.println(s));中System.out.println(s)就是重复逻辑
可以通过方法引用来使用已经存在的方案
2.1 方法引用符
方法引用符
:: 该符号为引用运算符，而它所在的表达式被称为方法引用
对比分析
Lambda表达式：usePrintable(s -> System.out.println(s));
分析：拿到参数s之后通过Lambda表达式，传递给System.out.println()方法去处理
方法引用：usePrintable(System.out:println);//隐含了把s参数给println方法
分析：直接使用System.out中的println方法来取代Lambda,代码更加的简洁
推导与省略
如果使用Lambda,那么根据"可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
如果使用方法引用，也是同样可以根据上下文进行推导
方法引用是Lambda的李生兄弟（可以使用Lambda表达式就可以使用方法引用）
范例
package test; public class Demo { public static void main(String[] args) { //Lambda表达式 usePrintable(i -> { System.out.println(i); //888 }); //方法引用 usePrintable(System.out::println); //888 } private static void usePrintable(Printable p) { p.printInt(888); } }
2.2 引用类方法
常用方法引用
引用类方法
引用类的实例方法（成员方法）
引用对象的实例方法
引用构造器
引用类方法，其实就是引用类的静态方法
格式：类名::静态方法
范例：Integer::parselnt
Integer类的方法：public static int parseInt(String s)将此String转换为int类型数据
练习
接口类
package test; public interface Converter { int convert(String s); }
测试类
package test; public class Demo { public static void main(String[] args) { // useConverter(s -> { // return Integer.parseInt(s); // }); useConverter(s -> Integer.parseInt(s)); //666 //引用类方法 useConverter(Integer::parseInt); //666 //Lambda表达式被类方法替代时，他的形式参数全部传给静态方法做参数;如s字符串传递给parseInt方法 } private static void useConverter(Converter c) { int number = c.convert("666"); System.out.println(number); } }
2.3 引用类的实例方法（成员方法）
引用类的实例方法，其实就是引用类中的成员方法
格式：类名::成员方法
练习
接口
package test; public interface MyString { String mySubString(String s,int x,int y); }
测试类
package test; public class Demo { public static void main(String[] args) { // useMyString((String s,int x,int y)->{ // return s.substring(x, y); //llo // }); useMyString((s,x,y)-> s.substring(x, y)); // //llo //引用类中的实例方法 useMyString(String::substring); //llo //Lambda表达式中的形式参数(s,x,y) //第一个参数作为调用者 //后面的参数全部传给实例方法作为参数 } public static void useMyString(MyString m) { String s = m.mySubString("HelloWorld", 2, 5); System.out.println(s); } }
2.4 引用对象的实例方法（成员方法）
引用对象的实例方法，其实就引用类中的成员方法
格式：对象名::成员方法
范例："HelloWorld"::toUpperCase
String类中的方法：public String toUpperCase()将此String所有字符转换为大写
练习
PrintString类
package test; public class PrintString { //把字符串转换成大写 public void printUpper(String s) { String result = s.toUpperCase(); System.out.println(result); } }
接口
package test; public interface Printer { void printUpperCase(String s); }
测试类
package test; public class Demo { public static void main(String[] args) { // usePrinter((String s ) -> { String result = s.toUpperCase(); System.out.println(result); //HELLO // System.out.println(s.toUpperCase()); // }); usePrinter(s -> System.out.println(s.toUpperCase())); //引用对象的实例方法 PrintString ps = new PrintString(); usePrinter(ps::printUpper); //HELLO } public static void usePrinter(Printer p) { p.printUpperCase("hello"); } }
2.5 引用构造器
引用构造器，就是引用构造方法
格式：类名::new
范例：Student::new
练习
测试类
package test; public class Demo { public static void main(String[] args) { // useStudentBuilder((String name,int age) -> { Student s =new Student(name,age); return s; // return new Student(name,age); // // }); useStudentBuilder((name, age) -> new Student(name, age)); useStudentBuilder(Student::new); //小黑,10 //Lambda表达式被引用构造器代替时，他的形式参数全部传递给构造器作为参数 } public static void useStudentBuilder(StudentBuilder sb) { Student s = sb.build("小黑", 10); System.out.println(s.getName() + "," + s.getAge()); } }
3 函数式接口
3.1 函数式接口概述
函数式接口：有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口只有确保接口中有且仅有一个抽象方法， Java中的Lambda才能顺利地进行推导
如何检测一个接口是不是函数式接口呢?
@FunctionalInterface
放在接口定义的上方:如果接口是函数式接口，编译通过；如果不是,编译失败
注意：我们自己定义函数式接口的时候，@Functionallnterface是可选的, 就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解
3.2 函数式接口作为方法的参数
需求
package test; public class Demo { public static void main(String[] args) { //匿名内部类 startThread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + "线程启动了"); //Thread-0线程启动了 } }); //Lambda表达式 startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了")); //Thread-1线程启动了 } public static void startThread(Runnable r) { //Runnable为函数式接口，上方有@FunctionalInterface // Thread t = new Thread(r); // t.start(); new Thread(r).start(); } }
如果方法的参数是函数式接口，可以使用Lambda表达式作为参数传递
startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
3.3 函数式接口作为方法的返回值
需求
package test; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; public class Demo { public static void main(String[] args) { //构造使用场景 //定义一个集合存储字符串 ArrayList array = new ArrayList(); array.add("cccc"); array.add("aa"); array.add("b"); array.add("dd"); System.out.println("排序前："+array); //排序前：[cccc, aa, b, dd] Collections.sort(array); //排序后:[aa, b, cccc, dd] Collections.sort(array,getComparator()); //排序后:[b, aa, dd, cccc] System.out.println("排序后:"+array); } public static Comparator<String> getComparator() { //匿名内部类 // Comparator<String> comp = new Comparator<String>() { // @Override // public int compare(String s1, String s2) { // return s1.length()-s2.length(); // } // }; // return comp; // return new Comparator<String>() { // @Override // public int compare(String s1, String s2) { // return s1.length()-s2.length(); // } // }; //Lambda表达式 // return (String s1,String s2) ->{ // return s1.length()-s2.length(); // }; return(s1,s2) -> s1.length()-s2.length(); } }
如果方法的返回值是函数式接口，可以使用Lambda表达式作为结果返回
public static Comparator<String> getComparator() { return(s1,s2) -> s1.length()-s2.length(); }
3.4 常用函数式接口
Java 8在java.util.function包下预定义了大量的函数式接口供我们使用
重点来学习下面的4个接口
Supplier [səˈplaɪər] 接口
Consumer [kənˈsuːmər] 接口
Predicate[ˈpredɪkət] 接口
Function接口
3.4.1 Supplier接口
Supplier<T>：包含一个无参的方法
T get()方法：获得结果
该方法不需要参数， 它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型,那么接口中的get()方法就会生产什么类型的数据供我们使用
package test; import java.util.function.Supplier; public class Demo { public static void main(String[] args) { // String s = getString(() -> { // return "小黑"; // }); String s = getString(() -> "小黑"); System.out.println(s); //小黑 int i = getInteger(() -> 10); System.out.println(i); //10 } //定义一个方法，返回字符数据 public static String getString(Supplier<String> sup) { return sup.get(); } //定义一个方法，返回整数数据 public static Integer getInteger(Supplier<Integer> sup) { return sup.get(); } }
练习
package test; import java.util.function.Supplier; public class Demo { public static void main(String[] args) { int[] arr = {22, 55, 11, 44, 33}; int maxValue = getMax(() -> { int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } return max; }); System.out.println(maxValue); //55 } public static int getMax(Supplier<Integer> sup) { return sup.get(); } }
3.4.2 Consumer接口
Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
Consumer ：包含两个方法
方法名 说明
void accept(T t) [əkˈsept] 对给定的参数执行此操作
default Consumer<T> andThen(Consumer after) 返回一个组合的Consumer，依次执行此操作，然后执行after操作
范例
package test; import java.util.function.Consumer; public class Demo { public static void main(String[] args) { // operatorString("小白",(String s)->{ // System.out.println(s); //小白 // }); operatorString("小白",s-> System.out.println(s)); //小白 // operatorString("小黑",System.out::println); //小黑 // operatorString("大熊猫",s -> { // System.out.println(new StringBuilder(s).reverse().toString()); //猫熊大 // }); operatorString("大熊猫",s -> System.out.println(new StringBuilder(s).reverse().toString())); //猫熊大 System.out.println("---------"); operatorString("小熊猫",s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString())); // 小熊猫 // 猫熊小 } //定义一个方法，用不同的方式消费同一个字符串数据两次 private static void operatorString(String name, Consumer<String> con1,Consumer<String> con2) { //1,void accept(T t) [əkˈsept] 对给定的参数执行此操作 // con1.accept(name); // con2.accept(name); //2,Consumer<T> andThen(Consumer after) 返回一个组合的Consumer，依次执行此操作，然后执行after操作 con1.andThen(con2).accept(name); } //定义一个方法，消费一个字符串数据 private static void operatorString(String name, Consumer<String> con) { con.accept(name); } }
练习
package test; import java.util.function.Consumer; public class Demo { public static void main(String[] args) { String[] strArray = {"小白,10", "小黑,20"}; // printInfo(strArray,(String str) ->{ // String name = str.split(",")[0]; // System.out.print("姓名:"+name); // },(String str)->{ // int age = Integer.parseInt(str.split(",")[1]); // System.out.println(",年龄:"+age); // }); //姓名:小白,年龄:10 //姓名:小黑,年龄:20 printInfo(strArray, str -> System.out.print("姓名:" + str.split(",")[0]), str -> System.out.println(",年龄:" + Integer.parseInt(str.split(",")[1]))); } private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) { for (String str : strArray) { con1.andThen(con2).accept(str); } } }
3.4.3 Predicate [predɪkeɪt] 接口
Predicate<T>接口通常用于判断参数是否满足指定的条件
常用的四个方法
方法名 说明
boolean test(T t) 对给定的参数进行判断(判断逻辑由Lambda表达式实现，返回一个布尔值
default Predicate<T> negate() 返回一个逻辑的否定，对应逻辑非
default Predicate <T> and(Predicate other) 返回一个组合判断，对应短路与
default Predicate <T> or(Predicate other) 返回一个组合判断，对应短路或
范例
package test; import java.util.function.Predicate; public class Demo { public static void main(String[] args) { // boolean b1 = checkString("hello",(String s) ->{ // return s.length()>8; // }); boolean b1 = checkString("hello", s -> s.length() > 8); System.out.println(b1); //1：false，2：true boolean b2 = checkString("hello",s->s.length()>8,s -> s.length()<15); System.out.println(b2); //3:false,4:true boolean b3 = checkString("hellojava",s->s.length()>8,s -> s.length()<15); System.out.println(b3); //3:true,4:true } //判断给定的字符串是否满足要求 private static boolean checkString(String s, Predicate<String> pre) { //1,boolean test(T t) 对给定的参数进行判断(判断逻辑由L ambda表达式实现，返回一个布尔值 // return pre.test(s); // return !pre.test(s); //输出相反的，不过用下一个方法 //2,default Predicate<T> negate() 返回一个逻辑的否定，对应逻辑非 return pre.negate().test(s); } //同一个结果给出两个不同的判断条件，最后把这两个判断结果做逻辑与的结果作为最终结果 private static boolean checkString(String s,Predicate<String> pre1,Predicate<String> pre2) { // boolean b1 = pre1.test(s); // boolean b2 = pre2.test(s); // boolean b = b1 && b2; // return b; //3,default Predicate <T> and(Predicate other) 返回一个组合判断，对应短路与 // return pre1.and(pre2).test(s); //源码：return (t) -> test(t) && other.test(t); //default Predicate <T> or(Predicate other) 返回一个组合判断，对应短路或 return pre1.or(pre2).test(s); //源码：return (t) -> test(t) || other.test(t); } }
练习
package test; import java.util.ArrayList; import java.util.function.Predicate; public class Demo { public static void main(String[] args) { String[] strArray = {"小黑,50", "大熊猫,40", "小白,20", "奥特曼,100"}; ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2, s -> Integer.parseInt(s.split(",")[1]) > 33); for(String str:array) { System.out.println(str); // 大熊猫,40 // 奥特曼,100 } } public static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) { //定义一个集合 ArrayList<String> array = new ArrayList<String>(); //遍历数组 for (String str : strArray) { if (pre1.and(pre2).test(str)) { array.add(str); } } return array; } }
3.4.4 Function接口
Function<T,R>接口通常用于对参数进行处理,转换（处理逻辑由Lambda表达式实现），然后返回一个新的值
常用的两个方法
方法名 说明
R apply(T t) 将此函数应用于给定的参数
default <V> Function andThen(Function after) 返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
案例
package test; import java.util.function.Function; public class Demo { public static void main(String[] args) { convert("100", s -> Integer.parseInt(s)); //100 // convert("100",Integer::parseInt); //100 convert(100, i -> String.valueOf(i + 566)); //666 convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566)); //666 } //定义一个方法，把一个字符串转换成int类型，在控制台输出 public static void convert(String s, Function<String, Integer> fun) { //1,R apply(T t) 将此函数应用于给定的参数 // Integer i = fun.apply(s); int i = fun.apply(s); System.out.println(i); } //定义一个方法，把一个int类型的数据加上一个整数之后，转换为字符串在控制台输出 public static void convert(int i, Function<Integer, String> fun) { String s = fun.apply(i); System.out.println(s); } //定义一个方法，把一个字符串转换成int类型，把int类型的数据加上一个整数之后，转换为字符串在控制台输出 public static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) { //Integer i = fun.apply(s); //String ss = fun.apply(i); //2,default <V> Function andThen(Function after) 返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果 String ss = fun1.andThen(fun2).apply(s);//源码：return (T t) -> after.apply(apply(t));相当于上两步 System.out.println(ss); } }
练习
package test; import java.util.function.Function; public class Demo { public static void main(String[] args) { String s = "小黑,20"; convert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70); //90 } public static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) { int i = fun1.andThen(fun2).andThen(fun3).apply(s); System.out.println(i); } }
