自定义注解的格式：
     修饰符 @interface 注解名{
          // 注解属性
     }

通信一定是基于软件结构实现的:
        1.C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。
            常见程序有ＱＱ、迅雷，IDEA等软件。

        2.B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。
            常见浏览器有谷歌、火狐等、软件：博学谷、京东、淘宝。
            （开发中的重点，基于网页设计界面，界面效果可以更丰富: Java Web开发）

    两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，
        就是在一定的协议下，实现两台计算机的通信的技术。

1.协议
       协议：计算机网络客户端与服务端通信必须事先约定和彼此遵守的通信规则。
       HTTP , FTP , TCP , UDP , SSH , SMTP。

   2.IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。
            IP地址用来给一个网络中的计算机设备做唯一的编号。

       IPv4:4个字节，32位组成。  192.168.70.70
           局域网
           城域网
           广域网（公网）

           局域网：公司内部用。
           公网：可以在任何地方访问。

       IPv6: 可以实现为所有设备分配IP  128位

       ipconfig：查看本机的IP
         ping 检查本机与某个IP指定的机器是否联通，或者说是检测对方是否在线。
         ping 空格 IP地址
         ping 220.181.57.216
         ping www.baidu.com
   3.端口：
       端口号就可以唯一标识设备中的进程（应用程序）了
       端口号：
       用两个字节表示的整数，它的取值范围是0~65535。
       0~1023之间的端口号用于一些知名的网络服务和应用。
       普通的应用程序需要使用1024以上的端口号。
       如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。报出端口被占用异常！！

       利用`协议`+`IP地址`+`端口号` 三元组合，
       就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

网络通信协议：通信协议是对计算机必须遵守的规则，
    只有遵守这些规则，计算机之间才能进行通信。

    -------------------------------------------------------------------------------
    应用层  ：应用程序（QQ,微信,浏览器）,可能用到的协议（HTTP,FTP,SMTP）   通常程序员只需要关心这一层
    ------------------------------------------------------------------------------
    传输层  ：TCP/IP协议 - UDP协议    计算机网络工程师需要精通的协议，有些技术我们也需要精通这一层协议，
    -----------------------------------------------------------------
    网络层  ：IP协议  封装自己的IP和对方的IP和端口
    -----------------------------------------------------------------
    数据链路层 ： 进入到硬件（网）
    -----------------------------------------------------------------
    TCP/IP协议：传输控制协议 (Transmission Control Protocol)。
        TCP协议是面向连接的安全的可靠的传输通信协议。
        1.在通信之前必须确定对方在线并且连接成功才可以通信。
        2.例如下载文件、浏览网页等(要求可靠传输)

    UDP：用户数据报协议(User Datagram Protocol)。
        UDP协议是一个面向无连接的不可靠传输的协议。
        1.直接发消息给对方，不管对方是否在线，发消息后也不需要确认。
        2.无线（视频会议，通话），性能好，可能丢失一些数据！！

一个该类的对象就代表一个IP地址对象。
 InetAddress类成员方法：
      static InetAddress getLocalHost()
         * 获得本地主机IP地址对象。
      static InetAddress getByName(String host)
         * 根据IP地址字符串或主机名获得对应的IP地址对象。
      String getHostName()
         * 获得主机名。
      String getHostAddress()
         * 获得IP地址字符串。

UDP协议的特点
         * 面向无连接的协议
         * 发送端只管发送，不确认对方是否能收到。
         * 基于数据包进行数据传输。
         * 发送数据的包的大小限制64KB以内
         * 因为面向无连接，速度快，但是不可靠。会丢失数据！

     UDP协议的使用场景
         * 在线视频
         * 网络语音电话

     UDP协议相关的两个类
         * DatagramPacket
             * 数据包对象
             * 作用：用来封装要发送或要接收的数据，比如：集装箱
         * DatagramSocket
             * 发送对象
             * 作用：用来发送或接收数据包，比如：码头
     DatagramPacket类构造器
         发送端用：
            new DatagramPacket(byte[] buf, int length, InetAddress address, int port)
              创建发送端数据包对象
             * buf：要发送的内容，字节数组
             * length：要发送内容的长度，单位是字节
             * address：接收端的IP地址对象
             * port：接收端的端口号

         接收端用：
             new DatagramPacket(byte[] buf, int length)
             * 创建接收端的数据包对象
             * buf：用来存储接收到内容
             * length：能够接收内容的长度

     DatagramPacket类常用方法
         * int getLength() 获得实际接收到的字节个数

     DatagramSocket类构造方法
         * DatagramSocket() 创建发送端的Socket对象，系统会随机分配一个端口号。
         * DatagramSocket(int port) 创建接收端的Socket对象并指定端口号

     DatagramSocket类成员方法
         * void send(DatagramPacket dp) 发送数据包
         * void receive(DatagramPacket p) 接收数据包

TCP/IP协议 ==> Transfer Control Protocol ==> 传输控制协议
     TCP/IP协议的特点
     * 面向连接的协议
     * 只能由客户端主动发送数据给服务器端，服务器端接收到数据之后，可以给客户端响应数据。
     * 通过三次握手建立连接，连接成功形成数据传输通道。
     * 通过四次挥手断开连接
     * 基于IO流进行数据传输
     * 传输数据大小没有限制
     * 因为面向连接的协议，速度慢，但是是可靠的协议。

     TCP协议的使用场景
         * 文件上传和下载
         * 邮件发送和接收
         * 远程登录

     TCP协议相关的类
         * Socket
             * 一个该类的对象就代表一个客户端程序。
         * ServerSocket
             * 一个该类的对象就代表一个服务器端程序。

     TCP通信也叫Socket网络编程，只要代码基于Socket开发，底层就是基于了可靠传输的
     TCP通信。

     Socket类构造方法
         * Socket(String host, int port)
         * 根据ip地址字符串和端口号创建客户端Socket对象
         * 注意事项：只要执行该方法，就会立即连接指定的服务器程序，如果连接不成功，则会抛出异常。
               如果连接成功，则表示三次握手通过。

     Socket类常用方法
         * OutputStream getOutputStream(); 获得字节输出流对象
         * InputStream getInputStream();获得字节输入流对象

     客户端的开发流程：
         1.客户端要请求于服务端的socket管道连接。
         2.从socket通信管道中得到一个字节输出流
         3.通过字节输出流给服务端写出数据。
     服务端的开发流程：
         1.注册端口。
         2.接收客户端的Socket管道连接。
         3.从socket通信管道中得到一个字节输入流。
         4.从字节输入流中读取客户端发来的数据。

public static void main(String[] args) throws Exception {
        // 1.客户端要请求于服务端的socket管道连接。
        // Socket(String host, int port)
        Socket socket = new Socket("127.0.0.1" , 9999);
        // 2.从socket通信管道中得到一个字节输出流
        OutputStream os = socket.getOutputStream();
        // 3.把低级的字节输出流包装成高级的打印流。
        PrintStream ps = new PrintStream(os);
        // 4.开始发消息出去
        ps.println("我是客户端，喜欢你很久了，第一次给你发消息，只想说：约吗？");
        ps.flush();
        System.out.println("客户端发送完毕~~~~");
    }

public static void main(String[] args) throws Exception {
       System.out.println("----服务端启动----");
       // 1.注册端口: public ServerSocket(int port)
       ServerSocket serverSocket = new ServerSocket(9999);
       // 2.开始等待接收客户端的Socket管道连接。
       Socket socket = serverSocket.accept();
       // 3.从socket通信管道中得到一个字节输入流。
       InputStream is = socket.getInputStream();
       // 4.把字节输入流转换成字符输入流
       Reader isr = new InputStreamReader(is);
       // 5.把字符输入流包装成缓冲字符输入流。
       BufferedReader br = new BufferedReader(isr);
       // 6.按照行读取消息 。
       String line ;
       if((line = br.readLine())!=null){
           System.out.println(line);
       }
   }

public static void main(String[] args) throws Exception {
        // 1.客户端要请求于服务端的socket管道连接。
        // Socket(String host, int port)
        Socket socket = new Socket("127.0.0.1" , 9999);
        // 2.从socket通信管道中得到一个字节输出流
        OutputStream os = socket.getOutputStream();
        // 3.把低级的字节输出流包装成高级的打印流。
        PrintStream ps = new PrintStream(os);
        // 4.开始发消息出去
        while(true){
            Scanner sc = new Scanner(System.in);
            System.out.print("请说：");
            ps.println(sc.nextLine());
            ps.flush();
        }
    }

public static void main(String[] args) throws Exception {
        System.out.println("----服务端启动----");
        // 1.注册端口: public ServerSocket(int port)
        ServerSocket serverSocket = new ServerSocket(9999);
        // 2.开始等待接收客户端的Socket管道连接。
        Socket socket = serverSocket.accept();
        // 3.从socket通信管道中得到一个字节输入流。
        InputStream is = socket.getInputStream();
        // 4.把字节输入流转换成字符输入流
        Reader isr = new InputStreamReader(is);
        // 5.把字符输入流包装成缓冲字符输入流。
        BufferedReader br = new BufferedReader(isr);
        // 6.按照行读取消息 。
        String line ;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }
    }

public static void main(String[] args) throws Exception {
        // 1.客户端要请求于服务端的socket管道连接。
        // Socket(String host, int port)
        Socket socket = new Socket("127.0.0.1" , 9999);
        // 2.从socket通信管道中得到一个字节输出流
        OutputStream os = socket.getOutputStream();
        // 3.把低级的字节输出流包装成高级的打印流。
        PrintStream ps = new PrintStream(os);
        // 4.开始发消息出去
        while(true){
            Scanner sc = new Scanner(System.in);
            System.out.print("请说：");
            ps.println(sc.nextLine());
            ps.flush();
        }
    }

public static void main(String[] args) throws Exception {
        System.out.println("----服务端启动----");
        // 1.注册端口: public ServerSocket(int port)
        ServerSocket serverSocket = new ServerSocket(9999);
        // 2.定义一个循环不断的接收客户端的连接请求
        while(true){
            // 3.开始等待接收客户端的Socket管道连接。
            Socket socket = serverSocket.accept();
            // 4.每接收到一个客户端必须为这个客户端管道分配一个独立的线程来处理与之通信。
            new ServerReaderThread(socket).start();
        }
    }
    
class ServerReaderThread extends Thread{
    private Socket socket ;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        try{
            // 3.从socket通信管道中得到一个字节输入流。
            InputStream is = socket.getInputStream();
            // 4.把字节输入流转换成字符输入流
            Reader isr = new InputStreamReader(is);
            // 5.把字符输入流包装成缓冲字符输入流。
            BufferedReader br = new BufferedReader(isr);
            // 6.按照行读取消息 。
            String line ;
            while((line = br.readLine())!=null){
                System.out.println(socket.getRemoteSocketAddress()+"说："+line);
            }
        }catch (Exception e){
            System.out.println(socket.getRemoteSocketAddress()+"下线了~~~~~~");
        }
    }
}

public static void main(String[] args) {
		try {
			// 1.客户端要请求于服务端的socket管道连接。
			// Socket(String host, int port)
			Socket socket = new Socket("127.0.0.1" , 9999);
			// 2.从socket通信管道中得到一个字节输出流
			OutputStream os = socket.getOutputStream();
			// 3.把低级的字节输出流包装成高级的打印流。
			PrintStream ps = new PrintStream(os);
			Scanner sc = new Scanner(System.in);
			while(true){
				System.out.print("请说：");
				String msg = sc.nextLine();
				ps.println(msg);
				ps.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

public class HandlerSocketThreadPool {
	
	// 线程池 
	private ExecutorService executor;
	// 线程池：3个线程  100个
	public HandlerSocketThreadPool(int maxPoolSize, int queueSize){
		executor = new ThreadPoolExecutor(
				maxPoolSize,
				maxPoolSize,
				120L, 
				TimeUnit.SECONDS,
				new ArrayBlockingQueue<Runnable>(queueSize) );
	}
	
	public void execute(Runnable task){
		this.executor.execute(task);
	}
}

class ReaderClientRunnable implements Runnable {
	private Socket socket ;

	public ReaderClientRunnable(Socket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {
		try {
			// 读取一行数据
			InputStream is = socket.getInputStream() ;
			// 转成一个缓冲字符流
			Reader fr = new InputStreamReader(is);
			BufferedReader br = new BufferedReader(fr);
			// 一行一行的读取数据
			String line = null ;
			while((line = br.readLine())!=null){ // 阻塞式的！！
				System.out.println("服务端收到了数据："+line);
			}
		} catch (Exception e) {
			System.out.println("有人下线了");
		}
	}
}

/ 放弃了1 客户端 一个线程的模型了
// 提供了线程池：
public static void main(String[] args) {
		try {
			System.out.println("----------服务端启动成功------------");
			ServerSocket ss = new ServerSocket(9999);

			// 一个服务端只需要对应一个线程池
			HandlerSocketThreadPool handlerSocketThreadPool =
					new HandlerSocketThreadPool(3, 100);

			// 客户端可能有很多个
			while(true){
				Socket socket = ss.accept() ;
				System.out.println("有人上线了！！");
				// 每次收到一个客户端的socket请求，都需要为这个客户端分配一个
				// 独立的线程 专门负责对这个客户端的通信！！
				handlerSocketThreadPool.execute(new ReaderClientRunnable(socket));
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

public class Constants {
	/** 常量 */
	public static final int PORT = 7778 ;
	
	/** 协议分隔符 */
	public static final String SPILIT = "003197♣♣㏘♣④④♣";
}

public class ServerChat {

	/** 定义一个集合存放所有在线的socket  */
	public static Map<Socket, String> onLineSockets = new HashMap<>();

	public static void main(String[] args) {
		try {
			/** 注册端口   */
			ServerSocket serverSocket = new ServerSocket(Constants.PORT);

			/** 循环一直等待所有可能的客户端连接 */
			while(true){
				Socket socket = serverSocket.accept();
				/** 把客户端的socket管道单独配置一个线程来处理 */
				new ServerReader(socket).start();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

class ServerReader extends Thread {

	private Socket socket;

	public ServerReader(Socket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {
		DataInputStream dis = null;
		try {
			dis = new DataInputStream(socket.getInputStream());
			/** 循环一直等待客户端的消息 */
			while(true){
				/** 读取当前的消息类型 ：登录,群发,私聊 , @消息 */
				int flag = dis.readInt();
				if(flag == 1){
					/** 先将当前登录的客户端socket存到在线人数的socket集合中   */
					String name = dis.readUTF() ;
					System.out.println(name+"---->"+socket.getRemoteSocketAddress());
					ServerChat.onLineSockets.put(socket, name);
				}
				writeMsg(flag,dis);
			}
		} catch (Exception e) {
			System.out.println("--有人下线了--");
			// 从在线人数中将当前socket移出去  
			ServerChat.onLineSockets.remove(socket);
			try {
				// 从新更新在线人数并发给所有客户端 
				writeMsg(1,dis);
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		}

	}

	private void writeMsg(int flag, DataInputStream dis) throws Exception {
//		DataOutputStream dos = new DataOutputStream(socket.getOutputStream()); 
		// 定义一个变量存放最终的消息形式 
		String msg = null ;
		if(flag == 1){
			/** 读取所有在线人数发给所有客户端去更新自己的在线人数列表 */
			/** onlineNames = [徐磊,zhangsan,李刚]*/
			StringBuilder rs = new StringBuilder();
			Collection<String> onlineNames = ServerChat.onLineSockets.values();
			// 判断是否存在在线人数 
			if(onlineNames != null && onlineNames.size() > 0){
				for(String name : onlineNames){
					rs.append(name+ Constants.SPILIT);
				}
				// 徐磊003197♣♣㏘♣④④♣zhangsan003197♣♣㏘♣④④♣李刚003197♣♣㏘♣④④♣
				// 去掉最后的一个分隔符 
				msg = rs.substring(0, rs.lastIndexOf(Constants.SPILIT));

				/** 将消息发送给所有的客户端 */
				sendMsgToAll(flag,msg);
			}
		}else if(flag == 2 || flag == 3){
			// 读到消息  群发的 或者 @消息
			String newMsg = dis.readUTF() ; // 消息
			// 得到发件人 
			String sendName = ServerChat.onLineSockets.get(socket);

			// 李刚 时间
			//    内容--
			StringBuilder msgFinal = new StringBuilder();
			// 时间  
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE");
			if(flag == 2){
				msgFinal.append(sendName).append("  ").append(sdf.format(System.currentTimeMillis())).append("\r\n");
				msgFinal.append("    ").append(newMsg).append("\r\n");
				sendMsgToAll(flag,msgFinal.toString());
			}else if(flag == 3){
				msgFinal.append(sendName).append("  ").append(sdf.format(System.currentTimeMillis())).append("对您私发\r\n");
				msgFinal.append("    ").append(newMsg).append("\r\n");
				// 私发 
				// 得到给谁私发 
				String destName = dis.readUTF();
				sendMsgToOne(destName,msgFinal.toString());
			}
		}
	}
	/**
	 * @param destName 对谁私发 
	 * @param msg 发的消息内容 
	 * @throws Exception
	 */
	private void sendMsgToOne(String destName, String msg) throws Exception {
		// 拿到所有的在线socket管道 给这些管道写出消息
		Set<Socket> allOnLineSockets = ServerChat.onLineSockets.keySet();
		for(Socket sk :  allOnLineSockets){
			// 得到当前需要私发的socket 
			// 只对这个名字对应的socket私发消息
			if(ServerChat.onLineSockets.get(sk).trim().equals(destName)){
				DataOutputStream dos = new DataOutputStream(sk.getOutputStream());
				dos.writeInt(2); // 消息类型
				dos.writeUTF(msg);
				dos.flush();
			}
		}

	}

	private void sendMsgToAll(int flag, String msg) throws Exception {
		// 拿到所有的在线socket管道 给这些管道写出消息
		Set<Socket> allOnLineSockets = ServerChat.onLineSockets.keySet();
		for(Socket sk :  allOnLineSockets){
			DataOutputStream dos = new DataOutputStream(sk.getOutputStream());
			dos.writeInt(flag); // 消息类型
			dos.writeUTF(msg);
			dos.flush();
		}
	}
}

public class User {
	private Integer id ;
	private String name ;
	
	public User(Integer id, String name) {
		this.id = id;
		this.name = name;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}
	
	
}

/**
     目标：实现客户端上传图片给服务端保存起来。

     开发客户端：本地图片:  ‪D:\图片资源\beautiful.jpg
     开发服务端：服务器路径： D:\约吧图片服务器
 */
public static void main(String[] args) throws Exception {
        // 1.请求于服务端的Socket管道连接。
        Socket socket = new Socket(Constants.SERVER_IP , Constants.SERVER_PORT);
        // 2.从socket管道中得到一个字节输出流包装成缓冲字节输出流
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        // 3.提取本机的图片上传给服务端
        // 4.得到一个缓冲字节输入流与本地图片接通
        BufferedInputStream bis =
                new BufferedInputStream(new FileInputStream(Constants.SRC_IMAGE));
        // 5.定义一个字节数组
        byte[] buffer = new byte[1024];
        int len ;
        while((len = bis.read(buffer)) != -1) {
            bos.write(buffer, 0 ,len);
        }
        bos.flush(); // 刷新图片数据到服务端！！
        socket.shutdownOutput(); // 告诉服务端我的数据已经发送完毕，请不要在等我了！
        bis.close(); // 可以关闭

        // 6.等待着服务端的响应数据！！
        BufferedReader  br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        System.out.println("收到服务端响应："+br.readLine());
    }

/**
 * 客户端常量包
 */
public class Constants {
    public static final String SRC_IMAGE = "D:\\itcast\\图片资源\\beautiful.jpg";
    public static final String SERVER_DIR = "D:\\itcast\\约吧图片服务器\\";
    public static final String SERVER_IP = "127.0.0.1";
    public static final int SERVER_PORT = 8888;

}

/**
      功能点：
      1.接收多个客户端传输来的图片数据存储到服务器路径：
      2.响应一个成功的消息给当前客户端。
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("----服务端启动----");
        // 1.注册端口: public ServerSocket(int port)
        ServerSocket serverSocket = new ServerSocket(Constants.SERVER_PORT);
        // 2.定义一个循环不断的接收客户端的连接请求
        while(true){
            // 3.开始等待接收客户端的Socket管道连接。
            Socket socket = serverSocket.accept();
            // 4.每接收到一个客户端必须为这个客户端管道分配一个独立的线程来处理与之通信。
            new ServerReaderThread(socket).start();
        }
    }
}

class ServerReaderThread extends Thread{
    private Socket socket ;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        try{
            // 1.从socket通信管道中得到一个字节输入流读取客户端发来的图片数据！
            InputStream is = socket.getInputStream();
            // 2.包装成高级的缓冲字节输入流
            BufferedInputStream bis = new BufferedInputStream(is);
            // 3.定义一个缓冲字节输出流通向目标路径（服务端路径）
            BufferedOutputStream bos =
                    new BufferedOutputStream(new FileOutputStream(Constants.SERVER_DIR+ UUID.randomUUID().toString()+".jpg"));
            byte[] buffer = new byte[1024];
            int len ;
            while((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0 ,len);
            }
            bos.close();
            System.out.println("服务端接收完毕了！");

            // 4.响应数据给客户端
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println("您好，已成功接收您上传的图片！");
            ps.flush();

            Thread.sleep(100000); // 等消失发送完毕被客户端接收后死亡！
        }catch (Exception e){
            System.out.println(socket.getRemoteSocketAddress()+"下线了~~~~~~");
        }
    }
}

public class BSserverDemo {
    public static void main(String[] args) {
        try {
            // 1.注册端口
            ServerSocket ss = new ServerSocket(8080);
            // 2.创建一个循环接收多个客户端的请求。
            while(true){
                Socket socket = ss.accept();
                // 3.交给一个独立的线程来处理！
                new ServerReaderThread(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 响应消息数据给浏览器显示。
            // 浏览器是基于HTTP协议通信！响应格式必须满足HTTP协议数据格式的要求，浏览器
            // 才能够识别，否则响应消息浏览器根本不认识。
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println("HTTP/1.1 200 OK"); // 响应数据的响应头数据！
            ps.println("Content-Type:text/html;charset=UTF-8");//响应数据的类型。网页或者文本内容！
            ps.println(); // 必须换一行
            // 以下开始响应真实的数据！！
            ps.println("<span style='color:green;font-size:100px;'>牛逼的128期<span>");

            Thread.sleep(4000);
            ps.close();

        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}

1.BIO通信模式：同步阻塞式通信。（Socket网络编程也就是上面的通信架构）
            -- 同步：当前线程要自己进行数据的读写操作。（自己去银行取钱）
            -- 异步: 当前线程可以去做其他事情，（委托一小弟拿银行卡到银行取钱，然后给你）
            -- 阻塞： 在数据没有的情况下，还是要继续等待着读。（排队等待）
            -- 非阻塞：在数据没有的情况下，会去做其他事情，一旦有了数据再来获取。（柜台取款，取个号，然后坐在椅子上做其它事，等号广播会通知你办理）
                BIO表示同步阻塞式IO，服务器实现模式为一个连接一个线程，
                即客户端有连接请求时服务器端就需要启动一个线程进行处理，
                如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
                同步阻塞式性能极差：大量线程，大量阻塞。

    2.伪异步通信：引入了线程池。
            不需要一个客户端一个线程，可以实现1个线程复用来处理很多个客户端！
            这种架构，可以避免系统的死机，因为不会出现很多线程，线程可控。
            但是高并发下性能还是很差：a.线程数量少，数据依然是阻塞的。数据没有来线程还是要等待！

    3.NIO表示同步非阻塞IO，服务器实现模式为请求对应一个线程，
        即客户端发送的连接请求都会注册到多路复用器上，
        多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

         1个主线程专门负责接收客户端：
         1个线程[c1 ,s2 ,c3,c4, ,s2 ,c3,c4,,c3,c4, ,s2 ,c3,c4]轮询所有的客户端，发来了数据才会开启线程处理
         这种架构性能还可以！！
         同步：线程还是要不断的接收客户端连接，以及处理数据。
         非阻塞：如果一个管道没有数据，不需要等待，可以轮询下一个管道是否有数据！

    4.AIO表示异步非阻塞IO，服务器实现模式为一个有效请求一个线程，
        客户端的I/O请求都是由操作系统先完成IO操作后再通知服务器应用来启动线程进行处理。
        异步：服务端线程接收到了客户端管道以后就交给底层处理它的io通信。
             自己可以做其他事情。
        非阻塞：底层也是客户端有数据才会处理，有了数据以后处理好通知服务器应用来启动线程进行处理。

什么是Lambda表达式？
         Lambda表达式是JDK1.8开始之后的新技术，是一种代码的新语法。
         是一种特殊写法，
         作用：“核心目的是为了简化匿名内部类的代码写法”。

     Lambda表达式的格式:
        (匿名内部类被重写方法的形参列表) -> {
           被重写方法的方法体代码。
        }

        -> 就是一个新语法，没有实际含义，但是不能省略！

     Lambda表达式的使用前提：
         （1）Lambda表达式并不能简化所有匿名内部类的写法。
         （2）Lambda表达式只能简化接口中只有一个抽象方法的匿名内部类形式。

     Lambda表达式只能简化函数式接口的匿名内部类写法：
         a.首先必须是接口。
         b.接口中只能有一个抽象方法。
     小结：
        Lambda表达式只能简化接口中只有一个抽象方法的匿名内部类写法。
        接口中只有一个抽象方法的接口称为函数式接口。
        Lambda只能简化函数式接口的匿名内部类写法。

Lambda表达式简化Runnable接口的匿名内部类写法

     @FunctionalInterface函数式接口注解：
        一旦某个接口加上了这个注解，这个接口只能有且仅有一个抽象方法。
        这个接口就可以被Lambda表达式简化。
        
        public class LambdaDemo {
    public static void main(String[] args) {
         Thread t = new Thread(new Runnable() {
             @Override
             public void run() {
                System.out.println(Thread.currentThread().getName()+":执行~~~");
             }
         });
         t.start();

        Thread t1 = new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+":执行~~~");
        });
        t1.start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+":执行~~~");
        }).start();

        new Thread(() -> System.out.println(Thread.currentThread().getName()+":执行~~~")).start();
    }
}

Lambda简化Comparator接口匿名内部类写法

public class CollectionsDemo02 {
    public static void main(String[] args) {
        List<Student> lists = new ArrayList<>();
        Student s1 = new Student("李铭",18,'男');
        Student s2 = new Student("冯龙",23,'男');
        Student s3 = new Student("王乐乐",21,'男');
        Collections.addAll(lists , s1 , s2 , s3);

        // 按照年龄进行升序排序！
        Collections.sort(lists, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                return s1.getAge() - s2.getAge();
            }
        });

        // 简化写法
        Collections.sort(lists ,(Student t1, Student t2) -> {
                return t1.getAge() - t2.getAge();
        });

        Collections.sort(lists ,(Student t1, Student t2) -> t1.getAge() - t2.getAge());

        // 参数类型可以省略
        Collections.sort(lists ,( t1,  t2) -> t1.getAge() - t2.getAge());

        System.out.println(lists);


    }
}

1）如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号！
    （2）如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。
        此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写
    （3）参数类型可以省略不写。
    （4）如果只有一个参数，参数类型可以省略，同时()也可以省略。

public class LambdaDemo01 {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("胡伟光");
        names.add("甘挺");
        names.add("洪磊");

        names.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        names.forEach((String s) -> {
                System.out.println(s);
        });

        names.forEach((s) -> {
            System.out.println(s);
        });

        names.forEach(s -> {
            System.out.println(s);
        });

        names.forEach(s -> System.out.println(s) );

        names.forEach(System.out::println);


    }
}

方法引用：
             方法引用是为了进一步简化Lambda表达式的写法。
             方法引用的格式：类型或者对象::引用的方法。
     关键语法是：“::”

     小结：
        方法引用可以进一步简化Lambda表达式的写法。
        关键语法是：“::”

1.静态方法的引用。
       2.实例方法的引用。
       3.特定类型方法的引用。
       4.构造器引用。

1.静态方法的引用。
      引用格式：
         类名::静态方法。
      简化步骤：
         a.定义一个静态方法，把需要简化的代码放到一个静态方法中去。
      静态方法引用的注意事项
         ” 重要：被引用的方法的参数列表要和函数式接口中的抽象方法的参数列表一致。“
   小结：
        静态方法引用的格式： 类名::静态方法。
        重要：被引用的方法的参数列表要和函数式接口中的抽象方法的参数列表一致,才可以引用简化！

2.实例方法的引用
          格式： 对象::实例方法。
          简化步骤：
              a.定义一个实例方法，把需要的代码放到实例方法中去。
          实例方法引用的注意事项
             ” 重要：被引用的方法的参数列表要和函数式接口中的抽象方法的参数列表一致。“

3.特定类型方法的引用。
           特定类型：String ,任何类型。
           格式：特定类型::方法。
           注意：
              如果第一个参数列表中的形参中的第一个参数作为了后面的方法的调用者，
              并且其余参数作为后面方法的形参，那么就可以用特定类型方法引用了。

4.构造器引用。
     格式是：类名::new。
     注意点：前后参数一致的情况下，又在创建对象就可以使用构造器引用
     s -> new Student(s) => Student::new

  小结：
       方法引用是可遇不可求，能用则用，不能用就不要用！

什么是Stream流？
        在Java 8中，得益于Lambda所带来的函数式编程，
        引入了一个全新的Stream流概念 ，用于解决已有集合/数组类库有的弊端。

    Stream流能解决什么问题?
        可以解决已有集合类库或者数组API的弊端。
        Stream认为集合和数组操作的API很不好用，所以采用了Stream流简化集合和数组的操作！！

    小结：
        Stream流是用来简化集合类库或者数组API的弊端。
        Stream流其实就一根传送带，元素在上面可以被Stream流操作。

Stream流式思想的核心：
                 是先得到集合或者数组的Stream流（就是一根传送带）
                 然后就用这个Stream流操作集合或者数组的元素。
                 然后用Stream流简化替代集合操作的API.

     集合获取流的API:
         (1) default Stream<E> stream();

     小结：
         集合获取Stream流用: stream();
         数组：Arrays.stream(数组)   /  Stream.of(数组);

forEach : 逐一处理(遍历)
    count：统计个数
       -- long count();
    filter : 过滤元素
       -- Stream<T> filter(Predicate<? super T> predicate)
    limit : 取前几个元素
    skip : 跳过前几个
    map : 加工方法
    concat : 合并流。

public class StreamDemo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        list.stream().filter( s -> s.length() == 3 ).filter( s -> s.startsWith("张"))
                .forEach( System.out::println);
        // 统计数量
        long count = list.stream().filter( s -> s.length() == 3 )
                .filter( s -> s.startsWith("张")).count();
        System.out.println(count);
        // 取前2个
        list.stream().filter(s -> s.length() == 3).limit(2)
                .forEach( System.out::println);
        // 跳过前2个
        list.stream().filter(s -> s.length() == 3).skip(2)
                .forEach( s-> System.out.println(s));
                
           // 需求：把名称都加上“黑马的:+xxx”
        list.stream().map(a -> "黑马的："+a).forEach(System.out::println);

        // 需求：把名称都加工厂学生对象放上去!!
        // list.stream().map(name -> new Student(name)).forEach(System.out::println);

        list.stream().map(Student::new).forEach(System.out::println);
        
		 // 数组流
        Stream<Integer> s1 = Stream.of(10, 20 ,30 ,40);
        // 集合流
        Stream<String> s2 = list.stream();
        // 合并流
        Stream<Object> s3 = Stream.concat(s1,s2);
        s3.forEach(System.out::println);
        
    }
}

终结方法：一旦Stream调用了终结方法，流的操作就全部终结了，不能继续使用，
       只能创建新的Stream操作。
       终结方法： foreach , count。

   非终结方法：每次调用完成以后返回一个新的流对象,
       可以继续使用，支持链式编程！

引入：
        Stream的作用是：把集合转换成一根传送带，借用Stream流的强大功能进行的操作。
        但是实际开发中数据最终的形式还是应该是集合，最终Stream流操作完毕以后还是要转换成集合。
        这就是收集Stream流。

    收集Stream流的含义：就是把Stream流的数据转回到集合中去。

    Stream流：手段。
    集合：才是目的。

    小结：
        收集Stream流的含义：就是把Stream流的数据转回到集合中去。

    熟练函数式编程，如Lambda表达式简化函数式接口的匿名内部类形式，
    以及四种方法引用简化Lambda表达式，以及流式编程思想如Stream简化集合或者数组的操作。

public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        Stream<String> zhangLists = list.stream().filter(s -> s.startsWith("张"));
        // 把stream流转换成Set集合。
        Set<String> sets = zhangLists.collect(Collectors.toSet());
        System.out.println(sets);

        // 把stream流转换成List集合。
        Stream<String> zhangLists1 = list.stream().filter(s -> s.startsWith("张"));
        List<String> lists= zhangLists1.collect(Collectors.toList());
        System.out.println(lists);

        // 把stream流转换成数组。
        Stream<String> zhangLists2 = list.stream().filter(s -> s.startsWith("张"));
        Object[] arrs = zhangLists2.toArray();
        // 可以借用构造器引用申明转换成的数组类型！！！
        String[] arrs1 = zhangLists2.toArray(String[]::new);
    }
}