java 从零开始，学习笔记之基础入门<IO流>（十八）

IO流

流的概述:

流就是以一定的传输方式将文件里面的内容进行读写。数据的传输状态可以抽象的表示为流。

流的分类：

按照输入输出方式分： 输入流和输出流

输入流： 将文件中的数据读入到内存当中来

输出流：将内存当中的数据写出到文件中去

按数据的处理类型分:

字符流:以字符为单位传输数据

字节流:以字节为单位传输数据

按照流的功能分:

节点流:可以向一个特定的地方读写数据

处理流:通过对已经存在的流的封装，通过对封装流的操作实现读写功能.

输入流: 按照字符和字节分

字节的输入流: InputStream

它是一个抽象类，继承它的子类有:

AudioInputStream,--音频输入流

ByteArrayInputStream--byte数组输入流

FileInputStream –-文件输入流

FilterInputStream,--文件过滤流

InputStream, --输入流

ObjectInputStream,--对象输入流

PipedInputStream,--管道流

SequenceInputStream,--序列输入流

StringBufferInputStream –可变长字符输入流

InputStream类的方法:

int	available() 返回此输入流的方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。
void	close() 关闭此输入流并释放与该流关联的所有系统资源。
void	mark(intreadlimit) 在此输入流中标记当前的位置。
boolean	markSupported() 测试此输入流是否支持 mark 和 reset 方法。
abstract int	read() 从输入流中读取数据的下一个字节。
int	read(byte[]b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int	read(byte[]b, intoff, intlen) 将输入流中最多 len 个数据字节读入 byte 数组。
void	reset() 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。
long	skip(longn) 跳过和丢弃此输入流中数据的 n 个字节。

InputStream输入流的过程:inputStream 是一个字节流，那么它就可以用来将文件读取到内存当中来，读取的文件类型可以是所有的二进制文件(mp3 mp4 exe pdf)

文件 à 内存

读取一个文件的步骤:

*找到要读的文件

*创建一个输入流的对象

*读文件内容 判断

*关闭流

package com.ibm.input;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

public class InputDemo {

//读文件

public static void main(String[] args) {

File file=new File("d:"+File.separator+"ibm.txt");

try {

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

InputStream is=new FileInputStream(file);

//用来装输入流中读取出来的数据

byte[] b=new byte[512];

int len=is.read();

//读取输入流中数据的长度

//如果长度等于-1则表示文件读取完

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

//如果直接将数组转换成String 则多出来的部分，我们需要用空格填充

System.out.println(new String(b));

System.out.write(b, 0, len);

}

//关闭流

is.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

OutputStream（输出流）

将读取到内存中的数据以流的形式输出到文件中去，输入的文件可以是原来的文件，也可以是新创建的。文件类型可以不一样。

子类有:

ByteArrayOutputStream, --Byte数组输出流

FileOutputStream, --文件输出流

FilterOutputStream,

ObjectOutputStream,--对象输出流

OutputStream,

PipedOutputStream

它一个抽象类，如果要创建此类的对象也是需要使用子类

此类拥有的方法有哪些:

void	close() 关闭此输出流并释放与此流有关的所有系统资源。
void	flush() 刷新此输出流并强制写出所有缓冲的输出字节。
void	write(byte[]b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
void	write(byte[]b, intoff, intlen) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void	write(intb) 将指定的字节写入此输出流。

将信息输出到文件中去:

package com.ibm.input;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

public class OutputDemo {

public static void main(String[] args) {

//指定需要输出的文件

File file =new File("d:"+File.separator+"ibm.txt");

//创建输出流的对象

try {

OutputStream os=new FileOutputStream(file,true);

String str="sss+sss";

byte[] b=str.getBytes();

os.write(b);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

True 表示的是往对应的文件中输出信息，并且不覆盖之前文件中的内容。

Write方法的三个参数:

Byte[]—表示的是需要写出的数组

Off –-从文件的什么地方开始写起

Len –写出文件的长度

字符的输入流: Reader

Reader是一个字符流，它可以用来读取文字信息，它是一个抽象的类

对应的子类有:

BufferedReader,--字符缓冲输入流

CharArrayReader,--char型字符缓冲区

FilterReader, --过滤字符流

InputStreamReader, --输入字符流

PipedReader,--管道字符流

StringReader –字符输入流

对应的方法有:

abstract void	close() 关闭该流并释放与之关联的所有资源。
void	mark(intreadAheadLimit) 标记流中的当前位置。
boolean	markSupported() 判断此流是否支持 mark() 操作。
int	read() 读取单个字符。
int	read(char[]cbuf) 将字符读入数组。
abstract int	read(char[]cbuf, intoff, intlen) 将字符读入数组的某一部分。
int	read(CharBuffertarget) 试图将字符读入指定的字符缓冲区。
boolean	ready() 判断是否准备读取此流。
void	reset() 重置该流。
long	skip(longn) 跳过字符。

读一个文本文件，将信息输出来:

package com.ibm.input;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.io.Reader;

public class ReaderDemo {

public static void main(String[] args) {

//读D盘下面的txt文件采用的方式是字符流读

File file=new File("d:"+File.separator+"ibm.txt");

try {

//创建字符流对象

Reader reader=new FileReader(file);

//创建字符缓冲流在构造器中传递的是字符流的对象

//使用BufferedReader这个类对Reader类进行封装是因为此类中有一个ReadLine方法可以返回一行的文本信息

BufferedReader br=new BufferedReader(reader);

String str=null;

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

System.out.println(str);

}

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

//此种采用字符流读信息只适合在读取的数据是字符的情况下,不能用它来读字节文件

}

package com.ibm.input;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

public class ReaderDemo02 {

public static void main(String[] args) {

File file =new File("d:"+File.separator+"ibm.txt");

InputStream is;

try {

is = new FileInputStream(file);

Reader reader=new InputStreamReader(is);

char[] c=new char[1024];

int len=0;

//将Reader流中的数据读出来，并且放入到字符数组中去判断文件是否读完

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

System.out.print(c);

}

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

Writer是一个字符输出流，可以将文本信息输出到文件中去，它也是一个抽象类

对应的子类有:

BufferedWriter,

CharArrayWriter,

FilterWriter,

OutputStreamWriter,

PipedWriter,

PrintWriter,

StringWriter

对应的方法:

Writer	append(charc) 将指定字符添加到此 writer。
Writer	append(CharSequencecsq) 将指定字符序列添加到此 writer。
Writer	append(CharSequencecsq, intstart, intend) 将指定字符序列的子序列添加到此 writer.Appendable。
abstract void	close() 关闭此流，但要先刷新它。
abstract void	flush()刷新该流的缓冲。
void	write(char[]cbuf) 写入字符数组。
abstract void	write(char[]cbuf, intoff, intlen) 写入字符数组的某一部分。
void	write(intc) 写入单个字符。
void	write(Stringstr) 写入字符串。
void	write(Stringstr, intoff, intlen) 写入字符串的某一部分。

将”我是中国人”这句话输入到一个txt文件中去，采用的输出是字符输出

对象输入，输出流：

package com.ibm.object;

import java.io.Serializable;

public class Student implements Serializable{

private String name;

private String pass;

privateintage;

publicvoid setName(String name ){

this.name = name ;

}

public String getName(){

returnname;

}

public String getPass() {

returnpass;

}

publicvoid setPass(String pass) {

this.pass = pass;

}

publicint getAge() {

returnage;

}

publicvoid setAge(int age) {

this.age = age;

}

}

package com.ibm.object;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

public class InputObject {

//对象序列化：就是将一个对象按照特定的格式序列化，序列化之后的对象

//可以保存在文件或者在网络中传递可以提高传递效率

//对象序列化必须实现Serializable或Externalizable接口

// ObjectInputStream从文件中读对象

// ObjectOutputStream将对象写到文件中去

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

Student st1 = new Student();

st1.setAge(21);

st1.setName("张三");

st1.setPass("123456");

Student st2 = new Student();

st2.setName("李四");

st2.setPass("654321");

st2.setAge(21);

//将对象通过对象输出流写到文件中去

File file = new File("d:\\ibm1.txt");

OutputStream os = new FileOutputStream(file);

ObjectOutputStream oos = new ObjectOutputStream(os);

oos.writeObject(st1);//将对象写入到对象输出流中去

oos.writeObject(st2);

oos.flush();//清空缓存

oos.close();//关闭流

}

}

package com.ibm.object;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInputStream;

public class OutputObject {

//将存储在文件中的值读出来，并且打出对象中的属性值

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

//将文件读进来，采用ObjectInputStream

File file = new File("d:\\ibm1.txt");

FileInputStream is = new FileInputStream(file);

ObjectInputStream ois = new ObjectInputStream(is);

Student st1 = (Student) ois.readObject();

Student st2 = (Student) ois.readObject();

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

System.out.println(st1.getPass());

System.out.println(st1.getAge());

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

System.out.println(st2.getPass());

System.out.println(st2.getAge());

}

}

andomAccessFile类是一个随机访问流

package com.ibm.random;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.RandomAccessFile;

public class InputRandomDemo {

/*RandomAccessFile类是一个随机访问流，它可以用来访问一个文件中

*任意指定的地方

*

* 提供了连个构造器

* RandomAccessFile(File file,String mode)

* RandomAccessFile(String name, String mode)

* mode 表示的是对文件的一种模式

* r(只读) rw（可读可写） rws(可读可写) rwd(可读可写)

* 随机访问流按照一定的顺序；来存储数据，那么它有一个特定的方法

* skipBytes(int n) 用来跳过多少个字节读信息

* seek(long pos) 将指针移到某个位置的方法

*

* */

//创建一个随机访问流，往文件中写入值

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

File file = new File("d:"+File.separator+"ibm.txt");

RandomAccessFile raf = new RandomAccessFile(file,"rw");

String name = null;

int age = 0;

String pass = null;

name = "cw ";

age = 22;

pass = "123456";

//将上面的属性通过随机访问流写入Student.txt文件中去

//第一个人

raf.writeBytes(name);

raf.writeBytes(pass);

raf.writeInt(age);

//第二个人

name = "sbb";

age = 21;

pass = "123456";

raf.writeBytes(name);

raf.writeBytes(pass);

raf.writeInt(age);

//第三个人

name = "gk ";

age = 20;

pass = "123456";

raf.writeBytes(name);

raf.writeBytes(pass);

raf.writeInt(age);

//关闭流

raf.close();

}

}

package com.ibm.random;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.RandomAccessFile;

public class OutRandomDemo {

public static void main(String[] args) {

//把文件中的信息通过随机访问流读出来

//读第二个人的信息

try {

RandomAccessFile raf=new RandomAccessFile("d:\\ibm.txt","r");

//当前指针没做任何操作，那么文件指针是从开始位置开始0

System.out.println(raf.getFilePointer());

//我要读取第二个人的信息，那么就应该把指针偏移量向下

raf.seek(13);

System.out.println("------第二个人的信息-------");

byte[] b=new byte[9];

for(int i=0;i<b.length;i++){

b[i]=raf.readByte();

}

//将 byte数组转换成字符串

String nameall=new String(b);

//在将字符串进行截取

String name=nameall.substring(0,3);

System.out.println(name);

String pass=nameall.substring(3);

System.out.println(pass);

int age=raf.readInt();

System.out.println(age);

//如果要取第一个人的信息，需要将指针偏移到0

raf.seek(0);

System.out.println(raf.getFilePointer());

System.out.println("------第一个人的信息-------");

byte[] b1=new byte[9];

for(int i=0;i<b1.length;i++){

b1[i]=raf.readByte();

}

//将 byte数组转换成字符串

String nameall1=new String(b1);

//在将字符串进行截取

String name1=nameall1.substring(0,3);

System.out.println(name1);

String pass1=nameall1.substring(3);

System.out.println(pass1);

int age1=raf.readInt();

System.out.println(age1);

raf.seek(26);

System.out.println("-----第三个人的信息-----");

byte[] b2=new byte[9];

for(int i=0;i<b2.length;i++){

b2[i]=raf.readByte();

}

//将 byte数组转换成字符串

String nameall2=new String(b2);

//在将字符串进行截取

String name2=nameall2.substring(0,3);

System.out.println(name2);

String pass2=nameall2.substring(3);

System.out.println(pass2);

int age2=raf.readInt();

System.out.println(age2);

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

文件压缩

单个文件压缩

package com.ibm.zip;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

/**

* @author Administrator

* 单个文件的压缩

*/

public class ZipDemo01 {

public static void main(String[] args) {

File infile=new File("d:"+File.separator+"ie.txt");

File outFile=new File("e:"+File.separator+"ie.zip");

try {

InputStream is=new FileInputStream(infile);

ZipOutputStream zos=new ZipOutputStream(new FileOutputStream(outFile));

//创建一个压缩文件的实体

ZipEntry ze=new ZipEntry(infile.getName());

zos.putNextEntry(ze);

//对文件实体按字节读取

byte[] b=new byte[1024];

int len;

while((len=is.read(b))!=-1){ //不等于-1表示文件没读完

zos.write(b, 0, len); //将文件输出到压缩文件中

}

//设置压缩文件的注释

zos.setComment("ibm.java");

zos.close();//关闭流

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

多个文件压缩

package com.ibm.zip;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

/**

* @author Administrator

* 多个个文件的压缩

*/

public class ZipDemo03 {

public static void main(String[] args) {

File infile=new File("d:"+File.separator+"zipDemo");

File outFile=new File("e:"+File.separator+"ee.zip");

InputStream is=null;

ZipOutputStream zos=null;

try {

zos=new ZipOutputStream(new FileOutputStream(outFile));

if(infile.isDirectory()){

File[] files=infile.listFiles();

for(int i=0;i<files.length;i++){

System.out.println(files[i].getName());

is=new FileInputStream(files[i]);

ZipEntry ze=new ZipEntry(files[i].getName());

zos.putNextEntry(ze);

//对文件实体按字节读取

byte[] b=new byte[1024];

int len;

while((len=is.read(b))!=-1){ //不等于-1表示文件没读完

zos.write(b, 0, len); //将文件输出到压缩文件中

}

//关闭输入流

is.close();

}

zos.close(); //关闭zip输出流

}

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}