共计 5477 个字符，预计需要花费 14 分钟才能阅读完成。
一、File 类
什么是文件：文件能够认为是相干记录或放在一起的数据的汇合
文件个别存在哪里：硬盘、光盘等等
File 提供了对以后文件系统中文件的局部操作
示例
package com.msbline.basic.io;
import java.io.File;
import java.io.IOException;
public class FileDemo {public static void main(String[] args) {File file = new File("src/abc.txt");
try {file.createNewFile();
// 判断文件的属性
file.canExecute();
file.canRead();
file.canWrite();
System.out.println(file.exists());
// 获取文件的名称
System.out.println(file.getName());
// 获取绝对路径
System.out.println(file.getAbsolutePath());
// 获取文件的父文件名称，如果文件的门路中只蕴含文件名称，则显示空
System.out.println(file.getParent());
// 返回文件绝对路径的标准
System.out.println(file.getCanonicalPath());
// 返回操作系统的文件分隔符
System.out.println(File.separator);
System.out.println("-----------------------------");
File file1 = new File("D:/");
// 无论以后文件是否存在，只有给定具体的门路，都能够返回相应的门路名称
System.out.println(file1.getAbsolutePath());
System.out.println(file1.isDirectory());
System.out.println(file1.isFile());
String[] list = file1.list();
for(String str : list){System.out.println(str);
}
System.out.println("------------------");
File[] files = file1.listFiles();
for(File file2 : files){System.out.println(file2);
}
System.out.println("------------------");
File[] files1 = File.listRoots();
for(File file2 : files1){System.out.println(file2);
}
System.out.println("------------------");
File file2 = new File("F:/a/b/c");
file2.mkdir();
file2.mkdirs();
File file3 = new File("F:/");
File[] files2 = file3.listFiles();
printFileName(files2);
} catch (IOException e) {e.printStackTrace();
}
}
public static void printFileName(File[] files){if(files != null){for(File file : files){if(file.isDirectory()){printFileName(file.listFiles());
}else {System.out.println(file.getAbsolutePath());
}
}
}
}
}二、IO 流的原理及概念
流的基本概念
流示意从一个文件将数据发送到另一个文件，蕴含一个流向的问题，最终须要抉择一个参照物，以后程序作为参照物
从一个文件中读取数据到程序中叫做输出流
从程序输入数据到另一个文件叫做输入流
三、IO 流的分类
1、解决流和节点流
解决流示例
package com.msbline.basic.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo {public static void main(String[] args) {File file = new File("src/abc.txt");
FileInputStream inputStream = null;
InputStreamReader inputStreamReader = null;
try{inputStream = new FileInputStream(file);
inputStreamReader = new InputStreamReader(inputStream);
char[] chars = new char[1024];
int length = inputStreamReader.read(chars);
System.out.println(new String(chars,0,length));
}catch (Exception e){e.printStackTrace();
}finally {
try {inputStreamReader.close();
} catch (IOException e) {e.printStackTrace();
}
try {inputStream.close();
} catch (IOException e) {e.printStackTrace();
}
}
}
}package com.msbline.basic.io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo {public static void main(String[] args) {File file = new File("src/abc.txt");
OutputStreamWriter outputStreamWriter = null;
FileOutputStream fileOutputStream = null;
try{fileOutputStream = new FileOutputStream(file);
outputStreamWriter = new OutputStreamWriter(fileOutputStream);
outputStreamWriter.write(99);
outputStreamWriter.write("马士兵教育");
outputStreamWriter.write("abcdefg",0,5);
}catch (Exception e){e.printStackTrace();
}finally {
// 解决流的敞开程序，个别依照创立的程序的逆序来敞开
try {outputStreamWriter.close();
} catch (IOException e) {e.printStackTrace();
}
try {fileOutputStream.close();
} catch (IOException e) {e.printStackTrace();
}
}
}
}2、字节流和字符流
所有文件的贮存是都是字节（byte）的贮存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再贮存这些字节到磁盘。在读取文件（特地是文本文件）时，也是一个字节一个字节地读取以造成字节序列
字节流可用于任何类型的对象，包含二进制对象，而字符流只能解决字符或者字符串；
字节流提供了解决任何类型的 IO 操作的性能，但它不能间接解决 Unicode 字符，而字符流就能够
字节流是最根本的，所有的 InputStrem 和 OutputStream 的子类都是, 次要用在解决二进制数据，它是按字节来解决的
但理论中很多的数据是文本，
又提出了字符流的概念，
它是按虚拟机的 encode 来解决，也就是要进行字符集的转化
这两个之间通过 InputStreamReader,OutputStreamWriter 来关联，
实际上是通过 byte[]和 String 来关联
在理论开发中呈现的汉字问题实际上都是在字符流和字节流之间转化不对立而造成的
示例
InputStream
package com.msbline.basic.io;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class StreamDemo1 {public static void main(String[] args) throws IOException {
InputStream inputStream = null;
try {
// 增加缓冲区的形式进行读取，每次会将数据增加到缓冲区中，// 当缓冲区满了之后，一次读取，而不是每次读取一个字节
inputStream = new FileInputStream("src/abc.txt");
byte[] bytes = new byte[1024];
int length = 0;
while ((length = inputStream.read(bytes))!=-1){System.out.println(new String(bytes,0,length));
}
} catch (Exception e) {e.printStackTrace();
}finally {inputStream.close();
}
}
}OutputStream
package com.msbline.basic.io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class OutputStreamDemo {public static void main(String[] args) throws IOException {File file = new File("src/aaa.txt");
OutputStream outputStream = null;
try{outputStream = new FileOutputStream(file);
outputStream.write(99);
outputStream.write("rnmashibing".getBytes());
outputStream.write(1);
}catch (Exception e){e.printStackTrace();
}finally {outputStream.close();
}
}
}Reader
package com.msbline.basic.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo {public static void main(String[] args) {
Reader fileReader = null;
try {fileReader = new FileReader("src/abc.txt");
int read = fileReader.read();
System.out.println((char)read);
} catch (Exception e) {e.printStackTrace();
}finally {
try {fileReader.close();
} catch (IOException e) {e.printStackTrace();
}
}
}
}writer
package com.msbline.basic.io;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class WriterDemo {public static void main(String[] args) {File file = new File("src/writer.txt");
Writer writer = null;
try{writer = new FileWriter(file);
writer.write("www.mashibing.com");
writer.write("马士兵教育");
writer.flush();}catch (Exception e){e.printStackTrace();
}finally {
try {writer.close();
} catch (IOException e) {e.printStackTrace();
}
}
}
}四、IO 流类的体系
正文完