今日内容
大点：
-
优化文件上传和优化多文件接收以及优化接收文件的效率
-
函数式接口
-
自定义函数接口
-
函数式编程
-
常用函数式接口
-
Stream流
1.文件上传优化(防止文件名重复被覆盖)
服务端在保存文件的名称如果名称固定(文件名字重复)，那么最终会导致服务器硬盘，只会保留一个文件，对上传的文件名称优化。
//文件名称定义规则"beautifrl"+System.currentTimeMillis()+new Random().nextInt(1000000)+".jpg";//获取当前时间
//这里的"beautifrl"可以自行定义不是固定的
2.服务器端接收多个文件的优化
服务器端，接收一个文件之后就关闭了,后面的其他客户端无法继续上传文件，使用循环进行改进，可以不断的接收不同的客户端传输过来的文件。
//使用循环 while(true){ Socket socket =serverSocket.accept(); .... .... }
3.服务端接收客户端文件的效率的优化(多线程同时接收多人发送的多个文件)
服务器端，在接收后文件的时候，假如某个客户端给你传输一个大文件，此时就不能在接受其他用户的文件，所以可以用多线程技术优化接收效率。
while(true){ Socket socket = serverSocket.accept(); //使用多线程技术，提高程序的效率 //有一个客户端上传文件，就开启一个线程，完成文件的上传 new Thread(new Runnable(){ //重写run方法，设置线程任务 @Override public void run(){ //使用网络字节输入流队象 InputStream is = socket.getInputStream(); //指定一个目录 new File("D:\upload"); if(!file.exits())//如果文件不存在 file.mkdirs; String filename = "beautiful"+System.currentTimeMillis()+new Random().nextInt(1000000)+".jpg"; //构建一个本地的文件字节输出流对象 new DileOutputStream(file+"\"+filename); //读写完成文件的上传，最终把文件写入到服务器的硬盘中 } }).start(); } //服务器不关闭 //ServerSocket.colse();
4.函数式接口：
4.1概念：函数式接口在java中有且仅有一个抽象方法的接口就称为函数式接口。
函数式接口适用于函数式编程的，在java当中的函数式编程体现在Lambd，所以函数式接口就是用来服务Lambda表达式。只有确保了接口当中有且仅有一个抽象方法，java中的Lambda才能顺利的进行推导。
备注："语法糖"是指使用更加便利方便，但是原理不变的代码语法。就比如遍历集合时使用for-each语法，其实底层使用的是迭代器，这便是"语法糖"。
4.2格式：只有确保接口当中有且仅有一个抽象方法即可：
修饰符 interface InretfaceName{ //只能定义一个抽象方法 public abstract 返回值类型 方法名称(参数列表); //还可以定义其他的非抽象方法 }
格式的示例：
public interface FunctionInterfaceOne{ //抽象方法 public abstract void show01(); public defaule void show02(){ //... } //void show03();有且仅有一个抽象方法，才成为函数式接口 }
4.3@Funacctionall注解
与@veride注解作用类似，Java 8中专门为函数式接口引入的一个新注解@FunctionalInterface，该注解主要定义在接口上。-旦在接口上使用该注解，编译期将会强制检查该接口是不是一个函数式接口， 该接口中是不是有且仅有一个抽象方法，如果不是，编译报错。
@Functionallnterface public interface FunctionInterfaceOne { //定义一个抽象方法 void method(){ //void show(); default void show02(){ } }
4.4
对于自定义的函数式接口，一般用于方法的参数和返回值上。
5.函数式编程
能够在兼顾Java的面向对象特性基础上，通过Lambda表达式与后面的方法引用，为开发者打开函数式编程的大门
5.1
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; }); }
备注：实际上是用内部类也可以达到这样的效果，只是将代码操作延迟到另外一个对象中通过调用方法来完成。
后面的代码的执行取决于前面条件的判断结果
5.2
public class Demo01Lambda{ //定义一个方法，开启线程的方法 public static void startThread(Runnable r){ new Thread(r).statr(); } 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()teComparator(){ //返回值就是一个函数式接口 /* 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"} } }
6.常用的函数式接口
JDK提供了大量的常用的函数式接口，丰富Lambda表达式的使用场景。他们主要在java.util.function包中被提供。
6.1Supplier接口
java.util.function.Supplier接口，该接口有且仅有一个无参的方法： T get()。 用来获取一个泛型参数指定类型等待对象数据。由于该接口是一个函数式接口，所以我们可以使用Lambda表达式来操作它。
代码如下：
// 定义一个方法，方法的参数传递一个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 }
6.2Consumer接口
accept方法：意思就是消费一个指定泛型的数据。
Consumer接口和accept方法的代码如下：
// 定义一个方法，方法的参数传递一个Consumer<String>接口,传递一个字符串变量 //,Consumer<String>接口是一个函数式接口类型，所以可以使用Lambda表达式 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接口和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接口规则
将打印地址的动作作为第三个Fonsumer接口的规则。
最终将三个Consumer接口按照规定的顺序拼接出来。
代码如下：
public static void main(String[] args) { // String[] arr ={"李四,20,南阳市","李四,20,南阳市","张三,20,郑州市","小孙,20,开封市","小丽,20,信阳市","小赵,20,洛阳市"}; consumers(arr, one-> System.out.println("姓名："+one.split(",")[0]+","), two -> System.out.println("年龄："+two.split(",")[1]+","), three-> System.out.println("地址："+three.split(",")[2]+",")); }
7.Stream流(1.8才有)
在Java1.8中，由于Lambda表达式这种函数式编程 JDK引入了一个全新的概念“Stream流”。用来解决已有集合类库的一些弊端的。
当我们需要对集合当中的元素进行操作的时候，总是需要对集合不停的循环遍历，再次循环遍历，...一定需要这样做么？
不一定，他只是你用来找到你需要元素的一种方式，并不是目的。目的就是想要去除不想要的元素并循环打印展示出来。以往的方式就是每次循环都要从头开始遍历，下次循环还是从头开始
Java1.8可以使用Lambda表达式的衍生物Stream流来优化你遍历集合的方式。
优化前的写法：
public class Demo01Stream{ 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的元素取出来 List<String> list2=new ArrayList<String>();// 已经取出 abc123 bcd125 abcd120 for(String str:list){ if(Str.contains("1")){ list2.add(str); } } //需要集合当中字符串不能超过6个的元素取出来 List<String> list3 = new ArrayList<String>(); for(String str:list2){ if(str.length() <=6){ list3.add(str); } } //遍历查看最终想要的元素集合 for(String str : list3){ System.out.println(str); } } }
优化后的写法：
public class Demo01Stream{ 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() .fiter(str ->str.contains("1")) .filter(str -> str.length() <=6) .forEach(str ->System.out.println(str));//abc123 bcd125 } }
一般：我们把流式思想称之为：生产流水线