javaSE---输入输出流2

最新推荐文章于 2024-04-16 14:10:01 发布

三斤伍花肉

最新推荐文章于 2024-04-16 14:10:01 发布

阅读量77

点赞数

分类专栏：笔记 javaSE io 文章标签： java

本文链接：https://blog.csdn.net/sinat_50855580/article/details/112147594

版权

笔记同时被 3 个专栏收录

78 篇文章 0 订阅

订阅专栏

javaSE

30 篇文章 0 订阅

订阅专栏

4 篇文章 0 订阅

订阅专栏

java中的输入输出流2

一：IO流的划分与区别【字节流与字符流】？
IO流用来读写文件的内容
流–数据的流动轨迹。

按照数据的流动方向
输入流—将数据读取到我们的处理程序中所形成的数据的流动轨迹就是输入流【读取数据】
输出流—将我们程序处理以后的数据写出到某一个文件中所形成的数据的流动轨迹就是输出流【写出数据】
按照每一次读写数据的大小
字节流—每一次读写一个字节【8位2进制】的数据量的流【字节流】
由于所有的数据都可被换算成字节，所以字节流是可以读写任何类型的数据【文本，视频，音频，图片】
字符流—每一次读写一个字符【16位2进制】的数据量的流【字符流】
不能读写任何类型的数据，只能读写文本类型的数据。
IO流的综合划分

在这里插入图片描述
二、常用的字节输入与字节输出流类
1.字节输出流—顶级类OutputStream
public abstract class OutputStream-----不能new
1.1 public class FileOutputStream extends OutputStream
构造方法

FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。 
FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。  
FileOutputStream(String name, boolean append) 通过String对象创建一个是否追加的字节输出流

例如：

package com.wangxing.fileoutput;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class FileOutPutStreamDemo {
	public static void main(String[] args) throws FileNotFoundException {
		//构造方法：
		/*
		FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。 
		FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。 

		FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
		FileOutputStream(String name, boolean append) 通过String对象创建一个是否追加的字节输出流
		*/
		
		//FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。 
		String stu1="D:"+File.separator+"Develop"+File.separator+"myfile1.txt";
		File file=new File(stu1);
		FileOutputStream out1=new FileOutputStream(file);
		//或者
		FileOutputStream out11=new FileOutputStream(new File("D:"+File.separator+"Develop"+File.separator+"myfile2.txt"));
		//上转型
		OutputStream out111=new FileOutputStream(file);
		
		//FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。 
		FileOutputStream out2=new FileOutputStream(stu1);
		FileOutputStream out22=new FileOutputStream("D:"+File.separator+"Develop"+File.separator+"myfile1.txt");
		OutputStream out222=new FileOutputStream(stu1);
		
		//FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
		FileOutputStream out3=new FileOutputStream(file,true);
		//或者
		FileOutputStream out33=new FileOutputStream(new File("D:"+File.separator+"Develop"+File.separator+"myfile2.txt"),true);
		//上转型
		OutputStream out333=new FileOutputStream(file,true);
		
		//FileOutputStream(String name, boolean append) 通过String对象创建一个是否追加的字节输出流
		FileOutputStream out4=new FileOutputStream(stu1,true);
		FileOutputStream out44=new FileOutputStream("D:"+File.separator+"Develop"+File.separator+"myfile1.txt",true);
		OutputStream out444=new FileOutputStream(stu1,true);
	}
}

实例方法：

实例方法
 Void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。 
 Void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 
 Void	write(int b) 将指定的字节写入此文件输出流。 
 Void	close() 关闭此文件输出流并释放与此流相关联的任何系统资源。

例如：

package com.wangxing.fileoutput;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutPutStreamDemo2 {

	public static void main(String[] args) throws IOException {
		/*
		 * 实例方法
           Void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。 
//           Void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 
           Void	write(int b) 将指定的字节写入此文件输出流。 
           Void	close() 关闭此文件输出流并释放与此流相关联的任何系统资源。 
		 */
		//1.准备需要写出的数据
		String info="Hello,World";
		//2.创建字节输出流对象
		String stu1="D:"+File.separator+"Develop"+File.separator+"myfile1.txt";
		File file=new File(stu1);
		FileOutputStream out1=new FileOutputStream(file,true);
		//Void	write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。 
		out1.write(info.getBytes());
		
		//关闭流
		out1.close();
		// Void	write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 
		//byte数组，从off位置写len个元素
		FileOutputStream out2=new FileOutputStream(file,true);
		byte[] b=info.getBytes();
		out2.write(b, 5, 5);
		// Void	write(int b) 将指定的字节写入此文件输出流。 
		out2.write(85);
		out2.close();
	}

}

在这里插入图片描述
2.字节输入流—顶级类InputStream
public abstract class InputStream—不能new
2.1public class FileInputStream extends InputStream

FileInputStream(File file) 通过File对象创建一个字节输入流

FileInputStream(String name) 通过String对象创建一个字节输入流

例如：

package com.wangxing.fileput;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

public class FileInPutStreamDemo1 {

	public static void main(String[] args) throws FileNotFoundException {
		//字节输入流 InPutStream的构造方法：
		/*
		FileInputStream(File file) 通过File对象创建一个字节输入流
		FileInputStream(String name) 通过String对象创建一个字节输入流
		*/
		//FileInputStream(File file) 通过File对象创建一个字节输入流
		String stu1="D:"+File.separator+"Develop"+File.separator+"myfile1.txt";
		File file=new File(stu1);
		FileInputStream put1=new FileInputStream(file);
		InputStream put11=new FileInputStream(file);
		
		//FileInputStream(String name) 通过String对象创建一个字节输入流
		FileInputStream put2=new FileInputStream(stu1);
		InputStream put22=new FileInputStream(stu1);
	}

}

实例方法：

int	read() 从该输入流读取一个字节的数据。 
返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
int	read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
返回值:读取的总字节数， 如果到达文件末尾返回-1
void	close() 关闭此文件输入流并释放与流相关联的任何系统资源。

package com.wangxing.fileput;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class FileInPutStreamDemo2 {

	public static void main(String[] args) throws IOException {
		/*
		 * int	read() 从该输入流读取一个字节的数据。 
                    返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
           int	read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
                    返回值:读取的总字节数， 如果到达文件末尾返回-1
           void	close() 关闭此文件输入流并释放与流相关联的任何系统资源。 
		 */
		String stu1="D:"+File.separator+"Develop"+File.separator+"myfile1.txt";
		File file=new File(stu1);
		FileInputStream put1=new FileInputStream(file);
		InputStream put11=new FileInputStream(file);
		//int	read() 从该输入流读取一个字节的数据。 
        //返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
//		byte bytearray[]=new byte[(int)file.length()]; 
//		int len=put1.read(bytearray);
//		System.out.println(len);//元素个数
//		//断流
//		put1.close();
//		//元素：
//		String info=new String(bytearray);
//		System.out.println(info);
		
		//int	read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
//        返回值:读取的总字节数， 如果到达文件末尾返回-1
		int len2=put1.read();//调用一次获取一个元素
		System.out.println("len2=="+len2);
	}

}

1.2 public class DataOutputStream extends FilterOutputStream implements DataOutput
数据输出流使应用程序以便携式方式将原始Java数据类型写入输出流
构造方法：
DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
实例方法：

void	writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。 
void	writeByte(int v) 将 byte作为1字节值写入底层输出流。 
void	writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。 
void	writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。 
void	writeFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入该 int值基础输出流作为一个4字节的数量，高字节。 
void	writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。 
void	writeLong(long v) 将 long写入底层输出流，为8字节，高字节为首。 
void	writeShort(int v) 将 short写入底层输出流作为两个字节，高字节优先。 
void	writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流。 
void	flush() 刷新此数据输出流。 
 void	close() 关闭此输出流并释放与此流相关联的任何系统资源。

例如：

package com.wangxing.dataoutputStream;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutPutStreamDemo1 {

	public static void main(String[] args) throws IOException {
		//DataOutPutStream直接写出基本数据类型，无需转换成字节数组
		//将被写出的基本数据类型转换成2进制形式，保存在文件中的数据是乱码
		//DataOutPutStream 构造方法
//		DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。 
		String stu1="D:"+File.separator+"Develop"+File.separator+"myfile1.txt";
		File file=new File(stu1);
		FileOutputStream out1=new FileOutputStream(file);//底层输出流
		DataOutputStream dataout1=new DataOutputStream(out1);//高级输出流
		
		//DataOutPutStream 实例方法
		/*
		 * void	writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。 
           void	writeByte(int v) 将 byte作为1字节值写入底层输出流。 
           void	writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。 
           void	writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。 
           void	writeFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入该 int值基础输出流作为一个4字节的数量，高字节。 
           void	writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。 
           void	writeLong(long v) 将 long写入底层输出流，为8字节，高字节为首。 
           void	writeShort(int v) 将 short写入底层输出流作为两个字节，高字节优先。 
           void	writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流。 
           void	flush() 刷新此数据输出流。 
           void	close() 关闭此输出流并释放与此流相关联的任何系统资源。 
		 */
		//void	writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。 
		dataout1.writeInt(1001);
		//void	writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
		dataout1.writeChar('\t');
		//void	writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。 
		dataout1.writeDouble(168.5);
		dataout1.writeChar('\t');
		//void	writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。 
		dataout1.writeBoolean(true);
		dataout1.writeChar('\t');
		//void	writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流。 
		dataout1.writeUTF("zhangsan");
		//void	flush() 刷新此数据输出流。 
		dataout1.flush();
		dataout1.close();
		out1.close();

	}

}

2.2 public class DataInputStream extends FilterInputStream implements DataInput
构造方法：

DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。

实例方法：

boolean	readBoolean() 
byte	readByte() 
char	readChar() 
double	readDouble() 
float	readFloat() 
int	readInt() 
long	readLong() 
short	readShort() 
String  readUTF() 
void	close()

例如：

package com.wangxing.dataputStream;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class DataPutStreamDemo1 {

	public static void main(String[] args) throws IOException {	
		//构造方法：
		// DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。
		String stu1="D:"+File.separator+"Develop"+File.separator+"myfile1.txt";
		File file=new File(stu1);
		FileInputStream in=new FileInputStream(file);
//		InputStream in2=new FileInputStream(file);
		DataInputStream din=new DataInputStream(in);
		
		//实例方法：
		/*
		boolean	readBoolean() 
		byte	readByte() 
		char	readChar() 
		double	readDouble() 
		float	readFloat() 
		int	readInt() 
		long	readLong() 
		short	readShort() 
		String  readUTF() 
		void	close() 
		*/ 
		boolean boo1=din.readBoolean();
		byte byte1=din.readByte();
		char char1=din.readChar();
		double double1=din.readDouble();
		float float1=din.readFloat();
		int int1=din.readInt();
		long long1=din.readLong();
		short short1=din.readShort();
		String utf=din.readUTF();
		din.close();
		in.close();
		System.out.println(boo1);
		System.out.println(byte1);
		System.out.println(char1);
		System.out.println(double1);
		System.out.println(float1);
		System.out.println(int1);
		System.out.println(long1);
		System.out.println(short1);
		System.out.println(utf);
		
	}

}

三.什么是序列化？如何实现序列化？
因为我们做操作的java对象可能需要在多台计算机之间传递。
序列化-----将一个java对象转换成2进制流数据过程。
反序列化—2进制流数据转换成一个java对象的过程。
在这里插入图片描述

如何实现序列化？
1.为被序列化的java对象的生成类实现一个序列化接口【Serializable】
public interface Serializable
特殊----该接口中一个方法都没有。
类的序列化由实现java.io.Serializable接口的类启用。不实现此接口的类将不会使任何状态序列化或反序列化。可序列化类的所有子类型都是可序列化的。
2. 通过java提供ObjectOutputStream类的writeObject(Object obj)
ObjectOutputStream的构造方法：

ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。

实例方法

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

例如：
Student类：

package com.wangxing.objectoutput;

import java.io.Serializable;

public class Student implements Serializable{ 
	
		public void  testMethod() {
			System.out.println("这是Student类的实例方法");
		}

}

序列化：

package com.wangxing.objectoutput;

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

public class ObjectOutPut {

	public static void main(String[] args) throws IOException {
		Student student=new Student();
		//构造方法：
		// ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。 
		String stu1="D:"+File.separator+"Develop"+File.separator+"Students.txt";
		File file=new File(stu1);
		FileOutputStream fops=new FileOutputStream(file);
		ObjectOutputStream oops=new ObjectOutputStream(fops);
		//实例方法：
		//void	writeObject(Object obj) 将指定的对象写入ObjectOutputStream。 
		oops.writeObject(student);
		oops.flush();//刷新
		oops.close();//关流
		fops.close();
	}

}

在这里插入图片描述
反序列化：
将上面序列化到记事本文件中的java对象，反序列化回来成一个可使用的java对象。此时就需要ObjectInputStream类的Object readObject()方法读取对象。
ObjectInputStream类
构造方法：

ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。

实例方法：

Object readObject() 从ObjectInputStream读取一个对象。

例如：

package com.wangxing.objectoutput;

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

public class test {

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//构造方法：
//		ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。 
//		实例方法
//		Object	readObject() 从ObjectInputStream读取一个对象。 
		//ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。 
		String path1="D:"+File.separator+"Develop"+File.separator+"Student.txt";
		File file=new File(path1);
		FileInputStream  in=new FileInputStream(file);
		ObjectInputStream  objin=new ObjectInputStream(in);
		Object  obj=objin.readObject();
	    objin.close();
		in.close();
		Student stu=(Student)obj;
		stu.testMethod();

	}

}

在这里插入图片描述

三斤伍花肉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
javaSE---输入输出流2

java中的输入输出流2一：IO流的划分与区别【字节流与字符流】？IO流用来读写文件的内容流–数据的流动轨迹。按照数据的流动方向输入流—将数据读取到我们的处理程序中所形成的数据的流动轨迹就是输入流【读取数据】输出流—将我们程序处理以后的数据写出到某一个文件中所形成的数据的流动轨迹就是输出流【写出数据】按照每一次读写数据的大小字节流—每一次读写一个字节【8位2进制】的数据量的流【字节流】由于所有的数据都可被换算成字节，所以字节流是可以读写任何类型的数据【文本，视频，音频，图片】字符流
复制链接

扫一扫

专栏目录