import org.junit.Test;

import java.io.*;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author lh
 * create 2019-12-13-19:30
 */
public class TCPtest1 {
    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        try {
            socket = new Socket("localhost", 8888);
            os = socket.getOutputStream();
            os.write("你好，我是客户端".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

    @Test
    public void server() {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
            //1.创建服务器端的ServerSocket，指明自己的端口号
            serverSocket = new ServerSocket(8888);
            //2.掉用accept()表示接收来自客户端的socke
            socket = serverSocket.accept();
            //3.获取输入流
            is = socket.getInputStream();

            byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len;
            while ((len = is.read(buffer)) != -1) {
                byteArrayOutputStream.write(buffer, 0, len);
            }
            System.out.println(byteArrayOutputStream.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (byteArrayOutputStream != null) {
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }


}

import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;
import org.junit.Test;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author lh
 * create 2019-12-13-20:20
 *
 * 这里就不做try catch了 实际是要的
 */
public class TCPtest2 {
    @Test
    public  void client() throws IOException {
        //1.
        Socket socket = new Socket("127.0.0.1",8889);
        //2.
        OutputStream os = socket.getOutputStream();
        //3.
        FileInputStream fis = new FileInputStream(new File("1.jpg"));
        //4.
        byte[] buffer = new byte[1024];
        int len ;
        while ((len = fis.read(buffer))!= -1) {
            os.write(buffer,0,len);
        }
        socket.shutdownOutput();
        //5.接收来自于服务器的信息
        InputStream inputStream = socket.getInputStream();
        ByteOutputStream byteOutputStream = new ByteOutputStream();
        byte[] buf= new byte[20];
        int lenth;
        while ((lenth = inputStream.read(buf)) != -1) {
            byteOutputStream.write(buf,0,lenth);
        }
        System.out.println(byteOutputStream.toString());
        //6.
        fis.close();
        os.close();
        socket.close();
    }

    @Test
    public void server() throws IOException {
        //1.
        ServerSocket ss = new ServerSocket(8889);
        //2.
        Socket socket = ss.accept();
        //3.
        InputStream is = socket.getInputStream();
        //4.
        FileOutputStream fileOutputStream = new FileOutputStream(new File("socket.jpg"));
        //5.
        byte[] buffer = new byte[1024];
        int len ;
        while ((len = is.read(buffer)) != -1) {
            fileOutputStream.write(buffer,0,len);
        }
        System.out.println("shoudao");
        //6.服务器给客户端反馈
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("服务器已经收到了".getBytes());
        //7.
        fileOutputStream.close();
        is.close();
        socket.close();
        ss.close();
    }
}

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

/**
 * TCP 实现客户端和服务器简单聊天
 * 客户端
 */
public class Client {
    public static void main(String[] args) throws IOException {
        // 指定服务器的IP地址     端口号
        Socket socket=new Socket("localhost",7832);
        System.out.println("***********客户端界面*************");
        System.out.println("与服务器连接成功！");
        InputStream is=socket.getInputStream();//得到Socket自带的输入流
        OutputStream os=socket.getOutputStream();//得到Socket自带的输出流

        BufferedReader br=new BufferedReader(new InputStreamReader(is));//将输入流 放入 缓存中
        PrintWriter pw=new PrintWriter(os,true);//通过输出流向服务器发消息

        Scanner input=new Scanner(System.in);
        String str=null;

        do{
            str=input.nextLine();
            pw.println(str);//发消息
            System.out.println("服务器："+br.readLine());//收消息
        }while (!str.equalsIgnoreCase("bye"));
    }
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**
 * TCP 实现客户端和服务器简单聊天
 * 服务器
 */
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server=new ServerSocket(7832);//Socket的服务器 并且指定端口号
        Socket socket=server.accept();//侦听连接请求，等待连接
        System.out.println("************服务器端界面************");
        System.out.println("与客户端连接成功！");
        InputStream ins=socket.getInputStream();//返回此套接字的输入流。
        OutputStream ous=socket.getOutputStream();//返回此套接字的输出流。

        BufferedReader br=new BufferedReader(new InputStreamReader(ins));//将客户端那边的信息 放入缓存流
        PrintWriter pw=new PrintWriter(ous,true);//通过Socket自带的流将数据输出到客户端

        Scanner input=new Scanner(System.in);
        String str=null;
        do{    //让客户端和服务器一直发送消息
            System.out.println("客户端："+br.readLine());//显示客户端的信息
            str=input.nextLine();
            pw.println(str);  //将信息输出到客户端
        }while (!str.equalsIgnoreCase("bye"));
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;


/**
 *
 * 客户端
 * 建两个类读、写
 */
public class Client1{

    public static void main(String[] args)  {
        try {

            Socket client = new Socket("127.0.0.1", 8888);
            System.out.println("***********客户端界面*************");
            System.out.println("与服务器连接成功！");
            new ClientRead(client).start();
            new ClientWrite(client).start();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

//读服务器信息
class ClientRead extends Thread {
    private Socket client;

    public ClientRead(Socket client) {
        this.client = client;
    }

    @Override
    public void run() {
        super.run();
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
            String line = "";
            while (true) {
                line = br.readLine();
                if (!line.isEmpty()) {
                    System.out.println("服务器说：" + line);
                }
                if (line.equals("bye")) {   //读到bye结束
                    System.out.println("聊天结束！");
                    return;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}
//写到服务器信息，回应
class ClientWrite extends Thread {
    private Socket client;

    public ClientWrite(Socket client) {
        this.client = client;
    }

    @Override
    public void run() {
        super.run();
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        try {
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
            String str = "";
            while (true) {
                str = input.readLine();
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;


/**
 *
 * 服务器
 * 建两个类，读写
 */
public class Server1 {

    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(8888);
            System.out.println("************服务器端界面************");
            Socket accept = ss.accept();
            System.out.println("与客户端连接成功！");
            new ServerRead(accept).start();
            new ServerWrite(accept).start();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
//读客户端信息线程
class ServerRead extends Thread {
    private Socket s;

    public ServerRead(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        super.run();
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
            String line = "";
            while (true) {
                line = br.readLine();
                if (!line.isEmpty()) {
                    System.out.println("客户端说：" + line);
                }
                if (line.equals("bye")) {   //读到bye结束
                    System.out.println("聊天结束！");
                    return;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//回应客户端信息线程，写
class ServerWrite extends Thread {
    private Socket socket;

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

    @Override
    public void run() {
        super.run();
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        try {
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            String str = "";
            while (true) {
                str = input.readLine();
                bw.write(str);
                bw.newLine();
                bw.flush();
            }

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

import org.junit.Test;

import javax.sql.DataSource;
import java.io.IOException;
import java.net.*;

/**
 * @author lh
 * create 2019-12-15-14:56
 */
public class UDPtest {
    @Test
    public void sender() throws IOException {
        DatagramSocket datagramSocket = new DatagramSocket();
        String str = "我是UDP发送";
        byte[] data = str.getBytes();
        InetAddress inetAddress = InetAddress.getLocalHost();

        DatagramPacket datagramPacket = new DatagramPacket(data, data.length, inetAddress, 9090);
        datagramSocket.send(datagramPacket);
        datagramSocket.close();
    }

    @Test
    public void receiver() throws IOException {
        DatagramSocket socket = new DatagramSocket(9090);
        byte[] buffer = new  byte[100];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
        socket.receive(packet);
        System.out.println(new String(packet.getData(),0,packet.getLength()));
    }
}

import java.lang.*;

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

/**
 * @author lh
 * create 2019-12-15-15:43
 * UDP 实现客户端和服务器简单聊天
 */
public class UDPClient {
        static DatagramSocket socket;
        private int port = 8080;
        static DatagramPacket packet;

        public static void main(String[] args) throws IOException {
            new UDPClient().service();
        }

        private void service() throws IOException {
            socket = new DatagramSocket();
            System.out.println("************客户端端界面************");
            int flag;
            while (true) {
                flag =send();
                if (flag == -1){
                    System.out.println("程序结束");
                    return;
                }
                receive();
            }
        }

        private int send() throws  IOException{
            Scanner input = new Scanner(System.in);
            String context = input.nextLine();
            byte[] bytes = context.getBytes();
            try {
                socket.connect(InetAddress.getByName("localhost"), port);
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
            packet = new DatagramPacket(bytes, bytes.length);
            try {
                socket.send(packet);
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("client:" + context);
            if (context.equals("bye")) {
                return -1;
            }else return 0;
        }

        private void receive() {
            byte[] b = new byte[100];
            packet = new DatagramPacket(b, 0, b.length);
            try {
                socket.receive(packet);
            } catch (IOException e) {
                e.printStackTrace();
            }
            byte[] data = packet.getData();
            System.out.println("server:" + new String(data));
            if (new String(data).equals("bye")) {
                System.out.println("程序结束");
                return;
            }
        }



}

package IO;

import org.junit.Test;
import sun.reflect.generics.tree.VoidDescriptor;

import javax.annotation.processing.Filer;
import java.io.*;

/**
 * @author lh
 * create 2019-11-28-19:54
 */
public class FileReaderWriterTest {
    /*
    1.read的理解：返回读入的一个字符，如果达到文件末尾，返回-1；  如：读a 返回97，所以我们可以使用（char）转一下，就是a了
    2.异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
    3.读入的文件要存在，不然报异常
     */

    @Test
    public void testFileReader() {
        FileReader fileReader = null;
        try {
            //1.实例对象
            File file = new File("hello.txt");
            //2.提供具体的流
            fileReader = new FileReader(file);

            //3.数据读入
            int data;
            while ((data = fileReader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null)
                    fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //对read（）操作升级：使用read的重载方法
    @Test
    public void testFileReadeer1() {
        FileReader fileReader = null;
        try {
            File file = new File("hello.txt");
            fileReader = new FileReader(file);

            char[] cbuf = new char[5];
            int len;
            while ((len = fileReader.read(cbuf)) != -1) {
//方式一：
                //错误的写法，因为数组是覆盖的写入，空的没进行覆盖，就会输出之前的字符
//                for (int i = 0; i < cbuf.length; i++) {
//                    System.out.print(cbuf[i]);
//                }
                //输出：
                /*
                hello word

                hello123lo1
                 */
//                for (int i = 0; i < len; i++) {   //正确写法
//                    System.out.print(cbuf[i]);
//                }
//方式二:
                //错误的,和上面错误一样
//                String str = new String(cbuf);
//                System.out.print(str);
                //正确写法：
                String str = new String(cbuf, 0, len);
                System.out.print(str);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null) {

                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }


    }

    /*
        输出操作对应的file可以不存在，在输出的过程中自动创建。
         如果存在，
            1.如果构造器是：FileWriter(file,false)或者FileWriter(file) :
            覆盖。(文件覆盖，就算覆盖前文件比较长，也全覆盖。)
            2.如果构造器是：FileWriter(file,true)，原有的基础上追加输出

    */
    @Test
    public void testFileWrite() {
        FileWriter fw = null;
        try {
            File file = new File("hello1.txt");
            fw = new FileWriter(file, false);
            fw.write("have gg");
//    fw.write("good" );
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close(); //不关闭的话，会发现文件创建了但是空的。
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    @Test
    public void testFileReaderWriter() throws IOException {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            File src = new File("hello.txt");
            File des = new File("hello2.txt");

            fr = new FileReader(src);
            fw = new FileWriter(des);

            //数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;
            while ((len = fr.read(cbuf))!= -1 ){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            //1.
            /*
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
             */

            //2
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

package IO;

import org.junit.Test;

import java.io.*;

/**
 * @author lh
 * create 2019-11-26-20:16
 */
public class FileIOstream {
    @Test
    //使用字节流 FileInput处理字节文件可能出现乱码
    public void testFileInputOutputStreamTest()  {
        FileInputStream fileInputStream = null;
        FileInputStream fis = null;

        try {
            //1.造文件
            File file = new File("hello.txt");

            //2.造流
            fis = new FileInputStream(file);

            //3.读数据
            byte[] buffer = new byte[5];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                String str = new String(buffer, 0, len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    /*
    实现对图的复制操作
     */
    public  void testFileInputOutputStream(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File src = new File("1.jpg");
            File des = new File("2.jpg");

            fis = new FileInputStream(src);
            fos = new FileOutputStream(des);

            //复制
            int len;
            byte[] buffer =new byte[5];
            while ((len = fis.read(buffer)) != -1) {

                fos.write(buffer,0,len);
                //因为不能字节输出数组到屏幕，所以创建一个str字符串来获取数据用以输出或者for来完成，但是write有处理数组的能力所以不用。
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //指定路径改下文件的复制
    public void copeFile(String srcpath,String despath){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File src = new File(srcpath);
            File des = new File(despath);

            fis = new FileInputStream(src);
            fos = new FileOutputStream(des);

            //复制
            int len;
            byte[] buffer =new byte[1024];
            while ((len = fis.read(buffer)) != -1) {

                fos.write(buffer,0,len);
                //因为不能字节输出数组到屏幕，所以创建一个str字符串来获取数据用以输出或者for来完成，但是write有处理数组的能力所以不用。
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    @Test
    public void testCopefile(){
        long start = System.currentTimeMillis();
        String srcpath = "C:\\Users\\华\\Desktop\\1.avi";
        String descpath = "C:\\Users\\华\\Desktop\\2.avi";
        copeFile(srcpath,descpath);

        long end =System.currentTimeMillis();

        System.out.println("复制操作花费的时间为" +(end - start));
    }
}

//指定路径改下文件的复制
public void copeFile(String srcpath,String despath){
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        File src = new File(srcpath);
        File des = new File(despath);

        fis = new FileInputStream(src);
        fos = new FileOutputStream(des);

        //复制
        int len;
        byte[] buffer =new byte[1024];
        while ((len = fis.read(buffer)) != -1) {

            fos.write(buffer,0,len);
            //因为不能字节输出数组到屏幕，所以创建一个str字符串来获取数据用以输出或者for来完成，但是write有处理数组的能力所以不用。
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}
@Test
public void testCopefile(){ 
    long start = System.currentTimeMillis();
    String srcpath = "C:\\Users\\华\\Desktop\\1.avi";
    String descpath = "C:\\Users\\华\\Desktop\\2.avi";
    copeFile(srcpath,descpath);

    long end =System.currentTimeMillis();

    System.out.println("复制操作花费的时间为" +(end - start));
}

package IO;

import org.junit.Test;

import java.io.*;

/**
 * 1.
 * BufferedInputStream
 * BufferedOutputStream
 * BufferedReader
 * BufeeredWriter
 * <p>
 * 2.作用：
 * 提供流的读取，写入的速度
 * <p>
 * 3.处理流，就是“套接”在已有的流的基础上
 *
 * @author lh
 * create 2019-11-29-19:03
 */
public class BufferedTest {
    /*
    实现非文件的复制
     */
    @Test
    public void testcopy() {
        long start = System.currentTimeMillis();
        String srcpath = "C:\\Users\\华\\Desktop\\1.avi";
        String descpath = "C:\\Users\\华\\Desktop\\3.avi";
        copyBufferedStreamTest(srcpath, descpath);
        long end = System.currentTimeMillis();

        System.out.println("复制操作花费的时间为" + (end - start));
    }

    public void copyBufferedStreamTest(String srcpath, String despath) {
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;


        try {
            //1.造文件
            File srcf = new File(srcpath);
            File descf = new File(despath);

            //2.造流
            //2.1 造节点流
            FileInputStream fileInputStream = new FileInputStream(srcf);
            FileOutputStream fileOutputStream = new FileOutputStream(descf);

            //2.2造缓冲流
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);


            //3.复制的细节：读取，写入
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bufferedInputStream.read(buffer)) != -1) {
                bufferedOutputStream.write(buffer, 0, len);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //资源的关闭
            //要求：先关闭外层的流，再关闭，内层的流
            if (bufferedInputStream != null) {

                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedInputStream != null) {
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            //说明：在关闭外层的流的同时，内层流也会自动的进行关闭。关于内层流的关闭，可以省略
//        fileInputStream.close();
//        fileOutputStream.close();
        }

    }

    @Test
    public void testBufferedRW() {
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;

        try {
    /*
    使用BufferedReader和BufferedWriter
     */
            bufferedReader = new BufferedReader(new FileReader(new File("hello.txt")));
            bufferedWriter = new BufferedWriter(new FileWriter(new File("hello3.txt")));

            //读写
//            //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//
//            int len;
//            while ((len = bufferedReader.read(cbuf)) != -1) {
//                bufferedWriter.write(cbuf, 0, len);
//                //            bufferedWriter.flush();
//            }

            //方式二
            String data;
            while ((data = bufferedReader.readLine()) != null) {
//                //方法一
//                bufferedWriter.write(data +"\n");  //data中不包含换行符

                //方法二
                bufferedWriter.write(data);
                bufferedWriter.newLine();

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedWriter != null) {
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package IO;
import org.junit.Test;

import java.io.*;

/**
 * 处理流之二:转换流的使用
 * 1.转换流 ：属于字符流
 * InputStreamReader：将一个字节的输入流转换为字符的输入流
 * OutputSreamWriter：将一个字符的输出流转换为字节的输出流
 * <p>
 * 2.作用：提供字节流与字符流之间的转换
 * <p>
 * 3.解码：字节、字节数组 -->字符数组、字符串
 * 编码：字符数组、字符串 -->字节、字节数组
 *
 * 4.字符集
 * ASCII美国信息交换标准代码。
 *  用1个字节的7可以表示。
 *  ISO8859-1：拉丁码表。欧洲码表
 *  用一个字节的8位表示。
 *  GB2312：中国中文编码表。最多两个字节编码所有字符。
 *  GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码。
 *  Unicode：国际标准编码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。2 16
 *  UTF-8：变长的编码方式，可以用1-4个字节来表示一个字符。(中文3个字节）
 *
 *
 * @author lh
 * create 2019-11-30-12:42
 */
public class InputsreamReaderTest {
    @Test
    //实现字节输入流到字符输出流的转换
    //处理异常应该使用try-chatch-finnally，这里就不改了
    public void test1() throws IOException {
        FileInputStream fis = new FileInputStream("dbcp.txt");
//    InputStreamReader isr =new InputStreamReader(fis);//使用系统默认的字符集
        //参数2指明了字符集
        InputStreamReader isr = new InputStreamReader(fis, "UTF-8");  //使用哪个字符集取决于文件本身的字符集

        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            String str = new String(cbuf, 0, len);
            System.out.print(str);
        }
        if (isr != null) {
            isr.close();
        }
    }

    @Test
    //处理异常应该使用try-chatch-finnally，这里就不改了
    public void test2() throws IOException {
        //1.造文件、造流
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw= new OutputStreamWriter(fos,"gbk");

        //2.读写过程
        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            osw.write(cbuf, 0, len);
        }

        //3.关闭
        isr.close();
        osw.close();
        //关闭操作时要注意关闭的对象，关错了会导致复制的文件为空。

    }
}

package IO;

import org.junit.Test;


import javax.naming.Name;
import javax.swing.*;
import java.io.*;

/**
 * 数据流：用于读取或写入基本数据类型的变量或字符串
 * @author lh
 * create 2019-11-30-17:07
 */
public class DataStream {
    @Test
    //将内存中的字符串、基本数据类型的变量写出到文件中
    public void test1() throws IOException {
        //1.
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

        //2.
        dos.writeUTF("小王");
        dos.flush();  //刷新操作，将内存中的数据写入文件
        dos.writeInt(23);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();

        //3.
        dos.close();
    }
    /*
    将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。
    注意点:读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致。
     */
    @Test
    public void test2() throws IOException {
        //1.
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

        //2.
        String str = dis.readUTF();
        int age = dis.readInt();
        boolean ismale = dis.readBoolean();

        System.out.println("name = " + str);
        System.out.println("age = " + age);
        System.out.println("is male ="+ ismale);
    }
}

public Thread(Runnable target) {
     init(null, target, "Thread-" + nextThreadNum(), 0);
 }

@Override
   public void run() {
       if (target != null) {
           target.run();
       }
   }

class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread =new MyThread();
        Thread t1 = new Thread(myThread) ;
        t1.start();

        Thread t2 = new Thread(myThread) ;
        t2.start();
    }


}