I/O流以及文件的基本操作

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

该blog是对文档及其I/O流知识要点层面的梳理及其回望，期待对诸位有一定的协助

文档实际操作：

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

文档基操：

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

Constructor	Description
File(File parent, String child)	给出要实际操作的询价的父途径和子文件目录
File(String pathname)	给出一个要实际操作文档的详细途径

Modifier and Type	Method	Description
boolean	public boolean createNewFile()  throws IOException	创建文件
boolean	delete()	删除文件夹
boolean	exists()	分辨给出途径是不是存有

再来一个案例：

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字节数键入流

常见的类一般方式 ：

Modifier and Type	Method	Description
void	close()	关掉此輸出流并释放出来与其流关系的一切服务器资源。
void	flush()	更新此輸出流并强制性载入一切已缓存的輸出字节数。
void	write(byte[] b)	輸出单独字节数数据信息
void	write(byte[] b, int off, int len)	輸出一部分字节数数据信息
abstract void	write(int b)	輸出一组字节数数据信息

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

其常见的构造函数是：

Constructor	Description
FileOutputStream(File file)	建立一个文档輸出流，以载入由特定file目标表明的文档。
FileOutputStream(File file, boolean append)	建立一个文档輸出流，以载入由特定file目标表明的文档。假如第二个主要参数为真，则字节数将被提到文档的结尾而不是开始

案例：

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字节数键入流：

此类的常见方式 ：

Modifier and Type	Method	Description
void	close()	关掉輸出流
abstract int	read()	载入单独字节数数据信息，假如如今早已载入到底了，回到-1
int	read(byte[] b)	载入一组字节数数据信息，回到的是载入的数量，要是没有数据信息早已载入究竟则回到-1
int	read(byte[] b, int off, int len)	载入一组字节数数据信息（只占二维数组的一部分）
byte[]	readAllBytes()	载入键入流所有字节数数据信息，JDK 1.9后增加
long	transferTo(OutputStream out)	键入运转存到輸出流，JDK 1.9以后增加

对文档的实际操作必须其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标识符流;

此类的常见方式 ：

Modifier and Type	Method	Description
Writer	append(char c)	将特定的标识符载入。
Writer	append(CharSequence csq)	将特定的标识符编码序列额外到此撰写器。
Writer	append(CharSequence csq, int start, int end)	将特定标识符编码序列的子序列增加到此撰写器
abstract void	close()	关掉資源
abstract void	flush()	更新資源流
void	write(char[] cbuf)	载入一组数组
abstract void	write(char[] cbuf, int off, int len)	载入一组数组的一部分
void	write(int c)	载入一个字符
void	write(String str)	载入一个字符串数组
void	write(String str, int off, int len)	载入一个字符串数组的一部分

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

类的新项目构造：

• java.lang.Object

•  

  • java.io.OutputStreamWriter

  •  

  • java.io.FileWriter

  • java.io.Writer

  •  

FileWriter常见构造函数：

Constructor	Description
FileWriter(File file)	给出File目标，结构一个FileWriter目标。
FileWriter(String fileName, boolean append)	结构一个给出文件夹名称的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标识符键入流：

此类常见的方式 ：

Modifier and Type	Method	Description
abstract void	close()	关掉資源
int	read()	载入单独标识符
int	read(char[] cbuf)	将标识符放进二维数组
long	skip(long n)	绕过标识符(好多个)
boolean	ready()	分辨这一流是不是已做好准备载入了

案例检测：

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();// 关掉键入流
        }
    }
}

变换流：

变换流	OutputStreamWriter	InputStreamReader
承继构造	public class OutputStreamWriterextends Writer {}	public class InputStreamReaderextends Reader
构造函数	public OutputStreamWriter(OutputStream out)	public InputStreamReader(InputStream in)

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

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

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(); 	// 关掉輸出流
    }
}

----	----	----