笔记-迎难而上之Java基础进阶7

序列化流

把对象以流的方式写入到文件中保存，叫做对象的序列化

把文件中保存的对象，以流的方式读取出来，叫做对象大反序列化

对象的序列化流_ObjectOutputtream继承自OutputStream

作用：把对象以流的方式写入到文件中保存

构造方法:

​ ObjectOutputStream(OutputStream out)

特有成员方法:

​ void writeObject(Object obj) 将指定的对象写入ObjectOutputStream

//做序列化需要对象，该对象还得实现Serializable接口
import java.io.*;
public class Person implements Serializable{
    //被transient关键字修饰的成员变量无法被序列化
    //假如String name 被transient修饰那么在写入对象的时候name 写入为null
	private String name;
	private int age;
	
	public Person(){}
	
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	
	public String toString(){
		String str = "姓名 "+name+" 年龄"+age;
		return str;
	}
       public void setName(String name ){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void  setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
	
}

import java.io.*;
public class ObjectOutputStreamDemo{
	public static void main(String[] args) throws IOException{
		//创建ObjectOutputStream对象，构造方法中传递字节输出流
		//字节输出流FileOutputStream绑定写入对象地址
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\study\demo14\a.txt"));
		//调用方法writeObject,写入对象
		oos.writeObject(new Person("新垣结衣",18));
		oos.writeObject(new Person("石原里美",20));
		//写出结果
		//� sr Person篝9'?l$ I ageL namet Ljava/lang/String;xp   t 鏂板灒缁撹。sq ~     t 鐭冲師閲岀編
		oos.close();
	}
}

对象的反序列化流量_ObjectInputStream

构造方法：

​ ObjectInputSteam(InputStream in)

特有成员方法:

Object readObject()

//反序列化的前提是读取的类必须存在class文件,必须实现Serializable接口
import java.io.*;
public class ObjectInputStreamDemo{
	public static void main(String[] args) throws IOException,ClassNotFoundException{
	//创建ObjectInputStream对象
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\study\demo14\a.txt"));
	//方法readObject的返回值是Object
	Object o = ois.readObject();
	Object o1 = ois.readObject();
	ois.close();
	System.out.println(o);
	System.out.println(o1);
        
	}
}

被transient修饰的name

序列化集合

import java.io.*;
import java.util.*;
public class TestDemo{
    public static void main(String[] args) throws Exception{
        //序列化集合，创建一个集合
        ArrayList<Person> list = new ArrayList<>();
        //添加元素
        list.add(new Person("林黛玉",18));
        list.add(new Person("贾宝玉",20));
        list.add(new Person("孙悟空",15));
        list.add(new Person("猪八戒",22));
        //创建ObjectOutputStream序列化流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\study\demo14\b.txt"));
        //序列化流对象
        oos.writeObject(list);
        //创建ObjectInputStream序列化流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\study\demo14\b.txt"));
        //反序列化
        Object o = ois.readObject();
        //强制把Object类型转换成ArrayList类型
        ArrayList<Person> list1= (ArrayList<Person>)o;
        //遍历集合
        for(Person p : list1){
            String str = p.getName()+" "+p.getAge();
            System.out.println(str);
        }

    }
}

打印流

PrintStream的特点:

1. 只负责数据的输出，不负责数据的读取
2. 与其他输出流不同，PrintStream 永远不会抛出 IOException
3. 有特有的方法,print,println

构造方法：

​ PrintStream(File file):输出的目的地是一个文件

​ PrintStream(OutputStream out ):输出的目的地是一个字节输出流

​ PrintStream(String fileName) :输出的目的地是一个文件路径

import java.io.*;
public class PrintStreamDemo{
	public static void main(String[] args) throws IOException{
		//创建打印流PrintStream对象
		//绑定输出的目的地
		PrintStream ps = new PrintStream("E:\study\demo14\print.txt");
		//如果调用父类继承过来的write,查看数据时候，会查询编码表
		ps.write(97);//输出结果是a
		//调用自己特有的方法
		ps.println("云想衣裳花想容");//a云想衣裳花想容
		//PrintStream 类与Stream类结合可以改变输出语句的目的地
		System.out.println("我在控制台输出");
		//System类的方法setOut可以改变输出语句的目的地
		//方法传递的参数是打印流PrintStream(这个打印流要绑定输出地址)
		//创建一个打印流，并且绑定输出地址
		PrintStream ps1 = new PrintStream("E:\study\demo14\目的地打印流");
		//调用System的方法setOut
		//静态方法直接调用,传递参数是打印流
		System.setOut(ps);
		System.out.println("我现在在目的地中输出了");
	}
}

网络编程

软件结构

C/S结构：全称为Client/Server结构，是指客户端和服务器结构，常见程序有QQ 迅雷，网盘，可以通过客户端发来访问服务器

B/S结构：全称为Browser/Server，是指浏览器和服务器的结构，常见浏览器有谷歌，火狐，可以通过输入网址来访问服务器

网络编程就是在一定的协议下，实现两台计算机的通信程序

IP地址：指互联网协议地址俗称IP,IP地址用来给一个网络中的计算机设备做唯一的编号，IP地址分为IPV4和IPV6

端口号：用两个字节表示的整数，他的取值范围是0-65535。其中0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。

我们通过IP地址加端口号，就可以保证数据准确无误的发送到对方计算机的指定软件上了

TCP协议

TCP通信：面向连接的通信，客户端和服务器必须经过三次握手，建立逻辑连接，才能通信(安全)

在服务器端有一个方法，叫accept客户端获取到请求的客户端你对象，客户端与服务器进行交互，需要使用到多个IO流对象，服务器是没有IO流的，服务器可以获取到请求的客户端对象Socket使用每个客户端的Socket中提供的IO流和客户端进行交互

TCP通信的客户端代码实现

Socket:此类实现客户端套接字，套接字是两台机器通信的端点

套接字：包含了IP地址和端口号的网络单位

构造方法：Socket(String host,int port)创建一个流套接字并将其连接到指定主机上的指定端口号

成员方法：

OutputStream getOutputStream() 返回此套接字的输出流

InputStream getInputStream() 返回此套接字的输入流

void close() 关闭此套接字

ServerSocket:此类实现服务器套接字

构造方法：ServerSocket(int port) 创建绑定到特定端口的 服务器套接字

成员方法：

​ Socket accept()侦听并接收到此套接字的连接

import java.io.*;
import java.net.*;
public class TCPClient{
    public static void main(String[] args) throws Exception{
        //创建一个客户端对象Soket,构造方法绑定服务器的IP地址和端口号
    	//构造方法一执行就会与服务器进行连接
        Socket socket = new Socket("127.0.0.1",5555);
        //要向服务器写数据，得先获取网络字节流
        //Socket中的方法getOutputStream可以获取字节输出流
        OutputStream os = socket.getOutputStream();
        //调用OutputStream对象的方法write，给服务器发送数据
        String str = "云想衣裳花想容t";
        byte[] bytes = str.getBytes();
        os.write(bytes);


        //读取服务器发送回来的数句
        //首先需要一个网络字节输入流
        InputStream is = socket.getInputStream();
        //使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据,
        byte[] bytes1 = new byte[1024];
        int len = is.read(bytes1);
        System.out.println(new String(bytes1,0,len));
        os.close();
        socket.close();
    }
}

import java.io.*;
import java.net.*;
public class TCPServer{
    public static void main(String[] args) throws Exception{
        //创建服务器ServerSocket对象
        ServerSocket ss = new ServerSocket(5555);
        //ServerSocket类中的方法accept可以获取到请求的客户端对象Socket
        //返回值是Socket,也就是说可以调用Socket类中的网络流方法
        Socket socket = ss.accept();
        //使用Socket对象的方法getInputStream();获取网络字节输入流
        //getInputStream流返回值是一个输入流InputStream
        InputStream is = socket.getInputStream();
        //使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据,
        byte[] bytes1 = new byte[1024];
        int len = is.read(bytes1);
        System.out.println(new String(bytes1,0,len));


        //获取网络字节输出流对象
        OutputStream os = socket.getOutputStream();
        //调用OutputStream对象的方法write，给服务器发送数据
        String str = "春风扶槛露华浓";
        byte[] bytes = str.getBytes();
        os.write(bytes);

    }
}

文件上传案例

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketAddress;

public class TCPClient {
    public static void main(String[] args) throws Exception {
        //创建字节输入流，绑定要读取的文件元
        //选择要上传的文件

        FileInputStream fis = new FileInputStream("E:\a.jpg");
        //创建Socket对象
        Socket socket = new Socket("127.0.0.1",11111);
        //获取OutputStream对象
        OutputStream os = socket.getOutputStream();
        int len =0;
        byte[] bytes = new byte[1024];
        //一边读取本地文件，一边写入到服务器
        while((len=fis.read(bytes))!=-1){
            os.write(bytes,0,len);
        }
        //写完之后要告诉服务器已经写完了
        //不然服务器会一直read(),会进入阻塞状态
        socket.shutdownOutput();
        //使用Socket方法，获取InputStream对象
        InputStream is = socket.getInputStream();
        while((len=is.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }

        fis.close();
        socket.close();
    }
}

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) throws Exception {
        //创建服务器
        ServerSocket server = new ServerSocket(11111);
        //调用server的方法accept,他会返回一个Socket
        while (true) {
            Socket socket = server.accept();
            InputStream is = socket.getInputStream();
            //创建字节输出流，绑定要输出的目的地
            String file = "train" + System.currentTimeMillis();
            FileOutputStream fos = new FileOutputStream("E:\study\demo14\" + "\" + file + ".jpg");
            int len = 0;
            byte[] bytes = new byte[1024];
            while ((len = is.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
            socket.getOutputStream().write("上传成功".getBytes());
            fos.close();
            socket.close();
        }
    }
}