Java IO

IO流

1.字节流

(1)InputStream OutputStream(抽象类，不可直接使用)

InputStream抽象了应用程序读取数据的方式

OutputStream抽象了应用程序写出数据的方式

(2)EOF=End 读到-1就读到结束

(3)输入流基本方法

读取一个字节无符号填充到int低8位，-1是EOF

int b=in.read();

读取数据填充到字节数组buf

in.read(byte[] buf)

读取数据到字节数组buf，从buf的start位置开始存放size长度的数据

in.read(byte[] buf,int start,int size)

(4)输出流基本方法

写出一个byte到流，b的低8位

out.write(int  b)

将buf字节数组都写入到流

out.write(byte[] buf)

字节数组buf从start位置开始写size长度的字节到流

out.write(byte[] buf,int start,int size)

(5)FileInputStream(可直接使用的类，继承了InputStream)

读取举例

一个一个字节的读取,遇到-1则说明读取完毕

public static void main(String[] args) throws IOException {
File file=new File("rafdemo\\raf.txt");
FileInputStream in=new FileInputStream(file);
int b=0;
while((b=in.read())!=-1){
System.out.println(b+"");
}
}

一次读取到字节数组中(字节数组的大小要足够大)

byte[] buf1=new byte[1000];
int size=in.read(buf1);
for(int i=0;i<size;i++){
System.out.println(buf1[i]&0xff);
}

一次读取一部分到一个数组中

byte[] buf2=new byte[500];
int size;
while((size=in.read(buf2,0,buf2.length))!=-1){
for(int i=0;i<size;i++){
System.out.println(buf2[i]&0xff);
}
}

(6)FileOutputStream

如果该文件不存在，则直接创建，如果存在，删除后创建

FileOutputStream out=new FileOutputStream("demo/out");

带有true表示存在则追加,具体使用请查阅api

FileOutputStream out=new FileOutputStream("demo/out.txt", true);

写入低八位

out.write('a');

一个Int需要写4次

int i=10;
out.write(i>>>24);
out.write(i>>>16);
out.write(i>>>8);
out.write(i);

写入字节数组

String gbk="你好";
out.write(gbk.getBytes());

一次写自己数组的一部分

byte[] buf=new byte[500];
String str="输出";
byte[] bte=str.getBytes();
for(int i=0;i<bte.length;i++){
buf[i]=bte[i];
}
int size=bte.length;
out.write( buf, 0, size);

写完以后，最好加上

out.flush();

(7)DataOutputStream/DataInputStream

对于”流”功能的扩展,可以更加方便的读取int,long,字符等类型数据

writeInt()/writeDouble/writeUTF()

写出创建

String file="f:\\javaio\\dos.dat";
DataOutputStream dos=new DataOutputStream(
new FileOutputStream(file));

各种写入的封装

dos.writeInt(10);
dos.writeLong(10l);
dos.writeDouble(10.5);
//采用utf-8编码写出
dos.writeUTF("中国");
//采用utf-16be编码写出
dos.writeChars("中国");

读入创建

String file="f:\\javaio\\dos.dat";
DataInputStream dis=new DataInputStream(
new FileInputStream(file));

各种读入的封装

int a=dis.readInt();
long b=dis.readLong();
double c=dis.readDouble();
String d=dis.readUTF();

(8)BufferedInputStream&BufferedOutputStream

这两个流类位于IO提供了带缓冲的区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能

创建

BufferedInputStream bis=new BufferedInputStream(
new FileInputStream(file));

BufferedOutputStream bos=new BufferedOutputStream(
new FileOutputStream(file));

用法同上面的FileInputStream一样;使用时查api就懂了

2.字符流（Write Read）—>操作的是文本文件

java的文本(char)是16位无符号整数,是字符的Unicode编码(双字节编码)

文本文件是文本(char)序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为bytede 存储

字符的处理,一次处理一个字符

字符的底层仍然是基本的字节序列

字符流的基本实现:

(1)

InputStreamReader 完成byte流解析为char流,按照编码解析

OutputStreamWriter 提供char流到byte流,按照编码处理

读入创建

String file="f:\\javaio\\Reader.txt";
FileInputStream in=new FileInputStream(file);
InputStreamReader isr=new InputStreamReader(in);//默认项目的编码

一个字符一个字符读入

int c;
while((c=isr.read())!=-1){
System.out.print((char)c);
}

批量读入

int size;
char[] buffer=new char[8*1024];
while((size=isr.read(buffer,0,buffer.length))!=-1){
String s=new String(buffer,0,size);
System.out.print(s);
}

输出创建

String file2="f:\\javaio\\Outer.txt";
FileOutputStream out=new FileOutputStream(file2);
OutputStreamWriter osw=new OutputStreamWriter(out);

写出一个字符

char s='我';
osw.write(s);
osw.flush();

一次写出一部分数组

char []s={'我','不','服','啊'};
osw.write(s,0,s.length);
osw.flush();

(2)

FileWriter/FileReader(不能指定编码格式)

将一个文件中的内容拷贝到另外一个中去

FileReader fr=new FileReader("f:\\javaio\\Reader.txt");
FileWriter fw=new FileWriter("f:\\javaio\\Reader2.txt");

int size;
char[] buff=new char[1024];
while((size=fr.read(buff,0,buff.length))!=-1){
fw.write(buff,0,size);

}
fw.flush();

fr.close();
fw.close()

(3)

字符流的过滤器

BufferedReader—->readLine 一次读一行

BufferedWriter/PrintWriter —–>写一行

文本复制

BufferedReader br=new BufferedReader(
new InputStreamReader(
new FileInputStream("f:\\javaio\\Reader.txt")));
BufferedWriter bw=new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream("f:\\javaio\\Reader4.txt")));
String line;
while((line=br.readLine())!=null){
System.out.
a9b3
println(line);
bw.write(line);
bw.newLine();//要自己换行，因为其本身不能自动换行
}
bw.flush();

bw.close();
br.close();

PrintWriter中的pw.println可自动实现换行

BufferedReader br=new BufferedReader(
new InputStreamReader(
new FileInputStream("f:\\javaio\\Reader.txt")));
PrintWriter pw=new PrintWriter("f:\\javaio\\Reader4.txt");

String line;
while((line=br.readLine())!=null){
System.out.println(line);
pw.println(line);

}
pw.flush();

pw.close();
br.close();