IO流_一些理解

一.

1.

public abstract class InputStream extends Object implements Closeable

这个抽象类是表示输入字节流的所有类的超类。

需要定义InputStream子类的应用InputStream必须始终提供一种返回输入的下一个字节的方法。

2.

public abstract class OutputStream extends Object implements Closeable, Flushable

这个抽象类是表示字节输出流的所有类的超类。 输出流接收输出字节并将其发送到某个接收器。

需要定义OutputStream子类的应用OutputStream必须至少提供一个写入一个字节输出的方法。

二.

1.

public class FileInputStream extends InputStream

A FileInputStream从文件系统中的文件获取输入字节。 什么文件可用取决于主机环境。

FileInputStream用于读取诸如图像数据的原始字节流。 要阅读字符串，请考虑使用FileReader 。

2.

public class FileOutputStream extends OutputStream

文件输出流是用于将数据写入到输出流File或一个FileDescriptor 。 文件是否可用或可能被创建取决于底层平台。 特别是某些平台允许一次只能打开一个文件来写入一个FileOutputStream （或其他文件写入对象）。 在这种情况下，如果所涉及的文件已经打开，则此类中的构造函数将失败。

FileOutputStream用于写入诸如图像数据的原始字节流。 对于写入字符流，请考虑使用FileWriter

三

1.

public class BufferedInputStream extends FilterInputStream

A BufferedInputStream为另一个输入流添加了功能，即缓冲输入和支持mark和reset方法的功能。 当创建BufferedInputStream时，将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次有多个字节。 mark操作会记住输入流中的一点，并且reset操作会导致从最近的mark操作之后读取的所有字节在从包含的输入流中取出新的字节之前重新读取。

2.

public class BufferedOutputStream extends FilterOutputStream

该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。

四.

1.

public class DataInputStream

extends FilterInputStream

implements DataInput数据输入流允许应用程序以独立于机器的方式从底层输入流读取原始Java数据类型。 应用程序使用数据输出流来写入稍后可以被数据输入流读取的数据。 

DataInputStream对于多线程访问来说不一定是安全的。 线程安全是可选的，是本课程中用户的责任。

2.

public class DataOutputStream

extends FilterOutputStream

implements DataOutput数据输出流使应用程序以便携式方式将原始Java数据类型写入输出流。 然后应用程序可以使用数据输入流来读取数据。

五.

1.

public class PrintStream

extends FilterOutputStream

implements Appendable, CloseableA PrintStream

由印刷的所有字符PrintStream被转换成使用平台的默认字符编码字节。 在需要编写字符而不是字节的情况下，应使用PrintWriter类。

六.

1.

在序列化和反序列化过程中需要特殊处理的类必须采用具有这些精确签名的特殊方法： 

 

  private void writeObject(

java.io.ObjectOutputStream out)

     throws IOException

 private void readObject(

java.io.ObjectInputStream in)

     throws IOException, ClassNotFoundException;

 private void readObjectNoData()

     throws ObjectStreamException;

2.

public class ObjectInputStream

extends InputStream

implements ObjectInput, ObjectStreamConstantsObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象。

public class ObjectOutputStream

extends OutputStream

implements ObjectOutput, ObjectStreamConstantsObjectOutputStream将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象。

七.

1.

public class ByteArrayInputStream

extends InputStreamA ByteArrayInputStream包含一个内部缓冲区，其中包含可以从流中读取的字节。 内部计数器跟踪read方法要提供的下一个字节。 

关闭ByteArrayInputStream没有任何效果。 在关闭流之后，可以调用此类中的方法，而不生成IOException 。

2.

public class ByteArrayOutputStream

extends OutputStream该类实现了将数据写入字节数组的输出流。 当数据写入缓冲区时，缓冲区会自动增长。 数据可以使用toByteArray()和toString() 。 

关闭ByteArrayOutputStream没有任何效果。 该流中的方法可以在流关闭后调用，而不生成IOException 。

package cn.hp.demo;

 

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintStream;

import java.io.PrintWriter;

import java.io.Reader;

import java.io.UnsupportedEncodingException;

import java.io.Writer;

import java.util.UUID;

 

import com.sun.javafx.stage.PopupWindowPeerListener;

 

/**

* File的案例类

* file文件操作

* 文件拷贝上传

*

*/

public class FileDemo {

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

long s= System.currentTimeMillis();

1.file对象的基本应用（文件信息的获取）

// testFile1("F:\\");

//--------------字节流---------------------

// 2.通过 文件流 实现文件上传 D:\\圣墟.txt 60491

// testFile2("D:\\java8.zip");

// 3.通过 缓冲流 实现文件上传 15583 16792

// testFile3("D:\\java8.zip");

// 4.通过file实现多文件上传

// testFile4("D:\\img");

// 5.打印流

// testPrintStream();

//--------------字符流-----------------------

// 6.PrintWriter打印流

// testPrintWriter();

// 7.FileWriter打印流

testFileWriter();

// 8.字符流 读写操

// testBufferedReader("D:\\圣墟.txt");

long e=System.currentTimeMillis();

System.out.println(e-s);

}

/**

* 8.字符流 读写操

* 思路:

* 1.创建 字符流 读写对象

* 2.读取传入的文件信息,通过写对象拷贝一份到指定位置

* @throws Exception

*/

private static void testBufferedReader(String src) throws Exception {

// 1.创建 字符流 读写对象

// Reader br = new BufferedReader(new FileReader(src));

BufferedReader br = new BufferedReader(new FileReader(src));

BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\圣墟2.txt"));

//读取文本有两种方式,

//1.按照字符读取

char [] c = new char[200];

int len=0;

while((len=br.read(c))!=-1) {

if(len!=200) {

System.out.println(len);

for (char d : c) {

System.out.print(d);

}

}

bw.write(c, 0, len);

}

//2.每次读取一行

// String line;//行

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

// byte[] b3 = line.getBytes("UTF-8");

// System.out.println(new String(b3));

// bw.write(line);

// bw.newLine();

// }

bw.close();

br.close();

}

 

 

 

/**

* 7.FileWriter打印流

*/

private static void testFileWriter() throws IOException {

//第二个参数如果是true,在文本后面追加,false文本内容清空,重头开始录入

FileWriter fw = new FileWriter("ccc.txt",true);

fw.write("3333测试 fileWriter...");

fw.write("4444测试 fileWriter...\n");

fw.write("4444测试 fileWriter...");

fw.close();

}

/**

* 6.PrintWriter打印流

*/

private static void testPrintWriter() throws FileNotFoundException, UnsupportedEncodingException {

PrintWriter pw = new PrintWriter("bbb.txt","UTF-8");

pw.write("测试打印流");

pw.println();

pw.write("你好 ....");

pw.close();

}

/**

* 5.打印流

*/

private static void testPrintStream() throws FileNotFoundException, UnsupportedEncodingException {

PrintStream ps = new PrintStream("aaa.txt","UTF-8");

ps.append("测试打印流");//追加

ps.println("打印流");//输出后本行结束,之后录入的换行

ps.append("你好 ....打印流");

ps.close();

}

 

/**

* 4.文件流 多文件上传

* 思路:

* 1.通过file将源文件路径建立联系,读取文件列表的信息

* 2.创建上传后的路径,不存在的话进行创建

* 3.读文件和写文件的过程

* 4.关闭流

* @throws IOException

*/

private static void testFile4(String src) throws IOException {

// 1.通过file将源文件路径建立联系,读取文件的路径信息

File srcFile = new File(src);

// 2.创建上传后的路径,不存在的话进行创建

String path= "D:\\upload\\";

File uploadFile = new File(path);

if(!uploadFile.exists()) {//判断是否存在该文件

uploadFile.mkdir();//一层文件夹的创建,如果是多层文件都不存在,需要用到mkdirs方法进行创建

}

//获取file的文件列表

File [] files = srcFile.listFiles();

if(files!=null) {//进行判断是否存在文件列表

for (File file : files) {//进行遍历,每次是一个文件

// 3.读文件和写文件的过程

//获取输入和输出流

InputStream is = new FileInputStream(file);

//目标路径

String distPath = path+System.currentTimeMillis()+file.getName();

OutputStream os = new FileOutputStream(distPath);

//读和写的具体实现

byte[] buf = new byte[1024];//通过字节数组提高读取效率

int len =0;//每次读取的长度,如果读取到文件末尾,该值==-1,代表结束

while ((len=is.read(buf))!=-1) {

os.write(buf, 0, len);

}

// 4.关闭流

os.close();

is.close();

}

}

}

 

/**

* 3.通过 缓冲流 实现文件上传

* @param string

* @throws IOException

*/

private static void testFile3(String src) throws IOException {

// 1.通过file将源文件路径建立联系,读取文件的路径信息

File srcFile = new File(src);

// 2.创建上传后的路径,不存在的话进行创建

String path= "D:\\upload\\";

File uploadFile = new File(path);

if(!uploadFile.exists()) {//判断是否存在该文件

uploadFile.mkdir();//一层文件夹的创建,如果是多层文件都不存在,需要用到mkdirs方法进行创建

}

if(srcFile.exists()) {

//创建输入缓冲流 ,也叫包装流

InputStream is = new BufferedInputStream(new FileInputStream(srcFile));

String distPath = path + UUID.randomUUID()+srcFile.getName();

OutputStream os = new BufferedOutputStream(new FileOutputStream(distPath));

//读和写的具体实现

byte[] buf = new byte[1024];//通过字节数组提高读取效率

int len =0;//每次读取的长度,如果读取到文件末尾,该值==-1,代表结束

while ((len=is.read(buf))!=-1) {

os.write(buf, 0, len);

}

os.close();

is.close();

}

}

/**

* 2.通过 文件流 实现文件上传

* 思路:

* 1.通过file与上传文件的路径建立联系

* 2.和上传文件的路径建立联系,如果不存在则创建文件夹

* 3.读文件和写文件

* 4.关闭流

* @param string

* @throws IOException

*/

private static void testFile2(String src) throws IOException {

// 1.通过file将源文件路径建立联系,读取文件的路径信息

File srcFile = new File(src);

// 2.创建上传后的路径,不存在的话进行创建

String path= "D:\\upload\\";

File uploadFile = new File(path);

if(!uploadFile.exists()) {//判断是否存在该文件

uploadFile.mkdir();//一层文件夹的创建,如果是多层文件都不存在,需要用到mkdirs方法进行创建

}

if(srcFile.exists()) {

//创建输入和输出流

InputStream is = new FileInputStream(srcFile);

String distPath = path + UUID.randomUUID()+srcFile.getName();

OutputStream os = new FileOutputStream(distPath);

byte [] b = new byte [1024];//提高读取效率

int len =0;//每次读取的长度

while((len=is.read(b))!=-1) {

os.write(b, 0, len);

}

os.close();

is.close();

}

}

/**

* 1.file对象的基本应用（文件信息的获取）

* 1.创建file对象，关联给定路径

* 2.获取该路径下的文件数组

* 3.进行判断，如果是文件，打印文件名称

* 如果是文件夹，递归调用，打印内部文件

*/

private static void testFile1(String src) {

//1.通过file对象，关联给定的路径

File srcFile = new File(src);

//2.获取该路径下的所有文件或文件夹的信息

File [] files = srcFile.listFiles();

//空文件夹中，不需要遍历调用

if(files!=null) {

//3.进行遍历

for (File file : files) {

if(file.isFile()) {//如果是文件，输出文件名称

if(file.getName().endsWith(".txt"))//最后是.txt结尾的进行输出文件信息

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

}

if (file.isDirectory()) {//如果是文件夹，进行递归调用，进入该文件夹下面进行遍历文件信息

// System.out.println("文件夹："+file.getAbsolutePath());

testFile1(file.getAbsolutePath());

}

}

}

}

}