java中的输入输出流2
9.2.IO流的划分与区别【字节流与字符流】？
IO流用来读写文件的内容 流--数据的流动轨迹。
- 按照数据的流动方向
输入流---将数据读取到我们的处理程序中所形成的数据的流动轨迹就是输入流【读取数据】
输出流---将我们程序处理以后的数据写出到某一个文件中所形成的数据的流动轨迹就是输出流【写出数据】
2.按照每一次读写数据的大小
字节流---每一次读写一个字节【8位2进制】的数据量的流【字节流】 由于所有的数据都可被换算成字节，所以字节流是可以读写任何类型的数据 【文本，视频，音频，图片】
字符流---每一次读写一个字符【16位2进制】的数据量的流【字符流】 不能读写任何类型的数据，只能读写文本类型的数据。
IO流的综合划分
9.3.常用的字节输入与字节输出流类
1.字节输出流---顶级类OutputStream
public abstract class OutputStream-----不能new
- 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.FileOutputStream;
import java.io.OutputStream;
public class FileOutPutStreamDemo1 {
public static void main(String[] args)throws Exception {
//字节输出流---OutPutStream[抽象类]
//FileOutputStream 构造方法
//FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。
//File file---File类型输出路径
String path1="f:"+File.separator+"20201201"+File.separator+"myfile1.txt";
File file1=new File(path1);
FileOutputStream out1=new FileOutputStream(file1);
//FileOutputStream out11=new FileOutputStream(new
//File("f:"+File.separator+"20201201"+File.separator+"myfile1.txt"));
//OutputStream out111=new FileOutputStream(file1);
//FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。
//String name---String类型输出路径
String path2="f:"+File.separator+"20201201"+File.separator+"myfile2.txt";
FileOutputStream out2=new FileOutputStream(path2);
//FileOutputStream out22=new
//FileOutputStream("f:"+File.separator+"20201201"+File.separator+"myfile2.txt");
//OutputStream out222=new FileOutputStream(path2);
//FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出
//流。
//File file---File类型输出路径
//boolean append--是否追加【true追加/false不可追加】
String path3="f:"+File.separator+"20201201"+File.separator+"myfile3.txt";
File file3=new File(path3);
FileOutputStream out3=new FileOutputStream(file3,true);
//FileOutputStream out33=new FileOutputStream(new
//File("f:"+File.separator+"20201201"+File.separator+"myfile3.txt"),true);
//OutputStream out333=new FileOutputStream(file3,false);
//FileOutputStream(String name, boolean append) 通过String对象创建一个是否追加的字
//节输出流
//String name---String类型输出路径
//boolean append--是否追加【true追加/false不可追加】
String path4="f:"+File.separator+"20201201"+File.separator+"myfile4.txt";
FileOutputStream out4=new FileOutputStream(path4,true);
//FileOutputStream out44=new
//FileOutputStream("f:"+File.separator+"20201201"+File.separator
// +"myfile4.txt",true);
//OutputStream out444=new FileOutputStream(path4,false);
}
}
实例方法
| 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.FileOutputStream;
public class FileOutPutStreamDemo2 {
public static void main(String[] args)throws Exception {
//FileOutputStream 实例方法
/*
//void write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
String path1="f:"+File.separator+"20201201"+File.separator+"myfile1.txt";
FileOutputStream out1=new FileOutputStream(path1,true);
String info="hello"; //被写出的数据String
byte bytearray[]=info.getBytes();
out1.write(bytearray);
out1.close();
*/
/*
//void write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写
//入此文件输出流。
String path1="f:"+File.separator+"20201201"+File.separator+"myfile2.txt";
FileOutputStream out1=new FileOutputStream(path1,true);
String info="helloworld"; //被写出的数据String
byte bytearray[]=info.getBytes();
out1.write(bytearray,5,5);
out1.close();
*/
//void write(int b) 将指定的字节写入此文件输出流。
String path1="f:"+File.separator+"20201201"+File.separator+"myfile3.txt";
FileOutputStream out1=new FileOutputStream(path1,true);
//out1.write(98);
String info="helloworld"; //被写出的数据String
byte bytearray[]=info.getBytes();
for(byte data:bytearray){
out1.write(data);
}
out1.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.fileinput;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class FileInputStreamDemo1 {
public static void main(String[] args)throws Exception {
//字节输入流---InputStream[抽象类]
//FileInputStream 构造方法
//FileInputStream(File file) 通过File对象创建一个字节输入流
//File file--File类型的输入路径
String path1="f:"+File.separator+"20201201"+File.separator+"myfile1.txt";
File file1=new File(path1);
FileInputStream in1=new FileInputStream(file1);
FileInputStream in11=new FileInputStream(new
File("f:"+File.separator+"20201201"+File.separator+"myfile1.txt"));
InputStream in111=new FileInputStream(file1);
//FileInputStream(String name) 通过String对象创建一个字节输入流
//String name--String类型的输入路径
String path2="f:"+File.separator+"20201201"+File.separator+"myfile2.txt";
FileInputStream in2=new FileInputStream(path2);
FileInputStream in22=new
FileInputStream("f:"+File.separator+"20201201"+File.separator+"myfile1.txt");
InputStream in222=new FileInputStream(path2);
}
}
实例方法
| int | read() 从该输入流读取一个字节的数据。 返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1 |
| int | read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。 返回值:读取的总字节数， 如果到达文件末尾返回-1 |
| void | close() 关闭此文件输入流并释放与流相关联的任何系统资源。 |
package com.wangxing.fileinput;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class FileInputStreamDemo2 {
public static void main(String[] args)throws Exception {
//FileInputStream 实例方法
//int read(byte[] b)
//从该输入流读取最多 b.length个字节的数据为字节数组。
//返回值:读取的总字节数， 如果到达文件末尾返回-1
/*
String path1="f:"+File.separator+"20201201"+File.separator+"myfile1.txt";
File file1=new File(path1);
FileInputStream in1=new FileInputStream(file1);
byte bytearray[]=new byte[(int)file1.length()];
int len=in1.read(bytearray);
in1.close();
String info=new String(bytearray);
System.out.println("info=="+info);
*/
//int read()
//从该输入流读取一个字节的数据。
//返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
String path1="f:"+File.separator+"20201201"+File.separator+"myfile2.txt";
File file1=new File(path1);
FileInputStream in1=new FileInputStream(file1);
//int len=in1.read(); 从该输入流读取一个字节的数据
byte bytearray[]=new byte[(int)file1.length()]; //用于保存读取来的数据
int len=0;//被读取来的数据所对应的整数值
int index=0;//字节数组下标
//持续读取直到文件末尾【-1】
while((len=in1.read())!=-1){
//保存读取的数据到数组
bytearray[index]=(byte)len;
index++;
}
in1.close();
String info=new String(bytearray);
System.out.println("info=="+info);
}
}
上面的字节输入输出流只能读写字节数组，不能直接控制基本数据类型的数据的读写
- 1 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.dataoutput;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class DataOutputStreamDemo1 {
public static void main(String[] args)throws Exception {
//DataOutputStream 可以直接写出基本类型数据，无需转换成字节数组
//将被写出的基本类型的数据转换成2进制形式写出，保存在文件中的数据是乱码
//DataOutputStream 构造方法
//DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输
//出流。
//OutputStream out---底层输出流[FileOutputStream]
String path1="f:"+File.separator+"20201201"+File.separator+"data1.txt";
File file1=new File(path1);
//FileOutputStream out1=new FileOutputStream(file1,true); //OutputStream的子类对
//象
OutputStream out1=new FileOutputStream(file1,true); //OutputStream的上转型对象
OutputStream的子类对象/OutputStream的上转型对象---底层输出流
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() 关闭此输出流并释放与此流相关联的任何系统资源。
*/
dataOut1.writeInt(1001); //int 1001 4
dataOut1.writeChar('\t');//char \t 2
dataOut1.writeBoolean(true); //boolean true 1
dataOut1.writeChar('\t');//char \t 2
dataOut1.writeDouble(12.5); //double 12.5 8
dataOut1.writeChar('\t');//char \t 2
dataOut1.writeUTF("zhangsan"); //String [utf-8] zhangsan 8
dataOut1.flush();
dataOut1.close();
out1.close();
}
}
2.2 public class DataInputStream extends FilterInputStream implements DataInput
构造方法
DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。
实例方法
| boolean | |
| byte | readByte() |
| char | readChar() |
| double | |
| float | |
| int | readInt() |
| long | readLong() |
| short | |
| String | readUTF() |
| void | close() |
package com.wangxing.datainput;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
public class DataInputStreamDemo1 {
public static void main(String[] args)throws Exception {
//DataInputStream 可以直接读取基本类型数据，无需转换成字节数组
//DataInputStream 构造方法
//DataInputStream(InputStream in) 创建一个新的数据输入流，以将从底层输入流中读取数
//据。
//InputStream in---底层输入流[FileInputStream]
String path1="f:"+File.separator+"20201201"+File.separator+"data1.txt";
File file1=new File(path1);
FileInputStream in1=new FileInputStream(file1); //InputStream的子类对象
//InputStream in1=new FileInputStream(file1); //InputStream的上转型对象
//InputStream的子类对象/InputStream的上转型对象---底层输入流
DataInputStream datain1=new DataInputStream(in1); // 高级输入流
//DataInputStream 实例方法
/*
boolean readBoolean()
byte readByte()
char readChar()
double readDouble()
float readFloat()
int readInt()
long readLong()
short readShort()
String readUTF()
void close()
*/
int intval=datain1.readInt(); //int 1001 4
char char1=datain1.readChar();//char \t 2
boolean booval=datain1.readBoolean(); //boolean true 1
char char2=datain1.readChar();//char \t 2
double douval=datain1.readDouble(); //double 12.5 8
char char3=datain1.readChar();//char \t 2
String stringval=datain1.readUTF(); //String [utf-8] zhangsan 8
datain1.close();
in1.close();
System.out.println(intval+" "+booval+" "+douval+" "+stringval);
}
}
9.4.什么是序列化？如何实现序列化？
因为我们做操作的java对象可能需要在多台计算机之间传递。
序列化-----将一个java对象转换成2进制流数据过程。
反序列化---2进制流数据转换成一个java对象的过程。
如何实现序列化？
1.为被序列化的java对象的生成类实现一个序列化接口【Serializable】
public interface Serializable
package com.wangxing.objectinoutput;
import java.io.Serializable;
//为被序列化的java对象的生成类实现一个序列化接口【Serializable】
public class Student implements Serializable{
public void testStudent(){
System.out.println("Student类的实例方法testStudent");
}
}
特殊----该接口中一个方法都没有。
类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化。 可序列化类的所有子类型都是可序列化的。
2.通过java提供ObjectOutputStream类的writeObject(Object obj)
ObjectOutputStream的构造方法
|
| ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。 |
实例方法
| void | writeObject(Object obj) 将指定的对象写入ObjectOutputStream。 |
package com.wangxing.objectinoutput;
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamDemo1 {
public static void main(String[] args)throws Exception {
//ObjectInputStream 构造方法
//ObjectInputStream(InputStream in) 创建从指定的InputStream读取的
//ObjectInputStream。
String path1="f:"+File.separator+"20201201"+File.separator+"student.txt";
File file1=new File(path1);
FileInputStream in1=new FileInputStream(file1);
//InputStream in1=new FileInputStream(file11);
ObjectInputStream objin1=new ObjectInputStream(in1);
//ObjectInputStream 实例方法
//Object readObject() 从ObjectInputStream读取一个对象。
Object obj=objin1.readObject();
Student student=(Student)obj;
objin1.close();
in1.close();
student.testStudent();
}
}
将上面序列化到记事本文件中的java对象，反序列化回来成一个可使用的java对象。此时就需要ObjectInputStream类的Object readObject()方法读取对象。
ObjectInputStream类
构造方法
ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。
实例方法
| Object | readObject() 从ObjectInputStream读取一个对象。 |
package com.wangxing.objectinoutput;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo1 {
public static void main(String[] args)throws Exception {
//ObjectOutputStream 构造方法
//ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的
//ObjectOutputStream。
String path1="f:"+File.separator+"20201201"+File.separator+"student.txt";
File file1=new File(path1);
FileOutputStream out1=new FileOutputStream(file1);
//OutputStream out1=new FileOutputStream(file1);
ObjectOutputStream objout1=new ObjectOutputStream(out1);
//ObjectOutputStream 实例方法
//void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
Student student=new Student();
objout1.writeObject(student);
objout1.flush();
objout1.close();
out1.close();
}
}
3357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
