Day11 2021.3.13转换流-序列反序列化-打印流-网络编程入门

最新推荐文章于 2024-04-15 00:06:38 发布

hc1235

最新推荐文章于 2024-04-15 00:06:38 发布

阅读量171

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/hc1235/article/details/114750358

版权

java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

Day11 2021.3.13

转换流

字符编码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jJNpW7gW-1615622417049)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313091620997.png)]

字符集(CharSet)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OTiIAHWx-1615622417051)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313091817100.png)]

ASCII字符集:

基本的ASCII字符集使用7位(bites)表示一个字符,共128个字符,ASCII的扩展字符集使用8位表示一个字符,公256字符,方便支持欧洲常用字符。

ISO-8859-1字符集:

拉丁码表,别名：Latin-1,使用单字节编码，兼容ASCII编码。

GBxxx字符:

为了显示中文而设计的一套字符集

GB2312:简体中文码表,一个小于127字符的意义是原来相同,但两个大于127的字符连在一起时,表示一个汉字。

GBK:常用的中文码表。双字节编码。

GB18030:最新的中文码表,可以由1个、2个、4个字节组成

Unicode字符集:

Unicode字符集编码系统为表达任意语言的任意字符而设计,是业内的一种标准,也称为统一码、标准万国码。最多使用4个字节的数字来表达。UTF-8、UTF-16、UTF-32。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hoDkeu3o-1615622417053)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313092903421.png)]

编码引出的问题

/*
    FileReader可以读取默认编码格式(UTF-8)的文件
    FileReader读取系统默认编码(中文GBK)会产生乱码
*/

OutputStreamWriter

package com.hong.Day011_Day020.Day011.Demo01;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/*
    java.io.OutputStreamWriter
    OutputStreamWriter是字符的桥梁流以字节流：向其写入的字符编码成使用指定的字节charset 。它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
构造方法:
    1.OutputStreamWriter(OutputStream out)创建一个使用默认字符编码的OutputStreamWriter。
    2.OutputStreamWriter(OutputStream out, Charset cs)创建一个使用给定字符集的OutputStreamWriter。
    3.OutputStreamWriter(OutputStream out, CharsetEncoder enc)创建一个使用给定字符集编码器的OutputStreamWriter。
    4.OutputStreamWriter(OutputStream out, String charsetName)创建一个使用命名字符集的OutputStreamWriter。
    参数:
        OutputStream out:字节输出流,可以用来写转换之后的字节到文件中
        String charsetName:指定编码表名称,默认UTF-8
特有方法:
    String getEncoding()返回此流使用的字符编码的名称。
使用步骤:
    1.创建OutputStreamWriter对象,构造方法中传递字节 输出流和指定的编码表名称
    2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储在缓冲区中(编码)
    3.使用OutputStreamWriter对象中的方法flush,刷新
    4.释放资源
*/
public class Demo01 {
    public static void main(String[] args) throws IOException {
        write_UTF_8();
    }
    /*
        使用转换流OutputStreamWriter
    */
    private static void write_UTF_8() throws IOException {
        //1.创建OutputStreamWriter对象,构造方法中传递字节 输出流和指定的编码表名称
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\javaIO\\acb.txt"),"utf-8");
        //2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储在缓冲区中(编码)
        osw.write("你好");
        //3.使用OutputStreamWriter对象中的方法flush,刷新
        osw.flush();
        //4.释放资源
        osw.close();
    }
}

InputStreamReader

package com.hong.Day011_Day020.Day011.Demo01;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/*
    java.io.InputStreamReader
    InputStreamReader是从字节流到字符流的桥：它读取字节，并使用指定的charset将其解码为字符 。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
构造方法:
    1.InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader。
    2.InputStreamReader(InputStream in, Charset cs)创建一个使用给定字符集的InputStreamReader。
    3.InputStreamReader(InputStream in, CharsetDecoder dec)创建一个使用给定字符集解码器的InputStreamReader。
    4.InputStreamReader(InputStream in, String charsetName)创建一个使用命名字符集的InputStreamReader。
    参数:
        InputStream in:字节输入流,可以用来读取文件
        String charsetName:指定编码表名称,默认UTF-8
特有方法:
    String getEncoding()返回此流使用的字符编码的名称。
    boolean    ready()告诉这个流是否准备好被读取。
使用步骤:
    1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
    2.使用InputStreamReader对象中的方法read读取文件
    3.释放资源
注意:
    构造方法中指定的编码表名称要和文件的编码相同,否则会发生乱码
*/
public class Demo02 {
    public static void main(String[] args) throws IOException {
        In_put();
    }

    private static void In_put() throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\javaIO\\acb.txt"),"utf-8");
        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while ((len = isr.read())!= -1){
            System.out.println((char) len);
        }
        //3.释放资源
        isr.close();
    }
}

练习:转换文件编码

package com.hong.Day011_Day020.Day011.Demo01;

import java.io.*;

/*
    将GBK编码的文本文件转换成UTF-8文件
*/
public class Demo03 {
    public static void main(String[] args) throws IOException {
        String b = write123("E:\\javaIO\\b.txt","GBK");
        read123("E:\\javaIO\\a.txt",b);
    }

    private static String write123(String file, String charsetName) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file),"utf-8");
        osw.write("你好");
        String a = osw.getEncoding();
        osw.flush();
        osw.close();
        return a;
    }

    private static void read123(String file,String charsetName) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream(file),charsetName);
        int len = 0;
        while ((len = isr.read())!=-1){
            System.out.println((char)len);
        }
        isr.close();
    }
}

序列化和反序列化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EBrtEhoO-1615622417055)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313102502644.png)]

序列化流(ObjectOutputStream)

package com.hong.Day011_Day020.Day011.Demo02;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
    java.io.ObjectOutputStream ObjectOutputStream 将Java对象的原始数据类型和图形写入OutputStream。
    对象的序列化流
    作用:把对象以流的方式写入到文件中保存
构造方法:
    1.protected    ObjectOutputStream()为完全重新实现ObjectOutputStream的子类提供一种方法，不必分配刚刚被ObjectOutputStream实现使用的私有数据。
   2.ObjectOutputStream(OutputStream out)创建一个写入指定的OutputStream的ObjectOutputStream。
    参数:OutputStream out
特有的成员方法:
    void writeObject(Object obj)将指定的对象写入ObjectOutputStream。
使用步骤:
    1.创建ObjectOutputStream对象,构造方法中传递字节输出流
    2.使用ObjectOutputStream对象中的方法writeObject
    3.释放资源
*/
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建ObjectOutputStream对象,构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\javaIO\\c.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject
        oos.writeObject(new Person("小明",18));
        //3.释放资源
        oos.close();
    }
}

package com.hong.Day011_Day020.Day011.Demo02;

import java.io.Serializable;

/*
    序列化和反序列化会抛出NotSerializableException异常
    只有实现了Serializable接口才能序列化和反序列化
    Serializable接口:标记接口
*/
public class Person implements Serializable {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

反序列化流(ObjectInputStream)

package com.hong.Day011_Day020.Day011.Demo02;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/*
    java.io.ObjectInputStream ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象。
    对象的反序列化流
    作用:将文件以流的形式读取
构造方法:
   1.protected ObjectInputStream()为完全重新实现ObjectInputStream的子类提供一种方法，不必分配刚刚被ObjectInputStream实现使用的私有数据。
   2.ObjectInputStream(InputStream in)创建从指定的InputStream读取的ObjectInputStream。
    参数:InputStream in
特有的成员方法:
    Object readObject()从ObjectInputStream读取一个对象。
使用步骤:
    1.创建ObjectInputStream对象,构造方法中传递字节输入流
    2.使用ObjectInputStream对象中的方法readObject
    3.释放资源
    4.用读取出来的对象(打印)
使用前提:
	1.类必须实现Serializable接口
	2.必须存在类对应的class文件
*/
public class Demo02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建ObjectInputStream对象,构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\javaIO\\c.txt"));
        //2.使用ObjectInputStream对象中的方法readObject
        Object o = ois.readObject();
        //3.释放资源
        ois.close();
        //4.用读取出来的对象(打印)
        System.out.println(o);//Person{name='小明', age=18}
    }
}

transient关键字(瞬态)

/*
    static:静态关键字
        静态优先于非静态加载到内存中(静态有限与对象进入到内存)
        被static修饰的成员变量不能被序列化,序列化的都是对象
    transient关键字:瞬态关键字
        被transient修饰的成员变量不能被序列化
*/

InvalidClassException异常

定义序列号格式：

 static final long serialVersionUID = 42L;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Lu2XfEH-1615622417056)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313105521414.png)]

如果可序列化类没有显式声明serialVersionUID，则序列化运行时将根据Java（TM）对象序列化规范中所述的类的各个方面计算该类的默认serialVersionUID值。但是， 强烈建议所有可序列化的类都明确声明serialVersionUID值，因为默认的serialVersionUID计算对类详细信息非常敏感，这可能会因编译器实现而异，因此可能会在反InvalidClassException化期间导致InvalidClassException的InvalidClassException。因此，为了保证不同Java编译器实现之间的一致的serialVersionUID值，一个可序列化的类必须声明一个显式的serialVersionUID值。还强烈建议，显式的serialVersionUID声明在可能的情况下使用private修饰符，因为这种声明仅适用于立即声明的类 - serialVersionUID字段作为继承成员无效。数组类不能声明一个显式的serialVersionUID，所以它们总是具有默认的计算值，但是对于数组类，放弃了匹配serialVersionUID值的要求。

练习:序列化集合

package com.hong.Day011_Day020.Day011.Demo03;

import java.io.*;
import java.util.ArrayList;

/*
    练习:序列化集合
    要求:
        1.将存有多个自定义对象的集合序列化操作,保存到list.txt文件中
        2.反序列化list.txt，并遍历集合,打印对象信息
    案例分析:
        1.把若干学生对象,保存到集合中
        2.把集合序列化
        3.反序列化读取时,只需要读取一次,转换为集合类型
        4.遍历集合,可以打印所有学生的信息
*/
public class Demo01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Student stu1 = new Student("东东",22);
        Student stu2 = new Student("捞逼",21);
        Student stu3 = new Student("陈捞逼",20);
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(stu1);
        arrayList.add(stu2);
        arrayList.add(stu3);
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\javaIO\\list.txt"));
        oos.writeObject(arrayList);
        oos.close();
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\javaIO\\list.txt"));
        Object a = ois.readObject();
        ois.close();
        System.out.println(a);
    }
}

package com.hong.Day011_Day020.Day011.Demo03;

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

打印流(PrintStream)

A PrintStream为另一个输出流添加了功能，即能够方便地打印各种数据值的表示。还提供了另外两个功能。与其他输出流不同， PrintStream从不抛出IOException ; 相反，异常情况只是设置一个可以通过checkError方法测试的内部标志。可以选择一个PrintStream ，以便自动刷新; 这意味着flush字节数组写入方法后自动调用，所述一个println方法被调用时，或者一个新行字符或字节（ '\n' ）被写入。

/*
    java.io.PrintStream:打印流
    PrintStream特点:
        1.只负责数据的输出,不负责数据的读取
        2.与其他输出流不同,PrintStream永远不会抛出IOException
        3.特有方法,print,println
            void print(Object obj)打印一个对象。
            void println()通过写入行分隔符字符串来终止当前行。
构造方法:
    1.PrintStream(File file)使用指定的文件创建一个新的打印流，而不需要自动换行。
    2.PrintStream(OutputStream out)创建一个新的打印流。
    3.PrintStream(String fileName)使用指定的文件名创建新的打印流，无需自动换行。
注意:
    1.如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表(97-->a)
    2.如果使用自己特有的方法print,println方法写数据,写的数据原样输出(97-->97)

    可以改变输出语句的目的地(打印流的流向)
    输出语句,默认在控制台输出
    使用System.setOut方法改变输出语句的目的地
*/

网络编程入门

软件结构

C/S结构:全称Client/Server结构,是指客户端和服务器结构。常见的有QQ、迅雷等
B/S结构:全称Browser/Server结构,是指浏览器和服务器结构,常见的有谷歌、火狐

网络通信协议

网络通信协议：通过计算机网络可以使多态计算机实现连接,位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则。
TCP/IP协议：传输控制协议/因特网互联协议,是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网,以及数据如何再它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议,并采用了四层分层模型,每一层都呼叫它的下一层所提供的协议来完成自己的需求。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Cx86Ggs-1615622417057)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313132042763.png)]

链路层：是用于定义物理传输通道,通常是对某些网络连接设备的驱动协议,例如针对光纤、网络提供的驱动。
网络层：是整个TCP/IP协议的核心，它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络
运输层：主要使用网络程序进行通信，在进行网络通信时，可以采用TCP协议，也可以采用UDP协议。
应用层：主要负责应用程序的协议，例如HTTP协议、FTP协议等。

协议分类

UDP：用户数据报协议(User Datagram Protocol)，UDP是无连接通信协议，即在数据传输时，数据的发送端和接受端不建立逻辑连接。

由于UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议。

但是在使用UDP协议传输数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。

特点：数据被限制在64kb以内，超出这个范围就不能发送了。

数据报(Datagram)：网络传输的基本单位
TCP：传输控制协议(Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接受端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

在TCP连接中必须要明确客户端与服务器端，由客户端向服务器端发出连接请求。每次连接的创建都需要经过“三次援手”。
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
  - 第一次握手，客户端向服务器端发出连接请求，等待服务器确认
  - 第二次握手，服务器端想客户端回送一个响应，通知客户端收到了连接请求
  - 第三次握手，客户端再次向服务器端发送确认信息，确认连接

网络编程三要素

协议

协议：计算机网络通信必须遵守的规则

IP地址

IP地址：指互联网协议地址(Internet Protocol Address),俗称IP。
IP地址分类：
1. IPv4：是一个32位的二进制数，通常被分为4个字节表示成192.168.65.100
2. IPv6：采用128位地址长度，每16个字节一组，分成8组十六进制数,表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789
常用命令
- 查看本机的IP地址，在控制台输入
```
ipconfig
```
- 检查网络是否连接，在控制台输入
```
ping 空格 IP地址
ping 172.16.184.173
```
- 特殊的IP地址
  
  本机的IP地址：127.0.0.1、localhost

端口号

端口号：用两个字节表示的整数，它的取值范围是0~65535。其中0-1023之间的端口号专门用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-joIW6rW9-1615622417058)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313135736205.png)]

TCP通信程序

TCP通行能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端(Client)与服务端(Server)。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HYoJsYW0-1615622417058)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313141150912.png)]

两端通信的步骤：

服务端程序，需要事先启动，等待客户端的连接
客户端主动连接服务端，连接成功才能通信，服务端不可以主动连接客户端

在JAVA中，提供了两个类用于实现TCP通信程序：

客户端：java.net.Socket类。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信
服务端：java.net.ServerSocket类。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接

Socket类

package com.hong.Day011_Day020.Day011.Demo04;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/*
    TCP通信的客户端:向服务器发送连接请求,给服务器发送数据,读取服务器回写的数据
    表示客户端的类:
        java.net.Socket 该类实现客户端套接字（也称为“套接字”）。 套接字是两台机器之间通讯的端点。
        套接字:包含了IP地址和端口号的网络单位
    构造方法:
           Socket(String host, int port)创建流套接字并将其连接到指定主机上的指定端口号。
            参数:
                String host:服务器主机的名称/服务器的IP地址
                int port:服务器的端口号
    成员方法:
        OutputStream getOutputStream()返回此套接字的输出流。
        InputStream    getInputStream()返回此套接字的输入流。
        void close()关闭此套接字。
    实现步骤:
        1.创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
        2.使用Socket对象中的方法getOutputStream()获取网络字节输出流
        3.使用网络字节输出流OutputStream对象中的write
        4.使用Socket对象中的方法getInputStream()获取网络字节输入流
        5.使用网络字节输入流InputStream对象中的read
        6.释放资源
    注意:
        1.客户端和服务器端进行交互,必须使用Socket中提供的网络流,不能使用自己创建的流对象
        2.当我们创建客户端对象Socket的时候,就会去请求服务器和服务器经过三次握手建立连接通道
            这时如果服务器没有启动,那么就会抛出异常
            如果服务器已经启动,那么就可以进行交互
*/
public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1.创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",8888);
        //2.使用Socket对象中的方法getOutputStream()获取网络字节输出流
        OutputStream os = socket.getOutputStream();
        //3.使用网络字节输出流OutputStream对象中的write
        os.write("你好服务器".getBytes());
        //4.使用Socket对象中的方法getInputStream()获取网络字节输入流
        InputStream is = socket.getInputStream();
        //5.使用网络字节输入流InputStream对象中的read
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        //6.释放资源
        socket.close();
    }
}

ServerSocket类

package com.hong.Day011_Day020.Day011.Demo04;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/*
    TCP通信的服务器端:接收客户端的请求,读取客户端发送的数据,给客户端回写数据
    表示服务器的类:
        java.net.ServerSocket 这个类实现了服务器套接字
    构造方法:
        ServerSocket(int port, int backlog)创建服务器套接字并将其绑定到指定的本地端口号，并指定了积压。
    服务器端必须明确一件事,必须要知道是哪个客户端请求的服务器
    成员方法:
        Socket accept()侦听要连接到此套接字并接受它。
    服务器的实现步骤:
        1.创建服务器ServerSocket对象和系统要指定的端口号
        2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
        3.使用Socket对象中的方法getInputStream()获取网络字节输入流
        4.使用网络字节输入流InputStream对象中的read
        5.使用Socket对象中的方法getOutputStream()获取网络字节输出流
        6.使用网络字节输出流OutputStream对象中的write
        7.释放资源
*/
public class TCPServerSocket {
    public static void main(String[] args) throws IOException {
        //1.创建服务器ServerSocket对象和系统要指定的端口号
        ServerSocket serverSocket = new ServerSocket(8888);
        //2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
        Socket socket = serverSocket.accept();
        //3.使用Socket对象中的方法getInputStream()获取网络字节输入流
        InputStream is = socket.getInputStream();
        //4.使用网络字节输入流InputStream对象中的read
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        //5.使用Socket对象中的方法getOutputStream()获取网络字节输出流
        OutputStream os = socket.getOutputStream();
        //6.使用网络字节输出流OutputStream对象中的write
        os.write("收到谢谢".getBytes());
        //7.释放资源
        socket.close();
        serverSocket.close();
    }
}

综合案例:文件上传案例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ejiAurjp-1615622417059)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313144645593.png)]

package com.hong.Day011_Day020.Day011.Demo05;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/*
    文件上传案例的客户端:读取本地文件,上传到服务器,读取服务器端写的数据
    实现步骤:
        1.创建一个本地字节输入流FileInputStream
        2.创建一个客户端对象Socket对象
        3.使用Socket方法getOutputStream
        4.使用本地字节输入流FileInputStream中的read
        5.使用网络字节输出流OutputStream中的write
        6.使用Socket方法中的getInputStream
        7.使用网络字节输入流InputStream中的read
        8.释放资源(FileInputStream,Socket)
*/
public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1.创建一个本地字节输入流FileInputStream
        FileInputStream fis = new FileInputStream("E:\\javaIO\\123.jpg");
        //2.创建一个客户端对象Socket对象
        Socket so = new Socket("127.0.0.1",8888);
        //3.使用Socket方法getOutputStream
        OutputStream os = so.getOutputStream();
        //4.使用本地字节输入流FileInputStream中的read
        int len = 0;
        byte[] bytes =new byte[1024];
        while ((len = fis.read(bytes))!= -1){
            //5.使用网络字节输出流OutputStream中的write
            os.write(bytes,0,len);
        }
        /*
            文件阻塞解决方法
            void shutdownOutput()禁用此套接字的输出流
        */
        so.shutdownOutput();
        //6.使用Socket方法中的getInputStream
        InputStream is = so.getInputStream();
        //7.使用网络字节输入流InputStream中的read
        while ((len = is.read(bytes))!= -1){
            System.out.println(new String(bytes,0,len));
        }
        //8.释放资源(FileInputStream,Socket)
        fis.close();
        so.close();
    }
}

package com.hong.Day011_Day020.Day011.Demo05;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;

/*
    文件上传案例的服务器端:读取客户端上传的文件,保存到服务器的硬盘,给客户端回写"上传成功"
    实现步骤:
        1.创建服务器ServerSocket对象和系统要指定的端口号
        2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
        3.使用Socket对象中的方法getInputStream()获取网络字节输入流
        4.判断目的地是否存在
        5.创建一个本地字节输出流FileOutputStream
        6.使用网络字节输入流InputStream对象中的read
        7.使用本地字节输出流FileOutputStream中的write
        8.使用Socket对象中的方法getOutputStream()
        9.使用网络字节输出流OutputStream中的write回写数据
        10.释放资源(FileOutputStream,Socket,ServerSocket)
*/
public class TCPServer {
    public static void main(String[] args) throws IOException , SocketException {
        //1.创建服务器ServerSocket对象和系统要指定的端口号
        ServerSocket serverSocket =new ServerSocket(8888);
        //2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
        Socket socket = serverSocket.accept();
        //3.使用Socket对象中的方法getInputStream()获取网络字节输入流
        InputStream is = socket.getInputStream();
        //4.判断目的地是否存在
        File file = new File("E:\\javaIO\\123");
        if (file.exists()){/*判断文件是否存在*/
            file.mkdirs();/*创建文件夹*/
        }
        //5.创建一个本地字节输出流FileOutputStream
        FileOutputStream fos = new FileOutputStream(file+"\\1.jpg");
        //6.使用网络字节输入流InputStream对象中的read
        int len = 0;
        byte[] bytes = new byte[1024];
        while (-1 != (len = is.read(bytes))){
            //7.使用本地字节输出流FileOutputStream中的write
            fos.write(bytes,0,len);
        }
        //8.使用Socket对象中的方法getOutputStream()
        //9.使用网络字节输出流OutputStream中的write回写数据
        socket.getOutputStream().write("上传成功".getBytes());
        //10.释放资源(FileOutputStream,Socket,ServerSocket)
        fos.close();
        socket.close();
        serverSocket.close();
    }
}

综合案例:文件上传案例优化(多线程)

package com.hong.Day011_Day020.Day011.Demo05;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/*
    文件上传案例的客户端:读取本地文件,上传到服务器,读取服务器端写的数据
    实现步骤:
        1.创建一个本地字节输入流FileInputStream
        2.创建一个客户端对象Socket对象
        3.使用Socket方法getOutputStream
        4.使用本地字节输入流FileInputStream中的read
        5.使用网络字节输出流OutputStream中的write
        6.使用Socket方法中的getInputStream
        7.使用网络字节输入流InputStream中的read
        8.释放资源(FileInputStream,Socket)
*/
public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1.创建一个本地字节输入流FileInputStream
        FileInputStream fis = new FileInputStream("E:\\javaIO\\123.jpg");
        //2.创建一个客户端对象Socket对象
        Socket so = new Socket("127.0.0.1",8888);
        //3.使用Socket方法getOutputStream
        OutputStream os = so.getOutputStream();
        //4.使用本地字节输入流FileInputStream中的read
        int len = 0;
        byte[] bytes =new byte[1024];
        while ((len = fis.read(bytes))!= -1){
            //5.使用网络字节输出流OutputStream中的write
            os.write(bytes,0,len);
        }
        /*
            文件阻塞解决方法
            void shutdownOutput()禁用此套接字的输出流
        */
        so.shutdownOutput();
        //6.使用Socket方法中的getInputStream
        InputStream is = so.getInputStream();
        //7.使用网络字节输入流InputStream中的read
        while ((len = is.read(bytes))!= -1){
            System.out.println(new String(bytes,0,len));
        }
        //8.释放资源(FileInputStream,Socket)
        fis.close();
        so.close();
    }
}

package com.hong.Day011_Day020.Day011.Demo05;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.Random;

/*
    文件上传案例的服务器端:读取客户端上传的文件,保存到服务器的硬盘,给客户端回写"上传成功"
    实现步骤:
        1.创建服务器ServerSocket对象和系统要指定的端口号
        2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
        3.使用Socket对象中的方法getInputStream()获取网络字节输入流
        4.判断目的地是否存在
        5.创建一个本地字节输出流FileOutputStream
        6.使用网络字节输入流InputStream对象中的read
        7.使用本地字节输出流FileOutputStream中的write
        8.使用Socket对象中的方法getOutputStream()
        9.使用网络字节输出流OutputStream中的write回写数据
        10.释放资源(FileOutputStream,Socket,ServerSocket)
*/
public class TCPServer {
    public static void main(String[] args) throws IOException , SocketException {
        //1.创建服务器ServerSocket对象和系统要指定的端口号
        ServerSocket serverSocket =new ServerSocket(8888);
        //2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
        /*
            让服务器一直处于监听状态(死循环accept方法)
        */
        while (true){
            /*
                使用多线程提高文件的效率
                有一个客户端上传文件就开启一个线程
            */
            Socket socket = serverSocket.accept();
            new Thread(new Runnable() {
                //完成文件的上传
                @Override
                public void run() {
                    try {
                        //3.使用Socket对象中的方法getInputStream()获取网络字节输入流
                        InputStream is = socket.getInputStream();
                        //4.判断目的地是否存在
                        File file = new File("E:\\javaIO\\123");
                        if (file.exists()){/*判断文件是否存在*/
                            file.mkdirs();/*创建文件夹*/
                        }
        /*
            自定义一个文件的命名规则:禁止同名的文件被覆盖
            规则:域名+毫秒值+随机数
        */
                        String fileName = "itcast" +System.currentTimeMillis()+new Random().nextInt(999999)+".jpg";
                        //5.创建一个本地字节输出流FileOutputStream
                        FileOutputStream fos = new FileOutputStream(file+"\\"+fileName);
                        //6.使用网络字节输入流InputStream对象中的read
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while (-1 != (len = is.read(bytes))){
                            //7.使用本地字节输出流FileOutputStream中的write
                            fos.write(bytes,0,len);
                        }
                        //8.使用Socket对象中的方法getOutputStream()
                        //9.使用网络字节输出流OutputStream中的write回写数据
                        socket.getOutputStream().write("上传成功".getBytes());
                        //10.释放资源(FileOutputStream,Socket,ServerSocket)
                        fos.close();
                        socket.close();

                    }catch (IOException e){
                        System.out.println(e);
                    }
                }
            }).start();
        }
        //serverSocket.close();
    }
}

模拟B/S服务器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r90zwdNx-1615622417060)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313154336344.png)]

nt len = 0;
byte[] bytes = new byte[1024];
while (-1 != (len = is.read(bytes))){
//7.使用本地字节输出流FileOutputStream中的write
fos.write(bytes,0,len);
}
//8.使用Socket对象中的方法getOutputStream()
//9.使用网络字节输出流OutputStream中的write回写数据
socket.getOutputStream().write(“上传成功”.getBytes());
//10.释放资源(FileOutputStream,Socket,ServerSocket)
fos.close();
socket.close();

                }catch (IOException e){
                    System.out.println(e);
                }
            }
        }).start();
    }
    //serverSocket.close();
}

}


## 模拟B/S服务器

[外链图片转存中...(img-r90zwdNx-1615622417060)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KqYeM9Sf-1615622417062)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313154649634.png)]

hc1235

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day11 2021.3.13转换流-序列反序列化-打印流-网络编程入门

Day11 2021.3.13转换流字符编码[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jJNpW7gW-1615622417049)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20210313091620997.png)]字符集(CharSet)[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OTiIAHWx-1615622417051)(C:\Use
复制链接

扫一扫