I/O流及其文档的操作过程

文档实际操作：

文档实际操作实际上便是一个FIle类；大家学习培训文档实际操作便是学习培训File类中的方式 ；

文档基操：

第一部分：学习培训文档的操作过程(先扒源代码及其文本文档)

再来一个案例：

import java.io.File;
import java.io.IOException;

public class FIleDelCre {
    public static void main(String[] args) throws IOException {
        File file = new File("e:\\IOFileSource\\xbhog.txt");
        if(file.exists()){
            file.delete();
        }else{
            System.out.println(file.createNewFile());
        }
    }
}

createNewFile：假如特定的文档不会有且已取得成功建立，则为True;假如特定的文档早已存有，则为False

知识要点(敲黑板划重点)：

途径分节符：处理不一样电脑操作系统下的途径标记难题（Windows->“\”;Linux->“/”）;

File file = new File("e:" File.separator  "IOFileSource" File.separator "xbhog.txt");

注：

/**
     * The system-dependent default name-separator character, represented as a
     * string for convenience.  This string contains a single character, namely
     * {@link #separatorChar}.
*/
public static final String separator = ""   separatorChar;

对父途径实际操作的方式 ：

import java.io.File;
import java.io.IOException;

public class FIleDelCre {
    public static void main(String[] args) throws IOException {
        File file = new File("e:" File.separator  "IOFileSource" File.separator "test" File.separator "demo" File.separator "xbhog.txt");
        if(!file.getParentFile().exists()){ //假如该文件的父文件目录不会有
            /*
            file.getParentFile().mkdirs();   //开展建立多级别父文件目录
            mkdirs最底层开展递归调用，完成多级别文件目录建立

            file.getParentFile().mkdir();   //开展建立一个父文件目录
            */
        }
        if(file.exists()){
            file.delete();
        }else{
            System.out.println(file.createNewFile());
        }
    }
}

注：mkdirs与mkdir的差别，最好是进到源代码中查询

文档目录表明：

流程表：

import java.io.File;
public class FilePwd {
    public static void main(String[] args) {
        File file = new File("D:"   File.separator);
		listDir(file);
    }
    public static void listDir(File file){
        if(file.isDirectory()){
            File[] Dirs = file.listFiles();
            while(Dirs != null){
                for (int i = 0; i < Dirs.length; i  ) {
                    listDir(Dirs[i]);  //递归调用
                }
            }
        }
        System.out.println(file);
    }
}

大量文件改名：

场景：

在数据收集的全过程中因为错误操作，促使xbhog-log文件夹下的全部文件后缀选用了.java,为了更好地调整这一不正确，规定促使该文件目录下的全部文件后缀统一换成.txt,另外也必须考虑到多级别文件目录下的文件更名实际操作。

import java.io.File;
public class FIleChangeName {
    public static void main(String[] args) {
        File file = new File("D:"   File.separator   "xbhog-log");
        renameDir(file);

    }
    public static void renameDir(File file){
        if(file.isDirectory()){
            File[] dirs = file.listFiles(); 
            for (int i = 0; i < dirs.length; i  ) {
                renameDir(dirs[i]);  //递归调用
            }
        }else {
            if (file.isFile()){ //分辨是不是为文档
                String fileName = null;  //文件目录
                if(file.getName().endsWith(".java")){  //分辨是不是以.java为末尾
                    fileName = file.getName().substring(0,file.getName().lastIndexOf(".")) ".txt";
                    File newfile = new File(file.getParentFile(), fileName);  //新的文件目录
                    file.renameTo(newfile);  //重新命名
                }
            }
        }
    }
}

字节流与标识符流：

字节流：outputStream及其inputStream

标识符流：Writer及其Reader

对資源实际操作的基本上流程：(文档为例子)--严苛依照下边流程

1. 假如要实际操作的資源是文档得话，最先必须根据File类目标寻找一个要实际操作的文件路径
2. 根据字节流或是标识符流的派生类为字节流或标识符流的目标创建对象(往上转型发展)
3. 实行存取数据
4. 关掉資源

OutputStream字节数键入流

常见的类一般方式 ：

对文档的实际操作必须其OutputStream下的派生类FileOutputStream来完成目标的创建对象；

其常见的构造函数是：

案例：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;

public class FIleOutputStearm {
    public static void main(String[] args) throws IOException {
        File file = new File("xbhog.txt");
        if(!file.exists()){     file.createNewFile();
        }
        OutputStream outputStearm = new FileOutputStream(file);
        String str = "欢迎光临xbhog的blog";
        outputStearm.write(str.getBytes(StandardCharsets.UTF_8));
        outputStearm.close();
    }
}

文档內容的增加：

    OutputStream stream = new FileOutputStream(file, true);
    String addStr = "-----它是增加的內容------";
    stream.write(addStr.getBytes());
    stream.close();

InputStream字节数键入流：

此类的常见方式 ：

对文档的实际操作必须其InputStream下的派生类FileInputStream来完成目标的创建对象；

读取文件的固定不动使用方法：

1. 创建文件键入流---InputStream input = new FileInputStream(file)
2. 设定数据信息的载入缓存文件区----new byte[1024]
3. 获取数据，将数据信息载入到缓存文件区中并放入载入的字节数数量 ----int len = input.read(data)
4. 字节转换为标识符流----new String(data,0,len)
5. 关掉資源

读取文件內容案例：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class FileInputStreamTest {
    public static void main(String[] args) throws IOException {
        File file = new File("xbhog.txt"); // 輸出文件路径
        if (file.exists()) {    // 文档存有
            InputStream input = new FileInputStream(file);// 文档键入流
            byte data[] = new byte[1024]; // 数据信息载入缓冲区域
            // 获取数据，将数据信息载入到缓冲区域当中，另外回到载入的字节数数量
            int len = input.read(data);
            System.out.println("【"   new String(data, 0, len)   "】");// 字节数变为字符串数组
            input.close();    // 关掉键入流

        }
    }
}

读取文件中的所有内容：

byte[] bytes = input.readAllBytes();
System.out.println(new String(bytes));

Writer标识符流：

为了更好地简单化輸出的实际操作，给予了Writer与Reader标识符流;

此类的常见方式 ：

在开展文件流的载入时，必须引进Writer下的FileWriter派生类；

类的新项目构造：

• java.lang.Object
• • java.io.Writer
  • • java.io.OutputStreamWriter
    • • java.io.FileWriter

FileWriter常见构造函数：

案例：

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter.txt"); // 輸出文件路径
        if(!file.exists()){
            file.createNewFile();
        }
        Writer out = new FileWriter(file) ; // 创建对象Writer类目标
        out.write("欢迎光临xbhog");	// 輸出字符串数组
        out.write("\n");
        out.append("Test\n");
        out.append("www.cblog.cn/xbhog") ;// 增加輸出內容
        out.close();// 关掉輸出流
    }
}

Reader标识符键入流：

此类常见的方式 ：

案例检测：

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter.txt");// 輸出文件路径
        if (file.exists()) {// 文档存有
            Reader in = new FileReader(file);  // 创建对象键入流
            char data[] = new char[1024];  // 缓冲区域
            //“热烈欢迎没了”
            in.skip(2);// 越过两个字符长度
            int len = in.read(data); // 获取数据
            System.out.println(new String(data, 0, len));
            in.close();// 关掉键入流
        }
    }
}

变换流：

完成二者的变换实际操作：

将字节数键入运转换为标识符键入流

import java.io.*;
public class ConversionOperations {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter1.txt"); 	// 輸出文件路径
        OutputStream output = new FileOutputStream(file) ;// 字节流
        Writer out = new OutputStreamWriter(output) ; 	// 字节数运转标识符流
        out.write("检测彼此之间的变换"); // 标识符流輸出
        out.close();	// 关掉輸出流
        output.close(); 	// 关掉輸出流
    }
}