笔记-迎难而上之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的特点:
- 只负责数据的输出，不负责数据的读取
- 与其他输出流不同，PrintStream 永远不会抛出 IOException
- 有特有的方法,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();
}
}
}
