JAVA的IO的字符流、字节流、socket初步认识

一、字节流

InputStream和OutputStream

package com.ccj.pxj.javaIo;
import java.io.*;
/**
 * 字节流的读写操作
 */
public class InputOutStreamApp {
    public static void main(String[] args) {
        read();
        write();
    }
    private static void write() {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            fis=new FileInputStream(new File("data/data.txt"));
            fos=new FileOutputStream(new File("data/ww.txt"));
            byte[] buffer=new byte[1024];
            int length=0;
            while(fis.read(buffer,0,buffer.length)!=-1){
                fos.write(buffer,0,buffer.length);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    private static void read() {
        FileInputStream fis=null;
        try {
           fis= new FileInputStream(new File("data/data.txt"));
           byte[] buffer=new byte[1024];
           int length=0;
           while(fis.read(buffer,0,buffer.length)!=-1){
              String result = new String(buffer,0,buffer.length);
               System.out.println(result);
           }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(fis!=null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

二、字符流

Reader和Writer

package com.ccj.pxj.javaIo;
import java.io.*;
public class ReadWriteApp {
    public static void main(String[] args) {
        read();
        write();
    }
    private static void write() {
        FileWriter writer=null;
        try {
            writer=new FileWriter(new File("data/t.txt"));
            writer.write("I am pxj\n");
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(writer!=null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    private static void read() {
         FileReader reader = null;
        try {
             char[] chars = new char[1024];
            reader=new FileReader(new File("data/data.txt"));
            int length=0;
            while ((reader.read(chars,0,chars.length))!=-1){
                System.out.println(new String(chars,0,chars.length));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

三、字节流转字符流

package com.ccj.pxj.javaIo;
import java.io.*;
public class BufferApp {
    public static void main(String[] args) {
      read();
      write();
    }
    private static void write() {
        BufferedWriter Writer=null;
        try {
             Writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("data/a",true)));
             Writer.write("I like wfy\n");
            Writer.write("I like life\n");
            Writer.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(Writer!=null){
                try {
                    Writer.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    private static void read() {
        BufferedReader bufferedReader=null;
        try {
           bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("data/data.txt"))));
           String message=null;
           while ((message=bufferedReader.readLine())!=null){
               System.out.println(message);
           }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

四、socket

服务端

package com.ccj.pxj.wfy.serversocket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
    public static void main(String[] args) {
        int port=8888;
        ServerSocket serverSocket=null;
        try {
            serverSocket = new ServerSocket(port);
            System.out.println("服务端启动。监听的端口号是：" + port);
            while (true) {
                Socket socket = serverSocket.accept();
                System.out.println("客户端【" + socket.getPort() + "】已建立连接.....");
                //创建IO相关的
                BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
             //接收客户端发送过来的数据
                 String message ;
                 while ((message=reader.readLine())!=null){
                     System.out.println("客户端【" + socket.getPort() + "】发送过来的信息是：" + message);
                 //返回给客户端数据
                     writer.write("--"+message+"\n");
                     writer.flush();
                     //判断客户端是否退出
                     if(Constants.QUIT.equalsIgnoreCase(message)){
                         System.out.println("客户端【" + socket.getPort() + "】已退出");
                         break;
                     }
                 }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(serverSocket!=null){
                try {
                    serverSocket.close();
                    System.out.println("服务器关闭");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端

package com.ccj.pxj.wfy.serversocket;
import java.io.*;
import java.net.Socket;
public class Client {
    public static void main(String[] args) {
        int post=8888;
        String host="localhost";
        Socket socket=null;
        try {
//            创建客户端的socket
            socket = new Socket(host, post);
//            创建IO相关
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
//       将信息发送给服务器
                String requestMessage = consoleReader.readLine();
                writer.write(requestMessage + "\n");
                writer.flush();
//            服务器返回内容
                String responseMessage = reader.readLine();
                System.out.println("接收到服务器返回的数据" + responseMessage);
//                判断是否退出
                if(Constants.QUIT.equalsIgnoreCase(requestMessage)){
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(socket!=null){
                try {
                    socket.close();
                    System.out.println("客户端关闭");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

常量

package com.ccj.pxj.wfy.serversocket;
public class Constants {
   public   static  final  String QUIT="quit";
}

思考题：

Socket

Server
多个客户端去连接

==> QQ群
每个人发送一个信息，群里的”所有人“（在线的人）都应该能接收到

Java BIO

类似我们刚刚的CS的QQ群
Java BIO
每个Client说的话其他在线用户都能接收的到

设计
服务端
框：能维护所有在线用户
serverSocket.accept 框加一个用户
socket.close() 框移除这个用户
Map<Integer,Writer>
key: socket的port
writer：把消息转发给其他在线用户
线程：Handler implements Runnable
每接收到一个socket，就创建一个线程去处理该socket的通信
客户端
可以在控制台上输入信息，发送给服务端
不仅仅能说话，而且还能够接收到其他用户发送的信息
两个线程
一个是说话的
另外一个是用来接收其他用户发送过来的信息（展示在控制台上）

Java SE
IO(BIO/NIO/AIO) Thread Socket Collection
Netty

IO
字节流
InputStream
OutputStream
字符流
Reader
Writer