【第22期】观点:IT 行业加班,到底有没有价值?

Java基础——IO(1)

原创 2015年11月19日 16:42:36

IO流

概述

Java中采用IO流的方式来进行数据传输,IO流分为两种:

    1)字节流的抽象基流:InputStream和OutputStream

    2)字符流的抽象基流:Reader和Writer

P.S.

此四个类派生出来的子类名称都是以父类名作为子类名的后缀,以前缀为其功能;如InputStream子类FileInputStream;Reader子类FileReader

 记住:如果要操作文字数据,建议优先考虑字符流。
    而且要将数据从内存写到硬盘上,要使用字符流中的输出流:Writer。
    硬盘的数据基本体现是文件,希望找到一个可以操作文件的Writer:FileWriter

字符流

字符流输入:

用例:


public class Test1 {
    public static void main(String[] args) throws IOException {
        File file = new File("d://IO");
        if(!file.exists()){
            //不存在则创建路径
            file.mkdirs();
        }
        FileWriter fw = new FileWriter(file+"/123.txt");
        fw.write("你好,字符流输入!");
        //刷新缓存到指定文件
        fw.flush();
        fw.close();
    }
}

若更改为:FileWriter fw = new FileWriter(file+”/123.txt”,true);

表示: 如果为 true,则将字节写入文件末尾处,而不是写入文件开始处 。

加ture常用来进行文件续写。

字符流输出

1.单个字符读取


public class Test2 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("d://IO/123.txt");
        int c = 0;
        while((c= fr.read())!=-1){
            //这里read的返回值是char值的int型,可以转型为char类型
            System.out.print((char)c);
        }
    }
}

2.字符数组读取


public class Test3 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("d://IO/123.txt");
        char []c = new char[1024];
        //返回值是读取的长度
        int len = fr.read(c);
            System.out.println(new String(c, 0, len));
    }
}

练习:

需求: 
将d盘一个文本文件复制到f盘、 
复制的原理: 
其实就是将c盘下的文件数据存储到e盘的一个文件中。 
步骤: 
1、在e盘创建一个文件。用于存储c盘文件中的数据。 
2、定义读取流和c盘文件关联。 
3、通过不断的读写完成数据存储。 
4、关闭资源。
/**
单字符传输
*/

public class Test4 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("D:\\IO\\123.txt");
        FileWriter fw = new FileWriter("f:\\copy123.txt");
        //单个字符传送
        int c ;
        while((c=fr.read())!=-1){
            /**public void write(int c)
             * c - 指定要写入字符的 int。
             */
            fw.write(c);
        }
        fr.close();
        fw.close();
    }
}

public class Test5 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("D:\\IO\\123.txt");
        FileWriter fw = new FileWriter("f:\\copy123.txt");
        // 字符数组传送
        char[] c = new char[1024];
        String buf = null;
        int len = 0;
        while ((len = fr.read(c)) != -1) {
            buf = new String(c, 0, len);
            fw.write(buf);
        }
        fw.close();
        fr.close();
    }
}

字符流的缓冲区——BufferedReader和BufferedWriter

使用注意:

1.使用缓冲区技术是为了解决性能问题,提高效率

2.需要先建立流对象,再将流对象交给缓冲区构造函数去处理

3. 记住,只要用到缓冲区,就要记得刷新。(关闭流同样会刷新,但为了排除意外事故,保证数据存在,建议写入一次就刷新一次)

     如:bufw.flush();

4.小知识:BufferedWriter缓冲区中提供了一个跨平台的换行符:newLine();可以在不同操作系统上调用,用作数据换行。

    如:bufw.newLine();

5.读取流缓冲区BufferedReader

     BufferedReader.readLine():另外开辟了一个缓冲区,存储的是原缓冲区一行的数据,不包含换行符。所以实际使用中常使用BufferedReader.newLine();方法换行

练习:使用字符缓冲区复制文本


public class Test6 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("D:\\IO\\Hello.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("f:\\CopyHello.java"));
        String buf = null;
        while((buf = br.readLine())!=null){
            bw.write(buf);
            //添加换行,否则输出文本没有格式
            bw.newLine();
            // //使用缓冲区的刷新方法将数据刷目的地中 
        }
        bw.close();
        br.close();
    }
}

练习:模仿一个BufferedReader的readLine方法


/*
需求:根据readLine方法原理,模拟BufferedReader写一个自己的MyBufferedReader
*/
import java.io.*;
//自定义缓冲类
class MyBufferedReader extends Reader
{
    private Reader r;//定义接收的流对象
    MyBufferedReader(Reader r)
    {
        this.r=r;
    }
    //自定义整行读取
    public String myReadLine()throws IOException
    {
        //创建一个容器,用来存储一行的字符
        StringBuilder sb =new StringBuilder();
        //一个字符一个字符读取
        for (int ch=0;(ch=r.read())!=-1 ; )
        {
                                            if(ch=='\r')//如果遇到回车符换行符,则继续
                continue;
            if(ch=='\n')//如果遇到换行符,表示该行读取完毕
                return sb.toString();
            else
                sb.append((char)ch);//将该行的字符添加到容器
        }
        if(sb.length()!=0)//如果读取结束,容器中还有字符,则返回元素
            return sb.toString();
        return null;
    }

    //复写父类中的抽象方法
    public int read(char[] cbuf, int off, int len) throws IOException
    {
        return r.read(cbuf,off,len);
    }

    //复写父类的close方法
    public void close()throws IOException
    {
        r.close();
    }
}
//测试MyBufferedReader
public class  Test7
{
    public static void main(String[] args) 
    {
        MyBufferedReader mbr=null;
        try
        {
            mbr=new MyBufferedReader(new FileReader("D:\\IO\\Hello.java"));
            for (String line=null;(line=mbr.myReadLine())!=null ; )
            {
                System.out.println(line);//显示效果
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("读取数据失败");
        }
        finally
        {
            try
            {
                if(mbr!=null)
                    mbr.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取流关闭失败");
            }
        }   
    }
}

LineNumberReader

此类定义了方法 setLineNumber(int) 和 getLineNumber(),它们可分别用于设置和获取当前行号。 

换行符('\n')、回车符('\r')

/*
需求:利用LineNumberReader的特有方法去设置和获取文件中数据的行号
*/
public class Test8 {
    public static void main(String[] args) {
        LineNumberReader lnr = null;
        try {
            // 将读取流对象传入
            lnr = new LineNumberReader(new FileReader("D:\\IO\\Hello.java"));
            lnr.setLineNumber(10);// 设置开始行号

            for (String line = null; (line = lnr.readLine()) != null;) {
                System.out.println(lnr.getLineNumber() + ":" + line);// 打印每行行号和字符
            }
        } catch (IOException e) {
            throw new RuntimeException("读取数据失败");
        } finally {
            try {
                if (lnr != null)
                    lnr.close();
            } catch (IOException e) {
                throw new RuntimeException("读取流关闭失败");
            }
        }
    }
}

装饰设计模式

通过多态进行一个功能的增强,不要仅仅使用继承,而应多使用多态。

字节流

1.基本操作与字符流类相同。但它不仅可以操作字符,还可以操作其他媒体文件。

2.由于媒体文件数据中都是以字节存储的,所以,字节流对象可直接对媒体文件的数据写入到文件中,而可以不用再进行刷流动作。

3.读写字节流:InputStream   输入流(读)

             OutputStream  输出流(写)

练习:复制图片等媒体资源


public class Test1 {
    public static void main(String[] args) throws IOException {
        InputStream in = new FileInputStream("d:\\IO\\ME.JPG");
        OutputStream out = new FileOutputStream("f:\\CopyME.JPG");

        /**
         * 另种写法:不推荐 
         * byte []b= new byte[in.available()];
         * 若in.available()值过大,会导致内存溢出
         *  p.s.
         *  in.available():返回文件中的字节个数
         */

        // 推荐写法,自定义字符缓冲区

        byte[] b = new byte[1024];
        int len = 0;
        while ((len = in.read(b)) != -1) {
            out.write(b, 0, len);
        }
        out.close();
        in.close();
    }
}

字节流缓冲区

练习:自定义字节流读取缓冲区


/* 
自定义字节流读取缓冲区 
思路: 
1、定义一个固定长度的数组 
2、定义一个指针和计数器用于读取数组长度,和计数数组元素是否取完为0 
3、每次将字节数据存入元素要先将数组中的元素取完 
*/  

/*
自定义字节流读取缓冲区
思路:
1、定义一个固定长度的数组
2、定义一个指针和计数器用于读取数组长度,和计数数组元素是否取完为0
3、每次将字节数据存入元素要先将数组中的元素取完

*/
import java.io.*;
class MyBufferedInputStream
{
       private InputStream in;
       private byte[] by=new byte[1024];
       private int count=0,pos=0;
       MyBufferedInputStream(InputStream in)
       {
              this.in=in;
       }


       //自定义读方法,一次读一个字节
       public int myRead()throws IOException
       {
              //通过in对象读取硬盘上数据,并存储by中。
              //存储在数组中的数据被读取完,再通过in对象从硬盘上读取数据
              if(count==0)
              {
                     count=in.read(by);
                     if(count<0)//文件数据全部被读取出来了
                            return -1;


                     pos=0;//初始化指针
                     byte b=by[pos];

                     count--;//每被读一个字节,表示数组中的字节数少一个
                     pos++;//指针加1
                     return b&255;//返回的byte类型提升为int类型,字节数增加,且高24位被补1,原字节数据改变。
                                          //通过与上255,主动将byte类型提升为int类型,将高24位补0,原字节数据不变。
                                          //而在输出字节流写入数据时,只写该int类型数据的最低8位。
              }
              else if(count>0)//如果数组中的数据没被读取完,则继续读取
              {
                     byte b=by[pos];

                     count--;
                     pos++;
                     return b&0xff;
              }
              return -1;
       }

       //自定义关闭资源方法
       public void close()throws IOException
       {
              in.close();
       }
}


//测试自定义输入字节流缓冲区
public class Test2
{
       public static void main(String[] args) 
       {
              long start=System.currentTimeMillis();
              //利用字节流的缓冲区进行复制
              copy_2();
              long end=System.currentTimeMillis();
              System.out.println("复制共用时:"+(end-start)+"毫秒");
       }
       //使用字节流的缓冲区进行复制
       public static void copy_2()
       {
              BufferedOutputStream bout=null;
              MyBufferedInputStream bin=null;
              try
              {
                     //关联复制文件输入流对象到缓冲区
                     bin=new MyBufferedInputStream(new FileInputStream("d:\\IO\\ME.JPG"));
                     //指定文件粘贴位置的输出流对象到缓冲区
                     bout=new BufferedOutputStream(new FileOutputStream("f:\\CopyME.JPG"));
                     int by=0;


                     while((by=bin.myRead())!=-1)
                     {
                            bout.write(by);//将缓冲区中的数据写入指定文件中
                     }
              }
              catch(IOException e)
              {
                     throw new RuntimeException("MP3复制失败");
              }
              finally
              {
                     try
                     {
                            if(bin!=null)
                                   bin.close();//关闭输入字节流
                     }
                     catch(IOException e)
                     {
                            throw new RuntimeException("读取字节流关闭失败");
                     }
                     try
                     {
                            if(bout!=null)
                                   bout.close();//关闭输出字节流
                     }
                     catch(IOException e)
                     {
                            throw new RuntimeException("写入字节流关闭失败");
                     }
              }
       }
}

流操作

键盘录入

一、键盘录入

1.标准输入输出流

    System.in:对应的标准输入设备,键盘。

    Ssytem.out:对应的是标准的输出设备,控制台。

    System.in的类型是InputStream.

    System.out的类型是PrintStream是OutputStream的子类FilterOutputStream的子类。

2.改进

由于键盘录入是字节流,效率较低。可不可以使用整行读取,那么需要借助readLine方法,但是这个是字符流的方法。所以,需要将字节流转换成字符流。

 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

练习:


/**
 * 需求:将键盘录入的数据转换成大写输出,显示在控制台,当输入over时,表示结束 
源:键盘录入。 
目的:控制台。 
 */
public class Test1 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        String s = null;
        while((s = br.readLine())!=null){
            if(s.equals("over"))
                break;
            bw.write(s.toUpperCase());
            bw.flush();

        }
    }
}

练习:


/**
 * 需求:想把键盘录入的数据存储到一个文件中。 
 * 源:键盘 
 * 目的:文件 
 * 把录入的数据按照指定的编码表(UTF-8),将数据存到文件中。  
 * 需求:想要将一个文件的数据打印在控制台上。 
 * 源:文件 
 * 目的:控制台 
 */
public class Test2 {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new FileWriter("f:\\MyTest.txt"));
        String s = null;
        while((s = br.readLine())!=null){
            if(s.equals("over"))
                break;
            bw.write(s);
            bw.flush();
            bw.newLine();
        }
        bw.close();
        br.close();
    }
}

流的操作规律

1、

    源:键盘录入。 

    目的:控制台。

2、需求:想把键盘录入的数据存储到一个文件中。

    源:键盘

    目的:文件。

    使用字节流通向字符流的转换流(桥梁):InputStreamReader

3、需求:想要将一个文件的数据打印在控制台上。

    源:文件

    目的:控制台

    使用字符流通向字节流的转换流(桥梁):OutputStreamWriter

4、流操作的基本规律:

    最痛苦的就是流对象有很多,不知道该用哪一个。

通过三个明确来完成:

4.1 明确源和目的。

    源:输入流。InputStream  Reader

    目的:输出流。OutputStream  Writer

4.2 操作的数据是否是纯文本。

    是:字符流

    否:字节流

4.3 当体系明确后,再明确要使用哪个具体的对象。通过设备来进行区分:

    源设备:内存,硬盘,键盘

    目的设备:内存,硬盘,控制台

5、规律体现

5.1 将一个文本文件中数据存储到另一个文件中。复制文件。

    1)源:因为是源,所以使用读取流:InputStream和Reader

         明确体系:是否操作文本:是,Reader

          明确设备:明确要使用该体系中的哪个对象:硬盘上的一个文件。Reader体系中可以操作文件的对象是FileReader

          是否需要提高效率:是,加入Reader体系中缓冲区 BufferedReader.

           FileReader fr = new FileReader("a.txt");

          BufferedReader bufr = new BufferedReader(fr);

    2)目的:输出流:OutputStream和Writer

         明确体系:是否操作文本:是,Writer

          明确设备:明确要使用该体系中的哪个对象:硬盘上的一个文件。Writer体系中可以操作文件的对象FileWriter。

          是否需要提高效率:是,加入Writer体系中缓冲区 BufferedWriter

           FileWriter fw = new FileWriter("b.txt");

          BufferedWriter bufw = new BufferedWriter(fw);

练习:将一个图片文件中数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。

    1)源:输入流,InputStream和Reader

        是否是文本?否,InputStream

        源设备:硬盘上的一个文件。InputSteam体系中可以操作文件的对象是FileInputSteam

        是否需要提供效率:是,BufferedInputStream

           BufferedInputSteambis=newBufferedInputStream(newFileInputStream("c:/users/asus/desktop/1.jpg"));

    2)目的:输出流,OutputStream和Writer

         是否是文本?否,OutputStream

         源设备:硬盘上的文件,FileOutputStream

         是否需要提高效率:是,加入BufferedOutputStream

           BufferedOutputStreambos=newBufferedOutputStream(newFileOutputStream("c:/users/asus/desktop/2.jpg"));

5.2 需求:将键盘录入的数据保存到一个文件中。

    1)源:InputStream和Reader

          是不是纯文本?是,Reader

           设备:键盘。对应的对象是System.in。——为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。所以既然明确了Reader,那么就将System.in转换成Reader。用Reader体系中转换流,InputStreamReader

          InputStreamReaderisr = new InputStreamReader(System.in);

         需要提高效率吗?需要,BufferedReader

         BufferedReaderbufr = new BufferedReader(isr);

   2)目的:OutputStream  Writer

         是否是存文本?是!Writer。

         设备:硬盘。一个文件。使用 FileWriter。

         FileWriter fw = newFileWriter("c.txt");

       需要提高效率吗?需要。

        BufferedWriter bufw = new BufferedWriter(fw);

5.3 扩展:想要把录入的数据按照指定的编码表(UTF-8)(默认编码表是GBK),将数据存到文件中。

    目的:OutputStream  Writer

    是否是存文本?是!Writer。

    设备:硬盘上的一个文件。使用 FileWriter。——但是FileWriter是使用的默认编码表:GBK。而存储时,需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。所以要使用的对象是OutputStreamWriter。

    该转换流对象要接收一个字节输出流,而且还可以操作的文件的字节输出流:FileOutputStream

    OutputStreamWriter osw =new OutputStreamWriter(newFileOutputStream("d.txt"),"UTF-8");

    需要高效吗?需要,BufferedWriter

    BufferedWriter bufw = new BufferedWriter(osw);

记住:

   转换流什么使用?

   字符和字节之间的桥梁。通常,涉及到字符编码转换时,需要用到转换流。

练习:将一个文本数据打印在控制台上。要按照以上格式自己完成三个明确。

    1)源:InputStreamReader

        是文本?是:Reader

        设备:硬盘。上的文件:FileReader

        是否需要提高效率?是:BufferedReader

         BufferedReader br=new BufferedReader(newFileReader("1.txt"));

    2)目的:OutputStream Writer

        是文本?是:Writer

        设备:控制台。对应对象System.out。由于System.out对应的是字节流,所以利用OutputSteamWriter转换流

        是否提高效率?是:BufferedWriter

          BufferedWriter bw =new BufferedWriter(newOutputStreamWriter(system.out));

练习:带编码的流操作


/**
 * 带编码集的操作
 * @author LQX
 *
 */
public class Test3 {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
        //指定UTF-8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("f://MyTest.java"), "UTF-8");
        String s = null;
        while((s = br.readLine())!=null){
            if(s.equals("over"))
                break;
            osw.write(s+"\r\n");
            osw.flush();            
        }
    }
}

public class Test4 {

    public static void main(String[] args) throws IOException {
        /*BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("f:\\MyTest.java")));
        String s = null;
        while((s = br.readLine())!=null){
            System.out.println(s);
        }*/
        //该文件在创建时我指定了编码为UTF-8,所以多出来是乱码
        FileReader fr = new FileReader("f:\\MyTest.java");
        char []c = new char[1024];
/*      int len = 0;
        while((len = fr.read(c))!=-1){
            System.out.println(new String(c, 0, len));
        }*/
        //修改后,设定了编码为UTF-8,能正确读出来
        InputStreamReader isr = new InputStreamReader(new FileInputStream("f:\\MyTest.java"), "UTF-8");
        int len = 0;
        while((len = isr.read(c))!=-1){
            System.out.println(new String(c, 0, len));
        }
    }
}

什么时候使用流转换?

1.目标设备是字节流,但操作是字符流,使用转换流作为桥梁,提高效率。

2.涉及文本字符编码表时,必须使用转换流,因为只有它才提供自定义编码。
版权声明: 举报

相关文章推荐

java 基础之IO框架

java IO框架

java之IO基础解析

1.什么是IO技术: 解释:IO技术其实就是用来解决设备与设备之间的数据传输问题。例如从内存到硬盘、从硬盘到内存等 2.IO知识点宏观了解: -2.1字节流: ---2.1.1什么是字节流: ...

Java基础之IO框架

流的分类Java的常用输入,输出流:java.io包中的stream类根据它们操作对象的类型是字符还是字节可分为两大类:字符流和字节流 Java的字节流: InputStream是所有字节输入流的祖...

Java基础学习之对IO流的理解

1 什么是IO   Java中I/O操作主要是指使用Java进行输入,输出操作。Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供...

Java中IO总结

java.io(Input/Output) Java的核心库java.io提供了全面的IO接口。包括:文件读写、标准设备输出等。Java中IO是以流为基础进行输入输出的,所有数据被串行化写入输出流...

Java基础之IO输入输出流

一、总概:     Java的IO痛java.io包下的类和接口来支持,在java.io包下主要包括输入、输出两种流,每种输入、输出流又可分为字节流和字符流两大类。其中字节流以字节为单位来处理输入。...

关于java基础--IO流

1,BufferedInputStream字符输入缓冲流  * BufferedInputStream:字符输入缓冲流,成为处理流(高级流)  * 它是字节流包装,所以不能直接的去操作数据源,只能...

java基础-IO流回顾

IO流回顾 java.io.File类的使用 IO原理及流的分类 文件流 FileOutputstream/FileInputStream/FileReader/FileWriter 缓冲流 Buff...

【物联网中间件平台-02】YFIOs技术白皮书(V1.1)

文档名称 YFIOs技术白皮书 版本 V1.1.0 说明 增加 技术特色和优势 章节 作者 叶帆 日期 2012-12-27 ...

linux内核之阻塞 IO(1)

大家都知道IO分为阻塞和非阻塞,
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)