从零开始的"E"世界(J2SE)

JavaNote11

IO流

1. File类

File类是IO包中唯一表示磁盘文件和磁盘目录的对象的路径.
该类包含了创建,删除文件,重命名文件,判断文件读写权限以及文件是否存在,查询等功能方法.
注意:只能设置和获取文件本身的信息,不能设置和获取文件的内容.

获取File路径和检测状态:
File getAbsoluteFile() :获取绝对路径
String getAbsolutePath():获取绝对路径
String getPath() :获取文件路径
String getName() :获取文件名称
File getParentFile():获取上级目录文件
String getParent() :获取上级目录路径

检测File状态的方法:
boolean canExecute() :判断是否是可执行文件
boolean canRead() :判断该文件是否可读
boolean canWrite():判断该文件是否可写
boolean isHidden():判断该文件是否是隐藏文件
long lastModified():判断该文件的最后修改时间
long length():获取该文件的长度大小(单位字节)

File类中方法-文件操作:
boolean isFile() :是否是文件
boolean createNewFile() :创建新的文件
static File createTempFile(String prefix, String suffix) :创建临时文件
boolean delete() :删除文件
void deleteOnExit() :在JVM停止时删除文件
boolean exists():判断文件是否存在
boolean renameTo(File dest) :重新修改名称

File类中方法-目录操作
boolean isDirectory() :判断是否是目录
boolean mkdir()  :创建当前目录
boolean mkdirs() :创建当前目录和上级目录
String[] list() :列出所有的文件名
File[] listFiles() :列出所有文件对象
static File[] listRoots() :列出系统盘符

列出指定目录中所有的文件,包括子文件夹中的所有文件(使用递归算法(recursion)).

    public static void main(String[] args) {
        File dir = new File("D:/Java/codes");
        listAllFile(dir);
    }

    //列出所有文件
    private static void listAllFile(File dir) {
        //第一级子文件
        File[] fs1 = dir.listFiles();
        for (File file : fs1) {
            //打印目录和文件
            System.out.println(file);
            //第二级(如果子文件是目录,则继续递归)
            if(file.isDirectory()){
                listAllFile(file);
            }
        }
    }

---

2. IO流的分类

• IO流的分类,站在不同的角度,分类方式是不一样的:
  
  • 1:根据流向划分: 输入流和输出流.
  • 2:根据数据的单位划分: 字节流和字符流.
  • 3:根据功能的划分:节点流和包装流.

四大基流:(字节输出流,字节输入流,字符输出流,字符输入流)
四大基流都是抽象类: 其他流都是继承于这四大基流的.
我们不能创建四大基流的对象,只能创建其子类对象.
无论是什么流,都有close方法,用来关闭资源.
如果操作文件,就得开通一个流对象关联我们得磁盘文件,如果不关闭资源,那么磁盘的文件一直被程序所引用着,不能删除,也不能更改.

---

3. 文件流

• FileInputStream: 文件的字节输入流
• FileOutputStream: 文件的字节输出流
• FileReader:文件的字符输入流
• FileWriter:文件的字符输出流

演示文件字节输入(输出)流

//输入流
public static void main(String[] args) throws Exception {
        //1:创建源
        File f = new File("file/stream.txt");
        //2:创建文件字节输出流对象,并接在源上
        InputStream in = new FileInputStream(f);
        //3:读入操作        
        byte[] buffer = new byte[5];
        //把文件中所有的数据都读取到程序中
        int len = -1;//表示当前读取的字节总数,如果为-1,表示读取到末尾了
        while((len = in.read(buffer)) != -1){
            System.out.println(new String(buffer, 0, len));
        }
        //4:关闭资源
        in.close();
    }

//输出流
public static void main(String[] args) throws Exception {
        //1:创建目标对象(表示把数据保存到哪一个文件)
        File target = new File("file/stream.txt");
        //2:创建文件字节输出流对象(水管)
        OutputStream out = new FileOutputStream(target, true);
        //3:具体的输出操作(往外写)        
        out.write("hello world".getBytes(), 6, 5);
        //4:关闭资源对象
        out.close();
    }

演示文件字符输入(输出)流

    public static void main(String[] args) throws Exception {
        //1:创建源
        File srcFile = new File("file/char.txt");
        //2:创建流对象
        Reader in = new FileReader(srcFile);
        //3:读取操作            
        char[] buffer = new char[5];//每次只能读取5字符
        int len = -1;//表示当前读取的字符数量
        while((len = in.read(buffer)) != -1){
            System.out.println(buffer);
        }   
        //4:关闭资源
        in.close();
    }

    public static void main(String[] args) throws Exception {
        //1:创建目标
        File target = new File("file/ch.txt");
        //2:创建输出流对象
        Writer out = new FileWriter(target);
        //3:写出操作        
        out.write("你好,师姐!");
        out.write("\n");//换行
        out.write("hello world");
        //flush(刷新)操作,输出流中都有flush方法 
        //out.flush();
        //4:关闭资源
        out.close();//调用close方法,系统在关闭资源前,会先调用flush方法.
    }

操作IO流的六字箴言:
读进来,写出去.
读进来: 进来强调了是输入, 读说明是read方法.
写出去: 出去强调了是输出,写说明是write方法.

---

4. 包装流和缓冲流

• BufferedInputStream: 字节缓冲输入流
• BufferedOutputStream: 字节缓冲输出流
• BufferedReader: 字符缓冲输入流
• BufferedWriter: 字符缓冲输出流

演示字节的缓冲输入(输出)流

public static void main(String[] args) throws Exception {
        //字节的缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("file/buffer.txt", true));
        bos.write("hello world".getBytes());
        bos.close();

        //字节的缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("file/buffer.txt"));
        byte[] buffer = new byte[1024];
        int len = -1;
        while((len = bis.read(buffer)) != -1){
            System.out.println(new String(buffer, 0 ,len));
        }
        bis.close();
    }

---

5. 转换流和内存流

转换流:把字节流转成字符流.

• InputStreamReader:把字节输入流转成字符输入流.
• OutputStreamWriter:把字节输出流转成字符输出流.

//使用转换流,完成文件的拷贝操作
public static void main(String[] args) throws Exception {
        File srcFile = new File("file/buffer.txt");
        File targetFile = new File("text/buffer_copy.txt");

        Reader in = new InputStreamReader(new FileInputStream(srcFile), "GBK");
        Writer out = new OutputStreamWriter(new FileOutputStream(targetFile),"GBK");


        char[] buffer = new char[10];
        int len = -1;
        while((len = in.read(buffer)) != -1){
            out.write(buffer, 0, len);
        }
        in.close();
        out.close();
    }

内存流(数组流):适配器模式:把数据先临时存在数组中,待会再从数组中获取出来.

• 字节内存流: ByteArrayInputStream/ByteArrayOutputStream
• 字符内存流: CharArrayReader/CharArrayWriter
• 字符串流:StringReader/StringWriter(把数据临时存储到字符串中)

演示字节数组流

public static void main(String[] args) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bos.write("ABCDE".getBytes());
        byte[] bs = bos.toByteArray();

        ByteArrayInputStream bis = new ByteArrayInputStream(bs);
        byte[] buffer = new byte[5];
        int len = -1;
        while ((len = bis.read(buffer)) != -1) {
            System.out.println(new String(buffer, 0, len));
        }

        bos.close();
        bis.close();
    }

---

6. 合并流

合并流/顺序流(SequenceInputStream):就是把多个输入流,合并成一个流对象

public static void main(String[] args) throws Exception {
        SequenceInputStream in = new SequenceInputStream(new FileInputStream("file/buffer.txt"),
                new FileInputStream("file/buffer2.txt"));

        byte[] buffer = new byte[1024];
        int len = -1;
        while ((len = in.read(buffer)) != -1) {
            System.out.println(new String(buffer, 0, len));
        }

        in.close();
    }

---

7. 打印流

• PrintStream: 字节打印流
• PrintWriter: 字符打印流

//字节打印流
public static void main(String[] args) throws Exception {
        PrintStream ps = new PrintStream(new File("file/out.txt"));
        ps.write("ABC".getBytes());
        ps.print(true);
        ps.print("will");
        ps.print(17);
        ps.close();
    }

//字符打印流
public static void main(String[] args) throws Exception {
        PrintWriter pw = new PrintWriter(new FileOutputStream(new File("file/out.txt")), true);
        pw.write("ABC");
        pw.print(true);
        pw.print("will");
        pw.print(17);
        pw.println();
        pw.close();
    }

---

8. 标准输入输出

• 标准的输入: 通过键盘录入数据给程序.
• 标准的输出: 在屏幕上显示程序数据.

标准流的重定向操作:
static void setIn(InputStream in) 重新分配“标准”输入流
static void setOut(PrintStream out) 重新分配“标准”输出流

public static void main(String[] args) throws Exception {
        //重定向标准输入流
        System.setIn(new FileInputStream("file/stream.txt"));

        //重定向标准输出流
        //System.setOut(new PrintStream("file/xx.txt"));
        System.out.println("begin...");
        int data = System.in.read();//接受键盘录入的一个字节
        System.out.println(data);

        System.out.println("end...");
    }

---

9. 扫描器类(Scanner)

    public static void main(String[] args) throws Exception {
        //扫描文件中的数据
        //Scanner sc = new Scanner(new File("file/temp.txt"),"GBK");

        //扫描键盘输入的数据
        //Scanner sc = new Scanner(System.in);

        //扫描字符串中的数据
        Scanner sc = new Scanner("师姐,哈哈");
        while(sc.hasNextLine()){
            String data = sc.nextLine();
            System.out.println("ECHO:"+ data);
        }
        sc.close();
    }

---

10. 数据流

数据流,提供了可以读/写任意数据类型的方法:
DataOutputStream: 提供了 writeXxx(xxx value)方法.
DataInputStream: 提供了 readXxx()方法.

public static void main(String[] args) throws Exception {
        File f = new File("file/data.txt");
        //write(f);
        read(f);
    }

    private static void read(File f) throws Exception {
        DataInputStream in = new DataInputStream(new FileInputStream(f));
        System.out.println(in.readByte());
        System.out.println(in.readChar());
        System.out.println(in.readUTF());

        in.close();
    }

    private static void write(File f) throws Exception {
        DataOutputStream out = new DataOutputStream(new FileOutputStream(f));
        out.writeByte(65);
        out.writeChar('花');
        out.writeUTF("师姐,你好");

        out.close();
    }

注意: writeXxx和readXxx必须要对应起来, writeByte写出的数据,此时只能使用readByte读取回来.

---

最后附上Java学习网址