Java入门级教学（超详细&下）

cocochimp

已于 2024-05-13 17:51:04 修改

阅读量403

点赞数

分类专栏： Java技术栈学习系列文章标签： java jvm 开发语言

于 2023-02-01 14:37:03 首次发布

本文链接：https://blog.csdn.net/m0_51634403/article/details/128833632

版权

Java技术栈学习系列专栏收录该内容

29 篇文章 23 订阅

订阅专栏

文章深入探讨了Java多线程编程，包括线程的创建、管理及同步机制，随后介绍了Lambda表达式与方法引用的强大功能，进一步讲解了函数式接口如Predicate、Function的应用，Stream流处理数据的方法，以及类加载、反射、模块化等高级主题，并通过经典案例加深理解。

摘要由CSDN通过智能技术生成

项目和markdown文件资料：
https://github.com/cocochimp/Java-H5-Study-Resources

文章目录

9.多线程
- 9.1 实现多线程
- 9.2 线程优先级
- 9.3 线程控制
- 9.4 线程同步
10. 网络编程
- 10.1 网络编程入门
- 10.2 UDP通信程序
- 10.3 TCP通信程序
11. Lambda表达式
- 11.1 Lambda练习1
- 11.2 Lambda练习2
- 11.3 Lambda练习3
- 11.4 Lambda表达式的省略模式
- 11.5 Lambda表达式的注意事项
12. 方法引用
- 12.1 引用类方法
- 12.2 引用对象的实例方法
- 12.3 引用类的实例方法
- 12.4 引用构造器
13. 函数式接口
- 13.1 Supplier接口
- 13.2 Consumer接口
- 13.3 Predicate接口
- 13.4 Function接口
14. Stream流
- 14.1 Stream流的常见生成方式
- 14.2 Stream流中间操作方法
- 14.3 Stream流终结操作方法
- 14.4 Stream流的收集操作
15. 类加载器
- 15.1 类加载
- 15.2 类加载器
16. 反射
- 16.1 获取Class类对象的三种方式
- 16.2 反射获取构造方法
- 16.3 反射获取成员变量
- 16.4 反射获取成员方法
17. 模块化
- 17.1 模块的基本使用
- 17.2 模块服务的基本使用
18.经典案例
- 18.1 生产者消费者(多线程)
- 18.2 Stream流综合练习(Stream流)
- 18.3 反射的案例(反射)

9.多线程

1、进程和线程

进程：是正在运行的程序

是系统进行资源分配和调用的独立单位

每一个进程都有它自己的内存空间和系统资源
线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径，则称为单线程程序

多线程：一个进程如果有多条执行路径，则称为多线程程序

2、线程的生命周期

线程一共有五种状态，线程在各种状态之间转换。

9.1 实现多线程

1、概述

多线程的实现方案有两种
- 继承Thread类
- 实现Runnable接口
相比继承Thread类，实现Runnable接口的好处
- 避免了Java单继承的局限性
- 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

2、实现多线程方式一：继承Thread类

方法介绍

方法名	说明
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用run方法()

实现步骤
- 定义一个类MyThread继承Thread类
- 在MyThread类中重写run()方法
- 创建MyThread类的对象
- 启动线程

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        // my1.run();
        // my2.run();
        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
    }
}

两个小问题
- 为什么要重写run()方法？
  
  因为run()是用来封装被线程执行的代码
- run()方法和start()方法的区别？
  
  run()：封装线程执行的代码，直接调用，相当于普通方法的调用
  
  start()：启动线程；然后由JVM调用此线程的run()方法

设置和获取线程名称

方法介绍

方法名	说明
void setName(String name)	将此线程的名称更改为等于参数name
String getName()	返回此线程的名称
Thread currentThread()	返回对当前正在执行的线程对象的引用

public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        //void setName(String name)：将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");
        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");
        my1.start();
        my2.start();
        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

3、实现多线程方式二：实现Runnable接口

Thread构造方法

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象

实现步骤
- 定义一个类MyRunnable实现Runnable接口
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
- 启动线程

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
        // Thread t1 = new Thread(my);
        // Thread t2 = new Thread(my);
        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"高铁");
        Thread t2 = new Thread(my,"飞机");
        //启动线程
        t1.start();
        t2.start();
    }
}

9.2 线程优先级

线程调度
- 两种调度方式
  - 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  - 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
- Java使用的是抢占式调度模型
- 随机性
  
  假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
优先级相关方法

方法名	说明
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

public class ThreadPriority extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();
        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");
        //public final int getPriority()：返回此线程的优先级
        System.out.println(tp1.getPriority()); //5
        System.out.println(tp2.getPriority()); //5
        System.out.println(tp3.getPriority()); //5
        //public final void setPriority(int newPriority)：更改此线程的优先级
        // tp1.setPriority(10000); //IllegalArgumentException
        System.out.println(Thread.MAX_PRIORITY); //10
        System.out.println(Thread.MIN_PRIORITY); //1
        System.out.println(Thread.NORM_PRIORITY); //5
        //设置正确的优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

9.3 线程控制

相关方法

方法名	说明
static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数
void join()	等待这个线程死亡
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

sleep演示：

public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");
        ts1.start();
        ts2.start();
        ts3.start();
    }
}

Join演示：

public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();
        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");
        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}

Daemon演示：

public class ThreadDaemon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();
        td1.setName("关羽");
        td2.setName("张飞");
        //设置主线程为刘备
        Thread.currentThread().setName("刘备");
        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();
        for(int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

9.4 线程同步

1、卖票

案例需求

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
实现步骤
- 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
- 在SellTicket类中重写run()方法实现卖票，代码步骤如下
- 判断票数大于0，就卖票，并告知是哪个窗口卖的
- 卖了票之后，总票数要减1
- 票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
- 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
- 创建SellTicket类的对象创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
- 启动线程

public class SellTicket implements Runnable {
    private int tickets = 100;
    //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" +tickets + "张票");
                tickets--;
            }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建SellTicket类的对象
        SellTicket st = new SellTicket();
        //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

2、卖票案例的问题

卖票出现了问题
- 相同的票出现了多次
- 出现了负数的票
问题产生原因

线程执行的随机性导致的

public class SellTicket implements Runnable {
    private int tickets = 100;
    @Override
    public void run() {
        //相同的票出现了多次
        // while (true) {
        // //tickets = 100;
        // //t1,t2,t3
        // //假设t1线程抢到CPU的执行权
        // if (tickets > 0) {
        // //通过sleep()方法来模拟出票时间
        // try {
        // Thread.sleep(100);
        // //t1线程休息100毫秒
        // //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
        // //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
        // } catch (InterruptedException e) {
        // e.printStackTrace();
        // }
        // //假设线程按照顺序醒过来
        // //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
        // System.out.println(Thread.currentThread().getName() + "正在出售第"+ tickets + "张票");
        // //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
        // //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
        // tickets--;
        // //如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97
        // }
        // }
        //出现了负数的票
        while (true) {
            //tickets = 1;
            //t1,t2,t3
            //假设t1线程抢到CPU的执行权
            if (tickets > 0) {
                //通过sleep()方法来模拟出票时间
                try {
                    Thread.sleep(100);
                    //t1线程休息100毫秒
                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照顺序醒过来
                //t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票
                //假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0;
                //t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票
                //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1;
                //t3抢到了CPU的执行权，在控制台输出：窗口3正在出售第-1张票
                //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2;
                System.out.println(Thread.currentThread().getName() + "正在出售第" +tickets + "张票");
                tickets--;
            }
        }
    }
}

9.4.1 同步代码块解决数据安全问题

安全问题出现的条件
- 是多线程环境
- 有共享数据
- 有多条语句操作共享数据
如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境
怎么实现呢?
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
- Java提供了同步代码块的方式来解决
同步代码块格式：

synchronized(任意对象) {
    多条语句操作共享数据的代码
}

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

同步的好处和弊端
- 好处：解决了多线程的数据安全问题
- 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            //tickets = 100;
            //t1,t2,t3
            //假设t1抢到了CPU的执行权
            //假设t2抢到了CPU的执行权
            synchronized (obj) {
                //t1进来后，就会把这段代码给锁起来
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                        //t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--; //tickets = 99;
                }
            }
            //t1出来了，这段代码的锁就被释放了
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

9.4.2 同步方法解决数据安全问题

同步方法的格式

同步方法：就是把synchronized关键字加到方法上

修饰符 synchronized 返回值类型 方法名(方法参数) {
    方法体；
}

同步方法的锁对象是什么呢? this

静态同步方法

同步静态方法：就是把synchronized关键字加到静态方法上

修饰符 static synchronized 返回值类型 方法名(方法参数) {
    方法体；
}

同步静态方法的锁对象是什么呢? 类名.class

public class SellTicket implements Runnable {
    private static int tickets = 100;
    private int x = 0;
    @Override
    public void run() {
        while (true) {
            sellTicket()；
        }
    }
    // 同步方法
    // private synchronized void sellTicket() {
    // if (tickets > 0) {
    // try {
    // Thread.sleep(100);
    // } catch (InterruptedException e) {
    // e.printStackTrace();
    // }
    // System.out.println(Thread.currentThread().getName() + "正在出售第" +tickets + "张票");
    // tickets--;
    // }
    // }
    // 静态同步方法
    private static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" +tickets + "张票");
            tickets--;
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

9.4.3 线程安全的类

StringBuffer
- 线程安全，可变的字符序列
- 从版本JDK 5开始，被StringBuilder 替代。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步
Vector
- 从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。与新的集合实现不同， Vector被同步。如果不需要线程安全的实现，建议使用ArrayList代替Vector。
Hashtable
- 该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或者值
- 从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。与新的集合实现不同， Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替 Hashtable

9.4.4 Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

ReentrantLock构造方法

方法名	说明
ReentrantLock()	创建一个ReentrantLock的实例

加锁解锁方法

方法名	说明
void lock()	获得锁
void unlock()	释放锁

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                       System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
                    }
                } finally {
                    lock.unlock();
                }
            }
        }
    }
    public class SellTicketDemo {
        public static void main(String[] args) {
            SellTicket st = new SellTicket();
            Thread t1 = new Thread(st, "窗口1");
            Thread t2 = new Thread(st, "窗口2");
            Thread t3 = new Thread(st, "窗口3");
            t1.start();
            t2.start();
            t3.start();
        }
    }

10. 网络编程

10.1 网络编程入门

1、概述

计算机网络

是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统
网络编程

在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换

2、网络编程三要素

IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
端口

网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识
协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议

3、IP地址

IP地址：是网络中设备的唯一标识

IP地址分为两大类
- IPv4：是给每个连接在网络上的主机分配一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit，也就是4个字节。例如一个采用二进制形式的IP地址是“11000000 10101000 00000001 01000010”，这么长的地址，处理起来也太费劲了。为了方便使用，IP地址经常被写成十进制的形式，中间使用符号“.”分隔不同的字节。于是，上面的IP地址可以表示为“192.168.1.66”。IP地址的这种表示法叫做“点分十进制表示法”，这显然比1和0容易记忆得多
- IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8 组十六进制数，这样就解决了网络地址资源数量不够的问题
DOS常用命令：
- ipconfig：查看本机IP地址
- ping IP地址：检查网络是否连通
特殊IP地址： 127.0.0.1：是回送地址，可以代表本机地址，一般用来测试使用

4、InetAddress

InetAddress：此类表示Internet协议（IP）地址

相关方法

方法名	说明
static InetAddress getByName(String host)	确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
String getHostName()	获取此IP地址的主机名
String getHostAddress()	返回文本显示中的IP地址字符串

public class InetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {
        //InetAddress address = InetAddress.getByName("itheima");
        InetAddress address = InetAddress.getByName("192.168.1.66");
        //public String getHostName()：获取此IP地址的主机名
        String name = address.getHostName();
        //public String getHostAddress()：返回文本显示中的IP地址字符串
        String ip = address.getHostAddress();
        System.out.println("主机名：" + name);
        System.out.println("IP地址：" + ip);
    }
}

5、端口和协议

端口
- 设备上应用程序的唯一标识
端口号
- 用两个字节表示的整数，它的取值范围是0_{65535。其中，0}1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败
协议
- 计算机网络中，连接和通信的规则被称为网络通信协议
UDP协议
- 用户数据报协议(User Datagram Protocol)
- UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
- 由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输
- 例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议
TCP协议
- 传输控制协议 (Transmission Control Protocol)
- TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过**“三次握手”**
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
  - 第一次握手，客户端向服务器端发出连接请求，等待服务器确认
  - 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
  - 第三次握手，客户端再次向服务器端发送确认信息，确认连接
- 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性， TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

10.2 UDP通信程序

1、UDP发送数据

Java中的UDP通信
- UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念
- Java提供了DatagramSocket类作为基于UDP协议的Socket
构造方法

方法名	说明
DatagramSocket()	创建数据报套接字并将其绑定到本机地址上的任何可用端口
DatagramPacket(byte[] buf,int len,InetAddress add,int port)	创建数据包,发送长度为len的数据包到指定主机的指定端口

相关方法

方法名	说明
void send(DatagramPacket p)	发送数据报包
void close()	关闭数据报套接字
void receive(DatagramPacket p)	从此套接字接受数据报包

发送数据的步骤
- 创建发送端的Socket对象(DatagramSocket)
- 创建数据，并把数据打包
- 调用DatagramSocket对象的方法发送数据
- 关闭发送端

public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
        DatagramSocket ds = new DatagramSocket();
        //创建数据，并把数据打包
        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
        byte[] bys = "hello,udp,我来了".getBytes();
        DatagramPacket dp = new
            DatagramPacket(bys,bys.length,InetAddress.getByName("192.168.1.66"),10086);
        //调用DatagramSocket对象的方法发送数据
        //void send(DatagramPacket p) 从此套接字发送数据报包
        ds.send(dp);
        //关闭发送端
        //void close() 关闭此数据报套接字
        ds.close();
    }
}

2、UDP接收数据

接收数据的步骤
- 创建接收端的Socket对象(DatagramSocket)
- 创建一个数据包，用于接收数据
- 调用DatagramSocket对象的方法接收数据
- 解析数据包，并把数据在控制台显示
- 关闭接收端
构造方法

方法名	说明
DatagramPacket(byte[] buf, int len)	创建一个DatagramPacket用于接收长度为len的数据包

相关方法

方法名	说明
byte[] getData()	返回数据缓冲区
int getLength()	返回要发送的数据的长度或接收的数据的长度

public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);
        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);
            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);
            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0,
                                                   dp.getLength()));
        }
    }
}

3、UDP通信程序练习

案例需求

UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束

UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收
UDP发送数据：

/*
    UDP发送数据：
    数据来自于键盘录入，直到输入的数据是886，发送数据结束
*/
public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        //自己封装键盘录入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = br.readLine()) != null) {
            //输入的数据是886，发送数据结束
            if ("886".equals(line)) {
                break;
            }
            //创建数据，并把数据打包
            byte[] bys = line.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length,
                                                   InetAddress.getByName("192.168.1.66"), 12345);
            //调用DatagramSocket对象的方法发送数据
            ds.send(dp);
        }
        //关闭发送端
        ds.close();
    }
}

UDP接收数据：

/*
    UDP接收数据：
    因为接收端不知道发送端什么时候停止发送，故采用死循环接收
*/
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);
        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);
            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);
            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0,
                                                   dp.getLength()));
        }
        //关闭接收端
        // ds.close();
    }
}

10.3 TCP通信程序

1、TCP发送数据

Java中的TCP通信
- Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过 Socket产生IO流来进行网络通信。
- Java为客户端提供了Socket类，为服务器端提供了ServerSocket类
构造方法

方法名	说明
Socket(InetAddress address,int port)	创建流套接字并将其连接到指定IP指定端口号
Socket(String host, int port)	创建流套接字并将其连接到指定主机上的指定端口号

相关方法

方法名	说明
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
        Socket s = new Socket("192.168.1.66",10000);
        //获取输出流，写数据
        //OutputStream getOutputStream() 返回此套接字的输出流
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());
        //释放资源
        s.close();
    }
}

2、TCP接收数据

构造方法

方法名	说明
ServletSocket(int port)	创建绑定到指定端口的服务器套接字

相关方法

方法名	说明
Socket accept()	监听要连接到此的套接字并接受它

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        //ServerSocket(int port) 创建绑定到指定端口的服务器套接字
        ServerSocket ss = new ServerSocket(10000);
        //Socket accept() 侦听要连接到此套接字并接受它
        Socket s = ss.accept();
        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys,0,len);
        System.out.println("数据是：" + data);
        //释放资源
        s.close();
        ss.close();
    }
}

10.3.1 TCP练习1

案例需求

客户端：发送数据，接受服务器反馈

服务器：收到消息后给出反馈
案例分析
- 客户端创建对象，使用输出流输出数据
- 服务端创建对象，使用输入流接受数据
- 服务端使用输出流给出反馈数据
- 客户端使用输入流接受反馈数据

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        ServerSocket ss = new ServerSocket(10000);
        //监听客户端连接，返回一个Socket对象
        Socket s = ss.accept();
        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("服务器：" + data);
        //给出反馈
        OutputStream os = s.getOutputStream();
        os.write("数据已经收到".getBytes());
        //释放资源
        // s.close();
        ss.close();
    }
}

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        Socket s = new Socket("192.168.1.66", 10000);
        //获取输出流，写数据
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());
        //接收服务器反馈
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys, 0, len);
        System.out.println("客户端：" + data);
        //释放资源
        // is.close();
        // os.close();
        s.close();
    }
}

10.3.2 TCP练习2

案例需求

客户端：数据来自于键盘录入, 直到输入的数据是886，发送数据结束

服务端：接收到数据在控制台输出
案例分析
- 客户端创建对象，使用键盘录入循环接受数据，接受一行发送一行，直到键盘录入886为止
- 服务端创建对象，使用输入流按行循环接受数据，直到接受到null为止

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);
        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new
                                               OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            if("886".equals(line)) {
                break;
            }
            //获取输出流对象
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        s.close();
    }
}

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);
        //监听客户端的连接，返回一个对应的Socket对象
        Socket s = ss.accept();
        //获取输入流
        BufferedReader br = new BufferedReader(new
                                               InputStreamReader(s.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        //释放资源
        ss.close();
    }
}

10.3.3 TCP练习3

案例需求

客户端：数据来自于键盘录入，直到输入的数据是886,发送数据结束

服务端：接受到的数据写入文本文件中
案例分析
- 客户端创建对象，使用键盘录入循环接受数据，接受一行发送一行，直到键盘录入886为止
- 服务端创建对象，创建输出流对象指向文件，每接受一行数据后使用输出流输出到文件中，直到接受到 null为止

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);
        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new
                                               OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            if("886".equals(line)) {
                break;
            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        s.close();
    }
}

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);
        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();
        //接收数据
        BufferedReader br = new BufferedReader(new
                                               InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\s.txt"));
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
        ss.close();
    }
}

10.3.4 TCP练习4

案例需求

客户端：数据来自于文本文件

服务器：接收到的数据写入文本文件
案例分析
- 创建客户端，创建输入流对象指向文件，从文件循环读取数据，每读取一行就使用输出流给服务器输出一行
- 创建服务端，创建输出流对象指向文件，从客户端接受数据，每接受一行就给文件中输出一行

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);
        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new
                                               FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new
                                               OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        br.close();
        s.close();
    }
}
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);
        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();
        //接收数据
        BufferedReader br = new BufferedReader(new
                                               InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
        ss.close();
    }
}

10.3.5 TCP练习5

案例需求

客户端：数据来自于文本文件，接收服务器反馈

服务器：接收到的数据写入文本文件，给出反馈
案例分析
- 创建客户端对象，创建输入流对象指向文件，每读入一行数据就给服务器输出一行数据，输出结束后使用shutdownOutput()方法告知服务端传输结束
- 创建服务器对象，创建输出流对象指向文件，每接受一行数据就使用输出流输出到文件中，传输结束后。使用输出流给客户端反馈信息
- 客户端接受服务端的回馈信息
相关方法

方法名	说明
void shutdownInput()	将此套接字的输入流放置在“流的末尾”
void shutdownOutput()	禁止用此套接字的输出流

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);
        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new
                                               FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new
                                               OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //public void shutdownOutput()
        s.shutdownOutput();
        //接收反馈
        BufferedReader brClient = new BufferedReader(new
                                                     InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);
        //释放资源
        br.close();
        s.close();
    }

    public class ServerDemo {
        public static void main(String[] args) throws IOException {
            //创建服务器Socket对象
            ServerSocket ss = new ServerSocket(10000);
            //监听客户端连接，返回一个对应的Socket对象
            Socket s = ss.accept();
            //接收数据
            BufferedReader br = new BufferedReader(new
                                                   InputStreamReader(s.getInputStream()));
            //把数据写入文本文件
            BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));
            String line;
            while ((line=br.readLine())!=null) { //等待读取数据
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
            //给出反馈
            BufferedWriter bwServer = new BufferedWriter(new
                                                         OutputStreamWriter(s.getOutputStream()));
            bwServer.write("文件上传成功");
            bwServer.newLine();
            bwServer.flush();
            //释放资源
            bw.close();
            ss.close();
        }
    }
}

10.3.6 TCP练习6

案例需求

客户端：数据来自于文本文件，接收服务器反馈

服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程
案例分析
- 创建客户端对象，创建输入流对象指向文件，每读入一行数据就给服务器输出一行数据，输出结束后使用shutdownOutput()方法告知服务端传输结束
- 创建多线程类，在run()方法中读取客户端发送的数据，为了防止文件重名，使用计数器给文件名编号，接受结束后使用输出流给客户端发送反馈信息。
- 创建服务端对象，每监听到一个客户端则开启一个新的线程接受数据。
- 客户端接受服务端的回馈信息

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);
        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new
                                               FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new
                                               OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        s.shutdownOutput();
        //接收反馈
        BufferedReader brClient = new BufferedReader(new
                                                     InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);
        //释放资源
        br.close();
        s.close();
    }
}
public class ServerThread implements Runnable {
    private Socket s;
    public ServerThread(Socket s) {
        this.s = s;
    }
    @Override
    public void run() {
        try {
            //接收数据写到文本文件
            BufferedReader br = new BufferedReader(new
                                                   InputStreamReader(s.getInputStream()));
            //解决名称冲突问题
            int count = 0;
            File file = new File("myNet\\Copy["+count+"].java");
            while (file.exists()) {
                count++;
                file = new File("myNet\\Copy["+count+"].java");
            }
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));
            String line;
            while ((line=br.readLine())!=null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
            //给出反馈
            BufferedWriter bwServer = new BufferedWriter(new
                                                         OutputStreamWriter(s.getOutputStream()));
            bwServer.write("文件上传成功");
            bwServer.newLine();
            bwServer.flush();
            //释放资源
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);
        while (true) {
            //监听客户端连接，返回一个对应的Socket对象
            Socket s = ss.accept();
            //为每一个客户端开启一个线程
            new Thread(new ServerThread(s)).start();
        }
    }
}

11. Lambda表达式

1、体验Lambda表达式

案例需求

启动一个线程，在控制台输出一句话：多线程程序启动了
实现方式一
- 实现步骤
  - 定义一个类MyRunnable实现Runnable接口，重写run()方法
  - 创建MyRunnable类的对象
  - 创建Thread类的对象，把MyRunnable的对象作为构造参数传递
  - 启动线程
实现方式二
- 匿名内部类的方式改进
实现方式三
- Lambda表达式的方式改进

//方式一的线程类
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("多线程程序启动了");
    }
}

public class LambdaDemo {
    public static void main(String[] args) {
        //方式一
        MyRunnable my = new MyRunnable();
        Thread t = new Thread(my);
        t.start();
        
        //方式二
        new Thread(new Runnable() {
            @Override
            public void run() {
            System.out.println("多线程程序启动了");
            }
        }).start();
        
        //方式三
        new Thread( () -> {
            System.out.println("多线程程序启动了");
        } ).start();
    }
}

函数式编程思想概述

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

而我们要学习的Lambda表达式就是函数式思想的体现

2、Lambda表达式的标准格式

格式：

(形式参数) -> {代码块}
- 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
- ->：由英文中画线和大于符号组成，固定写法。代表指向动作
- 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
组成Lambda表达式的三要素：
- 形式参数，箭头，代码块

11.1 Lambda练习1

Lambda表达式的使用前提
- 有一个接口
- 接口中有且仅有一个抽象方法
练习描述

无参无返回值抽象方法的练习
操作步骤
- 定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
- 定义一个测试类(EatableDemo)，在测试类中提供两个方法
  - 一个方法是：useEatable(Eatable e)
  - 一个方法是主方法，在主方法中调用useEatable方法

//接口
public interface Eatable {
    void eat();
}

//实现类
public class EatableImpl implements Eatable {
    @Override
    public void eat() {
        System.out.println("一天一苹果，医生远离我");
    }
}

//测试类
public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);
        
        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我");
            }
        });
        
        //Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }
    private static void useEatable(Eatable e) {
        e.eat();
    }
}

11.2 Lambda练习2

练习描述

有参无返回值抽象方法的练习
操作步骤
- 定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
- 定义一个测试类(FlyableDemo)，在测试类中提供两个方法
  - 一个方法是：useFlyable(Flyable f)
  - 一个方法是主方法，在主方法中调用useFlyable方法

public interface Flyable {
    void fly(String s);
}

public class FlyableDemo {
    public static void main(String[] args) {
        //在主方法中调用useFlyable方法
        
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });
        System.out.println("--------");
        
        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });
    }
    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

11.3 Lambda练习3

练习描述

有参有返回值抽象方法的练习
操作步骤
- 定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
- 定义一个测试类(AddableDemo)，在测试类中提供两个方法
  - 一个方法是：useAddable(Addable a)
  - 一个方法是主方法，在主方法中调用useAddable方法

public interface Addable {
    int add(int x,int y);
}
public class AddableDemo {
    public static void main(String[] args) {
        //在主方法中调用useAddable方法
        useAddable((int x,int y) -> {
            return x + y;
        });
    }
    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

11.4 Lambda表达式的省略模式

省略的规则
- 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
- 如果参数有且仅有一个，那么小括号可以省略
- 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

public interface Addable {
    int add(int x, int y);
}

public interface Flyable {
    void fly(String s);
}

public class LambdaDemo {
    public static void main(String[] args) {
        // useAddable((int x,int y) -> {
        // return x + y;
        // });
        
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });
     
        // useFlyable((String s) -> {
        // System.out.println(s);
        // });
        
        //如果参数有且仅有一个，那么小括号可以省略
        // useFlyable(s -> {
        // System.out.println(s);
        // });
        
        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));
        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }
    
    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
    
    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

11.5 Lambda表达式的注意事项

使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
必须有上下文环境，才能推导出Lambda对应的接口
- 根据局部变量的赋值得知Lambda对应的接口
  
  Runnable r = () -> System.out.println(“Lambda表达式”);
- 根据调用方法的参数得知Lambda对应的接口
  
  new Thread(() -> System.out.println(“Lambda表达式”)).start();

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

所需类型不同
- 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
- Lambda表达式：只能是接口
使用限制不同
- 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
- 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
实现原理不同
- 匿名内部类：编译之后，产生一个单独的.class字节码文件
- Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

12. 方法引用

1、概述

方法引用的出现原因

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要

那我们又是如何使用已经存在的方案的呢？

这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

public interface Printable {
    void printString(String s);
}
public class PrintableDemo {
    public static void main(String[] args) {
        //在主方法中调用usePrintable方法
        // usePrintable((String s) -> {
        // System.out.println(s);
        // });
        //Lambda简化写法
        usePrintable(s -> System.out.println(s));
        //方法引用
        usePrintable(System.out::println);
    }
    private static void usePrintable(Printable p) {
        p.printString("爱生活爱Java");
    }
}

2、方法引用符

方法引用符

:: 该符号为引用运算符，而它所在的表达式被称为方法引用
推导与省略
- 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
- 如果使用方法引用，也是同样可以根据上下文进行推导
- 方法引用是Lambda的孪生兄弟

12.1 引用类方法

引用类方法，其实就是引用类的静态方法

格式

类名::静态方法
范例

Integer::parseInt

Integer类的方法：public static int parseInt(String s) 将此String转换为int类型数据
练习描述
- 定义一个接口(Converter)，里面定义一个抽象方法 int convert(String s);
- 定义一个测试类(ConverterDemo)，在测试类中提供两个方法
  - 一个方法是：useConverter(Converter c) 、
  - 一个方法是主方法，在主方法中调用useConverter方法

public interface Converter {
    int convert(String s);
}

public class ConverterDemo {
    public static void main(String[] args) {
        //Lambda写法
        useConverter(s -> Integer.parseInt(s));
        
        //引用类方法
        useConverter(Integer::parseInt);
    }
    
    private static void useConverter(Converter c) {
        int number = c.convert("666");
        System.out.println(number);
    }
}

使用说明

Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

12.2 引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法

格式

对象::成员方法
范例

“HelloWorld”::toUpperCase

String类中的方法：public String toUpperCase() 将此String所有字符转换为大写
练习描述
- 定义一个类(PrintString)，里面定义一个方法
- public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出
- 定义一个接口(Printer)，里面定义一个抽象方法
  
  void printUpperCase(String s)
- 定义一个测试类(PrinterDemo)，在测试类中提供两个方法
  - 一个方法是：usePrinter(Printer p)
  - 一个方法是主方法，在主方法中调用usePrinter方法

public class PrintString {
    //把字符串参数变成大写的数据，然后在控制台输出
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}
public interface Printer {
    void printUpperCase(String s);
}
public class PrinterDemo {
    public static void main(String[] args) {
        //Lambda简化写法
        usePrinter(s -> System.out.println(s.toUpperCase()));
        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);
    }
    private static void usePrinter(Printer p) {
        p.printUpperCase("HelloWorld");
    }
}

12.3 引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

格式

类名::成员方法
范例

String::substring

public String substring(int beginIndex,int endIndex)

从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex
练习描述
- 定义一个接口(MyString)，里面定义一个抽象方法：
  
  String mySubString(String s,int x,int y);
- 定义一个测试类(MyStringDemo)，在测试类中提供两个方法
  - 一个方法是：useMyString(MyString my)
  - 一个方法是主方法，在主方法中调用useMyString方法

public interface MyString {
    String mySubString(String s,int x,int y);
}
public class MyStringDemo {
    public static void main(String[] args) {
        //Lambda简化写法
        useMyString((s,x,y) -> s.substring(x,y));
        
        //引用类的实例方法
        useMyString(String::substring);
    }
    private static void useMyString(MyString my) {
        String s = my.mySubString("HelloWorld", 2, 5);
        System.out.println(s);
    }
}

使用说明

Lambda表达式被类的实例方法替代的时候第一个参数作为调用者后面的参数全部传递给该方法作为参数

12.4 引用构造器

引用构造器，其实就是引用构造方法

l格式

类名::new
范例

Student::new
练习描述
- 定义一个类(Student)，里面有两个成员变量(name,age)
  
  并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
- 定义一个接口(StudentBuilder)，里面定义一个抽象方法
  
  Student build(String name,int age);
- 定义一个测试类(StudentDemo)，在测试类中提供两个方法
  - 一个方法是：useStudentBuilder(StudentBuilder s)
  - 一个方法是主方法，在主方法中调用useStudentBuilder方法

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

public interface StudentBuilder {
    Student build(String name,int age);
}

public class StudentDemo {
    public static void main(String[] args) {
        //Lambda简化写法
        useStudentBuilder((name,age) -> new Student(name,age));
        //引用构造器
        useStudentBuilder(Student::new);
    }
    private static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("林青霞", 30);
        System.out.println(s.getName() + "," + s.getAge());
    }
}

使用说明

Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

13. 函数式接口

1、概述

概念

有且仅有一个抽象方法的接口
如何检测一个接口是不是函数式接口

@FunctionalInterface

放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
注意事项我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

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

需求描述

定义一个类(RunnableDemo)，在类中提供两个方法

一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口

一个方法是主方法，在主方法中调用startThread方法

public class RunnableDemo {
    public static void main(String[] args) {
        //在主方法中调用startThread方法
        
        //匿名内部类的方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动了");
            }
        });
        
        //Lambda方式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
    }
    private static void startThread(Runnable r) {
        new Thread(r).start();
    }
}

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

需求描述

定义一个类(ComparatorDemo)，在类中提供两个方法

一个方法是：Comparator getComparator() 方法返回值Comparator是一个函数式接口

一个方法是主方法，在主方法中调用getComparator方法

public class ComparatorDemo {
    public static void main(String[] args) {
        //定义集合，存储字符串元素
        ArrayList<String> array = new ArrayList<String>();
        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");
        System.out.println("排序前：" + array);
        Collections.sort(array, getComparator());
        System.out.println("排序后：" + array);
    }
    private static Comparator<String> getComparator() {
        //匿名内部类的方式实现
        // return new Comparator<String>() {
        // @Override
        // public int compare(String s1, String s2) {
        // return s1.length()-s2.length();
        // }
        // };
        //Lambda方式实现
        return (s1, s2) -> s1.length() - s2.length();
    }
}

以下是常用的函数式接口

13.1 Supplier接口

Supplier接口

Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。
常用方法

只有一个无参的方法

方法名	说明
T get()	按照某种实现逻辑(由Lambda表达式实现)返回一个数据

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(() -> "林青霞");
        System.out.println(s);
        Integer i = getInteger(() -> 30);
        System.out.println(i);
    }
    //定义一个方法，返回一个整数数据
    private static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }
    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String> sup) {
        return sup.get();
    }
}

Supplier接口练习之获取最大值

案例需求

定义一个类(SupplierTest)，在类中提供两个方法

一个方法是：int getMax(Supplier sup) 用于返回一个int数组中的最大值

一个方法是主方法，在主方法中调用getMax方法

public class SupplierTest {
    public static void main(String[] args) {
        //定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};
        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);
    }
    //返回一个int数组中的最大值
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

13.2 Consumer接口

Consumer接口

Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
常用方法

Consumer：包含两个方法

方法名	说明
void accept(T t)	对给定的参数执行此操作
default Consumer andThen(Consumer after)	返回一个组合的Consumer，依次执行此操作，然后执行after操作

public class ConsumerDemo {
    public static void main(String[] args) {
        //操作一
        operatorString("林青霞", s -> System.out.println(s));
        //操作二
        operatorString("林青霞", s -> System.out.println(new
                                                      StringBuilder(s).reverse().toString()));
        System.out.println("--------");
        //传入两个操作使用andThen完成
        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) {
        // con1.accept(name);
        // con2.accept(name);
        con1.andThen(con2).accept(name);
    }
    
    //定义一个方法，消费一个字符串数据
    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }
}

Consumer接口练习之按要求打印信息

案例需求

String[] strArray = {“林青霞,30”, “张曼玉,35”, “王祖贤,33”};

字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX"的格式将信息打印出来
要求：
- 把打印姓名的动作作为第一个Consumer接口的Lambda实例
- 把打印年龄的动作作为第二个Consumer接口的Lambda实例
- 将两个Consumer接口按照顺序组合到一起使用

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
        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);
        }
    }
}

13.3 Predicate接口

Predicate接口

Predicate接口通常用于判断参数是否满足指定的条件
常用方法

方法名	说明
boolean test(T t)	对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
default Predicate negate()	返回一个逻辑的否定，对应逻辑非
default Predicate and(Predicate other)	返回一个组合判断，对应短路与
default Predicate or(Predicate other)	返回一个组合判断，对应短路或

public class PredicateDemo01 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("helloworld",s -> s.length() > 8);
        System.out.println(b2);
    }
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        // return !pre.test(s);
        return pre.negate().test(s);
    }
}

public class PredicateDemo02 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("helloworld", s -> s.length() > 8);
        System.out.println(b2);
        boolean b3 = checkString("hello",s -> s.length() > 8, s -> s.length() <
                                 15);
        System.out.println(b3);
        boolean b4 = checkString("helloworld",s -> s.length() > 8, s -> s.length()
                                 < 15);
        System.out.println(b4);
    }
    //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString(String s, Predicate<String> pre1,
                                       Predicate<String> pre2) {
        return pre1.or(pre2).test(s);
    }
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }
}

Predicate接口练习之筛选满足条件数据

练习描述
- String[] strArray = {“林青霞,30”, “柳岩,34”, “张曼玉,35”, “貂蝉,31”, “王祖贤,33”};
- 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
- 同时满足如下要求：姓名长度大于2；年龄大于33
分析
- 有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
- 必须同时满足两个条件,所以可以使用and方法连接两个判断条件

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
        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);
        }
    }
    //通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
    private 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;
    }
}

13.4 Function接口

Function接口

Function接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值
常用方法

方法名	说明
R apply(T t)	将此函数应用于给定的参数
default Function andThen(Function after)	返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

public class FunctionDemo {
    public static void main(String[] args) {
        //操作一
        convert("100",s -> Integer.parseInt(s));
        //操作二
        convert(100,i -> String.valueOf(i + 566));
        //使用andThen的方式连续执行两个操作
        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
    }
    //定义一个方法，把一个字符串转换int类型，在控制台输出
    private static void convert(String s, Function<String,Integer> fun) {
        // Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }
    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(int i, Function<Integer,String> fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }
    //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(String s, Function<String,Integer> fun1,
                                Function<Integer,String> fun2) {
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}

Function接口练习之按照指定要求操作数据

练习描述
- String s = “林青霞,30”;
- 请按照我指定的要求进行操作：
  
  1:将字符串截取得到数字年龄部分
  
  2:将上一步的年龄字符串转换成为int类型的数据
  
  3:将上一步的int数据加70，得到一个int结果，在控制台输出
- 请通过Function接口来实现函数拼接

public class FunctionTest {
    public static void main(String[] args) {
        String s = "林青霞,30";
        convert(s, ss -> ss.split(",")[1], Integer::parseInt, i -> i + 70);
    }
    private 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);
    }
}

14. Stream流

案例需求

按照下面的要求完成集合的创建和遍历
- 创建一个集合，存储多个字符串元素
- 把集合中所有以"张"开头的元素存储到一个新的集合
- 把"张"开头的集合中的长度为3的元素存储到一个新的集合
- 遍历上一步得到的集合
原始方式示例代码

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        
        //把集合中所有以"张"开头的元素存储到一个新的集合
        ArrayList<String> zhangList = new ArrayList<String>();
        for(String s : list) {
            if(s.startsWith("张")) {
                zhangList.add(s);
            }
        }
        // System.out.println(zhangList);
        
        //把"张"开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> threeList = new ArrayList<String>();
        for(String s : zhangList) {
            if(s.length() == 3) {
                threeList.add(s);
            }
        }
        // System.out.println(threeList);
        
        //遍历上一步得到的集合
        for(String s : threeList) {
            System.out.println(s);
        }
        System.out.println("--------");
        
        //Stream流来改进
        // list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() ==
        3).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() ==
                                                            3).forEach(System.out::println);
    }
}

使用Stream流示例代码

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        //Stream流来改进
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() ==
                                                            3).forEach(System.out::println);
    }
}

Stream流的好处
- 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印
- Stream流把真正的函数式编程风格引入到Java中

14.1 Stream流的常见生成方式

Stream流的思想

生成Stream流的方式
- Collection体系集合
  
  使用默认方法stream()生成流， default Stream stream()
- Map体系集合
  
  把Map转成Set集合，间接的生成流
- 数组
  
  通过Stream接口的静态方法of(T… values)生成流

public class StreamDemo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream()生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();
        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set.stream();
        
        //Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<String, Integer>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
        
        //数组可以通过Stream接口的静态方法of(T... values)生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }
}

14.2 Stream流中间操作方法

概述

中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。
常见方法

方法名	说明
Stream filter(Predicate predicate)	用于对流中的数据进行过滤
Stream limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流
Stream sorted()	返回由此流的元素组成的流，根据自然顺序排序
Stream sorted(Comparator comparator)	返回由该流的元素组成的流，根据提供的Comparator进行排序
Stream map(Function mapper)	返回由给定函数应用于此流的元素的结果组成的流
IntStream mapToInt(ToIntFunction mapper)	返回一个IntStream其中包含将给定函数应用于此流的元素的结果

filter代码演示

public class StreamDemo01 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        
        //需求1：把list集合中以张开头的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("--------");
        
        //需求2：把list集合中长度为3的元素在控制台输出
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("--------");
        
        //需求3：把list集合中以张开头的，长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() ==
                                                            3).forEach(System.out::println);
    }
}

limit&skip代码演示

public class StreamDemo02 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        //需求1：取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");
        //需求2：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");
        //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

concat&distinct代码演示

public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        //需求1：取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        //需求2：跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出
        // Stream.concat(s1,s2).forEach(System.out::println);
        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

sorted代码演示

public class StreamDemo04 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("linqingxia");
        list.add("zhangmanyu");
        list.add("wangzuxian");
        list.add("liuyan");
        list.add("zhangmin");
        list.add("zhangwuji");
        //需求1：按照字母顺序把数据在控制台输出
        // list.stream().sorted().forEach(System.out::println);
        //需求2：按照字符串长度把数据在控制台输出
        list.stream().sorted((s1,s2) -> {
            int num = s1.length()-s2.length();
            int num2 = num==0?s1.compareTo(s2):num;
            return num2;
        }).forEach(System.out::println);
    }
}

map&mapToInt代码演示

public class StreamDemo05 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");
        //需求：将集合中的字符串数据转换为整数之后在控制台输出
        // list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        // list.stream().map(Integer::parseInt).forEach(System.out::println);
        // list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        //int sum() 返回此流中元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

14.3 Stream流终结操作方法

概念

终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作。
常见方法

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素数

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");
        //需求1：把集合中的元素在控制台输出
        // list.stream().forEach(System.out::println);
        //需求2：统计集合中有几个以张开头的元素，并把统计结果在控制台输出
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
    }
}

14.4 Stream流的收集操作

概念

对数据使用Stream流的方式操作完毕后，可以把流中的数据收集到集合中。
常见方法

方法名	说明
R collect(Collector collector)	把结果收集到集合中

工具类Collectors提供了具体的收集方式

方法名	说明
public static Collector toList()	把元素收集到List集合中
public static Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)	把元素收集到Map集合中

public class CollectDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        /*
        //需求1：得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
        //需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for(String name : names) {
        System.out.println(name);
        }
        */
        //创建Set集合对象
        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(35);
        /*
        //需求3：得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(age -> age > 25);
        //需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for(Integer age : ages) {
        System.out.println(age);
        }
        */
        //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};
        //需求5：得到字符串中年龄数据大于28的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s ->
                                                                Integer.parseInt(s.split(",")[1]) > 28);
        //需求6：把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s ->
                                                                        s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Integer value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

15. 类加载器

15.1 类加载

类加载的描述
- 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化
类的加载
- 就是指将class文件读入内存，并为之创建一个 java.lang.Class 对象
- 任何类被使用时，系统都会为之建立一个 java.lang.Class 对象
类的连接
- 验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
- 准备阶段：负责为类的类变量分配内存，并设置默认初始化值
- 解析阶段：将类的二进制数据中的符号引用替换为直接引用
类的初始化
- 在该阶段，主要就是对类变量进行初始化
类的初始化步骤
- 假如类还未被加载和连接，则程序先加载并连接该类
- 假如该类的直接父类还未被初始化，则先初始化其直接父类
- 假如类中有初始化语句，则系统依次执行这些初始化语句
- 注意：在执行第2个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3
类的初始化时机
- 创建类的实例
- 调用类的类方法
- 访问类或者接口的类变量，或者为该类变量赋值
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类直接使用java.exe命令来运行某个主类

15.2 类加载器

1、类加载器的作用

负责将.class文件加载到内存中，并为之生成对应的 java.lang.Class 对象。虽然我们不用过分关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行！

2、JVM的类加载机制

全盘负责：就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
父类委托：就是当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储到缓存区

3、Java中的内置类加载器

Bootstrap class loader：它是虚拟机的内置类加载器，通常表示为null ，并且没有父null
Platform class loader：平台类加载器可以看到所有平台类，平台类包括由平台类加载器或其祖先定义的Java SE平台API，其实现类和JDK特定的运行时类
System class loader：它也被称为应用程序类加载器，与平台类加载器不同。系统类加载器通常用于定义应用程序类路径，模块路径和JDK特定工具上的类
类加载器的继承关系：System的父加载器为Platform，而Platform的父加载器为Bootstrap

4、ClassLoader 中的两个方法

方法分类

方法名	说明
static ClassLoader getSystemClassLoader()	返回用于委派的系统类加载器
ClassLoader getParent()	返回父类加载器进行委派

public class ClassLoaderDemo {
    public static void main(String[] args) {
        //static ClassLoader getSystemClassLoader()：返回用于委派的系统类加载器
        ClassLoader c = ClassLoader.getSystemClassLoader();
        System.out.println(c); //AppClassLoader
        //ClassLoader getParent()：返回父类加载器进行委派
        ClassLoader c2 = c.getParent();
        System.out.println(c2); //PlatformClassLoader
        ClassLoader c3 = c2.getParent();
        System.out.println(c3); //null
    }
}

16. 反射

概述

是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展

16.1 获取Class类对象的三种方式

三种方式分类
- 类名.class属性
- 对象名.getClass()方法
- Class.forName(全类名)方法

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象
        Class<Student> c1 = Student.class;
        System.out.println(c1);
        Class<Student> c2 = Student.class;
        System.out.println(c1 == c2);
        System.out.println("--------");
        //调用对象的getClass()方法，返回该对象所属类对应的Class对象
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1 == c3);
        System.out.println("--------");
        //使用Class类中的静态方法forName(String className)
        Class<?> c4 = Class.forName("com.itheima_02.Student");
        System.out.println(c1 == c4);
    }
}

16.2 反射获取构造方法

1、Class类获取构造方法对象的方法

方法名	说明
Constructor[] getConstructors()	返回所有公共构造方法对象的数组
Constructor[] getDeclaredConstructors()	返回所有构造方法对象的数组
Constructor getConstructor(Class… parameterTypes)	返回单个公共构造方法对象
Constructor getDeclaredConstructor(Class… parameterTypes)	返回单个构造方法对象

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException,
    NoSuchMethodException, IllegalAccessException, InvocationTargetException,
    InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //Constructor<?>[] getConstructors() 返回一个包含 Constructor对象的数组，Constructor对象反映了由该 Class对象表示的类的所有公共构造函数
        // Constructor<?>[] cons = c.getConstructors();
        //Constructor<?>[] getDeclaredConstructors() 返回反映由该 Class对象表示的类声明的所有构造函数的 Constructor对象的数组
        Constructor<?>[] cons = c.getDeclaredConstructors();
        for(Constructor con : cons) {
            System.out.println(con);
        }
        System.out.println("--------");
        //Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一个Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回一个 Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数
        //参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
        Constructor<?> con = c.getConstructor();
        //Constructor提供了一个类的单个构造函数的信息和访问权限
        //T newInstance(Object... initargs) 使用由此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例
        Object obj = con.newInstance();
        System.out.println(obj);
        // Student s = new Student();
        // System.out.println(s);
    }
}

2、Constructor类用于创建对象的方法

方法名	说明
T newInstance(Object…initargs)	根据指定的构造方法创建对象

3、反射获取构造方法并使用练习1

案例需求
- 通过反射获取公共的构造方法并创建对象
学生类

public class Student {
    //成员变量：一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;
    //构造方法：一个私有，一个默认，两个公共
    public Student() {
    }
    private Student(String name) {
        this.name = name;
    }
    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    //成员方法：一个私有，四个公共
    private void function() {
        System.out.println("function");
    }
    public void method1() {
        System.out.println("method");
    }
    public void method2(String s) {
        System.out.println("method:" + s);
    }
    public String method3(String s, int i) {
        return s + "," + i;
    }
    @Override
    public String toString() {
        return "Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", address='" + address + '\'' +
            '}';
    }
}

测试类

public class ReflectDemo02 {
    public static void main(String[] args) throws ClassNotFoundException,
    NoSuchMethodException, IllegalAccessException, InvocationTargetException,
    InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //public Student(String name, int age, String address)
        //Constructor<T> getConstructor(Class<?>... parameterTypes)
        Constructor<?> con = c.getConstructor(String.class, int.class,
                                              String.class);
        //基本数据类型也可以通过.class得到对应的Class类型
        //T newInstance(Object... initargs)
        Object obj = con.newInstance("林青霞", 30, "西安");
        System.out.println(obj);
    }
}

4、反射获取构造方法并使用练习2

案例需求
- 通过反射获取私有构造方法并创建对象
学生类：参见上方学生类
测试类

public class ReflectDemo03 {
    public static void main(String[] args) throws ClassNotFoundException,
    NoSuchMethodException, IllegalAccessException, InvocationTargetException,
    InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //private Student(String name)
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
        Constructor<?> con = c.getDeclaredConstructor(String.class);
        //暴力反射
        //public void setAccessible(boolean flag):值为true，取消访问检查
        con.setAccessible(true);
        Object obj = con.newInstance("林青霞");
        System.out.println(obj);
    }
}

16.3 反射获取成员变量

1、Class类获取成员变量对象的方法

方法分类

方法名	说明
Field[] getFields()	返回所有公共成员变量对象的数组
Field[] getDeclaredFields()	返回所有成员变量对象的数组
Field getField(String name)	返回单个公共成员变量对象
Field getDeclaredField(String name)	返回单个成员变量对象

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException,
    NoSuchFieldException, NoSuchMethodException, IllegalAccessException,
    InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //Field[] getFields() 返回一个包含 Field对象的数组， Field对象反映由该 Class对象表示的类或接口的所有可访问的公共字段
        //Field[] getDeclaredFields() 返回一个 Field对象的数组，反映了由该 Class对象表示的类或接口声明的所有字段
        // Field[] fields = c.getFields();
        Field[] fields = c.getDeclaredFields();
        for(Field field : fields) {
            System.out.println(field);
        }
        System.out.println("--------");
        //Field getField(String name) 返回一个 Field对象，该对象反映由该 Class对象表示的类或接口的指定公共成员字段
        //Field getDeclaredField(String name) 返回一个 Field对象，该对象反映由该Class对象表示的类或接口的指定声明字段
        Field addressField = c.getField("address");
        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        // obj.addressField = "西安";
        //Field提供有关类或接口的单个字段的信息和动态访问
        //void set(Object obj, Object value) 将指定的对象参数中由此 Field对象表示的字段设置为指定的新值
        addressField.set(obj,"西安"); //给obj的成员变量addressField赋值为西安
        System.out.println(obj);
        // Student s = new Student();
        // s.address = "西安";
        // System.out.println(s);
    }
}

2、Field类用于给成员变量赋值的方法

方法名	说明
voidset(Object obj,Object value)	给obj对象的成员变量赋值为value

3、反射获取成员变量并使用练习

案例需求
- 通过反射获取成员变量并赋值
学生类：参见上方学生类
测试类

public class ReflectDemo02 {
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //Student s = new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);
        //s.name = "林青霞";
        // Field nameField = c.getField("name"); //NoSuchFieldException:
        name
            Field nameField = c.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(obj, "林青霞");
        System.out.println(obj);
        //s.age = 30;
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj,30);
        System.out.println(obj);
        //s.address = "西安";
        Field addressField = c.getDeclaredField("address");
        addressField.setAccessible(true);
        addressField.set(obj,"西安");
        System.out.println(obj);
    }
}

16.4 反射获取成员方法

1、Class类获取成员方法对象的方法

方法分类

方法名	说明
Method[] getMethods()	返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class… parameterTypes)	返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class… parameterTypes)	返回单个成员方法对象

public class ReflectDemo01 {
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //Method[] getMethods() 返回一个包含 方法对象的数组， 方法对象反映由该 Class对象表示的类或接口的所有公共方法，包括由类或接口声明的对象以及从超类和超级接口继承的类
        //Method[] getDeclaredMethods() 返回一个包含 方法对象的数组， 方法对象反映由Class对象表示的类或接口的所有声明方法，包括public，protected，default（package）访问和私有方法，但不包括继承方法
        // Method[] methods = c.getMethods();
        Method[] methods = c.getDeclaredMethods();
        for(Method method : methods) {
            System.out.println(method);
        }
        System.out.println("--------");
        //Method getMethod(String name, Class<?>... parameterTypes) 返回一个 方法对象，该对象反映由该 Class对象表示的类或接口的指定公共成员方法
        //Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回一个方法对象，它反映此表示的类或接口的指定声明的方法 Class对象
        //public void method1()
        Method m = c.getMethod("method1");
        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        // obj.m();
        //在类或接口上提供有关单一方法的信息和访问权限
        //Object invoke(Object obj, Object... args) 在具有指定参数的指定对象上调用此方法对象表示的基础方法
        //Object：返回值类型
        //obj：调用方法的对象
        //args：方法需要的参数
        m.invoke(obj);
        // Student s = new Student();
        // s.method1();
    }
}

2、Method类用于执行方法的方法

方法名	说明
Objectinvoke(Object obj,Object… args)	调用obj对象的成员方法，参数是args,返回值是Object类型

3、反射获取成员方法并使用练习

案例需求
- 通过反射获取成员方法并调用
学生类：参见上方学生类
测试类

public class ReflectDemo02 {
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //Student s = new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        //s.method1();
        Method m1 = c.getMethod("method1");
        m1.invoke(obj);
        //s.method2("林青霞");
        Method m2 = c.getMethod("method2", String.class);
        m2.invoke(obj,"林青霞");
        // String ss = s.method3("林青霞",30);
        // System.out.println(ss);
        Method m3 = c.getMethod("method3", String.class, int.class);
        Object o = m3.invoke(obj, "林青霞", 30);
        System.out.println(o);
        //s.function();
        // Method m4 = c.getMethod("function"); //NoSuchMethodException:
        com.itheima_02.Student.function()
            Method m4 = c.getDeclaredMethod("function");
        m4.setAccessible(true);
        m4.invoke(obj);
    }
}

17. 模块化

1、概述

Java语言随着这些年的发展已经成为了一门影响深远的编程语言，无数平台，系统都采用Java语言编写。但是，伴随着发展，Java也越来越庞大，逐渐发展成为一门“臃肿” 的语言。而且，无论是运行一个大型的软件系统，还是运行一个小的程序，即使程序只需要使用Java的部分核心功能， JVM也要加载整个JRE环境。为了给Java“瘦身”，让 Java实现轻量化，Java 9正式的推出了模块化系统。Java被拆分为N多个模块，并允许Java程序可以根据需要选择加载程序必须的Java模块，这样就可以让Java以轻量化的方式来运行

其实，Java 7的时候已经提出了模块化的概念，但由于其过于复杂，Java 7，Java 8都一直未能真正推出，直到Java 9才真正成熟起来。对于Java语言来说，模块化系统是一次真正的自我革新，这种革新使得“古老而庞大”的Java语言重新焕发年轻的活力

17.1 模块的基本使用

在项目中创建两个模块。一个是myOne,一个是myTwo
在myOne模块中创建以下包和以下类，并在类中添加方法

在myTwo模块中创建以下包和以下类，并在类中创建对象并使用

在myOne模块中src目录下，创建module-info.java，并写入以下内容

在myTwo模块中src目录下，创建module-info.java，并写入以下内容

17.2 模块服务的基本使用

在myOne模块中新建一个包，提供一个接口和两个实现类

在myOne模块中修改module-info.java文件，添加以下内容

在myTwo模块中新建一个测试类

在myTwo模块中修改module-info.java文件，添加以下内容

18.经典案例

18.1 生产者消费者(多线程)

概述

生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。

所谓生产者消费者问题，实际上主要是包含了两类线程：

一类是生产者线程用于生产数据

一类是消费者线程用于消费数据

为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

Object类的等待和唤醒方法

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify()	唤醒正在等待对象监视器的单个线程
void notifyAll()	唤醒正在等待对象监视器的所有线程

案例需求

生产者消费者案例中包含的类：

奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作

生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作

消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作

测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下

①创建奶箱对象，这是共享数据区域

②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作

③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作

④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递

⑤启动线程

public class Box {
    //定义一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;
    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk) {
        //如果有牛奶，等待消费
        if(state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，就生产牛奶
        this.milk = milk;
        System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");
        //生产完毕之后，修改奶箱状态
        state = true;
        //唤醒其他等待的线程
        notifyAll();
    }
    public synchronized void get() {
        //如果没有牛奶，等待生产
        if(!state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第" + this.milk + "瓶奶");
        //消费完毕之后，修改奶箱状态
        state = false;
        //唤醒其他等待的线程
        notifyAll();
    }
}
public class Producer implements Runnable {
    private Box b;
    public Producer(Box b) {
        this.b = b;
    }
    @Override
    public void run() {
        for(int i=1; i<=30; i++) {
            b.put(i);
        }
    }
}
public class Customer implements Runnable {
    private Box b;
    public Customer(Box b) {
        this.b = b;
    }
    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}
public class BoxDemo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
        Box b = new Box();
        //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
        //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        Customer c = new Customer(b);
        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        //启动线程
        t1.start();
        t2.start();
    }
}

18.2 Stream流综合练习(Stream流)

案例需求

现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
- 男演员只要名字为3个字的前三人
- 女演员只要姓林的，并且不要第一个
- 把过滤后的男演员姓名和女演员姓名合并到一起
- 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

public class Actor {
    private String name;
    public Actor(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
public class StreamTest {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");
        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");
        /*
        //男演员只要名字为3个字的前三人
        Stream<String> manStream = manList.stream().filter(s -> s.length() ==
        3).limit(3);
        //女演员只要姓林的，并且不要第一个
        Stream<String> womanStream = womanList.stream().filter(s ->
        s.startsWith("林")).skip(1);
        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(manStream, womanStream);
        //把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
        // stream.map(Actor::new).forEach(System.out::println);
        stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));
        */
        Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3),
                      womanList.stream().filter(s ->
                                                s.startsWith("林")).skip(1)).map(Actor::new).
            forEach(p -> System.out.println(p.getName()));
    }
}

18.3 反射的案例(反射)

1、反射练习之越过泛型检查

案例需求
- 通过反射技术，向一个泛型为Integer的集合中添加一些字符串数据

public class ReflectTest01 {
    public static void main(String[] args) throws Exception {
        //创建集合
        ArrayList<Integer> array = new ArrayList<Integer>();
        
        // array.add(10);
        // array.add(20);
        // array.add("hello");
        
        Class<? extends ArrayList> c = array.getClass();
        Method m = c.getMethod("add", Object.class);
        m.invoke(array,"hello");
        m.invoke(array,"world");
        m.invoke(array,"java");
        System.out.println(array);
    }
}

2、运行配置文件中指定类的指定方法

案例需求
- 通过反射运行配置文件中指定类的指定方法

public class ReflectTest02 {
    public static void main(String[] args) throws Exception {
        //加载数据
        Properties prop = new Properties();
        FileReader fr = new FileReader("myReflect\\class.txt");
        prop.load(fr);
        fr.close();
        /*
        className=com.itheima_06.Student
        methodName=study
        */
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");
        //通过反射来使用
        Class<?> c = Class.forName(className);//com.itheima_06.Student
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        Method m = c.getMethod(methodName);//study
        m.invoke(obj);
    }
}

cocochimp

关注

0
点赞
踩
15

收藏

觉得还不错? 一键收藏
2
评论
Java入门级教学（超详细&下）

进程：是正在运行的程序是系统进行**资源分配**和**调用**的**独立单位** 每一个进程都有它自己的**内存空间**和**系统资源** 线程：是进程中的单个顺序控制流，是一条执行路径单线程：一个进程如果只有一条执行路径，则称为单线程程序多线程：一个进程如果有多条执行路径，则称为多线程程序
复制链接

扫一扫