java io操作_java 中 IO 操作总结

package jdk.util.sourceCode;

import java.io.*;

/**

* 经常会遇到各种 IO 流操作，IO 流操作一般分为两类：字符流和字节流。

* 以 "Reader" 结尾都是字符流，操作的都是字符型的数据

* 以 "Stream" 结尾的都是字节流，操作的都是 byte 类型的数据

* 二者的区别：

* 字节流没有缓冲区，是直接输出的；而字符流是先输出到缓冲区，然后在调用 close() 方法后再输出信息

* 处理对象不同，字节流能处理所有类型的数据，但是字符流只能处理字符类型的数据(只要是处理纯文本数据，就优先考虑使用字符流，除此之外都使用字节流)

* java byte -> short -> int -> long 1byte -> 2byte -> 4byte -> 8byte

*

*

*

* InputStream 和 OutputStream 是各种输入输出字节流的基类，所有字节流都继承于这两个基类

*

*

* FileInputStream 和 FileOutputStream 这两个从字面意思很容易理解，是对文件的字节流操作，也是最常见的 IO 操作流

*

*

* 非流式文件类 -- File 类

* 从定义来看，File 类是 Object 的直接子类，同时它继承了 Comparable 接口可以进行数组的排序

* File 类的操作包括文件的创建，删除，重命名，得到文件/文件夹的路径，创建时间等

* File 类是对文件系统中文件以及文件夹进行封装的一个对象，可以通过对象的思想来操作文件和文件夹

*

/

/**

* @author: util.you.com@gmail.com

* @date: 2019/5/25 15:40

* @description:

* @version: 1.0

* @className: TestIO

*/

public class TestIO {

public static void main(String[] args){

// 1.调用 新建文件

// createFile("F:\\github\\util.you.com@gmail.com\\jdk\\src\\main\\java\\jdk\\util\\sourceCode\\", "测试io.txt");

// 2.调用删除文件

// deleteFile("F:\\github\\util.you.com@gmail.com\\jdk\\src\\main\\java\\jdk\\util\\sourceCode\\","测试io.txt");

// 3.调用创建文件夹

// createFolder("F:\\github\\util.you.com@gmail.com\\jdk\\src\\main\\java\\jdk\\util\\sourceCode\\", "测试io文件夹");

// 4.列出指定目录下面的所有文件，包括隐藏文件

// listFiles("F:\\github\\util.you.com@gmail.com\\jdk\\src\\main\\java\\jdk\\util\\sourceCode\\");

// 5.判断指定的 文件夹是否是一个 目录(即是否是一个 文件夹)

// isFolder("F:\\\\github\\\\util.you.com@gmail.com\\\\jdk\\\\src\\\\main\\\\java\\\\jdk\\\\util\\\\sourceCode\\", "测试io文件夹");

// 6. 向指定的文件中(需要在文件名中给出路径和文件名,我这里是为了简便这样写了)通过 字节流 写入数据 (这里前提：认为该文件已经存在,不需要再创建)

// writeFileByByte("F:\\github\\util.you.com@gmail.com\\jdk\\src\\main\\java\\jdk\\util\\sourceCode\\测试io.txt");

// 7.从指定的文件中读取内容

// readFileByByte("F:\\github\\util.you.com@gmail.com\\jdk\\src\\main\\java\\jdk\\util\\sourceCode\\测试io.txt");

// 8. 从 指定文件读取内容并写入到 目标文件

readWriteFile("F:\\game\\xx.mp4",

"E:\\github-project\\jdk\\src\\main\\java\\jdk\\util\\sourceCode\\测试io.txt");

}

/**

* 因为 io 流基本是与 File(文件/文件夹) 操作密不可分的，因此 io 的操作，只要涉及到文件，文件夹的都必须使用 File 类

* 在指定的路径下，新建一个 指定文件名的 文件

* @param path 文件路径

* @param fileName 文件名

*/

public static void createFile(String path, String fileName){

// 因为是在 操作 文件，所以用到 File 对象【记住：所有与文件/文件夹操作相关的内容，都必须第一时间想到要用 File 对象】

File file = new File(path+fileName); // 实例化一个 file 操作对象

try {

file.createNewFile(); // 调用 file 文件/文件夹 实例对象的 方法，来新建文件

System.out.println("目标文件已存在: " + path + fileName);

} catch (IOException e) {

e.printStackTrace();

}

}

/**

* 删除一个指定路径下的 文件

* @param path 该文件的路径

* @param fileName 该文件的文件名

*/

public static void deleteFile(String path, String fileName){

File file = new File(path+fileName);

if(file.exists()){

file.delete();

System.out.println("目标文件已删除");

}else{

System.out.println("要删除的目标文件不存在");

}

}

/**

* 新建一个 文件夹

* @param path 路径

* @param folderName 文件夹名

*/

public static void createFolder(String path, String folderName){

File file = new File(path+folderName);

file.mkdir();

System.out.println("该文件夹已经存在于: " + path + folderName);

}

/**

* 列出指定目录下面的所有文件

* @param path 目录的路径名

*/

public static void listFiles(String path){

File file = new File(path);

if (file.isDirectory()){

File[] fileArray = file.listFiles();

for (int i = 0; i < fileArray.length; i++){

System.out.println( "该目录下的文件: " + fileArray[i]);

System.out.println( "该目录下的文件或文件夹的名字: " + fileArray[i].getName());

}

}else{

System.out.println(path + " 目录不存在");

}

}

/**

* 判断给定的 文件夹 是否是一个目录

* @param path

*/

public static void isFolder(String path, String folderName){

File file = new File(path + folderName);

if (file.isDirectory()){

System.out.println(path + folderName + " 是一个目录");

}else{

System.out.println(path + folderName + " 不是一个目录");

}

}

/**

* 通过 字节流 向 指定文件 写入内容

* @param fileName 文件名，这里为了简化，文件名中带上 路径

*/

public static void writeFileByByte(String fileName){

File file = new File(fileName);

OutputStream outputStream = null; // 从内存中 写入内容 到 文件中，这是输出流，因此要用 输出流

// FileOutputStream 的构造器大体上有两类：一类是 传入一个带有文件名和文件路径的字符串；另一类是 传入一个 File 文件/文件夹对象

try {

outputStream = new FileOutputStream(file, true); // 给 file 文件对象 构造一个字节输出流

} catch (FileNotFoundException e) {

e.printStackTrace();

}

// 这里穿插一个小知识点，即我们 给一个 int 参数，但是我们要让 outputStream 以 byte[] 的形式写入,接下来就看 int 转 byte[] 吧

int a = 12345678; // 为什么这样呢？因为 一个 int 是 4个byte,所以一个 int 转成 byte[] 后，一定是里面包含4个byte元素的 byte[] 数组

byte[] b = new byte[]{

(byte) ((a >> 24) & 0xFF),

(byte) ((a >> 16) & 0xFF),

(byte) ((a >> 8) & 0xFF),

(byte) ((a ) & 0xFF)

};

try {

outputStream.write(b); // 这里还有一个问题没解决：写入的时候，选择编码格式(稍后解决)

outputStream.close();

}catch (IOException e) {

e.printStackTrace();

}

}

/**

* 通过 字节流 从 指定文件 读取输出内容

* @param fileName 文件名，这里为了简化，文件名中带上 路径

*/

public static void readFileByByte(String fileName){

File file = new File(fileName);

InputStream inputStream = null; // 从 硬盘中 读取内容 到 内存中，这是 输入流，因此声明 输入流 对象

try {

inputStream = new FileInputStream(file);

// inputStream 读取内容有5个方法 read():默认读取一个byte,readBytes(byte b[], int off, int len)

// 这里我们采用 read(byte b[], int off, int len) 方法

byte[] byter = new byte[1024]; // 所以先实例化一个 byte[]

int len = inputStream.read(byter);

inputStream.close();

// 最后我们输出一下读取到的内容

System.out.println(new String(byter, 0, len));

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* @author: util.you.com@gmail.com

* @param: [sourceFile, desFile]

* @return: void

* @date: 2019/5/25 18:04

* @version: 1.0

* @description: 最后来一个 从 指定文件中 读取内容 到 指定目标文件中

*/

public static void readWriteFile(String sourceFile, String desFile){

File inputFile = new File(sourceFile);

File outputFile = new File(desFile);

InputStream inputStream = null;

OutputStream outputStream = null;

try {

inputStream = new FileInputStream(inputFile);

byte[] byter = new byte[1024];

inputStream.read(byter);

outputStream = new FileOutputStream(outputFile, true);

outputStream.write(byter);

outputStream.close();

inputStream.close();

System.out.println("操作完成");

}catch (Exception e){

System.out.println(e.getMessage());

}

}

}