[技术笔记] 【石家庄中心】IO流_字节流_转换流_打印流介绍及使用

本帖最后由小石姐姐于 2018-4-25 16:48 编辑

IO流_字节流_转换流_打印流介绍及使用

1 InputStream

2 OutputStream

3 ObjectOutputStream

4 ObjectInputStream

5 PrintWriter

6 OutputStreamWriter

7 InputStreamReader

8 PrintStream

9 PrintWriter

>>>>>>>> IO 流分类 <<<<<<<<<

* IO流分类:

* 按流向分:

* 输入流读取数据 FileReader 父类-->Reader

* 输出流写出数据 FileWriter 父类-->Writer

* 按数据类型分:

* 字节流

* 字节输入流读取数据 InputStream

* 字节输出流写出数据 OutputStream

* 字符流

* 字符输入流读取数据 Reader

* 字符输出流写出数据 Writer

*

* 按数据类型分类分的原因:

* 在计算机底层存储的单位都是字节(byte),所有的数据都是byte,用字节流读写数据的时候,

* 每次操作一个字节,一个汉子是2字节,读取一个汉子就需要读取两次,不是很方便,那使用字符流,

* 可以一次读取一个字符,需要几个字节由码表来定.

* 但是字符流也有他的局限性,它不能读取图片,和视频,字节流可以读取任何文件;

-------------------------------------------------------------

>>>>>>>> 字节输入,输出流简介 <<<<<<<<

InputStream

OutputStream

* 字节输入流:属于io包

* InputStream 此抽象类表示字节输入流的所有类的超类

* 可以一次读取一个字节,或一个字节数组

* 由于它是抽象类,需要通过它的子类去使用它,

* 子类有:

* FileInputStream:从文件中获得输入字节,可用于读取图像数据之类的原始字节流,

* 读字符时建议使用FileReader

* 间接子类:

* BufferedInputStream 高效输入缓冲流

*

* 字节输出流:

* OutputStream 此抽象类是输出字节流的超类.

* 字节输出流将字节直接写入到文件,没有缓冲区,因此不需要flush()刷新

* 需要通过子类去使用这个类

* 子类有:

* FileOutputStream: 用于写入图像数据之类的原始字节流.

* 写入字符时建议使用FileWriter

* 间接子类:

* BufferedOutputStream 高效输出缓冲流

*

----------------------------------------------------------

>>>>>>>> 字节流复制图片 <<<<<<<<

package com.jobday09;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

/*

* 分别使用子符流和字节流复制图片:

* 1.通过字符流复制的文件不能打开;

* 2.字节流可以

* 注意:

* 二进制文件只能使用字节流进行复制(也就使用windows自带记事本打不开读不懂的文件)

* 文本文件的复制既可以使用字符流,也可以使用字节流

解析 :

* 通过字符流复制的图片不能打开的

*

* 数据源目的地

* 传智学院.jpg 文件-------------->>java程序 -------------->> d:\\传智学院.jpg

*

* 1.字符读取图片文件:

* 把字节转换成字符,拿着字节到编码表中匹配,匹配上了就返回字符,如果匹配

* 不上,它会返回一个'?' 问好,这就造成了读取时的数据丢失.

* 2.文件读到jvm

* 3.把读到的数据写入到目标文件;

* 因为输出流的底层是字节,因此在写出的过程中,还会把字符对照这码表转回字节,

* 但是那些读进来的'?'问号无法转换会字节,就造成了数据的丢失.

* 并且我们可以查看通过字符流复制的图片,会比原图片小.

*/

public class 字节输入输出流的使用 {

public static void main(String[] args) throws IOException {

//字节流一次读取一个字节数组

method_01();

//字节流一次读写一个字节

method_02();

}

private static void method_02() throws FileNotFoundException, IOException {

//字节流一次读取一个字节

//创建字节输入流

FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\访问权限修饰符.jpg");

//创建字节输出流

FileOutputStream fos = new FileOutputStream("D:\\a\\访问权限修饰符.jpg");

int by;

while((by=fis.read())!=-1){

fos.write(by); //此处不需要刷新

}

fos.close();

fis.close();

}

//字节流一次读取一个字节数组

private static void method_01() throws FileNotFoundException, IOException {

//创建字节输入流

FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\访问权限修饰符.jpg");

//创建字节输出流

FileOutputStream fos = new FileOutputStream("D:\\a\\访问权限修饰符.jpg");

byte[] bys = new byte[1024];

int len ;

int i = 0;

while((len=fis.read(bys))!=-1){

System.out.println(len);

fos.write(bys, 0, len); //此处不需要刷新

i++;

}

fis.close();

fos.close();

System.out.println(i);

}

-------------------------------------------------------

>>>>>>>> 标准_输入输出流 <<<<<<<<<<<

* 标准输入输出流:

* public static final Inputstream in :字节输入流,用来读取键盘录入的数据

* InputStream is = System.in;

* public static final PrintStream out: 字节输出流,将数据输出到命令行

* System.out.println();

--------------------------------------------------------

>>>>>>> OutputStreamWriter_演示 <<<<<<<</

package com.jobday09;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.Writer;

public class OutputStreamWriter_演示 {

public static void main(String[] args) throws IOException {

// 创建输入流

BufferedReader br = new BufferedReader(new FileReader("IO流.txt"));

//创建高效输出流

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

String line ;

while((line=br.readLine())!=null){

bw.write(line);

bw.newLine();

bw.flush();

}

bw.close();

br.close();

}

private static void 标准流输出() throws FileNotFoundException, IOException {

// 创建输入流

BufferedReader br = new BufferedReader(new FileReader("IO流.txt"));

// 创建标准输出流对象

// OutputStream os = System.out;

// Writer w = new OutputStreamWriter(System.out);

Writer w = new OutputStreamWriter(System.out);

String line;

while ((line = br.readLine()) != null) {

w.write(line);

w.write("\r\n");

}

// 释放资源

w.close();

br.close();

}

private static void method01() throws FileNotFoundException, IOException {

// 创建输入流

BufferedReader br = new BufferedReader(new FileReader("IO流.txt"));

// 创建标准输出流对象

OutputStream os = System.out;

String line;

while ((line = br.readLine()) != null) {

/*

* //输出时要把字符串转成字节数组 os.write(line.getBytes()); //需要手动换行

* os.write("\r\n".getBytes());

*/

System.out.println(line);

// System.out.println();

}

// 释放资源

os.close();

br.close();

}

----------------------------------------------------

>>>>>>>> InputStreamReader_演示 <<<<<<<<<

package com.jobday09;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.Reader;

public class InputStreamReader_演示 {

public static void main(String[] args) throws IOException {

//创建输出流

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("fos.txt")));

//创建输输入流

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

// InputStream is = System.in;

// Reader r = new InputStreamReader(is);

/*byte[] bys = new byte[1024];

int len;*/

String str ;

while((str=br.readLine())!=null){

bw.write(str);

bw.newLine();

bw.flush();

if(str.equals("exit")){

break;

}

bw.close();

br.close();

}

------------------------------------------------------

>>>>>>>>> PrintStream / PrintWriter 概述 <<<<<<<<<<<

package com.jobday10;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.PrintWriter;

/*

* 打印流:

* PrintStream:

*

* PrintWriter:

* 可以自动换行,println()

* 不能输出字节(没有打印byte的方法),但是可以输出其它任意类型

* 通过某些配置,可以实现自动刷新(只有再调用println,printf或format才有用)

* 也是包装流,不具备写出功能(需要构建在基本流之上)

* 可以把字节输出流转换成字符输出流(构造方法可以传入以个标准输出流对象<字节流对象InputStream>)

*

* 注意: 只能输出不能输入

*/

public class PrintStream_PrintWriter {

public static void main(String[] args) throws IOException {

//创建输出流对象

PrintWriter pw = new PrintWriter("b.txt");

//写出数据

pw.write("java");

pw.write("world");

pw.write("hello");

pw.close();

}

-----------------------------

>>>>>> PrintStream / PrintWriter 打印流的自动刷新功能 <<<<<<<<

package com.jobday10;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

/* PrintWriter 与 PrintStream 一样

* 打印流的特有功能:

* 自动换行 : 使用方法println()实现自动换行

* 自动刷新 : 1.创建PrintWriter对象时启动自动刷新开关,并

* 且使用println(),printf(),format()三个方法实现自动刷新

* 2.启动刷新功能后,每输入一行就刷新写入一行

*

* 注意:1.创建FileWriter对象时boolean参数是否追加()

* 意思是:当用FileWriter对象最为打印流的参数时,可以打开FileWriter的自动追加功能,追加功能打开后

* 它会在上次输入结束处继续写入(不另起一行);

* 2.而创建打印流对象的boolean类型参数是否自动刷新

* PrintWriter类中带自动刷新的构造函数: PrintStream 也有类似方法

* PrintWriter(Writer out, boolean autoFlush)

* PrintWriter(OutputStream out, boolean autoFlush)

*

*/

public class 打印流的特有功能 {

public static void main(String[] args) throws IOException {

PrintWriter pw = new PrintWriter(new FileWriter("b.txt",true),true);

pw.println("haha");

pw.println("hehe");

pw.println("pingguo");

//注释掉释放功能,查看是否自动刷新,(结果:自动刷新)

//pw.close();

}

-------------------------------------------------

>>>>>> 使用打印流复制文本文件 <<<<<<<<

package com.jobday10;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

/*

* 使用打印流复制文本文件

*

* 数据源 IO流.txt 读取可以使用BufferedReader,一次可以读取一行

* 目的地 d:\\SystemInOutDemo.java 输出使用 PrintWriter

*/

public class 打印流复制文本 {

public static void main(String[] args) throws IOException {

//创建输入流对象

BufferedReader br = new BufferedReader(new FileReader("IO流.txt"));

//创建打印流对象

PrintWriter pw = new PrintWriter(new FileWriter("d:\\SysInOutDemo.java"),true);

String line;//存储读取的每行数据

while((line=br.readLine())!=null){

//写入

pw.println(line);//使用打印流以后,比普通的写入流,少了两行数据

//1.换行命令newLine/ "\r\n"

//2.刷新命令 flush()

}

pw.close();

br.close();

//有使用File的delete()方法件"d:\\SysInOutDemo.java"进行了删除

File file = new File("d:\\SysInOutDemo.java");

System.out.println(file.delete());

}

---------------------------------------------------------

>>>>>>>>> 对象造作流的概述 <<<<<<<<<<

* 对象操作流: 可以用于读写任意类型的对象

* 按照 <流向> 分类可以分为两种: 两种流的使用是对称相似的

* 1.对象输出流

* ObjectOutputStream //一个搞对象的字节数输出流

* 写对象方法

* writerObject()

* //构造方法,可以传入一个标准输出流

* ObjectOutputStream(OutputStream out);

* 2.对象输入流

* ObjectInputStream

* //读取对象

* readObject()

* //构造方法也可传入以变准输入流对象

* ObjectInputStream(InputStream in);

*

* 注意:

* 使用对象输出流写出对象,只能使用对象输入流来读取对象

* 只能将支持java.io.Serializable 接口的对象写入流中

*

* Serializable 接口:

* 类通过实现java.io.Serializable 接口启用起序列化功能.

* 未实现此接口的类将无法使用其任何状态序列化或反序列化.可序列化类

* 的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识

* 可序列化的语义。

*

------------------------------------

package com.jobday10;

import java.io.EOFException;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

/*

* 使用对象输出流和对象输入流读写对象:

* 注意:

* 1.将没有实现 io.Serializable接口的类的对象写出到文件是会报出"java.io.NotSerializableException"异常

* 该异常为:API 文档描述,当实例需要具有序列化接口时，抛出此异常。

* 2.创建一个实现了Serializable接口的类,它不需要实现方法,直接继承就行

* 3.对象输入流的读取方法,当读取完对象时,不返回null,或者-1之类的,它读取完最

* 后一个数据后就会抛出"java.io.EOFException"API文档描述:当输入过程中意外到达文件或流的末尾时，抛出此异常

* 这样我们就可以利用try...catch...捕获该异常,当捕获到该异常时就说明读取完数据了,然后在往下执行代码;

*

*/

import java.io.Serializable;

public class 对象操作流_读写对象 {

public static void main(String[] args) throws IOException, ClassNotFoundException {

对象输出流_写出对象();

//创建输入流对象的对象

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ObjectOutputStream"));

//读取对象

/*Object obj = ois.readObject();

System.out.println(obj);

Object obj2 = ois.readObject();

System.out.println(obj2);

Object obj3 = ois.readObject();

System.out.println(obj3);

ois.close();//释放资源

*/

//正确读取对象的方法

try{

while(true){

Object obj = ois.readObject();

System.out.println(obj);

}

}catch(EOFException e){

System.out.println("读到了文件的末尾");

}

/*Output:

Student [name=pingguo, age=15]

Student [name=xiangjiao, age=16]

读到了文件的末尾

*///~

}

//将对象写出到文件

private static void 对象输出流_写出对象() throws IOException, FileNotFoundException {

//创建对象输出流的对象

/*

FileOutputStream fos = new FileOutputStream("ObjectOutputStream");

//将字节输出流对象作为参数传入对象输出流

ObjectOutputStream oos = new ObjectOutputStream(fos);

*/

//上边的两步创建对象,可以和为一步,如下

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ObjectOutputStream"));

//创建学生对象

Student s1 = new Student("pingguo",15);

Student s2 = new Student("xiangjiao",16);

//将对象写入文件

oos.writeObject(s1);

oos.writeObject(s2);

//释放资源

oos.close();

}

//创建一个实现了Serializable接口的类,它不需要实现方法,直接继承就行

class Student implements Serializable{

String name;

int age;

public Student(String name, int age) {

super();

this.name = name;

this.age = age;

}

@Override //重写toString()方法,方便打印对象

public String toString() {

return "Student [name=" + name + ", age=" + age + "]";

}

--------------------------------------------

>>>>> 解决对象输入流读取对象出现异常的问题 <<<<<<<<<<<

package com.jobday10;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.util.ArrayList;

/*

* 解决对象输入流读取对象出现异常的问题:

* 1.当我们读取文件内的对象时不知道它有几个数据,需要读几次才能读取完毕,因此每次读取时要等到抛出异常时,才

* 知道读取完毕,但是如果只在文件里存一个对象,读取时,只读取一次就不会抛出异常.

* 2.可以使用一个实现了Serializable接口的集合来存储对象,然后把集合存入到文件,这样就可以一次将对象写入文件,

* 然后读取到的时候,一次就将全部对象读出,这样就避免了读取抛出异常的问题;

* 3.将集合读取出来后,读取出来的是一个Object类的对象(它是一个整体),如果想一个一个取出里边的对象,可以将Object

* 对象向下转型为对应的集合,然后再逐个取出对象.

* 4.使用集合将对象一次写入到文件中时,集合内存的对象也必须实现了Serializable接口,不然运行时会报错;

* 5.此方法需要抛出一个ClassNotFoundException异常(找不到类异常,也就是读取对象的所属类),

* 也就是说当读取的对象所属的类不存时(程序获取不到时),就会抛出ClassNotFoundException

*/

public class 解决_对象输入流_读取异常 {

public static void main(String[] args) throws IOException, ClassNotFoundException {

//通过集合将对象一次性写入文件();

//读取文件

//创建对象输入流的对象

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ObjectOutputStream"));

//读取文件

Object obj = ois.readObject(); //此方法需要抛出一个ClassNotFoundException

//异常(找不到类异常,也就是读取对象的所属类)

// System.out.println(obj);

/*Output:

[Student [name=xiangjiao, age=15], Student [name=juzi, age=16]]

*///~

//将读取的Object象obj向下转型为ArrayList集合,就可以或里边单独的对象了

ArrayList<Student> list1 = (ArrayList<Student>) obj;

//for循环逐个获取对象

for(Student student : list1 ){

System.out.println(student);

}

/*Output:

Student [name=xiangjiao, age=15]

Student [name=juzi, age=16]

*///~

//释放资源

ois.close();

}

private static void 通过集合将对象一次性写入文件() throws IOException, FileNotFoundException {

//创建对象输出流的对象

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ObjectOutputStream"));

//创建集合对象

ArrayList<Student> list = new ArrayList<Student>();

//添加学生

list.add(new Student("xiangjiao",15));

list.add(new Student("juzi",16));

//写出集合对象

oos.writeObject(list);

//释放资源

oos.close();

}

帐号		自动登录	找回密码
密码			加入黑马

[技术笔记] 【石家庄中心】IO流_字节流_转换流_打印流介绍及使用

0 个回复