java基础之IO流

流：能被连续读取数据的数据源 和能被连续写入数据的接收端 是字节序列的抽象概念。

流的分类

种 类	字 节 流	字 符 流
输入流	InputStream	Reader
输出流	OutputStream	Writer

字节流中的重要知识：

InputStream类的方法

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

OutputStream类的方法

方  法  申  明	功  能  摘  要
void close()	关闭此输入流并释放与此流有关的所有系统资源
void flush()	刷新此输出流并强制写出所有缓冲的输出字节
void write(byte[]  b)	将b.length字节从指定的byte数组写入此输出流
void writer(int b)	将指定的字节写入此输出流
void write(byte[] b, int off,int len)	将指定byte数组中从偏移量off开始的len字节写入此输出流

字节流读文件

public static void main(String[] args){
       FileInputStream fis = null;   //初始化对象
       try{
          //创建文件输入流对象
          fis = new FileInputStream("D://read.txt");
          int n = 512;       //设定读取的字节数
          byte buffer[] = new byte[n];
          //读取输入流
          while((fis.read(buffer,0,n) != -1) && (n > 0)){
               System.out.println(new String(buffer));
          }
       }catch(Exception e){
          System.out
       }finally{
          try{
               fis.close();
             }cathch(IOException e){
               e.printStackTrace();
             }
 
       }
}

字节流写入文件

public static void main(String[] args) throws IOException{
        System.out.print("输入要保存文件的内容");
        int count, n = 512;  //设定写入的字节数
        byte buffer[] = new byte[n];
        count = System.in.read(buffer);   //读取标准输入流
        //创建文件输出对象
        FileOutputStream fos = new FileOutputStream("D://read.txt");
        fos..write(buffer,0,count);       //写入输出流
        System.out.println("已保存到read.txt");  
        fos.close();   //释放资源
       
}

复制文件         

public static void main(String[] args){

     //创建文件输入流对象
     FileInputStream fis = new FileInputStream("src/oen.jpg");
     //创建文件输出流对象
     FileOutputStream fos = new FileOutputStream("tar/test.jpg");
     int len //记录每次读取的字节
     //复制文件前的系统时间
     long begin = System.currentTimeMillis();
     //读取文件是否到达文件末尾
     while((len = fis.read()) != -1){
        fos.write(len)    //将读到的字节写入文件

}
     //复制文件后的系统时间
     long end = System.currentTimeMillis();
     System.out.println("复制文件耗时：" + (len - begin) + "毫秒")；
     fos.close();
     fis.close();
}

 使用字节流复制文件虽然可以，但效率慢，

字符流的缓冲区

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

   //创建文件输入流对象
   FileInputStream fis = new FileInputStream("src/t1.jpg");
   //创建文件输出流对象
   FileOutputStream fos = new FileOutputStream("tar/t1.jpg");
   byte[] b = new byte[512];  //缓冲区大小
   int len;  //记录每次读取的字节
   //复制文件的系统时间
   long begin = System.currentTimeMillis();
   //读取文件并判断是否到达文件末尾
   while((len = fis.read(b)) != -1){
        fos.write(b,0,len);  //从第一个字节开始，向文件写入len个字节

   }
   //复制文件后的系统时间
   long end = System.currentTimeMillis();
   System.out.println("复制文件耗时："+(end - begin) + "毫秒");
   fos.close();
   fis.close();

}

字节缓冲流

 

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

     //创建文件输入流对象
     FileInputStream fis = new FileInputStream("src/t1.jpg");
     //创建文件输出流对象
     FileOutputStream fos = new FileOutputStream("tar/t1/jpg");
     //将创建的节点流对象作为形参传递给缓冲流的构造方法中
     BufferedInputStream  bis = new BufferdInputStream(fis);
     BufferedOutputStream bos = new BufferedOutputStream(fos);
     int len; //记录每次读取的字节
     //复制文件的系统时间
     long begin = System.currentTimeMillis();
     //读取文件并判断是否到达文件末尾
     while((len = bis.read(b)) != -1){
        bos.write(b,0,len);  //从第一个字节开始，向文件写入len个字节

     }
     //复制文件后的系统时间
     long end = System.currentTimeMillis();
     System.out.println("复制文件耗时："+(end - begin) + "毫秒");
     bos.close();
     bis.close();
     


}

字符流

字符流读取文件

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

   File f = new File("read.txt");
   FileReader fr = new FileReader(f);
   int len;  //记录读取的字符
   //判断是否读取到文件的末尾
   while((len = fr.read()) != -1){
      //打印文件内容
      System.out.println((char) len);
}
   fr.close();    //释放资源

}

字符流写入文件

public static void main(String[] args)throws IOExecption{
    File f = new File("read.txt");
    FileWriter fw = new FileWriter(f);
    fw.writer(".com")      //写入文件内容
    System.out.println("已保存到read.txt");
    fw.close();  //是否资源

}

字符流的缓冲区

缓冲区流：BufferedReader ，BufferedWriter  对流进行包装

public static void main(String[] args){

   FileReader fr = new FileReader("src/src.txt");
   FileWriter fw = new FileWriter("src/t1.txt");
   BufferedReader  br = new BufferedReader(fr);
   BufferedWriter bw = new BufferedWriter(fw);
   String str;
   //每次读取一行文本，判断是否到文件末尾
   while((str = br.readLine()) != null){
       bw.writer(str);
       //写入一个换行符，该方法会根据不同操作系统生成相应转换符
       bw.newLine();

}
  bw.close(); //释放资源
  br.close();

}

转换流  

          将字节流与字符流之间进行转换

          InputStreamReader,OutputStreamWriter

public static void main(String[] args) throws Exection{
  
   //创建字节输入流
   fileInputStream fis = new FileInputStream("src/src.txt");
   //将字节输入流装换为字符输入流
   InputStreamReader isr = new InputStreamReader(fis);
   //创建字节输出流
   FileOutputStream fos = new FileOutputStream("src/src1.txt");
   //将字符输出流转换为字节输出流
   OutputStreamWriter osw = new OutputStreamWriter(fos);
   int str;
   while((str = isr.read()) != -1){
         osw.writer(str);
}
   osw.close();
   isr.close();
}