输入输出都是针对Java内存而言输入流： 从磁盘传输数据到Java内存输出流：从Java内存传输数据到磁盘 2. 文件
创建文件
package com.erick.standard;
import java.io.File;
import java.io.IOException;
public class CreateFileDemo {
public static void main(String[] args) throws IOException {
method03();
}
private static void method01() throws IOException {
String path = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/1.txt";
File file = new File(path);
file.createNewFile();
}
private static void method02() throws IOException {
String parentPath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/";
File parentFile = new File(parentPath);
File file = new File(parentFile, "2.txt");
file.createNewFile();
}
private static void method03() throws IOException {
String parentPath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/";
String sonPath = "3.txt";
File file = new File(parentPath, sonPath);
file.createNewFile();
}
}
查看文件信息
private static void method01() {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/111.txt");
System.out.println(file.getName()); // 111.txt
System.out.println(file.getAbsolutePath()); // /Users/EShu/documents/based-on-java8/io-feature/src/main/resources/111.txt
System.out.println(file.getParent()); // /Users/EShu/documents/based-on-java8/io-feature/src/main/resources
System.out.println(file.length()); // 3
System.out.println(file.isFile()); //true
System.out.println(file.isDirectory()); // false
}
综合应用
package com.erick.standard;
import java.io.File;
import java.io.IOException;
public class FileOperations {
public static void main(String[] args) throws IOException {
method03();
}
private static void method01() {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/111.txt");
if (!file.exists()) {
System.out.println("file is not existing");
return;
}
if (file.delete()) {
System.out.println("file delete success");
} else {
System.out.println("file delete failure");
}
}
private static void method02() {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/erick");
if (!file.exists()) {
System.out.println("directory not existing");
return;
}
if (file.delete()) {
System.out.println("directory delete success");
} else {
System.out.println("directory delete failure");
}
}
private static void method03() throws IOException {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/haha/nice");
if (file.exists()) {
System.out.println("directory already exists!");
return;
}
if (file.mkdirs()) {
System.out.println("new directory create success");
} else {
System.out.println("new directory create failure");
}
}
}
二、输入输出流
# 流分类 按操作数据单位： 字节流（8bit） 字符流（） 1.1 字符流一次读取的字节大小是根据字符编码 1.2 字符流效率更高，但是只能读取文本 1.3 字节流是一个一个字节读取，效率低，但是可以读取二进制文件（音频） 按数据流向： 输入流 输出流 按流的角色： 节点流 处理流/包装流
| 抽象基类 | 字节流 | 字符流 |
|---|---|---|
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
Java的IO流设计40多个类，但是都是用上面的4个类派生而出子类类名都是由其父类名作为子类名后缀流就是链接不同文件的一种管道 1. FileInputStream
package com.erick.standard.input;
import java.io.FileInputStream;
import java.io.IOException;
public class InputStreamDemo {
public static void main(String[] args) throws IOException {
method02();
}
private static void method01() throws IOException {
String filePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/222.txt";
FileInputStream fileInputStream = new FileInputStream(filePath);
while (true) {
int result = fileInputStream.read();
if (result == -1) {
break;
} else {
System.out.println("读取到的数据是：" + (char) result);
}
}
fileInputStream.close();
}
private static void method02() throws IOException {
String filePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/222.txt";
FileInputStream fileInputStream = new FileInputStream(filePath);
byte[] buffer = new byte[5];
while (true) {
int byteSize = fileInputStream.read(buffer); // 返回实际读取的字节数
System.out.println("读取的字节的个数： " + byteSize);
if (byteSize == -1) {
break;
} else {
String result = new String(buffer, 0, byteSize);
System.out.println("读取的数据：" + result);
}
}
fileInputStream.close();
}
}
2. FileOutputStream
package com.erick.standard.d02;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
method02();
}
private static void method01() throws IOException {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.txt");
// 覆盖写
FileOutputStream fileOutputStream = new FileOutputStream(file);
fileOutputStream.write('H');
byte[] firstData = "helloerick".getBytes(StandardCharsets.UTF_8);
fileOutputStream.write(firstData);
byte[] secondData = "chinaisfirst".getBytes(StandardCharsets.UTF_8);
fileOutputStream.write(secondData, 0, 5);
fileOutputStream.close();
}
private static void method02() throws IOException {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.txt");
// 追加写
FileOutputStream fileOutputStream = new FileOutputStream(file, true);
fileOutputStream.write('A');
fileOutputStream.close();
}
}
3. 图片拷贝
package com.erick.standard.d02;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyImageDemo {
public static void main(String[] args) throws IOException {
copyImage();
}
private static void copyImage() throws IOException {
String srcFilePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/1.jpg";
String destFilePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/dest.jpg";
FileInputStream inputStream = new FileInputStream(srcFilePath);
FileOutputStream outputStream = new FileOutputStream(destFilePath);
byte[] buffer = new byte[1024];
while (true) {
int resultSize = inputStream.read(buffer);
if (resultSize == -1) {
break;
}
outputStream.write(buffer,0,resultSize);
}
outputStream.close();
inputStream.close();
System.out.println("copy finished...");
}
}
4. FileWriter/FileReader
字符流
package com.erick.standard.d02;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
method02();
}
private static void method01() throws IOException {
String filePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.txt";
FileReader fileReader = new FileReader(filePath);
while (true) {
// 读取的结果对应的int，如果读取不到，则是-1
int result = fileReader.read(); // 一次读取一个字符
if (result == -1) {
break;
} else {
System.out.println("读取的结果是：" + (char) result);
}
}
fileReader.close();
}
private static void method02() throws IOException {
String filePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.txt";
FileReader fileReader = new FileReader(filePath);
char[] buffer = new char[1024];
while (true) {
int result = fileReader.read(buffer); // 读取到的char的长度
if (result == -1) {
break;
} else {
String data = new String(buffer, 0, result);
System.out.println("读取到的多个字符为：" + data);
}
}
}
}
package com.erick.standard.d02;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
method01();
}
private static void method01() throws IOException {
String filePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.txt";
FileWriter fileWriter = new FileWriter(filePath,false);
fileWriter.write('舒'); // int类型，对应的数字
fileWriter.write("天道酬勤"); // string
fileWriter.write(new char[]{'a', '展', '#'}); // char[]
fileWriter.write(new char[]{'a', '展', '#'}, 0, 2);
fileWriter.write("加勒比的海盗", 0, 3);
fileWriter.flush();
fileWriter.close();
}
}
5. 文本的复制
package com.erick.standard.d02;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyTxtByCharDemo {
public static void main(String[] args) throws IOException {
method02();
}
private static void method01() throws IOException {
String srcFilePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/src.txt";
String destFilePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/dest.txt";
File srcFile = new File(srcFilePath);
File destFile = new File(destFilePath);
FileReader fileReader = new FileReader(srcFile);
FileWriter fileWriter = new FileWriter(destFile);
while (true) {
int readData = fileReader.read();
if (readData == -1) {
break;
} else {
fileWriter.write((char) readData);
}
}
fileWriter.close();
fileReader.close();
}
private static void method02() throws IOException {
String srcFilePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/src.txt";
String destFilePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/dest.txt";
File srcFile = new File(srcFilePath);
File destFile = new File(destFilePath);
FileReader fileReader = new FileReader(srcFile);
FileWriter fileWriter = new FileWriter(destFile);
char[] buffer = new char[1024];
while (true) {
// 读取到char[] 的buffer中，读取了多少个字符
int resultSize = fileReader.read(buffer);
if (resultSize == -1) {
break;
} else {
fileWriter.write(buffer, 0, resultSize);
}
}
fileWriter.close();
fileReader.close();
}
}
三、节点流/包装流
1. 节点流/包装流
# 二者区别 1. 节点流 - 可以从一个特定的数据源读写数据， 如FileReader， FileWriter - 底层流，直接和数据源相连 3. 包装流： - BufferedReader/ BufferedInputStream - 包装 节点流，可以消除不同节点流的实现差异， - 使用了 修饰器 模式，不会直接与数据源链接 - 增加了 缓冲 的方式，提高了输入输出的效率 - 提供更方便的方法来处理输入输出2. BufferedReader/BufferedWriter
字符流， 只能操作文本 3. BufferedInputStream/BufferedOutputStream
字节包装流，操作二进制文件
package com.erick.standard.d03;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedOutInputStreamDemo {
public static void main(String[] args) throws IOException {
method04();
}
private static void method01() throws IOException {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.txt");
FileInputStream fileInputStream = new FileInputStream(file);
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
while (true) {
int readResult = bufferedInputStream.read(); // 读取的字节的char
if (readResult == -1) {
break;
}
System.out.println("读取到的数据是： " + (char) readResult);
}
bufferedInputStream.close();
}
private static void method02() throws IOException {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.txt");
FileInputStream fileInputStream = new FileInputStream(file);
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
byte[] buffer = new byte[1024];
while (true) {
int dataSize = bufferedInputStream.read(buffer);
if (dataSize == -1) {
break;
}
String readData = new String(buffer, 0, dataSize);
System.out.println("读取到的数据是：" + readData);
}
bufferedInputStream.close();
}
private static void method03() throws IOException {
File file = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.txt");
FileOutputStream fileOutputStream = new FileOutputStream(file);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
bufferedOutputStream.write('H');
bufferedOutputStream.close();
}
private static void method04() throws IOException {
File srcFile = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/1.jpg");
FileInputStream srcFileInput = new FileInputStream(srcFile);
BufferedInputStream bufferedInputStream = new BufferedInputStream(srcFileInput);
File destFile = new File("/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/dest.jpg");
FileOutputStream fileOutputStream = new FileOutputStream(destFile);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
byte[] buffer = new byte[1024];
while (true) {
int readData = bufferedInputStream.read(buffer); // length for data size
if (readData == -1) {
break;
}
bufferedOutputStream.write(buffer, 0, readData);
}
bufferedOutputStream.close();
bufferedInputStream.close();
System.out.println("copy finished");
}
}
四、对象处理流
1. 序列化
序列化： - 在保存数据到文件、数据库时，不仅保存数据的值，还必须保存数据的类型 - 比如一个java对象的不同 k v 反序列化 - 将保存在文件，数据库的数据(值以及数据类型)，重新恢复成对应的对象的过程 要求： 想要实现对象的序列化，必须满足一定的条件 - 实现Serializable接口2. ObjectInputStream/ObjectOutputStream
包装类将对象完成数据的序列化读写顺序一定要保持一致
package com.erick.standard.d04;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class ObjectOutputDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
method02();
}
private static void method01() throws IOException {
String filePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.dat";
FileOutputStream fileOutputStream = new FileOutputStream(filePath);
ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
outputStream.writeInt(100);// 包装类Integer
outputStream.writeBoolean(true); // 包装类
outputStream.writeDouble(2.4);
outputStream.writeObject(new Dog("jack", 20));
outputStream.close();
System.out.println("write work done");
}
private static void method02() throws IOException, ClassNotFoundException {
String filePath = "/Users/EShu/documents/based-on-java8/io-feature/src/main/resources/2.dat";
FileInputStream fileInputStream = new FileInputStream(filePath);
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
System.out.println(objectInputStream.readInt());
System.out.println(objectInputStream.readBoolean());
System.out.println(objectInputStream.readDouble());
System.out.println(objectInputStream.readObject());
objectInputStream.close();
}
}
@Data
@AllArgsConstructor
class Dog implements Serializable {
private String name;
private int age;
}
3. 序列化细节
package com.erick.standard.d04;
import lombok.Builder;
import lombok.Data;
import java.io.Serializable;
@Data
@Builder
public class Dog implements Serializable {
private static final long serialVersionUID = 42L;
private String name;
private int age;
private String color;
transient String address;
}
五、标准输入输出流
# 字节流 包装流 System.in 标准输入 键盘 System.out 标准输出 显示器
package com.erick.standard.d05;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;
public class StandardStreamDemo {
public static void main(String[] args) {
method02();
}
private static void method01() {
InputStream in = System.in;
System.out.println(System.in.getClass());
PrintStream out = System.out;
System.out.println(System.out.getClass());
}
private static void method02() {
Scanner sc = new Scanner(System.in);
System.out.println("请输入内容");
String input = sc.next();
System.out.println(input);
}
}
六、打印流
