1、JavaIO流的简介
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，
方便更直观的进行数据操作。程序需要数据时要使用输入流读取数据，而当数据需要将一些数据保存起来时，就要使用输出流。
在java.io包中流的操作主要有字节流、字符流两个大类，两类中都有输入输出操作。在字节流中输出数据主要是OutputStream类完成，输入主要是InputStream类。在字符流中输出的主要是Writer类，输入主要是Reader类。
JavaIO流操作主要分为4步，以文件的操作为例，主要流程为:
a)使用File类打开一个文件。
b)通过字节流或字符流的子类指定输出的位置。
c)进行读/写操作。
d)关闭输入/输出。
2、字节流与字符流的区别与相同
字节流：读取或者输出是以一个字节形式。(以Stream结尾)
字符流：读取或者输出是以两个字节形式。(以Reader或者Writer结尾)
两者的区别：程序使用字节流会直接操作，而使用字符流会将数据放在缓存中，再从缓存中操作。也就是没有关闭字节流，数据还是可以被读取/输出，没有关闭字符流，数据是不会被从缓存中输出/读取。
两者的相同：无论字节流还是字符流都是抽象类，其余流都是继承于InputStream、OutputStream、Reader、Writer。
3、字节流主要有：
FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream、DataInputStream、DataOutputStream、PipedInputStream、PipedOutputStream、ZipInputsStream、ZipOutputStream
字符流主要有：
FileReader、FileWriter、BufferedReader、BufferedWriter、PipedReader、PiepdWriter
两个转化流：InputStreamReader、OutputStreamWriter
4、OutputStream类主要方法：
(1)public void close()throws IOException 关闭此输出流并释放与此流有关的所有系统资源。
(2)public void flush()throws IOException 刷新此输出流并强制写出所有缓冲的输出字节。
(3)public void write(byte[] b)throws IOException 将 b.length 个字节从指定的 byte 数组写入此输出流。
(4)public void write(byte[] b,int off,int len)throws IOException 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
(5)public abstract void write(int b)throws IOException 将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。
InputStream类主要方法：
(1)public int available()throws IOException可以取得输入文件的大小
(2)public void close()throws IOException 关闭此输入流并释放与该流关联的所有系统资源。
(3)public abstract int read()throws IOException
从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
5、有关文件内容操作的流(FileInputStream、FileOutputStream、FileReader、FileWriter)
构造方法：a)public FileInputStream(File file)throws FileNotFoundException
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
public FileInputStream(String name)throws FileNotFoundException
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
b)public FileOutputStream(File file)throws FileNotFoundException
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
public FileOutputStream(File file,boolean append)throws FileNotFoundException
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
c)FileReader的构造方法与FileInputStream类构造方法一致。
public FileReader(File file)throws FileNotFoundException
public FileReader(String fileName)throws FileNotFoundException
d)FileWriter的构造方法与FileOutputStream类构造方法一致。
public FileWriter(File file)throws IOException
public FileWriter(File file,boolean append)throws IOException
FileOutputStream的例子：
(1)怎样初始化并怎样将数据输出到文件里的
package com.dengdi.outputstream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class OutputStreamDmeo01 {
public static void main(String[] args) throws IOException {
File file=new File("E:"+File.separator+"outputStreamTest.txt");
OutputStream out=new FileOutputStream(file);
String str="Hello World!!!";
byte[] b=str.getBytes();
out.write(b);
out.close();
}
}
package com.dengdi.outputstream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class OutputStreamDemo02 {
public static void main(String[] args) throws IOException {
File file=new File("E:"+File.separator+"outputStreamTest.txt");
OutputStream out=null;
try {
out=new FileOutputStream(file, true);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String str="Hello World!!!";
byte[] b=str.getBytes();
out.write(b);
out.close();
}
}
(1)第一种方法
package com.dengdi.inputstream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
public class InputStreamDemo02 {
public static void main(String[] args) throws Exception {
File file=new File("E:"+File.separator+"inputStreamTest.txt");
InputStream input=new FileInputStream(file);
byte[] b=new byte[1024];
int len=input.read(b);
input.close();
System.out.println("内容为："+new String(b, 0, len));
}
}
package com.dengdi.inputstream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
public class InputStreamDemo03 {
public static void main(String[] args) throws Exception {
File file=new File("E:"+File.separator+"inputStreamTest.txt");
InputStream input=new FileInputStream(file);
byte[] b=new byte[(int)file.length()];
input.read(b);
input.close();
System.out.println("内容为："+new String(b));
}
}
package com.dengdi.inputstream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class InputStreamDemo04 {
public static void main(String[] args) throws Exception {
File file=new File("E:"+File.separator+"inputStreamTest.txt");
InputStream input=new FileInputStream(file);
byte[] b=new byte[1024];
int len=0;
int temp=0;
while((temp=input.read())!=-1){
b[len]=(byte) temp;
len++;
}
input.close();
System.out.println("内容为："+new String(b,0,len));
}
}
FileReader，FileWriter例子与上面例子基本一致，不再列举。
6、关于缓存区数据的操作流(BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter)
使用缓存区数据的操作流好处是可以不会出现乱码，而乱码产生的原因就是
构造方法: a)public BufferedInputStream(InputStream in)创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
b)public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
c)public BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流。
d)public BufferedWriter(Writer out)创建一个使用默认大小输出缓冲区的缓冲字符输出流。
其他方法: a)public void flush()throws IOException刷新此缓冲的输出流。这迫使所有缓冲的输出字节被写出到底层输出流中。
b)public String readLine()throws IOException读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。
BufferedReader怎么从文件中读取的例子：
package com.dengdi.bufferedreader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class BufferedReaderDemo01 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
System.out.println("请输入内容:");
try {
str = br.readLine();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
System.out.println(str);
br.close();
}
}
构造方法: a)public PipedInputStream() 创建尚未连接的 PipedInputStream。在使用前必须将其连接到 PipedOutputStream。
b)public PipedOutputStream()
创建尚未连接到管道输入流的管道输出流。必须在使用之前将管道输出流连接到管道输入流（既可由接收者连接，也可由发送者连接）。
c)public PipedReader()创建尚未连接的 PipedReader。使用前必须将其连接到 PipedWriter。
d)public PipedWriter()创建一个尚未连接到传送 reader 的传送 writer。必须在使用之前将其连接到传送 reader（既可由接收方连接，也可由发送方连接）。
其他方法: a)public void connect(PipedOutputStream src)throws IOException 使此管道输入流连接到管道输出流 src。
b)public void connect(PipedInputStream snk)throws IOException 将此管道输出流连接到接收者。
注意：如果 snk 是未连接的管道输入流，而 src 是未连接的管道输出流，则可以通过以下调用之一连接它们： src.connect(snk)或snk.connect(src)这两个调用的效果相同。
c)public void flush()throws IOException 刷新此输出流并强制写出所有缓冲的输出字节。
d)public void connect(PipedWriter src)throws IOException 使此传送 reader 连接到传送 writer src。
e)public void connect(PipedReader snk)throws IOException 将此传送 writer 连接到接收方。
注意：如果 snk 为未连接的传送 reader，而 src 为未连接的传送 writer，则可以通过以下任一调用使其连接： src.connect(snk)或： snk.connect(src)这两个调用的效果相同。
怎样实现管道流的例子：
package com.dengdi.piped;
import java.io.IOException;
import java.io.PipedOutputStream;
public class Send implements Runnable{
private PipedOutputStream pos=null;
public Send() {
super();
pos=new PipedOutputStream();
}
@Override
public void run() {
// TODO Auto-generated method stub
String str="Hello World!!";
try {
this.pos.write(str.getBytes());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
this.pos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public PipedOutputStream getPos() {
return pos;
}
public void setPos(PipedOutputStream pos) {
this.pos = pos;
}
}
package com.dengdi.piped;
import java.io.IOException;
import java.io.PipedInputStream;
public class Receive implements Runnable{
private PipedInputStream pis=null;
public Receive() {
pis=new PipedInputStream();
}
@Override
public void run() {
// TODO Auto-generated method stub
byte[] b=new byte[1024];
int len=0;
try {
len=pis.read(b);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
pis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String str=new String(b,0,len);
System.out.println(str);
}
public PipedInputStream getPis() {
return pis;
}
public void setPis(PipedInputStream pis) {
this.pis = pis;
}
}
package com.dengdi.piped;
import java.io.IOException;
public class PipedDemo {
public static void main(String[] args) {
Send send=new Send();
Receive receive=new Receive();
try {
send.getPos().connect(receive.getPis());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
new Thread(send).start();
new Thread(receive).start();
}
}
8、数据操作流(DataInputStream、DataOutputStream)
构造方法: a)public DataInputStream(InputStream in) 使用指定的底层 InputStream 创建一个 DataInputStream。
b)public DataOutputStream(OutputStream out) 创建一个新的数据输出流，将数据写入指定基础输出流。
其他方法: a)public final void writeInt(int v)throws IOException 将一个 int 值以 4-byte 值形式写入基础输出流中。
b)public final void writeDouble(double v)throws IOException 使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中。
c)public final void writeChars(String s)throws IOException 将字符串按字符顺序写入基础输出流。通过 writeChar 方法将每个字符写入数据输出流。
d)public final void writeChar(int v)throws IOException 将一个 char 值以 2-byte 值形式写入基础输出流中。
e)public final int readInt()throws IOException 从包含的输入流中读取此操作需要的字节。
f)public final int readInt()throws IOException 从包含的输入流中读取此操作需要的字节。
g)public final double readDouble()throws IOException 从包含的输入流中读取此操作需要的字节。
怎样使用数据操作流的例子：
package com.dengdi.Date;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataOutputStreamDemo {
public static void main(String[] args) throws IOException {
File file=new File("E:"+File.separator+"test.txt");
DataOutputStream dos=new DataOutputStream(new FileOutputStream(file));
String[] names={"衣服","裤子","鞋子"};
float[] prices={98.6f,95.7f,93.2f};
int[] numbers={3,2,1};
for(int i=0;i<names.length;i++){
dos.writeChars(names[i]);
dos.writeChar('\t');
dos.writeFloat(prices[i]);
dos.writeChar('\t');
dos.writeInt(numbers[i]);
dos.writeChar('\n');
}
dos.close();
}
}
package com.dengdi.Date;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class DataInputStreamDemo {
public static void main(String[] args) throws IOException {
File file = new File("E:" + File.separator + "test.txt");
DataInputStream dis = new DataInputStream(new FileInputStream(file));
int len = 0;
char c = 0;
char[] temp = new char[300];
String name =null;
float price =0.0f;
int number =0;
try {
while (true) {
if ((c = dis.readChar()) != '\t') {
temp[len] = c;
len++;
}
name = new String(temp, 0, len);
price = dis.readFloat();
dis.readChar();
number = dis.readInt();
dis.readChar();
System.out.printf("名称：%s;价格：%f;数量：%d\n", name, price, number);
}
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
dis.close();
}
}
9、压缩流(ZipInputStream、ZipOutputStream)
构造方法: a)public ZipInputStream(InputStream in) 创建新的 ZIP 输入流。
b)public ZipOutputStream(OutputStream out) 创建新的 ZIP 输出流。
c)public ZipEntry(String name) 使用指定名称创建新的 ZIP 条目。
其他方法: a)public boolean isDirectory() 如果为目录条目，则返回 true。
b)public void putNextEntry(ZipEntry e)throws IOException 开始写入新的 ZIP 文件条目并将流定位到条目数据的开始处。
怎么使用的例子
package com.dengdi.zip;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
public class ZipInputStreamDemo01 {
public static void main(String[] args) throws IOException {
File file=new File("E:"+File.separator+"dengdi.zip");
ZipFile zipFile=new ZipFile(file);
ZipInputStream zipInput=new ZipInputStream(new FileInputStream(file));
ZipEntry entry=null;
File outFile=null;
InputStream input=null;
OutputStream out=null;
while((entry=zipInput.getNextEntry())!=null){
System.out.println("解压缩"+entry.getName()+"文件.");
outFile=new File("E:"+File.separator+entry.getName());
if(!outFile.getParentFile().exists()){
outFile.getParentFile().mkdirs();
}
if(!outFile.exists()){
outFile.createNewFile();
}
input=zipFile.getInputStream(entry);
out=new FileOutputStream(outFile);
int temp=0;
while((temp=input.read())!=-1){
out.write(temp);
}
}
out.close();
input.close();
}
}
package com.dengdi.zip;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
public class ZipOutputStreamDemo01 {
public static void main(String[] args) throws IOException {
File file = new File("E:" + File.separator + "dengdi");
File zipFile = new File("E:" + File.separator + "dengdi.zip");
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile));
InputStream input = null;
if (file.isDirectory()) {
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
input = new FileInputStream(files[i]);
zos.putNextEntry(new ZipEntry(file.getName() + File.separator
+ files[i].getName()));
int temp=0;
while((temp=input.read())!=-1){
zos.write(temp);
}
input.close();
}
}
zos.close();
}
}
扫一扫
180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
