标签：JAVA String System 小白 File 通读 new main out
本文基于马士兵JAVA教学视频https://www.bilibili.com/video/BV1Ff4y147WP?p=257&spm_id_from=pageDriver学习撰写
目录
九、转换流-InputStreamReader,OutputStreamWriter
十一、数据流-DataInputStream,DataOutputStream
一、File类的引入
在java中操纵文件/目录？怎么办？
JAVA中最典型的特点就是面向对象，JAVA最擅长的也是操作对象，所以我们要把磁盘上的文件和文件夹封装成对象，对象属于File类的对象，有了这个对象，我们的程序就能直接操作文件了，还能对文件进行创建和删除。
二、File对文件的操作
public static void main(String[] args) throws IOException {
//将文件封装为一个File类的对象
File f = new File("src\\main\\resources\\test.txt");
//跨平台建议使用File.separator，获取拼接符
File f2 = new File("C:" + File.separator + "webapp\\test\\src\\main\\resources\\test.txt");
//常用方法
System.out.println("文件是否可读" + f.canRead());
System.out.println("文件是否可写" + f.canWrite());
System.out.println("文件名字" + f.getName());
System.out.println("文件上级目录" + f.getParent());
System.out.println("是否是一个目录" + f.isFile());
System.out.println("是否是一个文件" + f.isDirectory());
System.out.println("是否隐藏" + f.isHidden());
System.out.println("文件大小" + f.length());
System.out.println("是否存在 " + f.exists());
if (f.exists()) {
// f.delete();
} else {
f.createNewFile();
}
System.out.println(f == f2);
System.out.println(f.equals(f2)); //比较文件的路径
}二、File对目录的操作
public static void main(String[] args) {
File f = new File("C:\\webapp\\test\\src\\main\\resources");
System.out.println("文件是否可读" + f.canRead());
System.out.println("文件是否可写" + f.canWrite());
System.out.println("文件名字" + f.getName());
System.out.println("文件上级目录" + f.getParent());
System.out.println("是否是一个目录" + f.isFile());
System.out.println("是否是一个文件" + f.isDirectory());
System.out.println("是否隐藏" + f.isHidden());
System.out.println("文件大小" + f.length());
System.out.println("是否存在 " + f.exists());
//针对目录的方法
File f2 = new File("C:\\webapp\\test\\src\\main\\resources\\a\\b\\c");
//创建目录
//f2.mkdirs();
//删除，删除目录只会删一层，而且要保证没东西
//f2.delete();
//查询，
String[] list = f.list(); //文件夹下目录/文件对应名字的数组
for(String s:list){
System.out.println(s);
}
File[] files = f.listFiles();//作用更加广泛
for(File file:files){
System.out.println(file.getName()+","+file.getAbsolutePath());
}
}三、I/O流的引入
I/O用于处理设备直接数据的传输
形象的理解：I/O流当作一根“管子”：
I/O流体系结构(橙色是重点)：
四、FileReader读取文件内容
案例：通过JAVA完成文件的复制
功能分解1：文件-》程序：FileReader
一个字符一个字符的将文件中的内容读取到程序中了：
public static void main(String[] args) throws IOException {
//文件-》程序：
//1.有一个文件 --》创建一个File类
File f = new File("src\\main\\resources\\test.txt"); //内容：abc老师
//2.利用FileReader流，这个“管子”怼到源文件上面去 --》》创建一个FileReader的流对象
FileReader fr = new FileReader(f);
//3.进行操作“吸”的动作 --》读取文件
/*下面的代码验证了，如果到了文件的结尾处，读取的内容为-1
int n1 = fr.read();
int n2 = fr.read();
int n3 = fr.read();
int n4 = fr.read();
int n5 = fr.read();
int n6 = fr.read();
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4);
System.out.println(n5);
System.out.println(n6);*/
//方式1：
/*int n = fr.read();
while (n!=-1){
System.out.println(n);
n = fr.read();
}*/
//方式2：
int n;
while ((n=fr.read())!=-1){
System.out.print((char) n);
}
//4.“管”不用了，就要关闭--》》关闭流
//流，数据库，网络资源，靠JVM本身无法帮我们关闭，此时必须靠程序员手动关闭
fr.close();
}想一次读五个字符，不够的话下次再读五个字符
public static void main(String[] args) throws IOException {
//文件-》程序：
//1.有一个文件 --》创建一个File类
File f = new File("src\\main\\resources\\test.txt"); //内容：abc老师
//2.利用FileReader流，这个“管子”怼到源文件上面去 --》》创建一个FileReader的流对象
FileReader fr = new FileReader(f);
//3.进行操作“吸”的动作 --》读取文件
//引入一个"快递员的小车"，这个“小车”一次拉5个快递
char[] ch = new char[5]; //缓冲数组
int len = fr.read(ch);//一次读5个:返回值是数组中的有效长度
while (len!=-1){
//System.out.println(len);
/* 方式1：
for(int i=0;i<len;i++)
System.out.print(ch[i]);*/
//方式2：
String str = new String(ch,0,len);
System.out.print(str);
len = fr.read(ch);
}
//4.“管”不用了，就要关闭--》》关闭流
fr.close();
}功能分解2：程序-》文件：FileReader
一个字符一个字符的向外输出：
public static void main(String[] args) throws IOException {
//1.有一个目标文件
File f = new File("src\\main\\resources\\demo.txt");
//2.利用FileWriter流，这个“管子”怼到源文件上面去
FileWriter fw = new FileWriter(f);
//3.开始动作：输出动作
//一个字符一个字符往外输出
String str = "hello你好";
for(int i=0;i<str.length();i++){
fw.write(str.charAt(i));
}
//4.关闭流
fw.close();
}发现：如果目标文件不存在的话，那么会自动创建此文件。
如果目标文件存在，new FileWriter(f)相当于对源文件进行覆盖操作与new FileWriter(f,false)相同，而new FileWriter(f,true)表示追加在后面，而不是覆盖。
利用缓冲数组向外输出：
public static void main(String[] args) throws IOException {
//1.有一个目标文件
File f = new File("src\\main\\resources\\demo.txt");
//2.利用FileWriter流，这个“管子”怼到源文件上面去
FileWriter fw = new FileWriter(f,true);
//3.开始动作：输出动作
//一个字符一个字符往外输出
String str = "，你好中国";
char[] chars = str.toCharArray();
fw.write(chars);
//4.关闭流
fw.close();
}功能分解3：利用FileReader,FileWriter文件复制
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f1 = new File("src\\main\\resources\\test.txt");
//2.有一个目标文件
File f2 = new File("src\\main\\resources\\demo.txt");
//3.搞一个输入的管，怼到源文件上：
FileReader fr = new FileReader(f1);
//4.搞一个输出的管，怼到目标文件上去
FileWriter fw = new FileWriter(f2);
//5.开始动作
//方式1：一个字符一个字符的复制：
/*int n = fr.read();
while (n!=-1){
fw.write(n);
n = fr.read();
}*/
//方式2：利用缓冲字符数组：
/* char[] ch = new char[5];
int len = fr.read(ch);
while (len!=-1){
fw.write(ch,0,len);
len = fr.read(ch);
}*/
//方式3：将缓冲数组转为字符串写出
char[] ch = new char[5];
int len = fr.read(ch);
while (len!=-1){
String s = new String(ch,0,len);
fw.write(s);
len = fr.read(ch);
}
//4.关闭流(关闭流的时候遵循倒着关闭，后用先关)
fw.close();
fr.close();
}！！！警告，不要用字符流去操作非文本文件
文本文件：.txt .java .c .cpp ---》建议使用字符流操作
非文本文件：.jpg .mp3 .mp4 .doc .ppt ---》建议使用字节流操作
五、利用try-catch-finally处理异常
public static void main(String[] args) {
//1.有一个源文件
File f1 = new File("src\\main\\resources\\test.txt");
//2.有一个目标文件
File f2 = new File("src\\main\\resources\\demo.txt");
//3.管怼到源文件上：
FileReader fr = null;
FileWriter fw = null;
try {
fr = new FileReader(f1);
fw = new FileWriter(f2);
//4.开始动作
char[] ch = new char[5];
int len = fr.read(ch);
while (len!=-1){
String s = new String(ch,0,len);
fw.write(s);
len = fr.read(ch);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
//5.关闭流
try {
if(fw!=null) //防止空指针异常
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fr!=null)
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}六、FileInputStream读取文件中的内容
1、读取文本文件：
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f = new File("src\\main\\resources\\test.txt");
//2.将一个字节流管怼到源文件上
FileInputStream fis = new FileInputStream(f);
//3.开始读文件
/*
* 细节1：
* 文件是utf-8进行存储的，所以英文字符底层实际占用1个字节
* 但是中文字符，底层实际占用3个字节。
* 细节2：
* 如果文件是文本文件，那么就不要使用字节流读取了，建议使用字符流
*
* 细节3：read()读取一个字节，但是你有没有发现返回值是Int类型，而不是byte类型？
* read方法底层做了处理，让返回的数据都是正数
* 就是魏立避免如果字节返回的是-1的话，那到底是读入的字节还是文件结尾呢？
* */
int n = fis.read();
while (n!=-1){
System.out.println(n);
n = fis.read();
}
//4.关闭流
fis.close();
}2、利用字节流读取非文本文件：（以图片为案例：） --》一个字节一个字节的读取，效率低
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f = new File("src\\main\\resources\\Red dead.png");
//2.将一个字节流管怼到源文件上
FileInputStream fis = new FileInputStream(f);
//3.开始读文件
int count = 0; //计数器，计读入的字节个数
int n = fis.read();
while (n!=-1){
count++;
n = fis.read();
}
System.out.println(count);
//4.关闭流
fis.close();
}3、利用字节类型的缓冲数组：
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f = new File("src\\main\\resources\\Red dead.png");
//2.将一个字节流管怼到源文件上
FileInputStream fis = new FileInputStream(f);
//3.开始读文件
//利用缓冲数组：（快递员的小车）
int count = 0;
byte[] b = new byte[1024*6];
int len = fis.read(b); //len指读取的有效长度
while (len!=-1){
// System.out.println(len);
count += len;
len = fis.read(b);
}
System.out.println(count);
//4.关闭流
fis.close();
}七、FileInputStream,FileOutput完成非文本复制
1.读入一个字节写出一个字节
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f1 = new File("src\\main\\resources\\Red dead.png");
//2.有一个目标文件
File f2 = new File("src\\main\\resources\\Red dead1.png");
//3.将一个字节流管怼到源文件上
FileInputStream fis = new FileInputStream(f1);
//4.有一个输出管道，怼到木匾文件上
FileOutputStream fos = new FileOutputStream(f2);
//5.开始复制：（边读边写）
int n = -1;
while ((n=fis.read())!=-1){
fos.write(n);
}
//4.关闭流
fos.close();
fis.close();
}耗时：2147ms
2.利用缓冲数组（快很多）
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f1 = new File("src\\main\\resources\\Red dead.png");
//2.有一个目标文件
File f2 = new File("src\\main\\resources\\Red dead1.png");
//3.将一个字节流管怼到源文件上
FileInputStream fis = new FileInputStream(f1);
//4.有一个输出管道，怼到木匾文件上
FileOutputStream fos = new FileOutputStream(f2);
//5.开始复制：（边读边写）
//利用缓冲数组
byte[] b = new byte[1024*8];
int len = fis.read(b);
while (len!=-1){
fos.write(b,0,len);
len = fis.read(b);
}
//4.关闭流
fos.close();
fis.close();
}耗时：2ms
八、缓冲字节流处理器
想要完成上面的效果，单纯的靠FileInputStream,FileOutputStream是不可以完成的，这个时候就需要功能的加强，这个加强就需要引入新的流（在FileInputStream,FileOutputStream外面再套一层流）：BufferedInputStream,BufferedOutputStream,------>处理流
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f1 = new File("src\\main\\resources\\Red dead.png");
//2.有一个目标文件
File f2 = new File("src\\main\\resources\\Red dead1.png");
//3.将一个字节流管怼到源文件上
FileInputStream fis = new FileInputStream(f1);
//4.有一个输出管道，怼到木匾文件上
FileOutputStream fos = new FileOutputStream(f2);
//5.功能加强，在FileInputStream外面套一个管：BufferedInputStream；
BufferedInputStream bis = new BufferedInputStream(fis);
//6.功能加强，在FileOutputStream外面再套一个管：BufferedOutputStream；
BufferedOutputStream bos = new BufferedOutputStream(fos);
//7,开始动作
byte[] b = new byte[1024*6];
int len = bis.read(b);
while (len!=-1){
bos.write(b,0,len);
len = bis.read(b);
}
//8.关闭流
//如果处理流包裹着节点流的话，那么只要关闭高级流，里面的字节流也会随之被关闭
bos.close();
bis.close();
}耗时：1ms
九、转换流-InputStreamReader,OutputStreamWriter
作用：将字节流和字符流进行转换。
属于字节流还是字符流？属于字符流
InputStreamReader:将字节的输入流--》字符的输入流
OutputStreamWriter:将字符的输出流--》字节的输出流
1.将输入的字节流转换为输入的字符流，然后完成文件--》程序：
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f = new File("src\\main\\resources\\test.txt");
//2.需要一个输入的字节流接触文件：
FileInputStream fis = new FileInputStream(f);
//3.加入一个转化流，将字节流转换为字符流：（转换流属于一个处理流）
//将字节转换为字符的时候，需要指定一个编码，这个编码跟文件本身的编码格式统一
//如果编码格式不统一的话，那么控制台上展示的效果就会出现乱码
//InputStreamReader isr = new InputStreamReader(fis,"utf-8");
//获取程序本身的编码--》utf-8
InputStreamReader isr = new InputStreamReader(fis);
//4.开始动作，将文件中内容显示在控制台：
char[] ch = new char[20];
int len = isr.read(ch);
while (len!=-1){
System.out.print(new String(ch,0,len));
len = isr.read(ch);
}
//关闭流
isr.close();
}2.转换流，实现文本文件的复制
public static void main(String[] args) throws IOException {
//1.有一个源文件
File f1 = new File("src\\main\\resources\\test.txt");
//2.有一个目标文件
File f2 = new File("src\\main\\resources\\test1.txt");
//3.输入方向
FileInputStream fis = new FileInputStream(f1);
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
//4.输出方向
FileOutputStream fos = new FileOutputStream(f2);
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//5.开始动作
char[] ch = new char[20];
int len = isr.read(ch);
while (len!=-1){
osw.write(ch,0,len);
len = isr.read(ch);
}
//6.关闭流
osw.close();
isr.close();
}十、练习：键盘录入内容输出到文本文件
public static void main(String[] args) throws IOException {
//1.准备输入方向，键盘录入
InputStream in = System.in;
//字节流-》字符流
InputStreamReader isr = new InputStreamReader(in);
//在isr外面套一个缓冲流
BufferedReader br = new BufferedReader(isr);
//2.再准备输出方向：
//准备目标文件
File f = new File("src\\main\\resources\\test2.txt");
FileWriter fw = new FileWriter(f);
BufferedWriter bw = new BufferedWriter(fw);
//3.开始动作
String s = br.readLine(); //等待键盘录入，是一个阻塞方法
while (!s.equals("exit")){
bw.write(s);
bw.newLine();
s = br.readLine();
}
//4.关闭流
bw.close();
br.close();
}十一、数据流-DataInputStream,DataOutputStream
数据流：用来操作基本数据类型和字符串
DataInputStream：将文件中存储的基本数据类型和字符串写入内存变量中
DataOutputStream：将内存中的基本数据类型和字符串的变量写入文件中
代码：利用DataOutputStream向外写出变量
public static void main(String[] args) throws IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream(new File("src\\main\\resources\\test3.txt")));
dos.writeUTF("你好");
dos.writeBoolean(false);
dos.writeDouble(6.9);
dos.writeInt(82);
dos.close();
}结果
程序读入
DataInputStream dis = new DataInputStream(new FileInputStream(new File("src\\main\\resources\\test3.txt")));
System.out.println(dis.readUTF());
System.out.println(dis.readBoolean());
System.out.println(dis.readDouble());
System.out.println(dis.readInt());
//关闭流
dis.close();输出结果：
验证：文件我们看不懂，但是程序看得懂
要求：写出类型跟读入的类型必须要匹配！且读出顺序要一致。
十二、对象流-序列化和反序列化
对象流：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把JAVA中的对象写入到数据源中，也能把对象从数据源中还原回来。
序列化和反序列化：
ObjectOutputStream类：把内存中的JAVA对象转换成平台无关的二进制数据，从而允许把这种二进制数据持久的保存在磁盘上，或通过网络将这种二进制数据传输到另一个网络节点。---》序列化
用ObjectInputStream类：当其他程序获取了这种二进制数据，就可以恢复成原来的Java对象。---》反序列化
代码：操作字符串对象
首先将一个字符串对象写到文件中去
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("src\\main\\resources\\test4.txt")));
oos.writeObject("你好");
oos.close();
}查看文件：
我们看不懂文件的内容，但是程序是可以看懂的，所以可以写一个程序读文件中的内容：
//将文件中保存的字符串读入到内存
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("src\\main\\resources\\test4.txt")));
//读取
String s = (String) ois.readObject();
System.out.println(s);
//关闭流
ois.close();输出结果：
代码：操作自定义类对象
自定义的Person类：
public class Person {
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}测试类：
public static void main(String[] args) throws IOException, ClassNotFoundException {
//序列化：将内存中对象--》文件
//有一个对象：
Person p = new Person("lili",19);
//有对象流：
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("src\\main\\resources\\test5.txt")));
//向外写：
oos.writeObject(p);
//关闭流
oos.close();
}运行时异常
出现异常的原因：
想要序列化的对象对应的类必须要实现接口
接口内部什么都没有，这种接口叫标识接口，起标识作用，标识什么呢？只有实习这个接口的类的对象才能够序列化。
Person类修改为（实现接口）
public class Person implements Serializable {
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}测试：发现序列化成功，Person具备了序列化的能力。
这个二进制数据我们看不懂，但是程序可以看懂，所以我们可以用程序实现反序列化操作，将这个对象恢复到内存中。
测试：
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("src\\main\\resources\\test5.txt")));
//读入内存：
Person person = (Person) ois.readObject();
System.out.println(person.getName());
//关闭流
ois.close();打印结果：
证明了反序列化成功，将二进制数据--》内存
serialVersionUID：
凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态常量
：
private static final long serialVersionUID;serialVersionUID用来表明类的不同版本间的兼容性，简而远之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
如果类没有显示定义这个静态变量，它的值时JAVA运行时环境根据类的内部细节自动生成的，若类的实例变量做了修改，serialVersionUID可能发生变化。故建议，显示声明。
简单来说，JAVA的序列化机制时通过在运行时判断类的serialVersionUID来验证版本的一致性的，在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。
我现在在person类中加入toString方法：
public class Person implements Serializable {
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}再次运行的结果：Exception in thread "main" java.io.InvalidClassException: Person; local class incompatible: stream classdesc serialVersionUID = -873572521303181536, local class serialVersionUID = -7418736053376735269
序列化时不带toString方法，现在的这个类加了toString,出现不匹配问题。
解决：给类加入序列号
加入序列号后重新生成不带toString方法的版本，再添加toString方法，执行下列代码：
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("src\\main\\resources\\test5.txt")));
//读入内存：
Person person = (Person) ois.readObject();
System.out.println(person.toString());
//关闭流
ois.close();输出：
IDEA中自动配置序列号
勾选图中选定选项。在Person类上，Alt+回车即可生成。
细节：
1.被序列会的类的内部的所有属性，必须是可序列化的（基本数据类型都是可序列化的，但是自定义对象必须实现Serializable接口）
2.static,transient修饰的属性不可以被序列化。
标签：JAVA,String,System,小白,File,通读,new,main,out 来源： https://blog.csdn.net/qq_38071217/article/details/118513121
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。