线程安全的类—方法加入了synchronized关键字

  • StringBuffer
  • Vector(不常用) —- synchronizedList

  • Hashtable(不常用) —- synchronizedMap

    1.                               ------ synchronizedSet

    线程不安全的类

  • StringBuilder

  • ArrayList

  • HashMap ```java

    1.    new StringBuffer();
    2.   new StringBuilder();
    4.   new Hashtable<>();
    5.   new HashMap<>();
    7.   new Vector<>();
    8.   new ArrayList<>();
    10.   List<Integer> list = Collections.synchronizedList(new ArrayList<>());
    11.   Map<Integer,String> map = Collections.synchronizedMap(new HashMap<>());
    12.   Set<Integer> set = Collections.synchronizedSet(new HashSet<>());
  1. <a name="ovsgy"></a>
  2. ### Lock锁
  3. ```java
  4. public class MyThread implements Runnable {
  5.     private int tickets = 100; //总票数
  6.     private Lock lock = new ReentrantLock();
  9.     public MyThread() {
  10.     }
  13.     @Override
  14.     public void run() {
  15.         while (true) {
  16.             //解决线程同步安全问题
  17.             try {
  18.                 lock.lock();  //加锁
  19.                 if (tickets > 0) {
  20.                     try {
  21.                         Thread.sleep(100);
  22.                     } catch (InterruptedException e) {
  23.                         e.printStackTrace();
  24.                     }
  26.                     System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets-- + "张票");
  27.                 }
  28.             } finally {
  29.                 lock.unlock();//释放锁
  30.             }
  31.         }
  32.     }
  33. }

生产者消费者模式

image.png

  1. public class Customer implements Runnable{
  2.     private Box b;
  3.     public Customer(Box b) {
  4.         this.b = b;
  5.     }
  7.     @Override
  8.     public void run() {
  9.         while (true){
  10.             b.get();
  11.         }
  12.     }
  13. }
  1. public class Producer implements Runnable {
  2.     private Box b;
  3.     public Producer(Box b) {
  4.         this.b = b;
  5.     }
  7.     @Override
  8.     public void run() {
  9.         int i = 1;
  10.         while (i<6){
  11.             b.put(i++);
  12.         }
  13.     }
  14. }
  1. public class Box {
  2.     private int milk;
  3.     private boolean state = false;  //默认状态-->表示奶箱中没有奶
  5.     public synchronized void put(int milk){
  6.         if (state){
  7.             try {
  8.                 wait();
  9.             } catch (InterruptedException e) {
  10.                 e.printStackTrace();
  11.             }
  12.         }
  13.         this.milk = milk;
  14.         System.out.println("送来了第"+this.milk+"瓶奶");
  15.         //修改状态
  16.         state = true;
  17.         //唤醒其他等待线程
  18.         notifyAll();
  19.     }
  20.     public synchronized void get(){
  21.         if (!state){
  22.             try {
  23.                 wait();
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  27.         }
  28.         System.out.println("消费者消费了第"+this.milk+"瓶奶");
  30.         state = false;
  31.         notifyAll();
  32.     }
  33. }
  1. public class Demo {
  2.     public static void main(String[] args) {
  3.         Box b = new Box();
  4.         Producer p = new Producer(b);
  5.         Customer c = new Customer(b);
  7.         Thread t1 = new Thread(p);
  8.         Thread t2 = new Thread(c);
  10.         t1.start();
  11.         t2.start();
  12.     }
  13. }

送来了第1瓶奶 消费者消费了第1瓶奶 送来了第2瓶奶 消费者消费了第2瓶奶 送来了第3瓶奶 消费者消费了第3瓶奶 送来了第4瓶奶 消费者消费了第4瓶奶 送来了第5瓶奶 消费者消费了第5瓶奶

网络编程

  1. public static void main(String[] args) throws UnknownHostException {
  2.         //获取ip地址与主机名
  3.         InetAddress address = InetAddress.getByName("117.154.105.233");
  4.         String name = address.getHostName();
  5.         String ip = address.getHostAddress();
  6.         System.out.println(name);
  7.         System.out.println(ip);
  8.     }

UDP协议

优点:消耗少
缺点:不太可靠,数据可能会丢失
image.png

  1.  public static void main(String[] args) throws IOException {
  2.         DatagramSocket ds = new DatagramSocket();
  3.         byte[] bys = "Hello UDP协议".getBytes();
  4.         int len = bys.length;
  5.         InetAddress address = InetAddress.getByName("117.154.105.233");
  6.         int port = 10086;
  7.         //创建数据包
  8.         DatagramPacket dp = new DatagramPacket(bys, len, address, port);
  9.         //发送数据
  10.         ds.send(dp);
  11.         //关闭
  12.         ds.close();
  13.     }

image.png

  1.  public static void main(String[] args) throws IOException {
  2.         //接收数据
  3.         DatagramSocket ds = new DatagramSocket(10086);
  4.         byte[] bys = new byte[1024];
  5.         int len = bys.length;
  6.         //创建数据包
  7.         DatagramPacket dp = new DatagramPacket(bys, len);
  9.         ds.receive(dp);
  10.         //解析数据包
  11.         byte[] datas = dp.getData();
  12.         int lenth = dp.getLength();
  13.         String dataString = new String(datas,0,lenth);
  14.         System.out.println(dataString);
  15.         //关闭
  16.         ds.close();
  17.     }

TCP协议

三次握手
可以保证数据传输的安全

聊天示列

发送用户端
输入886结束退出
可多开SendDemo窗口

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  6. import java.net.InetAddress;
  8. public class SendDemo {
  9.     public static void main(String[] args) throws IOException {
  10.         DatagramSocket ds = new DatagramSocket();
  11.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  12.         String line;
  13.         while ((line=br.readLine())!=null){
  14.             if ("886".equals(line)){
  15.                 break;
  16.             }
  17.             byte[] bys = line.getBytes();
  18.             DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.115.249"),12345);
  19.             ds.send(dp);
  20.         }
  21.         ds.close();
  22.     }
  23. }

接收数据

  1. import java.io.IOException;
  2. import java.net.DatagramPacket;
  3. import java.net.DatagramSocket;
  5. public class ReceiveDemo {
  6.     public static void main(String[] args) throws IOException {
  7.         DatagramSocket ds = new DatagramSocket(12345);
  8.         while (true) {
  9.             byte[] bys = new byte[1024];
  10.             DatagramPacket dp = new DatagramPacket(bys, bys.length);
  11.             ds.receive(dp);
  12.             byte[] datas = dp.getData();
  13.             int len = dp.getLength();
  14.             String dataString = new String(datas, 0, len);
  15.             System.out.println("数据为:"+dataString);
  16.         }
  17.     }
  18. }

TCP协议

先启动服务器端

  1. public class ServerDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         ServerSocket ss = new ServerSocket(10000);
  4.         Socket s = ss.accept();
  6.         InputStream is = s.getInputStream();
  7.         byte[] bytes = new byte[1024];
  8.         int len = is.read(bytes);
  9.         String data = new String(bytes,0,len);
  10.         System.out.println("接受的数据是:"+data);
  11.         ss.close();
  12.     }
  13. }

再启动客户端程序

  1. public class ClientDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         Socket s = new Socket("192.168.217.249", 10000);
  5.         OutputStream os = s.getOutputStream();
  6.         os.write("hello 你好 java".getBytes());
  7.         s.close();
  8.     }
  9. }

接受的数据是:hello 你好 java

注意启动顺序,否则将报错

Exception in thread “main” java.net.ConnectException: Connection refused: connect at java.net.DualStackPlainSocketImpl.connect0(Native Method) at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:79) at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:350) at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:206) at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:188) at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:172) at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392) at java.net.Socket.connect(Socket.java:589) at java.net.Socket.connect(Socket.java:538) at java.net.Socket.(Socket.java:434) at java.net.Socket.(Socket.java:211) at icu.itheima_02.ClientDemo.main(ClientDemo.java:9)

增添反馈

  1. public class ServerDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         ServerSocket ss = new ServerSocket(10000);
  4.         Socket s = ss.accept();
  6.         InputStream is = s.getInputStream();
  7.         byte[] bytes = new byte[1024];
  8.         int len = is.read(bytes);
  9.         String data = new String(bytes,0,len);
  10.         System.out.println("服务器接受的数据是:"+data);
  12.         OutputStream os = s.getOutputStream();
  13.         os.write("数据已收到".getBytes());
  14.         ss.close();
  15.     }
  16. }
  1. public class ClientDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         Socket s = new Socket("192.168.217.249", 10000);
  5.         OutputStream os = s.getOutputStream();
  6.         os.write("hello 你好 java".getBytes());
  8.         InputStream is = s.getInputStream();
  9.         byte[] bytes = new byte[1024];
  10.         int len = is.read(bytes);
  11.         String data = new String(bytes,0,len);
  12.         System.out.println("提示:"+data);
  14.         s.close();
  15.     }
  16. }

键盘录入实现

  1. public class ServerDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         ServerSocket ss = new ServerSocket(10000);
  4.         //监听客户端连接,返回一个Socket对象
  5.         Socket s = ss.accept();
  7.         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
  8.         String line;
  9.         while ((line = br.readLine())!=null) {
  10.             System.out.println(line);
  11.         }
  12.         ss.close();
  13.     }
  14. }
  1. public class ClientDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         Socket s = new Socket("192.168.217.249", 10000);
  5.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  7.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
  8.         String line;
  9.         while ((line = br.readLine())!=null){
  10.             if ("886".equals(line)){
  11.                 break;
  12.             }
  13.             bw.write(line);
  14.             bw.newLine();
  15.             bw.flush();
  16.         }
  17.         s.close();
  18.     }
  19. }

写入到文本文件

….

  1. public class ServerDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         ServerSocket ss = new ServerSocket(10000);
  4.         //监听客户端连接,返回一个Socket对象
  5.         Socket s = ss.accept();
  7.         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
  9.         BufferedWriter bw = new BufferedWriter(new FileWriter("src\\copy.txt"));
  11.         String line;
  12.         while ((line = br.readLine())!=null) {
  13.             System.out.println(line);
  14.             bw.write(line);
  15.             bw.newLine();
  16.             bw.flush();
  17.         }
  18.         bw.close();
  19.         ss.close();
  20.     }
  21. }
  1. public class ClientDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         Socket s = new Socket("192.168.217.249", 10000);
  5.         BufferedReader br = new BufferedReader(new FileReader("src\\owx.txt"));
  7.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
  8.         String line;
  9.         while ((line = br.readLine())!=null){
  10.             if ("886".equals(line)){
  11.                 break;
  12.             }
  13.             bw.write(line);
  14.             bw.newLine();
  15.             bw.flush();
  16.         }
  17.         br.close();
  18.         s.close();
  19.     }
  20. }

多线程上传文件

…

lambda 表达式

image.png

  1. public class MyRunnable implements Runnable {
  2.     @Override
  3.     public void run() {
  4.         System.out.println("多线程程序启动了");
  5.     }
  6. }
  1. public class Demo {
  2.     public static void main(String[] args) {
  3.         MyRunnable m = new MyRunnable();
  4.         //普通调用
  5.         m.run();
  6.         //多线程方式调用
  7.         Thread thread = new Thread(m);
  8.         thread.start();
  9.         //匿名内部类方式
  10.         new Thread(new Runnable() {
  11.             @Override
  12.             public void run() {
  13.                 System.out.println("匿名内部类实现多线程启动了");
  14.             }
  15.         }).start();
  16.         //Lambda表达式的方式
  17.         new Thread( () ->{
  18.             System.out.println("Lambda表达式调用");
  19.         }).start();
  20.     }
  21. }

image.png

  1. public interface Eatable {
  2.     void eat();
  3. }
  1. public class EatableImpl implements Eatable {
  3.     @Override
  4.     public void eat() {
  5.         System.out.println("一天一苹果,就会没钱钱");
  6.     }
  7. }
  2. public class EatableDemo {
  3.     public static void main(String[] args) {
  4.         Eatable e = new EatableImpl();
  5.         useEatable(e);
  7.         useEatable(new Eatable() {
  8.             @Override
  9.             public void eat() {
  10.                 System.out.println("匿名内部类吃苹果");
  11.             }
  12.         });
  14.         useEatable(()->{
  15.             System.out.println("Lambda吃苹果");
  16.         });
  17.     }
  19.     private static void useEatable(Eatable e) {
  20.         e.eat();
  21.     }
  22. }

练习2 — 带参lambda

  1. public interface Flyable {
  2.     void fly(String s);
  3. }
  1. public class FlyableDemo {
  2.     public static void main(String[] args) {
  3.         useFlyable(new Flyable() {
  4.             @Override
  5.             public void fly(String s) {
  6.                 System.out.println("猜猜s是啥?-->"+s);
  7.                 System.out.println("恭喜你猜对啦!");
  8.             }
  9.         });
  10.         useFlyable((String s)->{
  11.             System.out.print("输出s:");
  12.             System.out.println(s);
  13.         });
  14.     }
  15.     public static void useFlyable(Flyable f){
  16.         f.fly("我想要飞得更高!");
  17.     }
  18. }

带参带返回值的Lambda

Variable used in lambda expression should be final or effectively final
在lambda表达式中使用的变量应该是最终的或有效的最终的。

  1. public interface Addable {
  2.     int add(int x,int y);
  3. }
  1. public class AddableDemo {
  2.     public static void main(String[] args) {
  3.         /*
  4.         匿名内部类定义的sum与外部定义的sum互不干扰
  5.          */
  6.         int aa =1;
  7.         int sum = useAddable(new Addable() {
  8.             @Override
  9.             public int add(int x, int y) {
  10.                 int aa = 3;  //不会显示已定义,不会报错
  11.                 int sum = x + y;
  12.                 return sum;
  13.             }
  14.         });
  15.         System.out.println(sum);
  16.         /*
  17.         而Lambda中定义的,只能在内部使用
  18.         但是外部定义的,两者内部都可以直接使用
  19.          */
  20.         int mul1 = useAddable((int x, int y) -> {
  21.             int aa = 5;  //报错提示:Variable 'aa' is already defined in the scope
  22.             int mul = x * y;
  23.             return mul;
  24.         });
  25.         System.out.println(mul1);
  26.     }
  28.     private static int useAddable(Addable a) {
  29.         int sum = a.add(12345, 54321);
  30.         return sum;
  31.     }
  32. }

Lambda表达式的省略模式

  1. public class AddableDemo {
  2.     public static void main(String[] args) {
  4.         useAddable(new Addable() {
  5.             @Override
  6.             public int add(int x, int y) {
  7.                 return x + y;
  8.             }
  10. //            @Override
  11. //            public void _print(String s) {
  12. //                System.out.println(s);
  13. //            }
  14.         });
  15.         //参数类型可省，多个参数不可只省一个，全部省略或全部不
  16.         //当执行语句只有一条且带有return,return也可以省略
  17.         useAddable((x, y) -> x + y);
  19.         //当参数只有一个,可以省略括号
  20.         //当执行语句只有一条,可省略大括号{}
  21.         useFlyable(s -> System.out.println(s));
  22.     }
  24.     private static void useAddable(Addable a) {
  25.         int sum = a.add(12345, 54321);
  26.         System.out.println(sum);
  27.     }
  29.     public static void useFlyable(Flyable f) {
  30.         f.fly("我想要飞得更高!");
  31.     }
  32. }

Lambda使用注意事项

  1. public class LambdaDemo {
  2.     /*
  3.      Lambda使用注意事项
  4.      */
  5.     public static void main(String[] args) {
  7.         useInner(() -> System.out.println("使用Lambda必须要有接口,且接口有且仅有一个方法"));
  9.         // 必须有上下文环境,才能推导出Lambda对应的接口
  10.         Runnable r = () -> System.out.println("接口1111");
  11.         new Thread(r).start();
  13.         new Thread(() -> System.out.println("接口22222")).start();
  14.     }
  17.     private static void useInner(Inner i) {
  18.         i.show();
  19.     }
  20. }

Lambda表达式与匿名内部类的区别

实现原理不同:
//匿名内部类会产生一个新的字节码 .class文件
//而 Lambda不会产生

  1. public class LambdaDemo {
  2.     /*
  3.      Lambda与匿名内部类区别
  4.      */
  5.     public static void main(String[] args) {
  6.         //只能实现接口
  7.         useInner(() -> System.out.println("使用Lambda必须要有接口,且接口有且仅有一个方法"));
  8.         //useAnimal(()-> System.out.println("实现抽象类调用")); //报错
  9.         //useStudent(()-> System.out.println("实现具体类调用"));  //报错
  11.         //匿名内部类会产生一个新的字节码 .class文件
  12.         //而 Lambda不会产生
  13.         useInner(new Inner() {
  14.             @Override
  15.             public void show() {
  16.                 System.out.println("匿名内部类实现接口");
  17.             }
  18.         });
  19.         useAnimal(new Animal() {
  20.             @Override
  21.             public void method() {
  22.                 System.out.println("匿名内部类实现抽象类");
  23.             }
  24.         });
  25.         useStudent(new Student() {
  26.             @Override
  27.             public void study() {
  28.                 System.out.println("匿名内部类实现具体类");
  29.             }
  30.         });
  31.     }
  34.     private static void useInner(Inner i) {
  35.         i.show();
  36.     }
  38.     private static void useAnimal(Animal a) {
  39.         a.method();
  40.     }
  42.     private static void useStudent(Student s) {
  43.         s.study();
  44.     }
  45. }

接口更新

image.png

  1. public interface MyInterface {
  2.     void show1();
  3.     void show2();
  4.     //默认方法: 使用 default 关键字修饰,可以含有方法体,可以被重写
  5.     default void show3(){
  6.         System.out.println("俺是默认方法");
  7.     }
  8.     //静态方法: 也可以拥有方法体
  9.     static void show4(){
  10.         System.out.println("俺是静态方法");
  11.     }
  13.     //java 9 新增私有方法
  14.     /*  注意:
  15.     默认方法可以调用静态方法和费静态方法
  16.     而静态方法只能调用私有的静态方法
  17.      */
  18.     private void show5(){
  20.     }
  21. }
  1. public class MyInterfaceImplOne implements MyInterface {
  2.     @Override
  3.     public void show1() {
  4.         System.out.println("ImplOne -->show1方法");
  6.     }
  8.     @Override
  9.     public void show2() {
  10.         System.out.println("ImplOne -->show2方法");
  11.     }
  13.     @Override
  14.     public void show3() {
  15.         System.out.println("默认方法被重写了哎");
  16.     }
  18.     //静态方法不可被重写
  19.     /*@Override
  20.     public void show4() {
  21.         System.out.println("默认方法被重写了哎");
  22.     }*/
  23. }
  1. public class MyInterfaceImplTwo implements MyInterface{
  2.     @Override
  3.     public void show1() {
  4.         System.out.println("ImplTwo -->show1方法");
  6.     }
  8.     @Override
  9.     public void show2() {
  10.         System.out.println("ImplTwo -->show2方法");
  11.     }
  12. }
  1. public class MyInterfaceDemo {
  2.     public static void main(String[] args) {
  3.         MyInterface mi1 = new MyInterfaceImplOne();
  4.         mi1.show1();
  5.         mi1.show2();
  6.         MyInterface mi2 = new MyInterfaceImplTwo();
  7.         mi2.show1();
  8.         mi2.show2();
  10.         mi2.show3();  //默认方法
  11.         //>>> 默认方法被重写了哎
  12.         mi1.show3();  //被重写后的默认方法
  13.         //>>> 俺是默认方法
  15.         //mi1.show4();  //报错
  16.         //>>> 静态方法不可通过接口实现类调用
  18.         MyInterface.show4();  //只能通过接口调用
  19.         //>>> 俺是静态方法
  20.     }
  21. }

方法引用

方法引用符 ::

  1. public interface Printable {
  2.     void _print(String s);
  3. }
  1. public class PrintableDemo {
  2.     public static void main(String[] args) {
  3.         usePrintable(s -> System.out.println("憨憨要"+s));
  4.         //>>> 憨憨要开心-的life
  6.         //可推导则可省,可根据上下文推导
  7.         //方法引用符 ::
  8.         System.out.println("开心-的life--区别");
  9.         //>>> 开心-的life--区别
  10.         usePrintable(System.out::println);
  11.         //>>> 开心-的life
  12.     }
  14.     private static void usePrintable(Printable p) {
  15.         p._print("开心-的life");
  16.     }
  17. }

Lambda表达式支持的引用方法

引用类方法

类名::静态方法

  1. public interface Converter {
  2.     int covert(String s);
  3. }
  1. public class ConverterDemo {
  2.     public static void main(String[] args) {
  3.         useConverter(s -> Integer.parseInt(s));
  4.         //类方法引用
  5.         useConverter(Integer::parseInt);
  6.     }
  8.     private static void useConverter(Converter c) {
  9.         int a = c.covert("666");
  10.         System.out.println(a);
  11.     }
  12. }

引用对象的实例方法

对象::成员方法

  1. public interface Printer {
  2.     void printUpperCase(String s);
  3. }
  1. public class PrintString {
  2.     public static void static_print(String s){
  3.         System.out.println(s.toUpperCase()); //转换为大写
  4.     }
  6.     public void _print(String s){
  7.         System.out.println(s.toUpperCase());
  8.     }
  9. }
  1. public class printerDemo {
  2.     public static void main(String[] args) {
  3.         //Lambda表达式
  4.         usePrinter(s -> System.out.println(s.toUpperCase()));
  5.         //>>> A
  7.         //引用对象的实例方法
  8.         usePrinter(PrintString::static_print);
  9.         //>>> A
  10.         PrintString ps = new PrintString();
  11.         usePrinter(ps::_print);
  12.         //>>> A
  15.     }
  17.     private static void usePrinter(Printer p) {
  18.         p.printUpperCase("a");
  19.     }
  20. }

引用类的实例方法

  1. public interface MyString {
  2.     String mySubString(String s,int x,int y);
  3. }
  1. public class MyStringDemo {
  2.     public static void main(String[] args) {
  3.         //截取输出 "Hello" 的[2,5)之间的字符
  4.         useMyString((s, x, y) -> s.substring(x, y));
  5.         //>>> llo
  7.         useMyString(String::substring);
  8.         //>>> llo
  9.     }
  11.     private static void useMyString(MyString ms) {
  12.         String s = ms.mySubString("Hello", 2, 5);
  13.         System.out.println(s);
  14.     }
  15. }

构造器引用

  1. public interface StudentBuilder {
  2.     Student build(String name,int age);
  3. }
  1. import lombok.Data;
  3. @Data
  4. public class Student {
  5.     private String name;
  6.     private int age;
  8.     public Student() {
  9.     }
  11.     public Student(String name, int age) {
  12.         this.name = name;
  13.         this.age = age;
  14.     }
  15. }
  1. public class StudentDemo {
  2.     public static void main(String[] args) {
  3.         useStudentBuilder((n,a)-> new Student(n,a));
  4.         //>>>   Student(name=张飞, age=33)
  5.         //      Student(name=关羽, age=40)
  7.         //构造器引用
  8.         useStudentBuilder(Student::new);
  9.         //>>>   Student(name=张飞, age=33)
  10.         //      Student(name=关羽, age=40)
  11.     }
  13.     private static void useStudentBuilder(StudentBuilder sb) {
  14.         Student sz = sb.build("张飞",33);
  15.         System.out.println(sz);
  16.         Student sg = sb.build("关羽",40);
  17.         System.out.println(sg);
  18.     }
  19. }

函数式接口

image.png

  1. //函数式接口注解标记
  2. @FunctionalInterface
  3. public interface MyInterface {
  4.     void show();
  6.     //void show1();  新增方法 注解将提示报错
  7. }
  1. public class MyInterfaceDemo {
  2.     public static void main(String[] args) {
  3.         MyInterface mi = ()-> System.out.println("函数式接口");
  4.         mi.show();
  5.     }
  6. }

函数式接口作为方法的参数

  1. public class RunnableDemo {
  2.     public static void main(String[] args) {
  3.         startThread(new Runnable() {
  4.             @Override
  5.             public void run() {
  6.                 System.out.println(Thread.currentThread().getName()+"多线程启动了");
  7.                 //>>> main多线程启动了
  8.             }
  9.         });
  10.         startThread(()-> System.out.println(Thread.currentThread().getName()+"Lambda多线程启动了"));
  11.         //>>> mainLambda多线程启动了
  12.     }
  14.     private static void startThread(Runnable r) {
  15.         r.run();
  16.     }
  17. }

函数式接口作为方法的返回值