IO流 博客分类： j2se io

A，java IO流式的输入输出原理：将所有的流理解为管道。

B，Java流的分类：所有的流都在IO包下面。

     1，从方向上分为输入流和输出流。

     2，从处理数据的单位可以分为字节流和字符流。
            字节流：可以处理一切文件    doc、图片、音频、视频
            字符流：只能处理文本文件    只能处理纯文本

     3，按功能可以分为节点流(没有套在其它流上的管道，是直接接在文件上的)和处理流(套在其它流(管道)之上的流(管道)称为处理流)。

C，输入/输出流类：

 

InputStream

 

 

read()   Reads the next byte of data from the input stream

read(byte[] b)  Reads some number of bytes from the input stream and stores them into the buffer array b.

 

 

OutputStream

 

write(int b)  Writes the specified byte to this output stream.

write(byte[] b) Writes b.length bytes from the specified byte array to this output stream.

 

 

 Reader

 

read() Read a single character.

read(char[] cbuf) Read characters into an array.

 

 

Writer

 

 

write(int c) Write a single character.

write (char[] cbuf)  Write an array of characters.

write(String str) Write a string.

D，常见的节点流和处理流：

节点流：直接接在文件上的， 而不是接在别的流上的流(2,3节讲) 

 

处理流：套在别的流上的流  缓冲流  转换流都是处理流。

 

 

E，文件流：

F，缓冲流：

 

BufferdReader 有一个非常好用的方法就是readLine();

G，数据流：

H，转换流：

 

I，Print流：

J，Object流：

 

 

IO写一个文件，当文件路径不存在时创建文件路径的做法是：

File f = new File(saveToFileStr.substring(0,saveToFileStr.lastIndexOf("/")));          
 if(!f.exists()){
     f.mkdirs();   
  }

 

用IO流读取MySql里面的Blob类型的数据到页面想显示处理的做法是：

String sBlob = "";
InputStream in = this.rs.getBinaryStream(1);//这里现在是指定的列下标的做法， 也可以指定列名  
byte[] buffer = new byte[10240];
int len = 0;
while ((len = in.read(buffer)) != -1) {
 sBlob += new String(buffer, 0, len, "utf-8");
}
in.close();
return sBlob;

 IO这一章的源码

 

package IO;
import java.io.*;
import java.sql.*;
/**
 * time:20110825
 * 该类是一个IO测试的类，每一个方法讲解一个小知识点。
 * @author Administrator
 *
 */
public class IOSample {
 public static void main(String[] args) {
  IOSample iOSample = new IOSample();
  //iOSample.PrintAFileToConsoleByInputStream("C:/IOSample.java");
  //iOSample.printAFileToConsoleByReader("C:/IOSample.java");
  //iOSample.printAFileToConsoleByReaderWithCharArray("C:/IOSample.java");
  //iOSample.FileCopyUseFileReaderAndFileWriter("C:/IOSample.java","D:/IOSample.java");
  //iOSample.FileCopyUseBufferdReaderAndBufferdWriter("C:/IOSample.java","D:/IOSample.java");
  //iOSample.Transform1OutputStreamWriter("C:/TransformFile.txt");
  //iOSample.Transform2WithSystemIN(new String[10]);
  //iOSample.DataStream();
  //iOSample.printStringOfExchangeSystemOutConsoleToFile("C:/log.log");
  //iOSample.PrintStreamOfPrintASpecifyFileToConsole(args[0],System.out);
  iOSample.PrintStreamOfPrntConsoleInputContentToSpecifyFile("C:/QQ.text");
 }
 /**
  * 该方法的作用是把传入的一个文件通过字节流的方式输出到控制台。
  * 优点：暂时没有发现。
  * 不足：中文字符输出之后是乱码显示的。一次只能读取一个字节(没有设小桶)。
  * 知识点：字节输入流。
  * @param fileName  带路径的文件名
  */
 public void PrintAFileToConsoleByInputStream(String fileName){
  try {
   FileInputStream fis = new FileInputStream(fileName);
   int c;
   while((c=fis.read())!=-1){
    System.out.print((char)c);
   }
   fis.close();
  } catch (FileNotFoundException e) {
   System.out.println("您传入的文件不没有找到，"+fileName+"请检查！！！");
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   System.out.println("发生了IO异常！！！");
   e.printStackTrace();
  }
  
 }
 /**
  * 该方法的作用是把传入的一个文件通过字节流的方式输出到控制台。
  * 优点：解决了中文字符乱码显示的问题。
  * 不足：一次只能读取一个字符(没有设小桶)。
  * 知识点：字符输入流。
  * @param fileName  带路径的文件名
  */
 public void printAFileToConsoleByReader(String fileName){
  try {
   FileReader fr = new FileReader(fileName);
   int c;
   while((c=fr.read())!=-1){
    System.out.print((char)c);
   }
   fr.close();
  } catch (FileNotFoundException e) {
   System.out.println("您传入的文件不没有找到，"+fileName+"请检查！！！");
   e.printStackTrace();
  } catch (IOException e) {
   System.out.println("发生了IO异常！！！");
   e.printStackTrace();
  }
 }
 
 /**
  * 该方法的作用是把传入的一个文件通过字节流的方式输出到控制台。
  * 优点：解决了中文字符乱码显示的问题。一次能读取指定长度的字节放到小桶里面，然后输出到控制台。
  * 不足：暂时没有发现。看中国记忆是怎么做的，我的做法应该和中国记忆的是一样的。
  * 知识点：字符流，用FileReader的read(char[] cbuf)方式 用读取字符数组的方式读取。
  * @param fileName  带路径的文件名
  */
 public void printAFileToConsoleByReaderWithCharArray(String fileName){
  try {
   FileReader fr = new FileReader(fileName);
   int b;
   char c[] = new char[1024];
   b = fr.read(c);
   while(b!=-1){
    //自己的做法。
    /*for(int i=0;i<b;i++){
     System.out.print(c[i]);
    }
    b = fr.read(c);*/
    //中国记忆的做法   这种做法貌似比我的效率要高些。20110825
    String str = new String(c,0,b);
    System.out.print(str);
    b = fr.read(c);
   }
   fr.close();
  } catch (FileNotFoundException e) {
   System.out.println("您传入的文件不没有找到，"+fileName+"请检查！！！");
   e.printStackTrace();
  } catch (IOException e) {
   System.out.println("发生了IO异常！！！");
   e.printStackTrace();
  }
 }
 /**
  * 该方法的功能是实现文件复制的功能
  * 知识点：字符流，用FileReader的read(char c)方式 用读取字符的方式读取。
  * @param sourceFile 带路径的源文件
  * @param targetFile 带路径的输出目标文件
  *  第4节讲
  */
 public void FileCopyUseFileReaderAndFileWriter(String sourceFile,String targetFile) {
  try {
   FileReader fr = new FileReader(sourceFile);
   FileWriter fw = new FileWriter(targetFile);
   int c;
   while((c=fr.read())!=-1){
    fw.write(c);
   }
   fr.close();
   fw.close();
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 /**
  * 该方法的功能是实现文件复制的功能 同时向控制台输出要复制的文件。
  * 知识点：带缓冲区的字符流，用BufferedReader的readLine()方式    用一次读一行方式读取。  readLine()这个方法非常重要
  * @param sourceFile
  * @param targetFile
  */
 public void FileCopyUseBufferdReaderAndBufferdWriter(String sourceFile,String targetFile) {
  try {
   BufferedReader br = new BufferedReader(new FileReader(sourceFile));
   BufferedWriter bw = new BufferedWriter(new FileWriter(targetFile));
   String str;
   while((str=br.readLine())!=null){
    bw.write(str);
    bw.newLine();
    System.out.println(str);
   }
   bw.close();
   br.close();
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 /**
  * 这个方法用转换流的方式向指定文件写入一些内容。
  * 如果不使用转换流使用FileOutputStream的话那么我们一次就只能够写一个字节，现在我们的做法是使用转换流一次写入多个字节。
  * 注意理解这里的OutputStreamWriter 是套在FileOutputStream上的流。
  * @param filePath
  *  第6节讲
  */
 public void Transform1OutputStreamWriter(String filePath){
  try {
   OutputStreamWriter osw = osw = new OutputStreamWriter(new FileOutputStream(filePath,true),"UTF-8");
   //true表示重原来的基础上添加,如果去掉，那么后一次写的时候就会把前一次写入的擦掉。"UTF-8"表示写入的字符编码集的格式，如果不指定的话拿到的就是GBK  因为我们电脑默认的就是安装的中文的Windows。
   System.out.println(osw.getEncoding());//如果不指定的话拿到的就是GBK  因为我们电脑默认的就是安装的中文的Windows.
   osw.write("I Love Studing Java!!! ");
   osw.write("好好学习，天天向上！");
   osw.close();
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 /**
  * 方法功能描述：使用转换流和标准的输入流将我们键盘录入的一行字符串回显在控制台。输入忽略大小写的exit推出程序。
  * 注意理解这里套了三层管道，System.in是最里面的，InputStreamReader是中间那层的。BufferedReader是最外层的。
  * System.in是阻塞式的的方法。
  * @param args
  */
 public void Transform2WithSystemIN(String args[]){
  InputStreamReader isr = new InputStreamReader(System.in);
  BufferedReader br = new BufferedReader(isr);
  String str;
  try {
   while((str=br.readLine())!=null){
    while(str.equalsIgnoreCase("exit")){
     System.exit(-1);
    }
    System.out.println(str.toUpperCase());
    br.close();
   }
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 /**
  *这节讲解数据流(DataInputStream , DataOutputStream)的知识，  使用数据流的好处是可以方便的对java的各种基本数据类型做操作。
  *顺便还讲了字节数组输入输出流(ByteArrayInputStream , ByteArrayOutputStream)。
  *这里注意有两点要着重理解：
  *    1，数据流是先进先出的。
  *    2，当我们new 一个ByteArrayOutputStream对象的时候做了两件事情：首先在内存里面产生了一个字节数组(默认长度是32个字节的)，其次是用一个输出流接在new出来的字节数组上面。
  *数据流是
  */
 public void DataStream(){
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  DataOutputStream dos = new DataOutputStream(baos);
  try {
   dos.writeDouble(Math.random());
   dos.writeBoolean(false);
   ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
   System.out.println(bais.available());
   DataInputStream dis = new DataInputStream(bais);
   System.out.println(dis.readDouble());
   System.out.println(dis.readBoolean());
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 /**
  * 该方法体现了打印流的知识1，
  * 功能描述：将向控制台输出信息写入指定的文件(相当于日志记录)
  * @param logFile
  */
 public void printStringOfExchangeSystemOutConsoleToFile(String logFile){
  try {
   FileOutputStream fos = new FileOutputStream(logFile,true);
   PrintStream ps = new PrintStream(fos);
   if(ps!=null){
    System.setOut(ps);
   }
   int b[] = new int[100];
   for(int i=0;i<b.length;i++){
    b[i] = i+1;
   }
   for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
   }
   ps.close();
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 /**
  * 打印流的方法2
  * 功能描述：将一个指定的文件的内容输出到控制台
  * @param fileName  指定的文件名
  * 注意：这里的文件名运行主方法时候要传入的参数，如果不传那么将报数组越界异常。
  */
 public void PrintStreamOfPrintASpecifyFileToConsole(String fileName,PrintStream ps){
  try {
   FileReader fr = new FileReader(fileName);
   BufferedReader br = new BufferedReader(fr);
   String tempstr;
   while((tempstr=br.readLine())!=null){
    ps.println(tempstr);
   }
   br.close();
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 /**
  * 打印流的方法3
  * 功能描述：实现将控制台输入的内容写入到指定的文件中去  可以理解为做日志记录。
  * 思路：分两步：一将输入流接上控制台。将输出流接上指定文件
  * @param fileName  指定的文件名
  */
 public void PrintStreamOfPrntConsoleInputContentToSpecifyFile(String fileName){
  //将输入流接上控制台
  InputStreamReader isr = new InputStreamReader(System.in);
  BufferedReader br = new BufferedReader(isr);
  //将输出流接上指定文件
  try {
   FileOutputStream fos = new FileOutputStream(fileName,true);
   OutputStreamWriter osw = new OutputStreamWriter(fos);
   BufferedWriter bw = new BufferedWriter(osw);
   PrintWriter pw = new PrintWriter(bw);
   String tempStr;
   while((tempStr = br.readLine())!=null){
    if(tempStr.equalsIgnoreCase("exit")){
     pw.println("---------------------"+new java.util.Date()+"---------------------------------");
     pw.close();
     br.close();
     System.exit(1);
    }
    pw.println(tempStr);
    System.out.println(tempStr);
   }
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 // 还有2件事情要完成  每件事情的四步都要求实现
 // 1，写一个方法能够实现将一个 图片文件/音频文件/视频文件/大文本文件存入数据库中去。
 // 存文本  pstmt.setCharacterStream(2,new Reader(new StringReader(new String("abc"))), new String("abc").length()); 存入文本文件的方法有问题，周一看看。
 // 存图片  pstmt.setBinaryStream(1, new FileInputStream(new File("c:/a.jpg")), (int) new File("c:/a.jpg").length());
 
 // 2，写一个方法能够实现从数据库中的Blob或者Clob中读取出来图片 音频文件  视频文件 大的文本文件，并且能够正常的显示。
 /*public void Task(){
  PreparedStatement pstmt = null;
  try {
   pstmt.setBinaryStream(1, new FileInputStream(new File("c:/a.jpg")), (int) new File("c:/a.jpg").length());
   pstmt.setCharacterStream(2,new Reader(new StringReader(new String("abc"))), new String("abc").length());
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }*/
}