活动地址：优快云21天学习挑战赛
Java中的输入输出流–字节流
9.3.常用的字节输入与字节输出流类
1.字节输出流—顶级类OutputStream
public abstract class OutputStream-----不能new
1.1 public class FileOutputStream extends OutputStream
构造方法
package com.lx.test1;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestFileOutputStream1 {
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
//FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。
String path1="F:"+File.separator+"test"+File.separator+"test1.txt";
File file1=new File(path1);
FileOutputStream out1=new FileOutputStream(file1);
OutputStream out11=new FileOutputStream(file1);
//FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。
FileOutputStream out2=new FileOutputStream(file1,true);
OutputStream out22=new FileOutputStream(file1,true);
//FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。
FileOutputStream out3=new FileOutputStream(path1);
OutputStream out33=new FileOutputStream(path1);
//FileOutputStream(String name, boolean append) 通过String对象创建一个是否追加的字节输出流
FileOutputStream out4=new FileOutputStream(path1,true);
OutputStream out44=new FileOutputStream(path1,true);
}
}
实例方法
package com.lx.test1;
import java.io.File;
import java.io.FileOutputStream;
public class TestFileOutputStream2 {
public static void main(String[] args)throws Exception {
//通过输出流 的写出方法将数据输出到文件中
/*
//void write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
//1准备需要写出的数据
String info="hello,world";
//2.创建字节输出流对象
String path1="F:"+File.separator+"test"+File.separator+"test1.txt";
File file1=new File(path1);
FileOutputStream out1=new FileOutputStream(file1,true);
//3.void write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
out1.write(info.getBytes());
//4.关闭流
out1.close();
*/
/*
//void write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
//1准备需要写出的数据
String info="hello,world";
//2.创建字节输出流对象
String path1="F:"+File.separator+"test"+File.separator+"test1.txt";
File file1=new File(path1);
FileOutputStream out1=new FileOutputStream(file1,true);
//3.void write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
byte b[]=info.getBytes();
out1.write(b,6,5);
//4.关闭流
out1.close();
*/
//void write(int b) 将指定的字节写入此文件输出流。 [执行一次只写出一个字节]
//1准备需要写出的数据
String info="hello,world";
//2.创建字节输出流对象
String path1="F:"+File.separator+"test"+File.separator+"test1.txt";
File file1=new File(path1);
FileOutputStream out1=new FileOutputStream(file1,true);
//3.void write(int b) 将指定的字节写入此文件输出流。 [执行一次只写出一个字节]
byte bytearray[]=info.getBytes();
for(byte b:bytearray) {
out1.write(b);
}
//关闭流
out1.close();
}
}
上面的字节输出流只能写出字节数组，不能直接写出基本数据类型的数据
1.2 public class DataOutputStream extends FilterOutputStream implements DataOutput
数据输出流使应用程序以便携式方式将原始Java数据类型写入输出流
构造方法
DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
package com.lx.test2;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestDataOutputStream1 {
public static void main(String[] args)throws Exception {
//DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
String path1="F:"+File.separator+"test"+File.separator+"data2.txt";
File file=new File(path1);
//FileOutputStream out=new FileOutputStream(file);
OutputStream out=new FileOutputStream(file);
DataOutputStream dout=new DataOutputStream(out);
}
}
实例方法：
package com.lx.test2;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestDataOutputStream2 {
public static void main(String[] args)throws Exception {
//DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
String path1="F:"+File.separator+"test"+File.separator+"data2.txt";
File file=new File(path1);
//FileOutputStream out=new FileOutputStream(file);
OutputStream out=new FileOutputStream(file,true);
DataOutputStream dout=new DataOutputStream(out);
//void writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。
dout.writeInt(1001);
//void writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
dout.writeChar('\t');
//void writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。
dout.writeDouble(168.5);
dout.writeChar('\t');
//void writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。
dout.writeBoolean(true);
dout.writeChar('\t');
//void writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流。
dout.writeUTF("zhangsan");
//void flush() 刷新此数据输出流。
dout.flush();
dout.close();
out.close();
}
}
2.字节输出流—顶级类InputStream
public abstract class InputStream—不能new
2.1public class FileInputStream extends InputStream
FileInputStream(File file) 通过File对象创建一个字节输入流
FileInputStream(String name) 通过String对象创建一个字节输入流
package com.lx.test1;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestInputStream2 {
public static void main(String[] args)throws Exception {
//FileInputStream(File file) 通过File对象创建一个字节输入流
String path1="F:"+File.separator+"test"+File.separator+"info.txt";
File file1=new File(path1);
FileInputStream in1=new FileInputStream(file1);
InputStream in11=new FileInputStream(file1);
//FileInputStream(String name) 通过String对象创建一个字节输入流
FileInputStream in2=new FileInputStream(path1);
InputStream in22=new FileInputStream(path1);
}
}
实例方法
package com.lx.test2;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestDataInputStream {
public static void main(String[] args)throws Exception {
//读取info.txt中的数据值到我们的程序中
/*
//创建被读取数据的文件路径
String path1="F:"+File.separator+"test"+File.separator+"info.txt";
//根据文件路径创建对应的Fiel对象
File file1=new File(path1);
//创建字节输入流对象
InputStream in1=new FileInputStream(file1);
//int read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。
//返回值:读取的总字节数， 如果到达文件末尾返回-1
byte bytearray[]=new byte[(int)file1.length()];
int len=in1.read(bytearray);
//关闭流
in1.close();
String info=new String(bytearray,0,len);
System.out.println(info);
*/
//创建被读取数据的文件路径
String path1="F:"+File.separator+"test"+File.separator+"info.txt";
//根据文件路径创建对应的Fiel对象
File file1 = new File(path1);
//创建子街输入流对象
InputStream in1 = new FileInputStream(file1);
//int read()从该输入流读取一个字节的数据。
//返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1
byte bytearray[] = new byte[(int)file1.length()];
//保存每一次读取的数据值
int data = 0;
//数组下标
int len = 0;
while((data = in1.read())!=-1) {
bytearray[len]=(byte)data;
len++;
}
//关闭流
in1.close();
String info = new String(bytearray,0,len);
System.out.println(info);
}
}
2.2 public class DataInputStream extends FilterInputStream implements DataInput
构造方法
DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。
package com.lx.test2;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestDataInputStream {
public static void main(String[] args)throws Exception {
//DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。
String path1="F:"+File.separator+"test"+File.separator+"data.txt";
File file=new File(path1);
//FileInputStream in=new FileInputStream(file);
InputStream in=new FileInputStream(file);
DataInputStream din=new DataInputStream(in);
}
}
package com.lx.test2;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestDataInputStream {
public static void main(String[] args)throws Exception {
//DataInputStream(InputStream in) 创建使用指定的底层InputStream的DataInputStream。
String path1="F:"+File.separator+"test"+File.separator+"data.txt";
File file=new File(path1);
//FileInputStream in=new FileInputStream(file);
InputStream in=new FileInputStream(file);
DataInputStream din=new DataInputStream(in);
//int readInt()
int intvalue=din.readInt();
//char readChar()
char op1=din.readChar();
//double readDouble()
double doublevalue=din.readDouble();
char op2=din.readChar();
//boolean readBoolean()
boolean booleanvalue=din.readBoolean();
char op3=din.readChar();
//String readUTF()
String string=din.readUTF();
din.close();
in.close();
System.out.println(intvalue);
System.out.println(doublevalue);
System.out.println(booleanvalue);
System.out.println(string);
}
}
9.4.什么是序列化？如何实现序列化？
因为我们做操作的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。
将java对象序列化到记事本文件。
package com.lx.test1;
import java.io.Serializable;
public class Student implements Serializable {
public void testMethod() {
System.out.println("这是Student类的实例方法");
}
}
package com.lx.test1;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class TestMain {
public static void main(String[] args)throws Exception {
Student student=new Student();
//ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。
String path1="F:"+File.separator+"test"+File.separator+"student2.txt";
File file=new File(path1);
FileOutputStream out=new FileOutputStream(file);
ObjectOutputStream objout=new ObjectOutputStream(out);
objout.writeObject(student);
objout.flush();
objout.close();
out.close();
}
}
将上面序列化到记事本文件中的java对象，反序列化回来成一个可使用的java对象。此时就需要ObjectInputStream类的Object readObject()方法读取对象。
ObjectInputStream类
构造方法
ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。
实例方法
Object readObject() 从ObjectInputStream读取一个对象。
package com.lx.test1;
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class Test {
public static void main(String[] args)throws Exception {
//ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。
String path1="F:"+File.separator+"test"+File.separator+"student2.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();
}
}
java中的输入输出流–字符流
9.5.常用的字符输入与字符输出流类
1.字符输出流—顶级类Writer
public abstract class Writer—不能new
1.1FileWriter — 方便写字符文件
构造方法
package com.lx.test1;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestWriter1 {
public static void main(String[] args) throws Exception{
//FileWriter(File file) 给一个File对象构造一个FileWriter对象。
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
File file1 = new File(path);
FileWriter out1 =new FileWriter(file1);
Writer out11 =new FileWriter(file1);
//FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。
FileWriter out2 = new FileWriter(file1,true);
Writer out22 = new FileWriter(file1,true);
//FileWriter(String fileName) 给一个String对象构造一个FileWriter对象。
FileWriter out3 = new FileWriter(path);
Writer out33 = new FileWriter(path);
//FileWriter(String fileName, boolean append) 给一个String对象构造一个是否允许追加FileWriter对象。
FileWriter out4 = new FileWriter(path,true);
Writer out44 = new FileWriter(path,true);
}
}
实例方法
package com.lx.test1;
import java.io.File;
import java.io.FileWriter;
public class TestWriter2 {
public static void main(String[] args) throws Exception{
//创建字符输出流对象
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
File file1 = new File(path);
FileWriter out1 = new FileWriter(file1);
//准备需要写出的数据
String info = "hello,world";
/*
//void write(char[]cbuf)写入一个符数组
char cbuf[]=info.toCharArray();
out1.write(cbuf);
*/
/*
//void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
char cbuf[]=info.toCharArray();
out1.write(cbuf,6,5);
*/
/*
//void write(int c) 写一个字符
char cbuf[]=info.toCharArray();
for(char c:cbuf) {
out1.write(c);
*/
/*
//void write(String str) 写一个字符串
out.write(info);
*/
//void write(String str, int off, int len) 写一个字符串的一部分。
out1.write(info,6,5);
out1.flush();
out1.close();
}
}
1.2 public class BufferedWriter—将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
构造方法
package com.lx.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
public class TestBufferedWriter1 {
public static void main(String[] args)throws Exception {
//BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
File file=new File(path);
FileWriter out=new FileWriter(file); //底层字符输出流
BufferedWriter bout1=new BufferedWriter(out);//高级字符输出流
//BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
BufferedWriter bout2=new BufferedWriter(out,100);//高级字符输出流
}
}
实例方法
package com.lx.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
public class TestBufferedWriter2 {
public static void main(String[] args)throws Exception {
//BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
File file=new File(path);
FileWriter out = new FileWriter(file);//底层字符输出流
BufferedWriter bout1 = new BufferedWriter(out);//高级字符输出流
//准备输出的数据
String info1 = "hello,world";
String info2 = "hello,world";
/*
//void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
char array[]=info.toCharArray();
bout1.write(array, 0, 5);
*/
/*
//void write(int c) 写一个字符
char array[]=info.toCharArray();
for(char c:array){
bout1.write(c);
}
*/
/*
//void write(String s, int off, int len) 写一个字符串的一部分。
bout1.write(info, 0, info.length());
*/
bout1.write(info1,0,info1.length());
//void newLine()写一行行分隔符
bout1.newLine();
bout1.write(info2, 0, info2.length());
bout1.flush();
bout1.close();
out.close();
}
}
1.3 public class OutputStreamWriter—将字节输出流转换成字符输出流
构造方法
OutputStreamWriter(OutputStream out) 将字节输出流转换成字符输出流
实例方法
package com.lx.test3;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class TestOutputStreamWriter {
public static void main(String[] args)throws Exception {
String info = "hello,world";
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
FileOutputStream out=new FileOutputStream(path);
//我们是可以通过FileOutputStream这个字节输出流将数据保存到文件中，
//但是需要将被保存的文件转换成字节数组才可以。
//如果我们不想将将被保存的文件转换成字节数组写出，这时我们可以通过OutputStreamWriter，
//将字节输出流转换成字符输出流，直接写出String数据
OutputStreamWriter owtiter=new OutputStreamWriter(out);
owtiter.write(info);
owtiter.flush();
owtiter.close();
out.close();
}
}
2.字符输入流—顶级类Reader
public abstract class Reader—不能new
2.1 FileReader—读取字符文件的
构造方法
package com.lx.test1;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestFileReader1 {
public static void main(String[] args)throws Exception {
//FileReader(File file) 创建一个新的 FileReader ，给出 File读取。
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
File file1=new File(path);
FileReader in1=new FileReader(file1);
Reader in11=new FileReader(file1);
//FileReader(String fileName)创建一个新的 FileReader ，给定要读取的文件的名称。
FileReader in2=new FileReader(path);
Reader in22=new FileReader(path);
}
}
实例方法
package com.lx.test1;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class TestBufferedReader2 {
public static void main(String[] args)throws Exception {
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
File file=new File(path);
FileReader in=new FileReader(file);
BufferedReader bin1=new BufferedReader(in);
//String readLine() 读一行文字。
//定义保存每一行数据的字符串变量
String line=null;
while((line=bin1.readLine())!=null) {
System.out.println(line);
}
bin1.close();
in.close();
}
}
2.2 public class BufferedReader–从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
构造方法
package com.lx.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class TestBufferedReader1 {
public static void main(String[] args)throws Exception {
//BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
File file=new File(path);
FileReader in=new FileReader(file);
BufferedReader bin1=new BufferedReader(in);
//BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。
BufferedReader bin2=new BufferedReader(in,100);
}
}
实例方法
package com.lx.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class TestInputStreamReader {
public static void main(String[] args)throws Exception {
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
FileInputStream in=new FileInputStream(path);
InputStreamReader ireader=new InputStreamReader(in);
BufferedReader bin=new BufferedReader(ireader);
String line=null;
while((line=bin.readLine())!=null) {
System.out.println(line);
}
bin.close();
ireader.close();
in.close();
}
}
使用BufferedReader的readLine方法来代替Scanner类的nextLine方法从控制台不去数据
package com.lx.test2;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class TestBufferedReader3 {
public static void main(String[] args)throws Exception {
BufferedReader bin1=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入姓名:");
String name=bin1.readLine();
System.out.println("你输入的姓名是==="+name);
}
}
2.3 public class InputStreamReader—将字节输入流转换成字符输入流
构造方法
InputStreamReader(InputStream in) 将字节输入流转换成字符输入流
实例方法
package com.lx.test3;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class TestInputStreamReader {
public static void main(String[] args)throws Exception {
String path="F:"+File.separator+"test"+File.separator+"msg.txt";
FileInputStream in=new FileInputStream(path);
InputStreamReader ireader=new InputStreamReader(in);
BufferedReader bin=new BufferedReader(ireader);
String line=null;
while((line=bin.readLine())!=null) {
System.out.println(line);
}
bin.close();
ireader.close();
in.close();
}
}
9.6.输入输出流的操作步骤
输入输出的操作步骤:
1.创建文件对象【File对象】，指定输入输出的位置
2.创建输入输出流对象
1.文本选字符流，其他的选字节
2.读取选输入，保存选输出
3.调用read()/write()方法
4.关闭流
扫一扫
2439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
