java 常见io流万字详解

武托邦

已于 2022-07-13 17:30:59 修改

阅读量700

点赞数 2

分类专栏： java初识文章标签： java 后端

于 2022-06-30 11:54:24 首次发布

本文链接：https://blog.csdn.net/m0_62953927/article/details/125528462

版权

java初识专栏收录该内容

17 篇文章 0 订阅

订阅专栏

文章目录

1.IO简介
2 文件
3常用流对象
6对象流ObjectOutputStream ObjectInputStream
7阿帕奇包的应用
- 7.1使用
- 7.2IOUtils使用

1.IO简介

1.1什么是IO流。

(input)输入：播放器打开视频。（读，东西类容不变）
(output)输出：写word到磁盘（写）。（东西类容增加）

1.2数据源（Data Source）

提供数据的媒介。（数据的来源）
源设备：为程序提供数据。一般为输入流。
目标设备：程序数据的目的，地一般对应输出流。
程序相当于一个黑盒子。（对于普通人来说）

1.3什么是流

输入/输出流的划分是相对程序而言的，并不是相对数据源。

是一连串连续动态的数据集合。
就是形容数据传输的过程。

1.4处理对象分类

节点流：可以直接读取数据的。（必须有）
处理流：（锦上添花）不直接连接到数据源或目的地的，（目的：提高性能）
如 BufferedInputStream、BufferedReader 等。处理流也叫包装流。在这里插入图片描述

1.5 java四大io抽象类及其他

InputStream/OutputStream 和 Reader/Writer 类是所有 IO 流类的抽象父类 在这里插入图片描述

1.6inputStream

1.61简介

由于是抽象类，需要子类进行重写。
向程序中输入数据。且数据单位字节为8bit。
返回-1读取完毕。

1.62常用方法

int read();读取1字节数据，并将字节的值作为int类型返回范围（0~255）。常用
void close();关闭输入流对象，释放相关系统资源。
如果未读出字节则返回-1（返回值为-1 表示读取结束）。

1.7OutputStream

1.71简介

抽象类是表示自己输出流的所有类的父类。输出流接收输出字节并将好这些字节发送到某地。

1.72常用方法：

void write(int n);向目的地写入一个字节。
void close();关闭输出流对象，释放相关资源。

1.8Reader

1.81简介

用于读取字符流抽象类。数据单位为字符。
int read():读取一个字符的数据，并将这个数据的值作为int 类型返回返回（0~65535）Unicode。
如果读取完毕，则返回-1；
void close()；关闭流对象释放相关系统资源。

1.82Writer

用于输出字符流抽象内数据单位为字符。
void Writer(int n); 向输出流中写入一个字符。
void close();关闭输出流对象，释放相关系统资源。

1.9总结

1.91规律

以字节为单位获取数据，命名以上Stram结尾的流一般是字节流。（FileinputStream）（图片，视频，甚至字符）
也只有字节流的.read();会返回（0-255）或者（0-65535）
以字符为单位数据获取数据，命名以上Reader/Writer结尾的流一般是字符流，如FileReader,FileWriter。（文本文件）。
都需要关闭，代表需要try {}catch以及其他报错方式。
传入的都是int类型。void write(int n)；

1.92常用操作

InputStream/OutputStream 字节流的抽象类。（输入流/输出流）

Reader/Writer 字符流的抽象类。（读/写）
不会直接调用。

FileInputStream/FileOutputStream 节点流：以字节为单位直接操作“文件”。（文件输入流/文件输出流）

ByteArrayInputStream/ByteArrayOutputStream 节点流：以字节为单位直接操作“字节数组对象”。（字节数组输入流/字节数组输出流）

ObjectInputStream/ObjectOutputStream 处理流：以字节为单位直接操作“对象”。（对象输入流/对象输出流）

DataInputStream/DataOutputStream 处理流：以字节为单位直接操作“基本数据类型与字符串类型”。（数据输入流/数据输入流）

FileReader/FileWriter 节点流：以字符为单位直接操作“文本文件”（注意：只能读写文本文件）。（文件读/文件写）

BufferedReader/BufferedWriter 处理流：将 Reader/Writer 对象进行包装，增加缓存功能，提高读写效率。（缓冲读/缓冲写）

BufferedInputStream/BufferedOutputStream 处理流：将 InputStream/OutputStream 对象进行包装，增加缓存功能，提高读写效率。（缓冲输入流/缓冲输出流）

InputStreamReader/OutputStreamWriter 处理流：将字节流对象转化成字符流对象。（输入流读/输出流写）有字符流与字节流之间的共同结尾特征。

PrintStream 处理流：将 OutputStream 进行包装，可以方便地输出字符，更加灵活。（输出流）

2 文件

浅尝

2.0用FileInputStream读取文件（输入文件到程序中）

注意：
只能一个一个读。

package javaio;
import java.io.FileInputStream;
public class firm01 {
    public static void main(String[] args) {
        //创建字节输入流
FileInputStream  fis=null;//在try的外面关闭流对象，原因是以后还要关闭。不能成为局部变量。
        try {
             fis = new FileInputStream("D:/a.txt.txt");//注意文件名
char s1=(char)fis.read();//只能打印一个值
char s2=(char)fis.read();//只能打印一个值
char s3=(char)fis.read();//只能打印一个值
int s4=fis.read();//只能打印一个值
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
                try { 
                    if(fis!=null) 
                    {
                    fis.close();}
                }catch (Exception e){
                    e.printStackTrace();//e是Throwable的实例异常对象，
                    // 用在catch语句中，相当于一个形参，
                    // 一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理
                }
            }
        }
    }

改进
说明：

//强制转化（类型）变量名高->底
//自动转化底到高
//byte ，short ->char->int->long->float->double
速度：StringBuilder>StringBuffer>String

package javaio;

import java.io.FileInputStream;

public class firmo2 {
    public static void main(String[] args) {
        //创建字节输入流

        FileInputStream  fis=null;//在try的外面关闭流对象，原因是以后还要关闭。不能成为局部变量。
        try {
            StringBuilder SB=new StringBuilder();
            fis = new FileInputStream("D:/a.txt.txt");//注意文件名
            int temp=0;//因为最后输出完会返回-1.所以用int型，然后可以//强//制转化为char型
         //   while(fis!=null)若这样写，fis会一直输出因为java.io.FileInputStream@1b6d3586，永远不为null
            while((temp=fis.read())!=-1)//读完之后会返回-1，读完之前返回（0~255的int值）
            {
              //  System.out.println(temp);
                SB.append((char)temp);//SB获取所有temp。
            }
            System.out.println(SB.toString());//输出。SB调用stringbuilder类的方法toString。
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(fis!=null) {
                try {
                    fis.close();
                }catch (Exception e){
                    e.printStackTrace();//e是Throwable的实例异常对象，
                    // 用在catch语句中，相当于一个形参，
                    // 一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理
                }
            }
        }
    }

2.1file类使用

File 类是 Java 提供的针对磁盘中的文件或目录转换对象的包装类。一个 File 对象而可以代表一个文件或目录，File 对象可以实现获取文件和目录属性等功能，可以实现对文件和目录的创建，删除等功能。

2.2操作file文件。

package javaio.fail;//对文件进行操作
import java.io.File;
public class firm0 {
    public static void main(String[] args)throws Exception {
        File file =new File("d:/ssds.txt");//创建，没有也会自动创建
        System.out.println( file.createNewFile());//成功返回ture
       // System.out.println(file.delete());//删除
        System.out.println(file.exists());//看是否存在
        System.out.println(file.getName());//返回文件名
        System.out.println(file.isFile());//是不是文件(可能为文件夹)
        System.out.println(file.isHidden());//是不是影藏文件(属性->影藏文件)
    }
}

2.3操作目录

package javaio;
//针对目录==文件夹
import 常用类.string;
import java.io.File;
public class file1 {
    public static void main(String[] args) {
        //创建File对象
        File file1 = new File("D:/SAM");//没有文件类型，就是目录
        System.out.println(file1.mkdir());//创建单级目录
        File file12 = new File("D:/S/m/q");//没有文件类型，就是目录
        System.out.println(file12.mkdirs());//mkdirs创建多级目录
        System.out.println(file1.isFile());//判断是不是一个文件
        System.out.println(file1.exists());//查询目录是否存在
        System.out.println(file1.isDirectory());//判断当前路径是否为目录
        System.out.println(file12.getParentFile());
        System.out.println(file12.getParentFile().getName());///调用单级目录可能不输出
        ;//
        File file2 = new File("d:/");//注意文件的格式 “d:/”
        String[] srr = file2.list();
        //String temp="ff";
        for (String temp : srr) {//返回所有文件与目录
            System.out.println(temp);
        }
        System.out.println("################################");
        File[] arr2=file2.listFiles();
        for(File temp:arr2)
        {
            System.out.println(temp);
        }

    }
}

3常用流对象

3.1文件字节流

可以处理所有文件（所有文件都是数字）。

3.11读取图片文件（文件字节流输入）

package javaio;

import java.io.File;
import java.io.FileInputStream;
//读取文本文件
public class fileinputstream {
    public static void main(String[] args) {
//几乎固定模板//
        FileInputStream fis4 = null;
        try {//创建文件字节输入流
        fis4=new FileInputStream("d:/实验图片.jpg");
        int temp=0;
        while((temp=fis4.read())!=-1)//未读完时会返回（0-255）之间的数组，有时还需要一个容器进行接收
                    {
                System.out.println(temp);
            }
        } catch (Exception e)
        {
            e.printStackTrace();
        } finally {
            try {
                if (fis4 != null) {//不等于空，就把它关了？
                    fis4.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            
        }
    }
}
//输出图片贼长的int类型不过在（0~255）之间。

3.12复制文件位置（文件字节流输出）

输出必先有输入

package javaio;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class fileoutputstream {
    public static void main(String[] args) {
        FileInputStream fis5 = null;
        FileOutputStream fos = null;
        try {
fis5 =new FileInputStream("d:/实验图片.jpg");
fos=new FileOutputStream("d:/复制图片位置.jpg");
int temp =0;
while((temp=fis5.read())!=-1) {
    fos.write(temp);
}//将数据从内存写入磁盘
            fos.flush();//清空缓存区的残留文件，详见http://t.csdn.cn/gqQKO
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(fis5!=null) {
                    fis5.close();
                }
                if(fos!=null)
                {
                    fos.close();
                }
            }catch (Exception e ) {
                    e.printStackTrace();
            }
        }
        }
        }

3.13通过缓冲区提高读写效率（建立缓冲区）

之前：一次一个一个字节搬。
之后：一次2的N次（1024等等）方方个字节搬
通过创建一个指定长度的字节数组作为缓冲区，以此来提高 IO 流的读写效率。该方式适用于读取较大图片时的缓冲区定义。一般情况下 1024 长度较为合适。
一般用于大文件。
方法1
buff意为缓冲。
搬大米。

package javaio;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class quickfileoutputstream {
    public static void main(String[] args) {
        FileInputStream fis5 = null;
        FileOutputStream fos = null;
        try {
            fis5 =new FileInputStream("d:/瀑布.jpg");//创建输入流
            fos=new FileOutputStream("d:/复制瀑布位置.jpg");//创建输出流
            /
            byte[]buff=new byte[2048];//创建缓冲区，提高读写效率。【创建拿大米的包】
            /
            int temp =0;
          //  while((temp=fis5.read())!=-1) {//返回当前数组长度

                while((temp=fis5.read(buff))!=-1) {//返回当前数组长度【把大米放入包里】
                //fos.write(temp);//改进
                fos.write(buff,0,temp);//循环一次，从buff数组里面读，从0开始读，读到temp大小
       
            }//将数据从内存写入磁盘
            fos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(fis5!=null) {
                    fis5.close();
                }
                if(fos!=null)
                {
                    fos.close();
                }
            }catch (Exception e ) {
                e.printStackTrace();
            }
        }
    }
}

3.14方法2（一次性搬完available()）

适用于小文件（大文件占用内存）
不需要while循环。
通过创建一个字节数组作为缓冲区，数组长度是通过输入流对象的 available()返回当前文件的预估长度来定义的。在读写文件时，是在一次读写操作中完成文件读写操作的

package javaio;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class twoquickfileoutput {
    public static void main(String[] args) {
        FileInputStream fis5 = null;
        FileOutputStream fos = null;
        try {
            fis5 =new FileInputStream("d:/瀑布.jpg");//创建输入流
            fos=new FileOutputStream("d:/复制f瀑布位置.jpg");//创建输出流
            /
                      //改为    读取预估大小长度进行
            byte[]buff=new byte[fis5.available()];//创建缓冲区，提高读写效率。
            fis5.read(buff);//读入
            fos.write(buff);//写入
            fos.flush();//将数据从内存写入磁盘
            /
//            int temp =0;
            //  while((temp=fis5.read())!=-1) {//返回当前数组长度
//            while((temp=fis5.read(buff))!=-1) {//返回当前数组长度
//                //fos.write(temp);//改进
//                fos.write(buff,0,temp);//写入内存
//            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(fis5!=null) {
                    fis5.close();
                }
                if(fos!=null)
                {
                    fos.close();
                }
            }catch (Exception e ) {
                e.printStackTrace();
            }
        }
    }
}

可以正常读入
在这里插入图片描述

3.15通过字节缓冲流提高读写效率（BufferedInputStream，BufferedOutputStream）

本身不具有io流的读写，只是在别的流加缓冲功能提高效率。就像是把别的流包装起来，因此缓冲流是一种处理流。
适用于对数据进行频繁读写操作时。
原理：当对文件或者其他数据源进行频繁的读写操作时**，效率比较低，这时如果使用缓冲流就** 能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地

package javaio;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class 拷贝文件 {
    public static void main(String[] args) {
        FileInputStream fis =null;
        FileOutputStream fos=null;
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try{
              fis=new FileInputStream("D:/瀑布.jpg");//节点流创建
              bis=new BufferedInputStream(fis);//处理流
              fos=new FileOutputStream("D:/FF.jpg");
              bos=new BufferedOutputStream(fos);
              int temp=0;
              //缓冲流中的 byte 数组长度默认是 8192
              while((temp=bis.read())!=-1)
              {
                  bos.write(temp);
              }
              bos.flush();
        }catch(Exception e)
        {
            e.printStackTrace();
        }finally {
            try {//关闭顺序：后开先关闭，只是基于节点流与处理流之间的比较，节点流与节点流之间没有先后关闭顺序要求，处理流之间同理。
          if(bis!=null)
          {
              bis.close();
          }
                if(fis!=null)
                {
                    fis.close();
                }
                if(bos!=null)
                {
                    bos.close();
                }
                if(fos!=null)
                {
                    fos.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

避免出现汉字无法正常读出（优化输入）

           bo=new ByteArrayOutputStream();
              byte[] bufferr=new byte[1024];
              int len;
              while ((len=ip.read(bufferr))!=-1)
              {
                      bo.write(bufferr,0,len);
              }
            System.out.println(bo.toString());

3.16定义文件拷贝工具类

package javaio;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class 自定义文件拷贝工具类 {
    public static void main(String[] args) {
copyFile("d:/瀑布.jpg","d:/少了-1.jpg");
    }
    /*
    *文件拷贝方法
     */
    public  static void copyFile(String src,String des){
        FileInputStream fis =null;
        BufferedInputStream bis=null;
        FileOutputStream fos=null;
        BufferedOutputStream  bos=null;
try{
//fis=new FileInputStream(src);//接收数据
//bis=new BufferedInputStream(new FileInputStream(src));
        bis=new BufferedInputStream(new FileInputStream(src));
            bos=new BufferedOutputStream(new FileOutputStream(des));
          int temp=0;
        while((temp=bis.read())!=-1)//草
{
    bos.write(temp);
}
bos.flush();
}catch(Exception e)
        {
            e.printStackTrace();
        }finally {
    try {//后开，先关闭
if(bis!=null)
{
    bis.close();
}
if (fis!=null)
{
    fis.close();
}
if(bos!=null)
{
    bos.close();
}
if(fos!=null)
{
    fos.close();
}
    }catch (Exception e)
    {
        e.printStackTrace();
    }
        }
    }
}

3.2文件字符流

处理的是文本文件

3.21文件字符输入流 FileReader

package javaio;

import java.io.FileReader;

public class 文件字符流 {
    public static void main(String[] args) {
        FileReader frd = null;
        try {//创建文件字符输入流
            frd = new FileReader("d:/a.txt.txt");
            int temp = 0;
            while ((temp = frd.read()) != -1) {//返回文本文件uncode的值，而字节流返回的就是字节数
              //  frd.read();
                System.out.println((char) temp);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {

                if (frd != null) {
                    frd.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

3.22文件字符输出流

文件字符输入流，不需要输入，要程序在执行框里面输出
*//（系统发现没有输入的文件名时，会把文件创建出来，创建出来也可以写入，不过之前写的会被覆盖）
要想不被覆盖则添加新参数 fw2 = new FileWriter(“d:/sxt.txt”,true);

package javaio;
//文件字符输入流，不需要输入，要程序在执行框里面输出
import java.io.FileReader;

public class 文件字符流 {
    public static void main(String[] args) {
        FileReader frd = null;
        try {//创建文件字符输入流
            frd = new FileReader("d:/a.txt.txt");
//            int temp = 0;
//            while ((temp = frd.read()) != -1) {
//              //  frd.read();
//                System.out.println((char) temp);
//            }
            int temp=0;
            while((temp=frd.read())!=-1)
            {
                System.out.println(temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {

                if (frd != null) {
                    frd.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

3.23问题

在try catch外面定义FiileWriter会报错，在里面Finaly里面无法关闭。所以依照上面代码就ok。


        try { FileWriter fw = new FileWriter("d:/sxt.txt");
            fw=null;
            fw.write("百变小樱");
            fw.flush();
        }catch (Exception e) {
              e.printStackTrace();
        }finally {//因为要关闭对象，close也会出现隐异常
            try
            {
             fw.close();
            //文件字符输出流2.java
//找不到符号

3.24使用字符流实现文本文件拷贝

package javaio;

import java.io.FileReader;
import java.io.FileWriter;

public class 使用字符流实现文本文件拷贝 {
    public static void main(String[] args) {
        FileReader fr=null;
        FileWriter fw=null;
        try {
          fr =new FileReader("D:/a.txt.txt");
          fw=new FileWriter("D:/aaaaa.txt");
          //
          char[] buffer=new char[1024];//改进,读到buffer数组里面
          //
          int temp=0;
//          while((temp=fr.read())!=-1)
//          {
//              fw.write(temp);
//          }
            while ((temp=fr.read(buffer))!=-1)
            {
                fw.write(buffer,0,temp);//写，从buffer中从0写到temp(所有长度)。
            }
            fw.flush();
        }catch(Exception e)
        {
         e.printStackTrace();
        }finally {
            try {//对于输入流与输出流关闭谁都可以。
              if(fr!=null)
              {
                  fr.close();
              }
              if(fw !=null)
              {
                  fw.close();
              }
            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

3.25字符输入缓冲流

。

package javaio;

import java.io.BufferedReader;
import java.io.FileReader;

public class 字符输入缓冲流 {
    public static void main(String[] args) {
        FileReader fr=null;
        BufferedReader br=null;
        try {
            fr=new FileReader("D:/a.txt.txt");
            br=new BufferedReader(fr);//套壳
            String temp="";//int temp=0;异曲同工
            while ((temp=br.readLine())!=null)//因为readline返回是string类型，所以用null
            //返回的字符串是它在文件里所读取的一行。
            {
               // br.read();
                System.out.println(temp);
            }
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(br!=null)
                {
                    br.close();
                }
                if(fr!=null)
                {
                    fr.close();
                }
            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

3.26字符输出缓冲流

bw.newLine();//换行

package javaio;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class 字符输出缓冲流 {
    public static void main(String[] args) {
        FileWriter fw=null;
        BufferedWriter bw=null;
        try {
            fw=new FileWriter("D:/通达.txt");
            bw=new BufferedWriter(fw);
            /
           bw.write("辅导员退退退");//输入东西。
           bw.write("北有清华，南有通达");
           bw.newLine();//换行
           bw.write("还是上网课好");
            
            bw.flush();
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(bw!=null)
                {
                    bw.close();
                }
                if(fw!=null)
                {
                    fw.close();
                }
            }catch (Exception  e)
            {
                e.printStackTrace();
            }
        }
    }
}

3.27实现文本文件的拷贝

//关闭顺序没有要求，（后开先关闭，只存在于处理流与节点流之间的比较）。

package javaio;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class 基于字符缓冲流实现文件拷贝 {
    public static void main(String[] args) {
        filecopychar("d:/a.txt.txt","d:/q.txt");

    }
    public  static  void filecopychar(String src,String des)
    {
        BufferedReader br=null;
        BufferedWriter bw =null;
        try {
          br=new  BufferedReader(new FileReader(src));
          bw=new BufferedWriter(new FileWriter(des));
          String temp="";
          while ((temp=br.readLine())!=null)//temp读入文件//因为readline返回是string类型，所以用null
            //返回的字符串是它在文件里所读取的一行。
          {
              //bw.write(src);//这句话代表写入什么东西。而src只是一个string字符。
              bw.write(temp);//代表读入字符。
              bw.newLine();//换行处理。
          }
          bw.flush();
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {//关闭顺序没有要求，后开先关闭，只存在于处理流与节点流之间的比较
            try {
                if(br!=null)
                {
                    br.close();

                }
                if(bw!=null)
                {
                    bw.close();
                }
            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }

    }
}

3.28为文件中的内容添加行号

package javaio;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
        public class 为文件中的内容添加行号 {
            public static void main(String[] args) {
                    BufferedReader br = null;
                    BufferedWriter bw = null;
                    try {
                        br = new BufferedReader(new FileReader("d:/a.txt.txt"));
                        bw = new BufferedWriter(new FileWriter("d:/abc.txt.txt"));
                        String temp = "";
                        int i=1;
                        while ((temp = br.readLine()) != null)//temp读入文件
                        {
                           // System.out.println();
                            //bw.write(src);//这句话代表写入什么东西。而src只是一个string字符。
                            bw.write(i+","+temp);//代表写入字符。
                            bw.newLine();//换行处理。
                            i++;
                        }
                        bw.flush();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            if (br != null) {
                                br.close();

                            }
                            if (bw != null) {
                                bw.close();
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }


            }
        }

4转换流

InputStreamReader/OutputStreamWriter 用来实现将字节流转化成字符流
system.in/system.out为字节流对象，如果我们想按行接收用户的输入时，就必须用到缓冲字符流 BufferedReader 特有的方法 readLine()，但是经过观察会发现在创建 BufferedReader 的构造方法的参数必须是一个 Reader 对象，这时候我们的转换流 InputStreamReader 就派上用场了。

4.11通过转换流实现键盘输入屏幕输出

加入了System.in/System.out
System.in会返回一个inputstream类型，虽然inputstream不可以实例化。
inputst ip=system.in

try {
InputStream is=System.in;//基于字节的方式来获取用户在键盘所输入的类容
int inputa=is.read();
System.out.println(inputa);
system.in会获取用户输入的字节文件，为了读出一行，要转化为字符型。
关于equals详见http://t.csdn.cn/4QjtZ

目的是为了一次读取一行

package javaio.转换流;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class 通过转换流实现键盘输入屏幕输出 {
    public static void main(String[] args) {
        BufferedWriter bw=null;
        BufferedReader br=null; //为了获取一行，定义字符输入缓冲流
        try {                                //system是标准输入流（int型）
            br=new BufferedReader(new InputStreamReader(System.in));//输入流读取器（转化为string类型）//InputStreamReader把字节流转换为字符
           bw=new BufferedWriter(new OutputStreamWriter(System.out));

//System.out.println(input);
            while (true) {
                bw.write("请输入：");
               // bw.flush();
                String input = br.readLine();
                if("exit".equals(input))//判断是否相等
                {
                    break;
                }
                bw.write("you input is"+input);
                bw.newLine();
                bw.flush();
            }
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(bw!=null)
                {
                    bw.close();

                }
                if(br!=null)
                {
                    br.close();
                }
            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

注意：

  BufferedReader br=null; //为了获取一行，定义字符输入缓冲流
                                 //system是标准输入流（int型）
         
           bw=new BufferedWriter(new OutputStreamWriter(System.out));
            String input=br.readLine();

            bw.write(input);
            bw.flush();

与` 功能一致

    String input=br.readLine();
System.out.println(input);

4.12通过字节流读取文件并添加行号

package javaio.转换流;

import java.io.*;

public class 通过字节流读取文件并添加行号 {
    public static void main(String[] args) {
        BufferedReader br=null;
        BufferedWriter bw=null;
        try {
           br =new BufferedReader(new InputStreamReader(new  FileInputStream("D:/a.txt.txt")));
            bw=new BufferedWriter(new OutputStreamWriter(new   FileOutputStream("D:/qq.txt")));
            String temp="";
            int i=1;
            while ((temp=br.readLine())!=null)
            {
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }
            bw.flush();
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(br!=null)
                {
                    br.close();
                }
                if(bw!=null)
                {
                    bw.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

4.2字符输出流 PrintWriter

该对象具有自动行刷新缓冲字符输出流，特点是可以按行写出字符串，并且可通过 println();方法实现自动换行

package javaio.转换流;
import java.io.*;
//
public class 字符输出流 {
    public static void main(String[] args) {
        BufferedReader br=null;
        PrintWriter pw=null;
        try {
            br=new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt.txt")));
            pw=new PrintWriter("D:/jjj.txt");//PipedWriter本身就是节点流，不用做节点流包装。
            String temp="";
            int i=1;
            while ((temp=br.readLine())!=null)
            {
                pw.println(i+","+temp);
                i++;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(br!=null) {
                br.close();
            }
                if(pw!=null)
                {
                    pw.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }


        }

    }
}

4.21字节数组输入流 ByteArrayInputStream 和 ByteArrayOutputStream

经常用在需要流和数组之间转化的情况。
不会有编译异常出现，所以不用try catch ，但要关闭所以用try ——finaly。

package javaio.转换流;
/、、、、、、、、、、、、、、、、、、、、、、
import java.io.ByteArrayInputStream;

//不会有编译异常出现，所以不用try catch ，但要关闭所以用try ——finaly
public class 字节数组输入流 {                            /其实是字节数组输入流
    public static void main(String[] args) {
        byte[] arr="abcdefg".getBytes();//完成字节数组。
        ByteArrayInputStream bis=null;
        StringBuilder sb=new StringBuilder();

        try {//改构造方法的参数是一个字节数组，这个字节数组就是数据源
            bis=new ByteArrayInputStream(arr);
            int temp=0;
            while ((temp=bis.read())!=-1)
            {
              sb.append((char) temp);

            }
            System.out.println( sb.toString());

        }finally {
            try {
                bis.close();

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }


    }
}

4.22字节数组输出流 ByteArrayInputStream

FileInputStream 是把文件当做数据源。ByteArrayInputStream 则是把内存中的” 字节数组对象”当做数据源


package javaio.转换流;
/、、、、、、、、、、、、、、、、、、、、、、

import java.io.ByteArrayOutputStream;

//不会有编译异常出现，所以不用try catch ，但要关闭所以用try ——finaly
public class 字节数组输出流正版 {                            /其实是字节数组输入流
    public static void main(String[] args) {

        ByteArrayOutputStream bos=null;



        try {//改构造方法的参数是一个字节数组，这个字节数组就是数据源
            StringBuilder sb=new  StringBuilder();
         bos=new  ByteArrayOutputStream();//输出不需要参数
         bos.write('f');//写入
         bos.write('q');
         bos.write('e');
         bos.write('t');
         bos.write('y');
         byte[] arr= bos.toByteArray();//基于字节形式放到了数组当中
            for(int i=0;i<arr.length;i++)
            {
                //System.out.println(arr[i]);
               sb.append((char)arr[i] );

            }
         System.out.println(sb.toString());


        }finally {
            try {
                if(bos!=null) {
                bos.close();
            }
            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }


    }
}

5数据流DataInputStream 和 DataOutputStream

数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式从底层输入输出流中操作 Java 基本数据类型与字符串类型。
成功避免了当输入输出时还要进行数据转换的问题。

5.1数据输出流DataInputStream

package javaio.数据流;

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;

public class dataoutput {

    private static DataOutputStream dos;
    private static DataOutputStream dos1;

    public static void main(String[] args) {
        dos = null;
        try {
            dos =new DataOutputStream(new BufferedOutputStream(new FileOutputStream("d:/qq.txt"))) ;
            dos.writeChar('a');
            dos.writeInt('a');
            dos.writeDouble('a');
            dos.writeBoolean(true);

            dos.writeUTF("我擦");
            dos.flush();
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(dos !=null)
                {
                    dos.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

5.2数据输入流 DataOutputStream

注意要按照写入顺序。

package javaio.数据流;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;

public class datainputstream {
    public static void main(String[] args) {
        DataInputStream dis=null;
        try {
           dis=new DataInputStream(new BufferedInputStream(new FileInputStream("d:/qq.txt")) );
           //直接读取数据，读取顺序与写入一致，
            System.out.println("char"+dis.readChar());
            System.out.println("整型"+dis.readInt());
            System.out.println("浮点"+dis.readDouble());
            System.out.println("bool"+dis.readBoolean());
            System.out.println("文字"+dis.readUTF());
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(dis!=null)
                {
                    dis.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

6对象流ObjectOutputStream ObjectInputStream

将对象存储到硬盘上的文件（序列化），将对象通过网络传输到另一个电脑（反序列化）。
只有实现了 Serializable 接口的类的对象才能被序列化。Serializable 接口是一个空接口，只起到标记作用。
序列化和反序列化是什么
二进制文件的编码与解码。

6.1操作基本数据类型

6.11写出基本数据类型数据

package javaio.数据流;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

import java.io.ObjectOutputStream;

public class 写出基本数据类型 {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try {

            oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/a.txt")));
            oos.writeChar('a');
            oos.writeInt('a');
            oos.writeDouble('a');
            oos.writeBoolean(true);
            oos.writeUTF("我擦");
            oos.flush();

        } catch (Exception e) {
            e.printStackTrace();
            try {

            } finally {
                try {
                    if (oos != null) {
                        oos.close();
                    }
                } catch (Exception g) {
                    g.printStackTrace();
                }
            }
        }
    }
}

6.12读基本数据类型

package javaio.对象流;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class 读基本数据类型对象 {
    public static void main(String[] args) {
        ObjectInputStream ois=null;
        try {
            ois=new ObjectInputStream(new BufferedInputStream(new FileInputStream("d:/a.txt")));
            System.out.println(ois.readChar());
            System.out.println(ois.readInt());
            System.out.println(ois.readDouble());
            System.out.println(ois.readBoolean());
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(ois!=null)
                {
                    ois.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

6.2将对象序列化到文化

ObjectOutputStream可以将一个内存中的ava对象通过序列化的方式写入到磁盘的文
件中。被序列化的对象必须要实现Serializable序列化接口，否则会抛出异常。

6.21创建对象Serializable

public class users1 implements Serializable {

package javaio.对象流;

import java.io.Serializable;
//创建对象                     此接口无任何抽象方法
public class users1 implements Serializable {
        private  int userid;
        private   String username;
        private String  userage;

    public users1(int userid, String username, String userage) {
        this.userid = userid;
        this.username = username;
        this.userage = userage;
    }

    public int getUserid() {
        return userid;
    }

    public String getUsername() {
        return username;
    }

    public String getUserage() {
        return userage;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setUserage(String userage) {
        this.userage = userage;
    }
}

6.22序列化对象ObjectOutputStream

package javaio.对象流;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class objectoutstreamobjectty {
    public static void main(String[] args) {
        ObjectOutputStream oos=null;
        try {            //一定需要一个字节输出流对象。。因为是二进制文件。
            oos=new ObjectOutputStream(new FileOutputStream("d:/qqq.txt"));
            users user=new users(1,"xiaomi","three");
            oos.writeObject(user);//ObjectOutputStream下面的writrobject，
            oos.flush();

        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(oos!=null)
                {
                    oos.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

6.23将对象反序列化到磁盘当中ObjectInputStream

package javaio.对象流;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class objectinpuctstream {
    public static void main(String[] args) {
        ObjectInputStream ois=null;
        try {
            ois=new ObjectInputStream((new FileInputStream("D:/qqq.txt")));
            users user = (users) ois.readObject();
            System.out.println(user.getUserid());
            System.out.println(user.getUsername());
            System.out.println(user.getUserage());
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(ois!=null)
                {

                    ois.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

6.3随机访问流

实现对一个文件的读写。
可以访问文件的任意位置，不像其他牛只能按照先后顺序读取。适用于客户端。
RandomAccessFile(String name, String mode) name 用来确定文件； mode 取 r(读)或 rw(可读写)，通过 mode 可以确定流对文件的访问权限。
seek(long a) 用来定位流对象读写文件的位置，a 确定读写位置距离文件开头的字节个数。

getFilePointer() 获得流的当前读写位置

package javaio;

import java.io.RandomAccessFile;

public class 随机访问流 {
    public static void main(String[] args) {
        RandomAccessFile raf=null;
        try {
            raf =new RandomAccessFile("d:/qqq.txt","rw");
            //写入文件当中
            int [] arr=new  int[]{1,23,44,56,5,4,67,8};
            for(int i=0;i<arr.length;i++)
            {
                raf.writeInt(arr[i]);
            }
            //访问
            raf.seek(8);//注意不是数组下标，而是字节如int为4个字节，只能是0 ，4,8，。。。。。
            //  System.out.println(raf.readInt());
            //交替打印
            for(int i=0;i<8;i+=2)
            {
                raf.seek(i*4);
                System.out.println(raf.readInt());  //输出指定位置
            }
            //替换以前某位置文件。
            System.out.println("***************");
            raf.seek(8);//定位
            raf.writeInt(876);//赋值
        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

6.5file在IO中的作用

当以文件作为数据源或目标时，除了可以使用字符串作为文件以及位置的指定以外，我们也可以使用 File 类指定.

package javaio.fail;

import java.io.*;

public class failinio {
    public static void main(String[] args) {
        BufferedReader br=null;
        BufferedWriter bw=null;
        try {
           // br=new BufferedReader(new FileReader("d:/qqq.txt"));//以前
            br=new BufferedReader(new FileReader(new File("d:/a.txt.txt")));//现在
            bw=new BufferedWriter(new FileWriter(new File("d:/qqq.txt")));
            String temp="";
            int i=1;
            while ((temp=br.readLine())!=null)
            {
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }

        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                if(br!=null)
                {
                    br.close();
                }
                if(bw!=null)
                {
                    bw.close();
                }

            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

7阿帕奇包的应用

7.1使用

package javaio.apacheio包;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.FileFilter;

public class fileutilsdemo {
    public static void main(String[] args) throws Exception{
        //文件输出
    // new InputStreamReader(new FileInputStream("d:/a.txt","utf-8"));
              //这玩意被弃用了？
//      String content=  FileUtils.readFileToString(new File("d:/qqq.txt","utf-8"));
//        System.out.println(content);
//文件拷贝
        FileUtils.copyDirectory(new File("D:/XXX"),new File("c:/www"),(new FileFilter() {
            @Override
            //在文件拷贝时过滤条件
            public boolean accept(File pathname) {
                if(pathname.isDirectory()||pathname.getName().endsWith("txt"))
                {
                    return true;
                }
                return false;
            }
        }) );

    }
}

7.2IOUtils使用

package javaio.apacheio包;

import org.apache.commons.io.IOUtils;

import java.io.FileInputStream;

public class ioutils {
    public static void main(String[] args) throws Exception{
        String contrnt=  IOUtils.toString(new FileInputStream("d:/q.txt"),"utf-8" );
        System.out.println(contrnt);
    }
}