今日内容
- 函数式接口
- 自定义函数接口
- 函数式编程
- 常用函数式接口
- Stream流
- 方法引用
文件上传优化
文件的名称需要优化
服务端，保存文件的名称如果名称固定，那么最终会导致服务器硬盘，只会保留一个文件，对上传的文件名称优化，
//文件名称定义规则：
"beautiful" + System.currentTimeMillis() + new Random().nextInt(1000000) + ".jpg";服务器端接收文件的优化
服务器端，接收一个文件之后就关闭了，后面的其他客户端无法继续上传文件，使用循环进行改进，可以不断的接收不同的客户端传输过来的文件。
// 使用循环
while(true) {
Socket socket = serverSocket.accept();
....
....
}服务器端接收客户端文件的效率的优化
服务器端，在接收文件的时候，加入某个客户端给你传输一个大文件，此时就不能再接收其他用户的文件，所以可以用多线程技术优化接收效率。
while(true) {
Socket socket = serverSocket.accept();
// 使用多线程技术，提高程序的效率
// 有一个客户端上传文件，就开启一个线程，完成文件的上传
new Thread(new Runnable() {
// 重写run方法，设定线程的任务
@Override
public void run() {
// 使用网络字节输入流对象
InputStream is = socket.getInputStream();
// 指定一个目录
File file = new File("D:\\upload");
if(!file.exits()) {
file.mkdirs();
}
// 防止同名的文件被覆盖
String filename = "beautiful" + System.currentTimeMillis() + new Random().nextInt(1000000) + ".jpg";
// 构建一个本地的文件字节输出流对象
new FileOutputStream(file + "\\" + filename);
// 一读一写完成文件的上传，最终把文件写入到服务器端的硬盘当中。
.....
}
}).start();
}
// 服务端不关闭
// serverSocket.close();函数式接口
概念
函数式接口在Java指的是：有且仅有一个抽象方法的接口就称为函数式接口。
函数式接口，适用于函数式编程的，在Java当中的函数式编程体现在Lambda，所以函数式接口就是用来服务Lambda表达式。只有确保接口当中有且仅有一个抽象方法，Java中的Lambda才能顺利进行推导。
备注："语法糖"是指使用更加便利方便，但是原理不变的代码语法。就比如遍历集合时使用for-each语法，其实底层使用的是迭代器，这便是"语法糖"。
格式
只有确保接口当中有且仅有一个抽象方法即可：
修饰符 interface InterfaceName{
// 只能定义一个抽象方法
public abstract 返回值类型 方法名称(参数列表);
// 还可以定义其他的非抽象方法
}示例：
public interface FunctionInterfaceOne {
public abstract void show01();
public default void show02(){
//.....
}
// void show03(); 有且仅有一个抽象方法，才称为函数式接口
}@FunctionalInterface注解
与@Override注解作用类似，Java 8中专门为函数式接口引入的一个新注解@FunctionalInterface,该注解主要定义在接口上。一旦在接口上使用该注解，编译期将会强制检查该接口是不是一个函数式接口，该接口中是不是有且仅有一个抽象方法，如果不是，编译报错。
@FunctionalInterface
public interface FunctionInterfaceOne {
// 定义一个抽象的方法
void method();
//void show();
default void show02(){
}
}自定义函数式接口的用途
对于自定义的函数式接口，一般用于方法的参数和返回值上。
函数式编程
能够在兼顾Java的面向对象特性基础上，通过Lambda表达式与后面的方法引用，为开发者打开函数式编程的的大门。
Lambda的延迟加载
有些场景的代码运行执行后，结果不一定会被使用到，从而造成性能的浪费。而Lambda表达式是延迟执行的，正好可以解决此问题，提升性能。
代码如下：
public static void main(String[] args) {
// 定义一些日志信息
String message1 = "执行mysqld.exe操作";
String message2 = "执行java.exe操作";
String message3 = "执行tomcat.exe操作";
// 调用showLog方法，参数是一个函数式接口--BuildLogMessage接口，所以可以使用Lambda表达式
/* showLog(2, () -> {
// 返回一个拼接好的字符串
return message1 + message2 + message3;
});*/
// 简化Lambda表达式
/*
使用Lambda表达式作为参数传递，
只有满足条件，日志的等级小于等于3
才会调用此接口BuildLogMessage当中的方法buildLogMessage
才会进行字符串的拼接动作
如果条件不满足，日志的等级大于3
那么BuildLogMessage接口当中的方法buildLogMessage也不会执行
所以拼接字符串的动作也不会执行
所以不会存在性能上的浪费。
*/
showLog(4, () -> {
System.out.println("前面的日志等级大于3，此处不执行！");
return message1 + message2 + message3;
});
}备注：实际上使用内部类也可以达到这样的效果，只是将代码操作延迟到另外一个对象当中通过调用方法来完成。
后面的代码的执行取决于前面的条件的判断结果。
使用Lambda作为方法的参数和返回值
在Java当中，Lambda表达式是作为匿名内部类的替代品，如果一个方法的参数是一个函数式接口类型，那么可以使用Lambda表达式进行替代。
java.lang.Runnable接口就是一个函数式接口
代码如下：
public class Demo01Lambda {
// 定义一个方法，开启线程的方法,方法传入一个函数式接口类型的参数
public static void startThread(Runnable r) {
new Thread(r).start();
}
public static void main(String[] args) {
startThread(() -> {
System.out.println("开启一个新线程，线程任务被执行了！");
});
// 优化Lambda
startThread(() ->System.out.println("开启一个新线程，线程任务被执行了！");
}
}如果一个方法的返回值类型是一个函数式接口，那么我们可以直接使用一个Lambda表达式。
java.util.Comparator接口是一个函数式接口
代码如下：
public class Demo02Lambda {
// 定义一个方法，方法的返回值类型是一个函数式接口类型Comparator
public static Comparator<String> createComparator() {
// 返回值就是一个函数式接口
/*return new Comparator() {
@Override
public int compare(String o1,String o2){
// 自定义比较的规则 升序/降序
// 字符串的长度
return o1.length()-o2.length();// 升序
}
}
*/
// 使用Lambda 字符串的长度升序
return (o1,o2) -> o1.length() - o2.length();
}
public static void main(String[] args) {
String[] strs = {"aaa","a","abcdefg","ggggg"};
Arrays.sort(strs, createComparator());
System.out.println(Arrays.toString(strs));// {"a","aaa","ggggg","abcdefg"}
}
}常用的函数式接口
JDK提供了大量常用的函数式接口，丰富Lambda表达式的使用场景。他们主要在java.util.function包中被提供。
Supplier接口
java.util.function.Supplier<T>接口，该接口有且仅有一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。由于该接口是一个函数式接口，所以我们可以使用Lambda表达式来操作它。
Supplier<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get()方法就会生产什么类型的数据。
代码如下：
// 定义一个方法，方法的参数传递一个Supplier<T>接口，泛型指定String，get方法就会返回一个String
public static String getString(Supplier<String> sup) {
return sup.get();
}
// 定义一个方法，方法的参数传递一个Supplier<T>接口，泛型我指定为Integer，get方法就会返回一个int
public static int getNum(Supplier<Integer> sup) {
return sup.get();
}
public static void main(String[] args) {
// 调用getString方法，方法的参数传递Supplier<T>是一个函数式接口，那么我们就可以使用Lambda
/* String str = getString(() -> {
// 生产一个字符串并返回
return "你好Java";
});
System.out.println(str);*/
// 求一个int类型的数组中的最值
int[] arr = {10,20,5,8,3,50};
int maxNum = getNum(() -> {
// 求出数组的最大值
int max = arr[0];
for (int i : arr) {
// 判断
if (max < i) {
max = i;
}
}
return max;
});
// 输出最大值
System.out.println(maxNum);// 50
}Consumer 接口
java.util.function.Consumer<T>接口刚好和Supplier接口相反，它不是用来生产一个数据，而是消费一个数据。
数据的类型由泛型来指定。
accept方法
意思就是消费一个指定泛型的数据。
代码如下：
// 定义一个方法，方法的参数传递一个Consumer<String>接口,传递一个字符串变量
public static void consumer(String str, Consumer<String> con) {
// 使用消费型接口对象，消费传递的字符串值。
con.accept(str);
}
public static void main(String[] args) {
// 来调用消费方法consumer,Consumer<String>接口是一个函数式接口类型，所以可以使用Lambda表达式
consumer("abcdefg", name -> {
// 把里面的abcdefg字符串改为大写输出 消费的规则自定义
String str = name.toUpperCase();
String s = new StringBuffer(str).reverse().toString();
System.out.println(s);// GFEDCBA
});
}默认的方法：andThen
如果一个方法的参数和返回值全都是Consumer类型，那么就可以实现这样的效果：消费数据的时候，首先做一个消费的操作，在做一个消费的操作，实现组合。可以通过Consumer接口当中的默认方法:andThen来实现。
代码如下：
// 定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Consumer接口的泛型指定为字符串
public static void consumers(String str, Consumer<String> con1,Consumer<String> con2) {
/* con1.accept(str);
con2.accept(str);*/
// andThen 连续消费 default Consumer<String> andThen
// 先执行左边的Consumer--con1的动作，andThen--->再次执行Consumer--con2动作
con1.andThen(con2).accept(str);
// 规则 con1连接con2 ，先执行con1消费数据，在执行con2消费数据
}
public static void main(String[] args) {
// 由于consumers方法的参数Consumer接口是一个函数式接口，可以使用Lambda表达式
consumers("Java31-中国最棒-都是业界大佬", (name1)->{
// 消费规则
// 截取传入的字符串
String sub = name1.substring(0, 6);
System.out.println(sub);
}, (name2) -> {
// 定义消费的规则 分成字符串数组展示
String[] strs = name2.split("-");
System.out.println(Arrays.toString(strs));// {“Java31","中国最棒","都是业界大佬"}
});
}通过查看源码得知：andThen方法不允许传入一个null对象否则就会抛出空指针异常。
要想把两次消费的动作连接起来，需要传入两个Consumer接口，通过andThen方法实现一步一步执行消费动作。
练习：
定义一个字符串数组，存储每一个人的信息如："张三，20，郑州市",存储5个人的信息
使用Consumer接口，按照指定的格式进行打印输出：姓名:张三;年龄:20;地址:郑州市
要求将打印姓名的动作作为第一个Consumer接口的规则
将打印年龄的动作作为第二个Consumer接口的规则
将打印地址的动作作为第三个Consumer接口的规则。
最终将三个Consumer接口按照规定的顺序拼接输出出来。
代码如下：
// 规则
public static void consumers(String[] arr, Consumer<String> con1, Consumer<String> con2, Consumer<String> con3) {
// 操作arr数组当中的每一个元素
for (String str : arr) {
con1.andThen(con2).andThen(con3).accept(str);// 定义了消费的先后的顺序
}
}
public static void main(String[] args) {
// 定义一个字符串数组
String[] arr = {"李四,20,南阳市", "张三,20,郑州市", "小孙,20,开封市", "小丽,20,信阳市", "小赵,20,洛阳市"};
// 调用consumers方法，由于Consumer接口是一个函数式接口，所以可以使用Lambda
consumers(arr, one -> System.out.print("姓名:" + one.split(",")[0] + ";"),
two -> System.out.print("年龄:" + two.split(",")[1] + ";"),
three -> System.out.println("地址:" + three.split(",")[2]));
}编译器代码
/*
函数式接口：有且仅有一个抽象方法
接口当中可以包含其他方法(默认、静态、私有...)
@FunctionalOInterface注解
作用：可以检测接口是否为一个函数式接口
是：编译通过
否：编译失败
*/
@FunctionalInterface
public interface FunctionInterfaceOne {
// 定义一个抽象的方法
void method();
//void show();
default void show02(){
}
}/*
@Override 重写注解
检查方法是否为重写的方法
是：通过编译
否：编译失败。
*/
public class FunctionInterfaceOneImpl implements FunctionInterfaceOne {
@Override
public void method() {
System.out.println("这是实现类的重写的方法");
}
/*
* @Override public void show() {
*
* }
*/
/*
* @Override public void show02(){
*
* }
*/
}/*
函数式接口：一般都是作为方法的参数和返回值使用的。
*/
public class FunctionalInterfaceDemo01 {
// 定义一个方法，参数使用函数式接口FunctionInterfaceOne
public static void show(FunctionInterfaceOne ffo) {
// 调用里面的方法
ffo.method();
}
public static void main(String[] args) {
// 使用函数式接口
show(new FunctionInterfaceOneImpl());// 这是实现类的重写的方法
// 使用匿名内部类
show(new FunctionInterfaceOne() {
@Override
public void method() {
int i = 0 / 0;
System.out.println("这是匿名内部类重写的方法");// 这是匿名内部类重写的方法
}
});
// 使用，Lambda表达式
show(() -> {
System.out.println("这是使用Lambda表达式重写的方法");// 这是使用Lambda表达式重写的方法
});
// 简化Lambda表达式
show(() -> System.out.println("这是使用简化Lambda表达式重写的方法"));
}
}日志
@FunctionalInterface
public interface BuildLogMessage {
// 定义有且仅有一个抽象方法 拼接日志信息
public abstract String buildLogMessage();
}/*
showLog()方法如果传递的日志等级不是3以下的，
那么就不会显示拼接之后的日志信息
所以对于程序来说，你这个日志信息的拼接的动作就浪费了。
*/
public class Demo01Logger {
// 定义一个方法，根据日志的等级，显示日志信息的内容
public static void showLog(int level, String message) {
// 对日志的等级做一个判断,如果日志的等级在3以下，就全部输出日志信息
if (level <= 3) {
System.out.println(message);
return;
}
// 输出其他信息
System.out.println("日志等级较高，不显示");
}
public static void main(String[] args) {
// 定义一些日志信息
String message1 = "执行mysqld.exe操作";
String message2 = "执行java.exe操作";
String message3 = "执行tomcat.exe操作";
// 调用showLog方法，传递日志等级和日志信息
showLog(4, message1 + message2 + message3);
}
}/*
使用Lambda优化刚才的日志输出案例
Lambda的特点：具有延迟加载
Lambda的使用前提：提供一个函数式接口。
*/
public class Demo02Lambda {
// 定义一个显示日志的方法，方法的参数传递日志的等级和BuildLogMessage接口
public static void showLog(int level, BuildLogMessage log) {
// 对日志等级进行判断，如果是3以下的就进行输出日志信息
if (level <= 3) {
System.out.println(log.buildLogMessage());
}
}
public static void main(String[] args) {
// 定义一些日志信息
String message1 = "执行mysqld.exe操作";
String message2 = "执行java.exe操作";
String message3 = "执行tomcat.exe操作";
// 调用showLog方法，参数是一个函数式接口--BuildLogMessage接口，所以可以使用Lambda表达式
/*
* showLog(2, () -> { // 返回一个拼接好的字符串 return message1 + message2 + message3; });
*/
// 简化Lambda表达式
/*
* 使用Lambda表达式作为参数传递， 只有满足条件，日志的等级小于等于3
* 才会调用此接口BuildLogMessage当中的方法buildLogMessage 才会进行字符串的拼接动作 如果条件不满足，日志的等级大于3
* 那么BuildLogMessage接口当中的方法buildLogMessage也不会执行 所以拼接字符串的动作也不会执行 所以不会存在性能上的浪费。
*/
showLog(4, () -> {
System.out.println("前面的日志等级大于3，此处不执行！");
return message1 + message2 + message3;
});
}
}生产与消费
// Supplier<T>接口被称之为生产型接口，指定接口的泛型是什么类型，那么接口中的get()方法就会生产什么类型的数据。
public class Demo01Supplier {
// 定义一个方法，方法的参数传递一个Supplier<T>接口，泛型指定String，get方法就会返回一个String
public static String getString(Supplier<String> sup) {
return sup.get();
}
// 定义一个方法，方法的参数传递一个Supplier<T>接口，泛型我指定为Integer，get方法就会返回一个int
public static int getNum(Supplier<Integer> sup) {
return sup.get();
}
public static void main(String[] args) {
// 调用getString方法，方法的参数传递Supplier<T>是一个函数式接口，那么我们就可以使用Lambda
/*
* String str = getString(() -> { // 生产一个字符串并返回 return "你好Java"; });
* System.out.println(str);
*/
// 求一个int类型的数组中的最值
int[] arr = { 10, 20, 5, 8, 3, 50 };
int maxNum = getNum(() -> {
// 求出数组的最大值
int max = arr[0];
for (int i : arr) {
// 判断
if (max < i) {
max = i;
}
}
return max;
});
// 输出最大值
System.out.println(maxNum);
}
}/*
accept()方法：消费一个指定类型的数据
Consumer接口是一个消费型接口，泛型指定什么数据类型，使用accept方法就消费什么类型的数据
至于具体怎么消费（使用），需要自定义。（统计，求和，输出，。。。。）
*/
public class Demo02Consumer {
// 定义一个方法，方法的参数传递一个Consumer<String>接口,传递一个字符串变量
public static void consumer(String str, Consumer<String> con) {
// 使用消费型接口对象，消费传递的字符串值。
con.accept(str);
}
public static void main(String[] args) {
// 来调用消费方法consumer,Consumer<String>接口是一个函数式接口类型，所以可以使用Lambda表达式
consumer("abcdefg", name -> {
// 把里面的abcdefg字符串改为大写输出 消费的规则自定义
String str = name.toUpperCase();
String s = new StringBuffer(str).reverse().toString();
System.out.println(s);// GFEDCBA
});
}
}public class Demo03ConsumerAndThen {
// 定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Consumer接口的泛型指定为字符串
public static void consumers(String str, Consumer<String> con1, Consumer<String> con2) {
/*
* con1.accept(str); con2.accept(str);
*/
// andThen 连续消费 default Consumer<String> andThen
// 先执行左边的Consumer--con1的动作，andThen--->再次执行Consumer--con2动作
con1.andThen(con2).accept(str);
// 规则 con1连接con2 ，先执行con1消费数据，在执行con2消费数据
}
public static void main(String[] args) {
// 由于consumers方法的参数Consumer接口是一个函数式接口，可以使用Lambda表达式
consumers("Java31-中国最棒-都是业界大佬", (name1) -> {
// 消费规则
// 截取传入的字符串
String sub = name1.substring(0, 6);
System.out.println(sub);
}, (name2) -> {
// 定义消费的规则 分成字符串数组展示
String[] strs = name2.split("-");
System.out.println(Arrays.toString(strs));// {“Java31","中国最棒","都是业界大佬"}
});
}
}public class Demo04Stream {
public static void main(String[] args) {
// 构建一个集合
List<String> list = new ArrayList<String>();
list.add("abc123");
list.add("aaa22");
list.add("bcd125");
list.add("abcd120");
list.add("bbb230");
// 需要字符串中包含数字1的元素取出来 代码很优雅
// 需要集合当中字符串长度不能超过6个的元素取出来
// 遍历查看最终想要的集合元素 链式编程
list.stream()
.filter(str -> str.contains("1"))
.filter(str -> str.length() <= 6)
.forEach(str ->System.out.println(str));
/*
* abc123 bcd125
*/
}
}/*
定义一个字符串数组，存储每一个人的信息如："张三，20，郑州市",存储5个人的信息
使用Consumer接口，按照指定的格式进行打印输出：姓名:张三;年龄:20;地址:郑州市
要求将打印姓名的动作作为第一个Consumer接口的规则
将打印年龄的动作作为第二个Consumer接口的规则
将打印地址的动作作为第三个Consumer接口的规则。
最终将三个Consumer接口按照规定的顺序拼接输出出来。 andThen
*/
public class DemoConsumerTest {
// 规则
public static void consumers(String[] arr, Consumer<String> con1, Consumer<String> con2, Consumer<String> con3) {
// 操作arr数组当中的每一个元素
for (String str : arr) {
con1.andThen(con2).andThen(con3).accept(str);// 定义了消费的先后的顺序
}
}
public static void main(String[] args) {
// 定义一个字符串数组
String[] arr = { "李四,20,南阳市", "张三,20,郑州市", "小孙,20,开封市", "小丽,20,信阳市", "小赵,20,洛阳市" };
// 调用consumers方法，由于Consumer接口是一个函数式接口，所以可以使用Lambda
consumers(arr, one -> System.out.print("姓名:" + one.split(",")[0] + ";"),
two -> System.out.print("年龄:" + two.split(",")[1] + ";"),
three -> System.out.println("地址:" + three.split(",")[2]));
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
