Java输⼊输出流（⼀）——常⽤的输⼊输出流
1.流的概念：在Java中，流是从源到⽬的地的字节的有序序列。Java中有两种基本的流——输⼊流（InputStream）和输出流（OutputStream）。
根据流相对于程序的另⼀个端点的不同，分为节点流和过滤流。
（1）节点流：以特定源如磁盘⽂件、内存某区域或者线程之间的管道为端点的构造输⼊输出流，是⼀种基本的流。
（2）过滤流：以其他已经存在的流为端点构造的输⼊输出流。
根据流中的数据单位分为字节流和字符流。
（1）字节流：流中的数据是以8位字节为单位进⾏读写，以InputStream和OutputStream为基础类。
（2）字符流：流中的数据是以16为字符为单位进⾏读写，以Reader和Writer为基础类。
2.字节流
InputStream和OutputStream是字节流的两个顶层⽗类，提供了输⼊流类和输出流类的通⽤API。
2.1 输⼊字节流
InputStream基本⽅法：
（1）基本读⽅法;: int read() int read（byte[] b） int read(byte[] b,int off,int len)
(2) 关闭流：void close()
(3) 返回输⼊流中还有多少可读字节 int available()
(4) 跳过指定字节 long skip(long n)
(5) 回读数据 boolean markSupported() void Mark(int readlimt) void reset()
2.2 输出字符流
OutputStream基本⽅法：
java创建文件（1）基本写⽅法：void write（int c） void write(byte[] b) void write(byte[] b,int off,int len)
(2) 关闭流：void close()
(3)q强制输出：void flush（）
3.字符流：
Reader和Writer是字符流的顶层⽗类，字符流能够处理Unicode字符集中的所有字符。成员⽅法和字节流类似。
3.输⼊/输出流的套接
节点流在程序中不是很常见，⼀般通过过滤流将多个流套接起来，利⽤各个流的特性共同处理数据。例如下图：⼀个⽂件流为了为了提⾼效率，套接了缓存流，最后套接了数据流。
4、常见的输⼊输出流
4.1 ⽂件流：⽂件流属于节点流，包括FileInputStream和FileOutputStream类以及Reader和Writer类。这些类都是对⽂件系统中的⽂件进⾏读写。⽂件流的创建是调⽤相应的构造⽅法，并经常以字符串形式的⽂件名或者⼀个File类的对象为参数，例如：
public FileInputStream(String name);
public FileInputStream(File file);
例⼦：使⽤⽂件流实现⽂件的复制。
（1）通过⽂件字节流实现：
package ch07;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyBytes {
public static void main(String[] args) throws IOException {
//create two File class object
// File inputFile=new File("E:\\workspace\\tmpfile\\");
// File outputFile=new File("E:\\workspace\\tmpfile\\");
//create file input/output byteStream
FileInputStream inputStream=new FileInputStream(new File("E:\\workspace\\tmpfile\\")); //attention：throw exception
FileOutputStream outputStream=new FileOutputStream(new File("E:\\workspace\\tmpfile\\"));
int c;
while((ad())!=-1){
outputStream.write(c);
System.out.println(c);
}
inputStream.close();
outputStream.close();
System.out.println("done! the file is in E:\\workspace\\tmpfile\\");
}
}
（2）使⽤⽂件字符流实现
package ch07;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Copy {
public static void main(String[] args) throws IOException{
//创建⽂件字符输⼊/输出流
FileReader in =new FileReader("E:\\workspace\\tmpfile\\farrago.doc");
FileWriter out=new FileWriter("E:\\workspace\\tmpfile\\outagainb.doc");
int c;
while((ad())!=-1){
System.out.println(c);
out.write(c);
}
in.close();
out.close();
}
}
运⾏时需要在指定⽬录下存在farrago.doc，程序运⾏后会在相同的⽬录下⽣成outagainb.doc。⾥⾯内容和farrago.doc⼀样。
4.2 缓冲流
缓冲流BufferedInputStream和BufferedOutputStream类和BufferedReader和BufferedWriter类。这种流把数据从原始流成块读⼊或者积累到⼀个⼤数据快的时候在成批写出。BufferedOutputStream和Buffere
dWrite仅仅在缓冲区满或者调⽤flush()时候才把数据写到⽬的地。
构造⽅法：
public BufferedInputStream(InputStream in)
public BufferedInputStream(InputStream in，int size)
4.3 管道流
管道流可以实现线程之间的数据的直接传输。
（1）管道流模型：
PipedReader/PipedInputStream实现管道的输⼊流，⽽PipedWriter和PipedOutputStream实现输出流。
（2）管道流的创建：
管道流的创建是将管道输⼊流和管道输出流进⾏挂连。构造⽅法有下⾯两种⽅式：
PipedInputStream pInputStream=new PipedInputStream();
PipedOutputStream pOutputStream=new PipedOutputStream(pInputStream);
或者
PipedInputStream pInputStream=new PipedInputStream();
PipedOutputStream pOutputStream=new PipedOutputStream();
（3）管道流实例：单词处理程序。从⽂件中读⼊单词，将每个单词逆序，然后按照逆序排列，最后将逆序还原输出。RhymingWords.java：包括main（）,reverse()和sort（）⽅法。在main()中调⽤reverse()和sort()对单词进⾏处理，然后处理结果显⽰package ch07;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintWriter;
import java.io.Reader;
import ch07.ReverseThread;
import ch07.SortThread;
public class RhymingWords {
public static void main(String[] args) throws IOException {
String pathname="E:\\workspace\\tmpfile\\";
FileReader words=new FileReader(pathname);
/
/进⾏单词的逆序排序在逆序还原
Reader rhymedWords=reverse(sort(reverse(words)));
//将处理后的单词列表输出显⽰
BufferedReader in=new BufferedReader(rhymedWords);
String input;
while((adLine())!=null)
System.out.println(input);
in.close();
}
//创建管道，创建并且启动单词逆序线程
public static Reader reverse(Reader source) throws IOException{
BufferedReader in =new BufferedReader(source);
PipedWriter pipeOut=new PipedWriter();
PipedReader pipeIn=new PipedReader(pipeOut);
PrintWriter out=new PrintWriter(pipeOut);
new ReverseThread(out, in).start();
return pipeIn;
}
public static Reader sort(Reader source) throws IOException{ BufferedReader in=new BufferedReader(source);
PipedWriter pipeOut=new PipedWriter();
PipedReader pipeIn=new PipedReader(pipeOut);
PrintWriter out=new PrintWriter(pipeOut);
new SortThread(out, in).start();
return pipeIn;
}
}
ReverseThread.java：执⾏逆序的线程类
package ch07;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
public class ReverseThread extends Thread {
private PrintWriter out=null;
private BufferedReader in=null;
public ReverseThread(PrintWriter out,BufferedReader in){
this.out=out;
this.in=in;
}
//逆序线程的线程体
public void run(){
if(out!=null && in!=null){
try{
String input;
while((adLine())!=null){
out.println(reverseIt(input));
out.flush();
}
out.close();
}catch (IOException e) {
System.out.println("ReverseThread run "+e);
// TODO: handle exception
}
}
}
//实现单词逆序算法
private String reverseIt(String rawWord){
int i,len=rawWord.length();
StringBuffer dest=new StringBuffer(len);
for(i=(len-1);i>=0;i--){
dest.append(rawWord.charAt(i));
}
String();
}
}
SortThread.java：执⾏排序的线程类
package ch07;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
public class SortThread extends Thread{
private PrintWriter out=null;
private BufferedReader in=null;
public SortThread(PrintWriter out,BufferedReader in){
this.in=in;
this.out=out;
}
//排序线程的线程体
public void run(){
int MAXWORDS=50;
if(out!=null &&in!=null){
try{
String[] listOfWords=new String[MAXWORDS];
int numWords=0;
while((listOfWords[numWords]=in.readLine())!=null){
numWords++;
}
quickSort(listOfWords,0,numWords-1);
for(int i=0;i<numWords;i++)
out.println(listOfWords[i]);
out.close();
}catch (IOException e) {
// TODO: handle exception
System.out.println("SortThread run:"+e);
}
}
}
//实现快速排序
private static void quickSort(String[] a,int lo0,int hi0){ int lo=lo0;
int hi=hi0;
if(lo>=hi)
return;
String mid=a[(lo+hi)/2];
while(lo<hi){
while(lo<hi&&a[lo]pareTo(mid)<0)
lo++;
while(lo<hi&&a[hi]pareTo(mid)>0)
hi--;
if(lo<hi){
String temp=a[lo];
a[lo]=a[hi];
a[hi]=temp;
lo++;
hi--;
}
}
if(hi<lo){
int temp=hi;
hi=lo;
lo=temp;
}
quickSort(a, lo0, lo);
quickSort(a, lo==lo0?lo+1:lo, hi0);
}
}
在本例中包含的单词为：
程序运⾏结果为：
实现押韵处理。
在该程序中数据流的⽅向如下：
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论