Java学习笔记（IO_1）

17 IO

关于IO流，可参见: Java IO流学习总结

17.1 IO流

IO流用来处理设备之间的数据传输。Java对数据的操作是通过流的方式。

• 流按操作数据分为两种：字节流和字符流；
• 按流向分为：输入流，输出流。

字节流读取文字字节数据后，不直接操作而是先查指定的编码表，获取对应的文字。再对这个文字进行操作。简单说：字节流+编码表。

17.1.1 IO流常用基类

字节流的抽象基类：InputStream,OutputStream.

字符流的抽象基类：Reader,Writer.

P.S.
由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。

写

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

例1：

    import java.io.FileWriter;    import java.io.IOException;    public class FileWriterDemo {        public static void main(String[] args) throws IOException {            //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件            FileWriter fw = new FileWriter("F:\\javatest\\IOtest\\demo.txt");            fw.write("Gabriel1");            //刷新流对象中缓冲的数据，将数据刷至目的地中            fw.flush();            //关闭流资源，但是关闭之前会刷新一次内部缓冲的数据，将数据刷到目的地中，            //和flush区别：flush刷新后，流可以继续使用，close刷新后，会关闭流            fw.close();        }    }

例2：

    import java.io.FileWriter;    import java.io.IOException;    public class FileWriterDemo {        public static void main(String[] args) {            FileWriter fw = null;            try {                fw =new FileWriter("F:\\javatest\\IOtest\\demo.txt");                fw.write("abc");            } catch (IOException e) {                System.out.println("catch:"+e.toString());                e.printStackTrace();            }finally{                try {                    if(fw!=null)                        fw.close();                } catch (IOException e) {                    System.out.println("catch:"+e.toString());                }            }        }    }

将abc写入到demo.txt中。

例3：

public class FileWriterDemo {    public static void main(String[] args) {        try {            FileWriter fw = new FileWriter("F:\\javatest\\IOtest\\demo.txt",true);            fw.write("a");            fw.close();        } catch (IOException e) {            System.out.println("catch:"+e.toString());            e.printStackTrace();        }    }}

将a写入到demo.txt中，并接着文字往后写,为“abca”。

读

- 方式1：
第一种读取方式：使用read()方法读取文本文件数据。

例4:

import java.io.FileReader;import java.io.IOException;public class FileReaderDemo {    public static void main(String[] args) throws IOException {        FileReader fr = new FileReader("F:\\javatest\\IOtest\\demo.txt");        //调用读取流对象的read方法，一次读一个字符，每次调用自动往下读        while(true){            int ch = fr.read();            if(ch==-1)                break;            System.out.println("ch:"+(char)ch);        }        fr.close();    }}

运行结果：

- 方式2：
第二种读取方式：使用read(char[])方法读取文本文件数据。

例5：

public class FileReaderDemo {    public static void main(String[] args) throws IOException {        char[] buf = new char[2];        FileReader fr = new FileReader("F:\\javatest\\IOtest\\demo.txt");        int num = 0;        while((num=fr.read(buf))!=-1){            System.out.println("num:"+num+".."+new String(buf,0,num));        }        fr.close();    }}

运行结果：

拷贝

1. 在D盘创建一个文件，用于存储C盘文件中的数据；
2. 定义读取流和C盘文件关联；
3. 通过不断的读写完成数据存储；
4. 关闭资源。

方法一：
例6：

import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class CopeTest {    public static void main(String[] args) throws IOException {        copy_1();    }    public static void copy_1() throws IOException{        FileWriter fw = new FileWriter("D:\\RuntimeDemo_copy.txt");        FileReader fr = new FileReader("F:\\javatest\\Circle.java");        int ch = 0;        while((ch=fr.read())!=-1){            fw.write(ch);        }        fw.close();        fr.close();    }}

方法二:
例7：

import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class CopeTest {    public static void main(String[] args) throws IOException {        copy_1();    }    public static void copy_1() throws IOException{        FileWriter fw = null;        FileReader fr = null;        fw = new FileWriter("D:\\RuntimeDemo_copy.txt");        fr = new FileReader("F:\\javatest\\BasicGeneric.java");        char[] ch = new char[1024];        int len = 0;        while((len=fr.read(ch))!=-1){            fw.write(ch,0,len);        }        fw.close();        fr.close();    }}

缓冲区

缓冲区的出现提高了对数据的读写效率。

对应类：

• BufferedWriter
• BufferedReader

P.S.
缓冲区要结合流才可以使用。
作用：在流的基础上对流的功能进行了增强。

例8：

import java.io.*;public class BufferedReaderDemo {    public static void main(String[] args) throws IOException {        FileReader fr = new FileReader("F:\\javatest\\BasicGeneric.java");        BufferedReader bufr = new BufferedReader(fr);        String line = null;        while((line=bufr.readLine())!=null){            System.out.println(line);        }        bufr.close();    }}

例9：

import java.io.*;public class CopeMp {    public static void main(String[] args) throws IOException {        long start = System.currentTimeMillis();        copy_1();        long end = System.currentTimeMillis();        System.out.println((end-start)+"毫秒");    }    public static void copy_1() throws IOException{        BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("C:/Users/Administrator/Desktop/[解读中国经济].林毅夫.扫描版(ED2000.COM).pdf"));        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("D:\\Demo_copy.pdf"));        int by = 0;        while((by=bufis.read())!=-1){            bufos.write(by);        }        bufos.close();        bufis.close();    }}

例10：

import java.io.IOException;import java.io.InputStream;public class ReadInTest {    public static void main(String[] args) throws IOException {        InputStream in = System.in;        StringBuilder sb = new StringBuilder();        while(true){            int ch = in.read();            if(ch=='\r'){                continue;            }            if(ch=='\n'){                String s = sb.toString();                if("over".equals(s))                    break;                System.out.println(s.toUpperCase());                sb.delete(0, sb.length());            }            else                sb.append((char)ch);        }    }}

运行结果：将输入的字符串转成大写输出

File类

1. 创建

   • boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false；和输出流不一样，输出流对象一建立即创建文件，而且文件已经存在，会覆盖；
   • boolean mkdir():创建文件夹；
   • boolean mkdirs():创建多级文件夹。

2. 删除

   • boolean delete():删除失败返回false；
   • void deleteOnExit():在程序退出时删除指定文件。
3. 判断
   
   • boolean exists()：文件是否存在。
   • isFile();
   • isDirectory();
   • isHidden();
   • isAbsolute()
4. 获取
   
   • getName();
   • getPath();
   • getParent();
   • getAbsolutePath();
   • lastModified();
   • length();

例11：

        import java.io.File;        import java.io.IOException;         public class FileDemo {            public static void main(String[] args) throws IOException {                method();                method_1();                method_2();                method_3();            }            public static void method() throws IOException{                File f = new File("a.txt");                write("create:"+f.createNewFile());                //write("delete:"+f.delete());            }            public static void method_1(){                File f = new File("FileDemo.java");                f.mkdir();                write("execute:"+f.canExecute());            }            public static void method_2(){                File f = new File("file.java");                //f.mkdir();                //判断文件对象是否是文件或者目的时，                //必须要先判断该文件对象封装的内容是否存在。                write(f.exists());                write("execute:"+f.isDirectory());                write("execute:"+f.isFile());                write(f.isAbsolute());              }               public static void method_3(){                File f = new File("b.java");                write("path:"+f.getPath());                write("absolutepath"+f.getAbsolutePath());                write("parent："+f.getParent());//该方法绝对路径中的父目录，获得相对路径则返回null            }            public static void write(Object obj){                System.out.println(obj);            }        }

第二次运行结果：

例12：

import java.io.File;import java.io.FilenameFilter;public class FielDemo2 {    public static void main(String[] args) {        listRootsDemo();        listDemo();        File f = new File("E:/IELTS");        show(f,0);    }    public static void listDemo(){        File f = new File("d:\\software");        String[] names = f.list();        for(String name:names){            System.out.println(name);        }    }    public static void listRootsDemo(){        File[] files = File.listRoots();        for(File f:files){            System.out.println(f);        }    }    public static void show(File dir,int level){        System.out.println(getLevel(level)+dir.getName());        level++;        File[] files = dir.listFiles();        for(int x=0;x<files.length;x++){            if(files[x].isDirectory()){                show(files[x],level);//递归法                      }            if(files[x].isFile())            System.out.println(getLevel(level)+files[x]);                   }    }    public static String getLevel(int level){        StringBuilder sb = new StringBuilder();        sb.append("|--");        for(int i=0;i<level;i++){            sb.insert(0, "   ");        }        return sb.toString();    }}

运行结果：

例13（查询文件数量）：

import java.io.BufferedWriter;import java.io.File;import java.io.FileWriter;import java.io.IOException;import java.util.ArrayList;import java.util.List;public class CreatFileList {    public static void main(String[] args) throws IOException {        File dir =  new File("F:/javatest");        List<File> list = new ArrayList<File>();        fileToList(dir,list);        File file = new File(dir,"javalist.txt");        writeToFile(list,file.toString());    }    public static void fileToList(File dir,List<File> list){        File[] files = dir.listFiles();        for(File file:files){            if(file.isDirectory())            {                fileToList(file,list);            }            if(file.getName().endsWith(".java"))                list.add(file);         }    }    public static void writeToFile(List<File> list,String javaListFile) throws IOException{        BufferedWriter bufw = null;         try {            bufw =  new BufferedWriter(new FileWriter(javaListFile));            for(File f:list){                String path = f.getAbsolutePath();                bufw.write(path);                bufw.newLine();                bufw.flush();            }        } catch (IOException e) {            e.printStackTrace();        }finally{            if(bufw!=null){                bufw.close();            }        }    }}

运行结果：将F:/javatest目录下所有的.java文件的地址打印到F:/javatest/javalist.txt中。

Properties集合

Map

• |–Hashtable
• |–Properties

特点：

1. 该集合中的键和值都是字符串类型。
2. 集合中的数据可以保存到流中，或者从流中获取。
3. 通常该集合用于操作以键值对形式存在的配置文件。
   Properties集合的存和取。

例14：

    import java.io.*;    import java.util.Properties;    import java.util.Set;    public class PropertiesDemo {        public static void main(String[] args) throws IOException {            setAndGet();            method_1();        }        public static void method_1() throws IOException{            BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));            String line = null;            Properties prop = new Properties();            while((line=bufr.readLine())!=null){                if(line.startsWith("#"))                    continue;                String[] arr = line.split("=");                prop.setProperty(arr[0], arr[1]);            }            bufr.close();            System.out.println(prop);        }        public static void setAndGet() throws IOException{            Properties prop = new Properties();            prop.setProperty("Gabriel","20");            prop.setProperty("Mary","12");            prop.setProperty("Lucy","11");            prop.setProperty("Gabriel", "5");            FileOutputStream fos = new FileOutputStream("info.txt");            prop.store(fos, "name+age");            fos.close();            Set<String> names = prop.stringPropertyNames();            for(String name:names){                String value = prop.getProperty(name);                System.out.println(name+" "+value);            }        }    }

运行结果：

例15：

计数器：获取一个应用程序的运行次数，超过5次则提醒已使用超限。

import java.io.*;import java.util.Properties;public class RunCount {    public static void main(String[] args) throws IOException {        Properties prop = new Properties();        File file =  new File("count.ini");        if(!file.exists())            file.createNewFile();        FileInputStream fis = new FileInputStream(file);        prop.load(fis);        int count = 0;        String value = prop.getProperty("time");        if(value!=null){            count = Integer.parseInt(value);            if(count>=5){                System.out.println("使用次数超限");                return;            }        }            count++;        prop.setProperty("time", count+"");        FileOutputStream fos = new FileOutputStream(file);        prop.store(fos, "count");        fos.close();        fis.close();    }}

打印流

PrintWriter与PrintStream：可以直接操作输入流和文件。

• PrintStream为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
• 与其他输出流不同，PrintStream永远不会抛出IOException。
• PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。
• 在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。

PrintStream:

1. 提供了打印方法可以对多种数据类型值进行打印，并保持数据的表示形式
2. 它不抛IOException

构造函数，接收三种类型的值：

1. 字符串路径
2. File对象
3. 字节输出流

PrintWriter：字符打印流

构造函数参数：

1. 字符串路径
2. File对象
3. 字节输出流
4. 字符输出流

例16：

    import java.io.*;    public class PrintStreamDemo {        public static void main(String[] args) throws IOException {            BufferedReader bufr =                     new BufferedReader(new InputStreamReader(System.in));            PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);            String line = null;            while((line=bufr.readLine())!=null){                if("over".equals(line)){                    break;                }                out.println(line.toUpperCase());            }            out.close();            bufr.close();        }    }

序列流
SequenceInputStream：对多个流进行合并。

例17：

    import java.io.*;    import java.util.Enumeration;    import java.util.Vector;    public class SequenceDemo {        public static void main(String[] args) throws IOException {            Vector<FileInputStream> v = new Vector<FileInputStream>();            v.add(new FileInputStream("F:\\JavaProject\\TestIO\\1.txt"));            v.add(new FileInputStream("F:\\JavaProject\\TestIO\\2.txt"));            v.add(new FileInputStream("F:\\JavaProject\\TestIO\\3.txt"));            Enumeration<FileInputStream> en = v.elements();            SequenceInputStream sis = new SequenceInputStream(en);            FileOutputStream fos = new FileOutputStream("F:\\JavaProject\\TestIO\\4.txt");            byte[] buf = new byte[1024];            int len = 0;            while((len=sis.read(buf))!=-1){                fos.write(buf,0,len);            }            fos.close();            sis.close();        }    }

例18：合并与分割文件：

import java.io.*;import java.util.*;public class SplitFile {    public static void main(String[] args) throws IOException {        splitFile();        merge();    }    public static void merge() throws IOException{//合并文件        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();        //将碎片文件和流对象添加并存储在集合中        for(int x=1;x<=3;x++){            al.add(new FileInputStream("F:\\JavaProject\\TestIO\\"+x+".part"));             }        final Iterator<FileInputStream> it = al.iterator();        //多个流合并为序列流        Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){            public boolean hasMoreElements(){                return it.hasNext();            }            public FileInputStream nextElement() {                return it.next();            }        };//匿名类        SequenceInputStream sis = new SequenceInputStream(en);        FileOutputStream fos =  new FileOutputStream("F:\\JavaProject\\TestIO\\0.bmp");        byte[] buf = new byte[1024];        int len  = 0;        while((len=sis.read(buf))!=-1){            fos.write(buf, 0, len);        }        fos.close();        sis.close();    }    public static void splitFile() throws IOException{ //分割文件        FileInputStream fis = new FileInputStream("F:\\JavaProject\\TestIO\\1.jpg");        FileOutputStream fos = null;        byte[] buf = new byte[1024*20];        int len = 0;        int count = 1;        while((len=fis.read(buf))!=-1){            fos = new FileOutputStream("F:\\JavaProject\\TestIO\\"+(count++)+".part");            fos.write(buf, 0, len);            fos.close();        }        fis.close();    }}

管道流

PipedInputStream和PipedOutputStream：输入输出可以直接进行连接，通过结合线程使用。

例19：

import java.io.*;public class PipedStreamDemo {    public static void main(String[] args) throws IOException {        PipedInputStream in = new PipedInputStream();        PipedOutputStream out = new PipedOutputStream();        in.connect(out);        Read r = new Read(in);        Write w = new Write(out);        new Thread(r).start();        new Thread(w).start();    }}class Read implements Runnable{    private PipedInputStream in;    Read(PipedInputStream in){        this.in = in;    }    public void run() {         try {            byte[] buf = new byte[1024];            int len = in.read(buf);            String s = new String(buf,0,len);            System.out.println(s);            in.close();        } catch (IOException e) {            throw new RuntimeException("管道读取失败");        }    }}class Write implements Runnable{    private PipedOutputStream out;    Write(PipedOutputStream out){        this.out=out;    }    public void run() {             try {            Thread.sleep(2000);            out.write("piped".getBytes());            out.close();        } catch (Exception e) {            throw new RuntimeException("管道输出流失败");        }    }}

运行结果：piped