s-day11-TCP服务器端代码的实现

s-day10/src/com/inmind/buffered01/Demo01.java

@@ -0,0 +1,79 @@
+package com.inmind.buffered01;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+/*
+1.缓冲流的介绍
+缓冲流：基于字节字符流，本身本身没有读写功能，底层封装了一8192长度的缓冲区（数组），提高读写效率，也叫高效流
+
+字节缓冲流： BufferedInputStream BufferedOutputStream
+字符缓冲流： BufferedReader   BufferedWriter
+------------------------------------------------------------------------------------
+字节缓冲流的基本使用以及使用缓冲流复制文件（一次读写一个字节）
+  字节缓冲输入流：BufferedInputStream
+    构造方法：
+    BufferedInputStream(InputStream in) 创建一个 BufferedInputStream并保存其参数，输入流 in供以后使用。
+    常用方法：
+    int read()  ：读取一个字节数据
+    int read(byte[] bytes) ： 读取一个字节数组
+
+ 字节缓冲输出流：BufferedOutputStream
+    构造方法：
+    BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
+    常用方法：
+    void write(int b) 将指定的字节写入缓冲的输出流。
+    public void write(byte[] b)
+    void write(byte[] b, int off, int len) 从偏移量 off开始的指定字节数组写入 len字节到缓冲输出流。
+
+ */
+public class Demo01 {
+    public static void main(String[] args) throws Exception {
+        //使用缓冲流复制文件
+        //创建字节缓冲输入流
+        FileInputStream fis = new FileInputStream("1.jpg");
+        BufferedInputStream bis = new BufferedInputStream(fis);
+        //创建字节缓冲输出流
+        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2.jpg"));
+        long start = System.currentTimeMillis();
+        //缓冲流一次读写一个字节,使用43ms
+        int c ;//保存读取的一个字节数据
+        //缓冲流不停读写
+        while ((c = bis.read()) != -1) {
+            bos.write(c);
+        }
+        long end = System.currentTimeMillis();
+        System.out.println("复制所需的毫秒值："+(end-start));
+
+        bis.close();
+        bos.close();
+
+    }
+
+
+
+
+
+
+    //使用字节输入输出流进行一次读写一个字节，复制文件  6477ms
+    public static void method(String[] args)throws Exception {
+        //1.创建字节输入流
+        FileInputStream fis = new FileInputStream("D:\\io_test\\upload\\1.jpg");
+        //2.创建字节输出流
+        FileOutputStream fos = new FileOutputStream("1.jpg");
+        //3.不停地读写到另一个文件中（边读边写）
+        long start = System.currentTimeMillis();
+        //方式一：一次读写一个字节
+        int c;//用来记录读取的字节数据
+        while ((c = fis.read()) != -1) {
+            fos.write(c);
+        }
+        long end = System.currentTimeMillis();
+        System.out.println("复制所需的毫秒值："+(end-start));
+        //4.资源释放
+        fis.close();
+        fos.close();
+    }
+}

s-day10/src/com/inmind/buffered01/Demo02.java

@@ -0,0 +1,29 @@
+package com.inmind.buffered01;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+/*
+字节缓冲流一次读写一个字节数组的方式复制文件
+ */
+public class Demo02 {
+    public static void main(String[] args) throws Exception {
+        //创建字节缓冲输入输出流
+        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("2.jpg"));
+        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("3.jpg"));
+        //一次读写一个字节数组,
+        byte[] bytes = new byte[1024];
+        long start = System.currentTimeMillis();
+        int len;
+        while ((len = bis.read(bytes)) != -1) {
+            bos.write(bytes, 0, len);
+        }
+        long end = System.currentTimeMillis();
+        System.out.println("复制所用时间："+(end - start));//3ms
+
+        bis.close();
+        bos.close();
+    }
+}

s-day10/src/com/inmind/buffered01/Demo03.java

@@ -0,0 +1,64 @@
+package com.inmind.buffered01;
+
+import java.io.*;
+
+/*
+字符缓冲流的基本使用
+    字符缓冲流： BufferedReader ， BufferedWriter
+    字符缓冲输入流：BufferedReader
+    构造方法
+    BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
+
+    常用方法：
+    int read() 读一个字符
+    int read(char[] cbuf) 将字符读入数组。
+
+
+    字符缓冲输出流：BufferedWriter
+    构造方法：
+    BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
+
+    常用方法：
+    void write(int c) 写一个字符
+    void write(char[] cbuf) 写入字符数组的一部分。
+    void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
+    void write(String s) 写一个字符串的一部分。
+    void write(String s, int off, int len) 写一个字符串的一部分。
+
+    注意：
+    	1.字符缓冲流的基本使用与昨天的字符流一模一样
+    	2.字符缓冲流就是底层封装了一个8192的字符数组，提高字符流的读写效率
+ */
+public class Demo03 {
+
+    //字符缓冲输出流写字符的基本操作，与字符流一模一样
+    public static void main(String[] args) throws Exception {
+        BufferedWriter bw = new BufferedWriter(new FileWriter("source2.txt"));
+        bw.write('我');
+        char[] chars = {'爱', '中', '国'};
+        bw.write(chars);
+        bw.write(chars,1,2);
+        bw.write("外面又在下暴雨了");
+        bw.flush();
+        bw.close();
+    }
+
+
+    //字符缓冲输入流读取字符的基本操作，与字符流一模一样
+    public static void method(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new FileReader("source1.txt"));
+        //一次读取一个字符
+        /*int ch;//保存读取的字符数据
+        while ((ch = br.read()) != -1) {
+            System.out.println((char) ch);
+        }*/
+        //一次读取一个字符数组
+        char[] chars = new char[1024];
+        int len;
+        while ((len = br.read(chars)) != -1) {
+            System.out.println(new String(chars,0,len));
+        }
+
+        br.close();
+    }
+}

s-day10/src/com/inmind/buffered01/Demo04.java

@@ -0,0 +1,50 @@
+package com.inmind.buffered01;
+
+import java.io.*;
+
+/*
+字符缓冲流中特有的功能
+    BufferedWriter: newLine 它能够进行多个系统之间的换行的兼容
+
+    BufferedReader: readLine 它能够将文件中的内容按一行文本来读取
+ */
+public class Demo04 {
+    public static void main(String[] args) throws Exception {
+        /*
+        字符缓冲输入流,一次读取一行文本
+        String readLine() 读一行文字。
+         */
+//        BufferedReader br = new BufferedReader(new FileReader("source2.txt"));
+        BufferedReader br = new BufferedReader(new FileReader("s-day10\\src\\com\\inmind\\buffered01\\Demo01.java"));
+        /*String line = br.readLine();
+        System.out.println(line);
+
+        line = br.readLine();
+        System.out.println(line);
+
+        line = br.readLine();
+        System.out.println(line);
+
+        line = br.readLine();
+        System.out.println(line);*/
+        String line;//用来保存读取一行的文本
+        while ((line = br.readLine()) != null) {
+            System.out.println(line);
+        }
+
+        br.close();
+
+    }
+
+    //BufferedWriter: newLine 它能够进行多个系统之间的换行的兼容
+    public static void method(String[] args) throws Exception {
+        //使用字符缓冲输出流,输出我是谁我在哪我干嘛
+        BufferedWriter bw = new BufferedWriter(new FileWriter("source2.txt"));
+        bw.write("我是谁");
+        bw.newLine();
+        bw.write("我在哪");
+        bw.newLine();
+        bw.write("我在干嘛");
+        bw.close();//调用flush输出内容
+    }
+}

s-day10/src/com/inmind/buffered01/Test05.java

@@ -0,0 +1,54 @@
+package com.inmind.buffered01;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.HashMap;
+
+/*
+字符缓冲流的练习(文本排序)【BufferedReader  BufferedWriter】
+    3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
+    8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
+    4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
+    2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
+    1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
+    9.今当远离，临表涕零，不知所言。
+    6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
+    7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
+    5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也
+
+    实现分析:
+        1.创建一个Map对象保存键值对,9---->今当远离，临表涕零，不知所言
+        2.创建字符缓冲输入流对象,读取每行文本（readLine）
+        3.读到每行文本时,按.切割,左边作为key,右边的文本就作为值,保存到map
+        4.根据1~9的顺序,将Map中的文本数据输出到文件中,每行要换行（newLine）
+
+*/
+public class Test05 {
+    public static void main(String[] args) throws Exception {
+        //1.创建一个Map对象保存键值对,9---->今当远离，临表涕零，不知所言
+        HashMap<String, String> maps = new HashMap<>();
+        //2.创建字符缓冲输入流对象,读取每行文本（readLine）
+        BufferedReader br = new BufferedReader(new FileReader("source2.txt"));
+        //3.读到每行文本时,按.切割,左边作为key,右边的文本就作为值,保存到map
+        String line;
+        while ((line = br.readLine()) != null) {
+            //.表示正则中的每个字符，会把所有内容切割掉
+            String[] values = line.split("\\.");
+            maps.put(values[0], values[1]);//9---->今当远离，临表涕零，不知所言
+        }
+        System.out.println(maps.size());
+        System.out.println(maps);
+        //4.根据1~9的顺序,将Map中的文本数据输出到文件中,每行要换行（newLine）
+        BufferedWriter bw = new BufferedWriter(new FileWriter("source1.txt"));
+        for (int i = 1; i <= 9; i++) {
+            String s = maps.get(i+"");
+            bw.write(i+"-"+s);
+            bw.newLine();
+            bw.flush();
+        }
+        br.close();
+        bw.close();
+    }
+}

s-day10/src/com/inmind/object_stream03/Demo09.java

@@ -0,0 +1,26 @@
+package com.inmind.object_stream03;
+
+import java.io.FileOutputStream;
+import java.io.ObjectOutputStream;
+
+/*
+序列化流保存对象(ObjectOutputStream)
+构造方法：
+     ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。
+
+ 常用方法：
+    void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
+
+
+ */
+public class Demo09 {
+    public static void main(String[] args) throws Exception {
+        Student student = new Student("张三", 18,"123456");
+        //获取序列化流对象，写出对象（将对象保存到文件中）
+        FileOutputStream fos = new FileOutputStream("student.txt");
+        ObjectOutputStream oos = new ObjectOutputStream(fos);
+        //注意：如果要序列化对象，对应的类，必须支持序列化操作，也就是实现Serializable，类似一个标记的功能，表示可以序列化
+        oos.writeObject(student);
+        oos.close();
+    }
+}

s-day10/src/com/inmind/object_stream03/Demo10.java

@@ -0,0 +1,25 @@
+package com.inmind.object_stream03;
+
+import java.io.*;
+
+/*
+反序列化流读取对象(ObjectInputStream)
+构造方法：
+    ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。
+
+常用方法：
+    Object readObject() 从ObjectInputStream读取一个对象。
+
+ */
+public class Demo10 {
+    public static void main(String[] args) throws Exception {
+        //使用反序列化流读取之前保存的学生对象
+        FileInputStream fis = new FileInputStream("student.txt");
+        ObjectInputStream ois = new ObjectInputStream(fis);
+        Object o = ois.readObject();//多态：父类引用指向子类对象
+        if (o instanceof Student) {
+            Student s = (Student) o;
+            System.out.println(s);
+        }
+    }
+}

s-day10/src/com/inmind/object_stream03/Student.java

@@ -0,0 +1,46 @@
+package com.inmind.object_stream03;
+
+import java.io.Serial;
+import java.io.Serializable;
+
+public class Student implements Serializable {
+    @Serial
+    //固定一个序列化版本号即可
+    private static final long serialVersionUID = 2840703362371023312L;
+
+    String name;
+    int age;
+    /*
+    注意：
+    1.静态内容只跟类有关，跟对象无关，所以序列化时静态内容不能被保存的
+    2.transient表示瞬态，瞬间的值，被它修饰的成员变量，就不能序列化
+     */
+
+    //static String password;//针对静态数据不能保存下来，但是会被共享，不符合业务
+    transient String password;//瞬态，该变量就不会被序列化
+
+    public Student(String name, int age, String password) {
+        this.name = name;
+        this.age = age;
+        this.password = password;
+    }
+
+    @Override
+    public String toString() {
+        return "Student{" +
+                "name='" + name + '\'' +
+                ", age=" + age +
+                ", password='" + password + '\'' +
+                '}';
+    }
+
+    public Student(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+
+    public void method(){
+        System.out.println(1);
+    }
+}

s-day10/src/com/inmind/object_stream03/Test11.java

@@ -0,0 +1,38 @@
+package com.inmind.object_stream03;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+
+/*
+序列化流的练习
+
+需求:
+1. 将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。
+2. 反序列化list.txt ，并遍历集合，打印对象信息。
+ */
+public class Test11 {
+    public static void main(String[] args) throws Exception {
+        //1. 将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。
+        ArrayList<Student> lists = new ArrayList<>();
+        lists.add(new Student("张三1", 18));
+        lists.add(new Student("张三2", 19));
+        lists.add(new Student("张三3", 20));
+        lists.add(new Student("张三4", 21));
+
+        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
+        oos.writeObject(lists);
+        oos.close();
+        //2. 反序列化list.txt ，并遍历集合，打印对象信息。
+        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
+        Object o = ois.readObject();
+        if (o instanceof ArrayList) {
+            ArrayList<Student> students = (ArrayList<Student>) o;
+            for (Student s : students) {
+                System.out.println(s);
+            }
+        }
+    }
+}

s-day10/src/com/inmind/print_stream04/Demo12.java

@@ -0,0 +1,29 @@
+package com.inmind.print_stream04;
+
+import java.io.PrintStream;
+
+/*
+打印流的基本使用(PrintStream)(了解)
+构造方法
+PrintStream(String fileName) 使用指定的文件名创建新的打印流，无需自动换行
+
+常用方法：
+print():直接输出内容，但不换行
+println():直接输出内容，但换行
+
+ */
+public class Demo12 {
+    public static void main(String[] args) throws Exception {
+        //往相对路径dest.txt中打印字符串
+        PrintStream ps = new PrintStream("dest.txt");
+        //调用打印输出功能
+        ps.println("我是谁");
+        ps.println("我在哪");
+        ps.print("我在干嘛");
+        ps.close();
+
+//        System.setOut(ps); 不要这么做
+
+        System.out.println("我是System打印的");
+    }
+}

s-day10/src/com/inmind/print_stream04/Demo13.java

@@ -0,0 +1,37 @@
+package com.inmind.print_stream04;
+/*
+IO流：字节流和字符流
+字节输入输出流：
+    InputStream
+    OutputSteam
+常用子类：
+    FileInputStream
+    FileOutputSteam
+
+
+字符输入输出流：
+    Reader
+    Writer
+常用子类：
+    FileReader
+    FileWriter
+
+
+字节缓冲流：底层封装了个8192的数组提高读写效率
+    BufferedInputStream
+    BufferedOutputSteam
+字符缓冲流：
+    BufferedReader
+    BufferedWriter
+
+转换流：可以根据指定的编码方式进行读写数据（GBK UTF-8）
+InputStreamReader
+OutputSteamWriter
+
+序列化流：
+ObjectInputStream
+ObjectOutputSteam
+
+ */
+public class Demo13 {
+}

s-day10/src/com/inmind/transfer_stream02/Demo06.java

@@ -0,0 +1,27 @@
+package com.inmind.transfer_stream02;
+
+import java.io.FileReader;
+
+/*
+    使用字符流,读取电脑中的文件数据到java内存
+
+    出现乱码的原因:中文数据在读写操作的前后的编码方式不一致.
+    注意：
+        1.UTF-8，字母和数字只占1个字节，而一个中文占3个字节，它的前128个字符完全兼容ASCII码表
+        2.GBK，字母和数字只占1个字节，而一个中文占2个字节，它的前128个字符完全兼容ASCII码表
+ */
+public class Demo06 {
+    public static void main(String[] args) throws Exception {
+        //字符输入流
+//        FileReader fr = new FileReader("D:\\io_test\\file_gbk.txt");//gbk编码，utf-8解码出现了乱码
+        FileReader fr = new FileReader("D:\\io_test\\file_utf8.txt");
+        //一次读取一个字符数组的方式
+        char[] chars = new char[1024];
+        int len;
+        while ((len = fr.read(chars)) != -1) {
+            System.out.println(new String(chars,0,len));
+        }
+
+        fr.close();
+    }
+}

s-day10/src/com/inmind/transfer_stream02/Demo07.java

@@ -0,0 +1,81 @@
+package com.inmind.transfer_stream02;
+
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+
+/*
+9.编码表的介绍
+编码：将字符转换成字节（类似加密）
+解码：将字节转换成字符（类似解密）
+
+编码表：将每个国家的文字和二进制对应起来
+
+ASCII 使用1个字节表示字符（第一位一定是0表示正数），0~127
+ISO-8859-1 使用1个字节表示字符，包扩了ASCII的，表示拉丁，欧洲的语言，不包含中文
+
+gb2312: 使用2个字节表示1个字符，7000个简体中文和符号
+big5:  使用2个字节表示繁体字，片假名
+
+GBK（国标码），使用2个字节表示1个字符，涵盖2万多个中文，繁体字完全兼容ASCII
+
+unicode（万国码） u+0000到U+10FFFF的字符，包含110万字符，包含所有国家的文字
+
+utf-8 :使用1,2,3,4个字节表示字符（3个字节表示1个中文）
+
+utf-16 :使用2 ，4个字节表示字符
+
+utf-32 :使用4个字节表示字符，比较占用内存
+
+注意:
+    1.GBK针对国内的字符进行编解码操作,它前128个字符完全兼容ascii,一个中文占2个字节
+    2.utf-8针对国际的字符进行编解码操作,它前128个字符完全兼容ascii,一个中文占3个字节
+-------------------------------------------------------------------------------
+转换流_指定编码读取(InputStreamReader)
+
+InputStreamReader是从字节流到字符流的桥梁:解码
+
+构造方法：
+    InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
+    InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。
+
+常用方法：
+    close()
+    int read();
+    int read(char[]  chars)
+
+ 注意:转换流的作用是指定编码方式去读写文件
+
+
+ */
+public class Demo07 {
+    //指定GBK编码方式去读取指定文件
+    public static void main(String[] args) throws Exception {
+        //创建转换输入流，并指定gbk编码
+        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\io_test\\file_gbk.txt"),"GBK");
+        char[] chars = new char[1024];
+        int len;
+        while ((len = isr.read(chars)) != -1) {
+            System.out.println(new String(chars,0,len));
+        }
+
+        isr.close();
+    }
+
+
+    //指定utf-8编码方式去读取指定文件
+    public static void method() throws Exception {
+        /*
+        创建转换输入流
+        InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
+         */
+//        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\io_test\\file_utf8.txt"));
+        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\io_test\\file_utf8.txt"),"utf-8");
+        //一次读一个字符或者字符数组
+        int ch ;
+        while ((ch = isr.read())!=-1){
+            System.out.print((char) ch);
+        }
+
+        isr.close();
+    }
+}

s-day10/src/com/inmind/transfer_stream02/Demo08.java

@@ -0,0 +1,43 @@
+package com.inmind.transfer_stream02;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+
+/*
+转换流_按照指定编码写数据(OutputStreamWriter)
+OutputStreamWriter是从字符流到字节流的桥梁: 编码
+
+构造方法：
+    OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
+    OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。
+
+常用方法：
+    close
+    flush
+    void write(char[] cbuf) 写入一个字符数组。
+    abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
+    void write(int c) 写一个字符
+    void write(String str) 写一个字符串
+    void write(String str, int off, int len) 写一个字符串的一部分。
+
+
+ */
+public class Demo08 {
+    //使用转换输出流,指定utf-8编码方式输出内容到文件中
+    public static void main(String[] args) throws Exception{
+        FileOutputStream fos = new FileOutputStream("D:\\io_test\\file_utf81.txt");
+//        OutputStreamWriter osw = new OutputStreamWriter(fos);
+        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
+        osw.write("呵呵，今天不下雨了，abc123");
+        osw.flush();
+        osw.close();
+    }
+    //使用转换输出流,指定GBK编码方式输出内容到文件中
+    public static void method() throws Exception {
+        FileOutputStream fos = new FileOutputStream("D:\\io_test\\file_gbk1.txt");
+        OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
+        osw.write("呵呵，今天不下雨了，abc123");
+        osw.flush();
+        osw.close();
+    }
+}

s-day11/src/com/inmind/network01/Demo01.java

@@ -0,0 +1,21 @@
+package com.inmind.network01;
+/*
+软件架构的分类：
+C(client)/S(server):需要安装一个客户端，才能获取一些服务，比如桌面版腾讯会议，QQ，微信，爱奇艺，LOL（这不是我们今后的）
+B(browser)/S(server):只需要一个浏览器，就可以获取一些服务，比如百度，淘宝，京东，爱奇艺网站（这是javaWEB方向）
+
+网络编程--协议介绍：
+	HTTP（HyperText Transfer Protocol，超文本传输协议）：用于在万维网（WWW）中传输超文本数据，是浏览网页、获取网络资源的基础协议，比如你在浏览器中访问网页，就是通过 HTTP 协议进行数据交互 。
+
+	FTP（File Transfer Protocol，文件传输协议）：专门用于在网络上进行文件的传输，支持用户上传、下载文件到 FTP 服务器，常被用于网站文件更新、资源共享等场景，像一些站长会用 FTP 工具向网站服务器上传网页文件 。
+
+	TFTP（Trivial File Transfer Protocol，简单文件传输协议）：相较于 FTP 更简单、轻量，不具备复杂的权限管理等功能，适用于对传输要求不高、简单的文件传输场景，比如在小型网络设备（路由器等）配置文件传输中可能会用到 。
+
+	SMTP（Simple Mail Transfer Protocol，简单邮件传输协议）：主要负责电子邮件的发送，把用户撰写的邮件从发件方邮件客户端或服务器发送到收件方的邮件服务器，是邮件系统中邮件传递的 “搬运工” 。
+
+	SNMP（Simple Network Management Protocol，简单网络管理协议）：用于管理网络中的设备（如路由器、交换机等），可以实现网络设备状态监测、性能统计、配置管理等功能，帮助网络管理员维护网络的正常运行 。
+
+	DNS（Domain Name System，域名系统）：负责将域名（如 www.example.com ）解析为对应的 IP 地址，因为在网络中设备实际通过 IP 地址通信，有了 DNS ，人们就可以用好记的域名访问网站，而不用记住复杂的 IP 地址 。
+ */
+public class Demo01 {
+}

s-day11/src/com/inmind/tcp03/TcpClientDemo06.java

@@ -0,0 +1,49 @@
+package com.inmind.tcp03;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+/*
+TCP的客户端的实现
+    在java中使用一个类Socket表示客户端
+    构造方法:
+        Socket(String host, int port) 创建流客户端并将其连接到指定主机(IP地址)上的指定端口号。
+        参数一host:要请求服务的服务器的ip地址
+        参数二port:要请求服务的服务器上的软件端口号
+
+    常用方法:
+        void close() 关闭此套接字。
+        InetAddress getInetAddress() 返回套接字所连接的地址。
+        InputStream getInputStream() 返回此套接字的输入流.(接收响应数据的)
+        OutputStream getOutputStream() 返回此套接字的输出流。 (发送请求)
+        void shutdownOutput() 禁用此套接字的输出流 (设置了一个发送请求数据的结束标记)
+
+     客户端的实现步骤（对照IO图说明API的作用）:
+        1.创建客户端对象
+        2.获取字节输出流发送请求数据
+        3.获取字节输入流接收响应数据
+        4.释放资源
+ */
+public class TcpClientDemo06 {
+    public static void main(String[] args) throws Exception {
+        //1.创建客户端对象192.168.23.107
+        Socket socket = new Socket("127.0.0.1", 10024);
+        //2.获取字节输出流发送请求数据
+        OutputStream os = socket.getOutputStream();
+        os.write("淘宝的官网".getBytes());
+        //告诉服务器，请求数据结束标记
+        socket.shutdownOutput();
+        //3.获取字节输入流接收响应数据
+        InputStream is = socket.getInputStream();
+        //一次读取一个字节数组
+        byte[] bytes = new byte[1024];
+        int len;
+        System.out.println("服务器响应的数据为：");
+        while ((len = is.read(bytes)) != -1) {
+            System.out.println(new String(bytes,0,len));
+        }
+        //4.释放资源
+        socket.close();
+    }
+}

s-day11/src/com/inmind/tcp03/TcpServerDemo07.java

@@ -0,0 +1,55 @@
+package com.inmind.tcp03;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/*
+TCP服务器端代码的实现
+    在java中使用类ServerSocket表示服务器
+
+    构造方法:
+        ServerSocket(int port) 创建绑定到指定端口的服务器套接字。
+        参数port:服务器软件的端口号
+
+    常用方法:
+        Socket accept() 接收客户端的请求,还将客户端的请求数据封装到服务器的Socket对象返回值中
+            InetAddress getInetAddress() 返回套接字所连接的地址。
+            InputStream getInputStream() 返回此套接字的输入流.(接收请求数据的)
+            OutputStream getOutputStream() 返回此套接字的输出流。 (发送响应数据)
+        void close() 关闭此套接字。
+     服务器的实现步骤:
+        1.创建服务器对象
+        2.接收客户端请求
+        3.获取请求数据
+        4.业务逻辑代码
+        5.发送响应数据
+        6.释放资源
+ */
+public class TcpServerDemo07 {
+    public static void main(String[] args) throws Exception {
+        //1.创建服务器对象
+        ServerSocket serverSocket = new ServerSocket(10024);
+        //2.接收客户端请求
+        Socket socket = serverSocket.accept();//阻塞的方法，等待客户端发来请求
+        System.out.println(socket.getInetAddress());//获取客户端的ip地址
+        //3.获取请求数据
+        InputStream is = socket.getInputStream();
+        //一次读取一个字节数组
+        byte[] bytes = new byte[1024];
+        int len;
+        System.out.println("客户端请求数据为：");
+        while ((len = is.read(bytes)) != -1) {
+            System.out.println(new String(bytes,0,len));//请求数据的展示
+        }
+        //4.业务逻辑代码
+        String result = "www.taobao.com";//要响应的数据
+        //5.发送响应数据
+        OutputStream os = socket.getOutputStream();
+        os.write(result.getBytes());
+        //6.释放资源
+        socket.close();
+        serverSocket.close();
+    }
+}

s-day11/src/com/inmind/udp02/Demo02.java

@@ -0,0 +1,46 @@
+package com.inmind.udp02;
+
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+
+/*
+UDP（印度飞饼）
+1.面向无连接
+2.传输不安全
+3.传输数据有限制，64KB以内
+
+在java中使用DatagramSocket来表示UDP的客户端和服务端
+构造方法
+DatagramSocket() 创建客户端的Socket对象，系统会随机分配一个端口号。
+DatagramSocket(int port) 创建服务端的Socket对象，并指定端口号。
+
+常用方法：
+void send(DatagramPacket p) 发送数据包
+void receive(DatagramPacket p) 使用数据包接收数据
+
+DatagramPacket ：数据包
+DatagramPacket(byte[] buf, int length, InetAddress address, int port) 创建发出去的数据包对象
+DatagramPacket(byte[] buf, int length) 创建接收数据的数据包对象
+int getLength() 返回要发送的数据的长度或接收到的数据的长度
+
+需求：使用UDP实现快速通信，实现1发1收
+客户端的实现
+ */
+public class Demo02 {
+    public static void main(String[] args) throws Exception {
+        //1创建客户端对象（丢飞饼的阿三）
+        DatagramSocket socket = new DatagramSocket();//随机分配端口
+
+        //2.创建数据包对象，封装要发出去的数据（创建一个飞饼）
+        byte[] bytes = "我爱java,java爱我".getBytes();
+//        DatagramPacket packet = new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),10022);
+        DatagramPacket packet = new DatagramPacket(bytes,bytes.length,
+                InetAddress.getByName("192.168.23.174"),10022);
+        //3.客户端正式发送这个数据包出去
+        socket.send(packet);
+        System.out.println("客户端数据发送完毕~~");
+        socket.close();
+
+    }
+}

s-day11/src/com/inmind/udp02/Demo03.java

@@ -0,0 +1,41 @@
+package com.inmind.udp02;
+
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+
+/*
+作为UDP服务端，接收客户端发送的数据
+
+在java中使用DatagramSocket来表示UDP的客户端和服务端
+构造方法
+DatagramSocket(int port) 创建服务端的Socket对象，并指定端口号。
+
+常用方法：
+void receive(DatagramPacket p) 使用数据包接收数据
+
+DatagramPacket ：数据包
+DatagramPacket(byte[] buf, int length) 创建接收数据的数据包对象
+int getLength() 返回要发送的数据的长度或接收到的数据的长度
+
+需求：创建服务器，接收客户端的数据
+ */
+public class Demo03 {
+    public static void main(String[] args) throws Exception {
+        System.out.println("服务端启动了.....");
+        //1.创建服务端的对象(并指定端口号)
+        DatagramSocket socket = new DatagramSocket(10022);
+        //2.创建出一个数据包对象，用于接收数据（飞饼）
+        byte[] bytes = new byte[64 * 1024];//64KB
+        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
+
+        //3.服务器开始正式使用数据包，接收客户端的数据
+        socket.receive(packet);//阻塞方法，等待客户端发送的数据
+        //4.获取数据包的ip地址，和端口号
+        int length = packet.getLength();//获取数据包中字节数据的长度
+        String result = new String(bytes, 0, length);
+        System.out.println(packet.getPort());//获取数据包的端口
+        System.out.println(packet.getAddress().getHostAddress());//获取数据包的IP地址
+        System.out.println(result);
+        socket.close();//服务器资源释放
+    }
+}

s-day11/src/com/inmind/udp02/UdpClientDemo04.java

@@ -0,0 +1,46 @@
+package com.inmind.udp02;
+
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.util.Scanner;
+
+/*
+UDP多发多收
+ */
+public class UdpClientDemo04 {
+    public static void main(String[] args) throws Exception {
+        //1.创建客户端对象
+        DatagramSocket ds = new DatagramSocket();
+        //2.创建数据包发送数据
+        Scanner sc = new Scanner(System.in);
+
+        //3.不停地发，用户输入什么就发送什么
+        while (true) {
+            System.out.println("请输入：");
+            String line = sc.nextLine();//阻塞
+
+            if ("exit".equals(line)) {//这样写避免了空指针异常的可能性
+                break;
+            }
+
+            byte[] bytes = line.getBytes();
+            /*
+        public DatagramPacket(byte buf[], int offset, int length,
+                          InetAddress address, int port)
+          参数一：封装要发出去的数据
+          参数二：发送出去的数据大小（字节个数）
+          参数三：服务端的IP地址（找到服务器主机）
+          参数四：服务端程序的端口号
+         */
+            DatagramPacket dp = new DatagramPacket(
+                    bytes, bytes.length,
+                    InetAddress.getByName("192.168.23.107"), 10023);
+            //4.开始正式发送数据包
+            ds.send(dp);
+        }
+
+
+        System.out.println("程序结束");
+    }
+}

s-day11/src/com/inmind/udp02/UdpServerDemo05.java

@@ -0,0 +1,27 @@
+package com.inmind.udp02;
+
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+
+//启动服务器，不停地获取客户端的信息
+public class UdpServerDemo05 {
+    public static void main(String[] args) throws Exception {
+        System.out.println("服务器启动");
+        //1.创建服务器对象
+        DatagramSocket ds = new DatagramSocket(10023);
+        //2.不停地获取数据包
+        byte[] buffer = new byte[1024 * 64];
+        while (true) {
+            //3.创建出一个数据包，用于接收客户端的数据
+            DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
+            //4.服务器正式接收数据包
+            ds.receive(dp);
+            //5.将字节数据转为字符，并显示对应客户端的信息
+            int length = dp.getLength();//获取数据包中字节数据的长度
+            String result = new String(buffer, 0, length);
+            System.out.println(dp.getPort());//获取数据包的端口
+            System.out.println(dp.getAddress().getHostAddress());//获取数据包的IP地址
+            System.out.println(result);
+        }
+    }
+}