🎉🎉🎉点进来你就是我的人了
博主主页：🙈🙈🙈戳一戳,欢迎大佬指点!
人生格言：当你的才华撑不起你的野心的时候,你就应该静下心来学习!欢迎志同道合的朋友一起加油喔🦾🦾🦾
目标梦想：进大厂，立志成为一个牛掰的Java程序猿，虽然现在还是一个🐒嘿嘿
谢谢你这么帅气美丽还给我点赞！比个心
目录
1.File类
File概述
File属性
2.File类对文件进行操作
3.File类对目录进行操作
5.InputStream方法简介
6.OutputStream方法简介
7.InputStream和OutputStream的使用
7.1 FileInputStream读取文件中内容
【1】读取文本文件：
【2】利用字节流读取非文本文件：一个字节一个字节的读取（以图片为案例)
【3】利用字节类型的缓冲数组：
7.2 FileInputStream,FileOutputStream完成非文本文件的复制
【1】读入一个字节，写出一个字节：
【2】利用缓冲字节数组：
8.System类的使用
9.try-with-resource语句
1.File类
在java程序中操纵 文件/目录 ？怎么办？
java程序，最典型的特点，面向对象，java程序最擅长的就是操作对象，盘符上的文件/目录，将它的各种信息进行了封装，封装为一个对象，
java程序最擅长的就是操纵对象，这个对象属于 ---》File类
盘符上的文件---》封装为对象---》对象属于File类的对象--》有了这个对象，我们程序就可以直接操纵这个对象，通过这个对象获取文件的各种信息，还可以对文件进行创建 ，删除。
File概述
在java中提供了一个File类通过这个类来完成文件系统的相关操作例如：
1）列出目录中有哪些文件
2）创建文件
3）创建目录
4）删除文件
5）重命名文件
…
这个File类就描述了一个文件/目录，通过这个对象就可以实现以上的功能
File属性
构造方法
方法
2.File类对文件进行操作
public class Test01 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//将文件封装为一个File类的对象：
File f = new File("d:\\test.txt");
File f1 = new File("d:\\test.txt");
File f2 = new File("d:/test.txt");
//File.separator属性帮我们获取当前操作系统的路径拼接符号
//在windows，dos下，系统默认用“\”作为路径分隔符 ，在unix，url中，使用“/”作为路径分隔符。
File f3 = new File("d:"+File.separator+"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.isDirectory());
System.out.println("是否是一个文件："+f.isFile());
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 == f1);//比较两个对象的地址
System.out.println(f.equals(f1));//比较两个对象对应的文件的路径
//跟路径相关的：
System.out.println("绝对路径："+f.getAbsolutePath());
System.out.println("相对路径："+f.getPath());
System.out.println("toString:"+f.toString());
System.out.println("----------------------");
File f5 = new File("demo.txt");
if(!f5.exists()){
f5.createNewFile();
}
//绝对路径指的就是：真实的一个精准的，完整的路径
System.out.println("绝对路径："+f5.getAbsolutePath());
//相对路径：有一个参照物，相对这个参照物的路径。
//在main方法中，相对位置指的就是：D:\IDEA_workspace\TestJavaSE
//在junit的测试方法中，相对路径指的就是模块位置
System.out.println("相对路径："+f5.getPath());
//toString的效果永远是 相对路径
System.out.println("toString:"+f5.toString());
File f6 = new File("a/b/c/demo.txt");
if(!f5.exists()){
f5.createNewFile();
}
System.out.println("绝对路径："+f6.getAbsolutePath());
System.out.println("相对路径："+f6.getPath());
}
}
3.File类对目录进行操作
public class Test02 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//将目录封装为File类的对象：
File f = new File("D:\\IDEA");
System.out.println("文件是否可读："+f.canRead());
System.out.println("文件是否可写："+f.canWrite());
System.out.println("文件的名字："+f.getName());
System.out.println("上级目录："+f.getParent());
System.out.println("是否是一个目录："+f.isDirectory());
System.out.println("是否是一个文件："+f.isFile());
System.out.println("是否隐藏："+f.isHidden());
System.out.println("文件的大小："+f.length());
System.out.println("是否存在："+f.exists());
System.out.println("绝对路径："+f.getAbsolutePath());
System.out.println("相对路径："+f.getPath());
System.out.println("toString:"+f.toString());
//跟目录相关的方法：
File f2 = new File("D:\\b\\b\\c");
File f3 = new File("D:\\c\\b\\c");
//创建目录：
// f2.mkdir();//创建单层目录
f2.mkdirs();//创建多层目录
//删除：如果是删除目录的话，只会删除一层，并且前提：这层目录是空的，里面没有内容，如果内容就不会被删除
f2.delete();
//查看：
String[] list = f.list();//文件夹下目录/文件对应的名字的数组
for(String s:list){
System.out.println(s); //只能输出文件名
}
System.out.println("=========================");
File[] files = f.listFiles();//作用更加广泛
for(File file:files){
//能通过对象去获取名字和路径等等
System.out.println(file.getName()+","+file.getAbsolutePath());
}
}
}5.InputStream方法简介
针对文件内容，使用“流对象”来进行操作。Java标准库中的流对象，从类型上分为字节流操作二进制数据的和字符流操作文本数据的。字节流中，又存在InputStream和OutputStream两个抽象类。
InputStream方法：
InputStream只是一个抽象类，要使用还要具体的实现类，对于文件读取来说，通常使用FileInputStream，其构造方法如下：
6.OutputStream方法简介
方法：
OutputStream也是一个抽象类，要使用需要具体的实现类，而对于写入文件来说，使用FIleOutputStream。
7.InputStream和OutputStream的使用
文本文件：.txt .java .c .cpp ---》建议使用字符流操作
非文本文件：.jpg, .mp3 , .mp4 , .doc , .ppt ---》建议使用字节流操作
7.1 FileInputStream读取文件中内容
【1】读取文本文件：
public class Test01 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//功能：利用字节流将文件中内容读到程序中来：
//1.有一个源文件：
File f = new File("D:\\Test.txt");
//2.将一个字节流这个管 怼 到 源文件上：
FileInputStream fis = new FileInputStream(f);
//3.开始读取动作
/*
细节1：
文件是utf-8进行存储的，所以英文字符 底层实际占用1个字节
但是中文字符，底层实际占用3个字节。
细节2：
如果文件是文本文件，那么就不要使用字节流读取了，建议使用字符流。
细节3：
read()读取一个字节，但是你有没有发现返回值是 int类型，而不是byte类型？
read方法底层做了处理，让返回的数据都是“正数”,到达末尾该方法就会返回-1
之所以让read方法返回值是int, 就是为了避免如果字节返回的是-1的话，那到底是读入的字节，还是到文件结尾呢。
*/
int n = fis.read();
while(n!=-1){
System.out.println(n);
n = fis.read();
}
//4.关闭流：
fis.close();
}
}【2】利用字节流读取非文本文件：一个字节一个字节的读取（以图片为案例)
public class Test02 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//功能：利用字节流将文件中内容读到程序中来：
//1.有一个源文件：
File f = new File("D:/b/hello.png");
//2.将一个字节流这个管 怼 到 源文件上：
FileInputStream fis = new FileInputStream(f);
//3.开始读取动作
int count = 0;//定义一个计数器，用来计读入的字节的个数
int n = fis.read();
while(n!=-1){
count++;
System.out.println(n);
n = fis.read();
}
System.out.println("count="+count);
//4.关闭流：
fis.close();
}
}
【3】利用字节类型的缓冲数组：
public class Test03 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//功能：利用字节流将文件中内容读到程序中来：
//1.有一个源文件：
File f = new File("D:/b/hello.png");
//2.将一个字节流这个管 怼 到 源文件上：
FileInputStream fis = new FileInputStream(f);
//3.开始读取动作
//利用缓冲数组：（快递员的小车）
byte[] b = new byte[1024*6];
int len = fis.read(b);//len指的就是读取的数组中的有效长度
while(len!=-1){
//System.out.println(len);
for(int i = 0;i<len;i++){
System.out.println(b[i]);
}
len = fis.read(b);
}
//4.关闭流：
fis.close();
}
}7.2 FileInputStream,FileOutputStream完成非文本文件的复制
【1】读入一个字节，写出一个字节：
public class Test04 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//功能：完成图片的复制：
//1.有一个源图片
File f1 = new File("D:/b/hello.png");
//2.有一个目标图片：
File f2 = new File("D:/b/hello2.png");
//3.有一个输入的管道 怼 到 源文件：
FileInputStream fis = new FileInputStream(f1);
//4.有一个输出的管道 怼到 目标文件上：
FileOutputStream fos = new FileOutputStream(f2);
//5.开始复制：（边读边写）
int n = fis.read();
while(n!=-1){
fos.write(n);
n = fis.read();
}
//6.关闭流：(倒着关闭流，先用后关)
fos.close();
fis.close();
}
}
复制结果如下图:
【2】利用缓冲字节数组：
public class Test05 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//功能：完成图片的复制：
//1.有一个源图片
File f1 = new File("D:/b/hello.png");
//2.有一个目标图片：
File f2 = new File("D:/b/hello3.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);
}
//6.关闭流：(倒着关闭流，先用后关)
fos.close();
fis.close();
}
}
复制结果如下图:
8.System类的使用
【1】System的属性：
System.in : “标准”输入流。---》默认情况下 从键盘输入
System.out :“标准”输出流。 ---》默认情况下，输出到控制台。
【2】System.in ：“标准”输入流。---》默认情况下 从键盘输入
public class Test01 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) throws IOException {
//得到的是标准的输入流：--》从键盘输入：
//InputStream in = System.in;
//调用方法：
//int n = in.read();//read方法等待键盘的录入，所以这个方法是一个阻塞方法。
//System.out.println(n);
//以前案例：从键盘录入一个int类型的数据：
//从上面的代码证明，键盘录入实际上是：System.in
//形象的理解：System.in管，这个管怼到键盘上去了，所以你从键盘录入的话，就从这个管到程序中了
//Scanner的作用：扫描器：起扫描作用的，扫键盘的从这根管出来的数据
/*Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println(i);*/
//既然Scanner是扫描的作用，不一定非得扫 System.in进来的东西，还可以扫描其他管的内容：
Scanner sc = new Scanner(new FileInputStream(new File("d:\\Test.txt")));
while(sc.hasNext()){
System.out.println(sc.next());
}
}
}【3】System.out : 返回的输出流 、 打印流（PrintStream）
public class Test02 {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//写到控制台：
PrintStream out = System.out;
//调用方法：
out.print("你好1");//直接在控制台写出，但是不换行
out.print("你好2");
out.print("你好3");
out.print("你好4");
out.println("我是中国人1");//直接在控制台写出，并且换行操作
out.println("我是中国人2");
out.println("我是中国人3");
out.println("我是中国人4");
System.out.println("你是");
System.out.print("中国人");
}
}
9.try-with-resource语句
try-with-resources是Java 7中引入的一个特性，它是为了简化在程序中使用资源（例如文件、网络连接等）的管理。在Java程序中，资源的正确关闭非常重要，因为资源泄漏可能导致性能问题、程序错误或其他问题。try-with-resources语句确保在代码块执行完毕后自动关闭资源，无论代码执行过程中是否发生异常。
try-with-resources语句实现自动关闭资源的方式是通过在资源实现java.lang.AutoCloseable或java.io.Closeable接口的情况下，确保close()方法被调用。这两个接口都包含一个close()方法，它们的实现负责释放资源。
try-with-resources语句的基本结构如下：
try (ResourceType resource = new ResourceType()) {
// 使用资源的代码
} catch (Exception e) {
// 处理异常的代码
}
当程序执行到
try语句块结束时，如果resource实现了AutoCloseable或Closeable接口，那么close()方法将被自动调用。这确保了无论try块中是否抛出异常，资源都会被正确关闭。因此，
try-with-resources语句可以自动关闭资源，主要是因为它依赖实现AutoCloseable或Closeable接口的资源，使得在try语句块结束时自动调用close()方法。这简化了资源管理，降低了资源泄漏和相关问题的风险。注意:如果一个资源没有实现
AutoCloseable或Closeable接口，那么try-with-resources语句将无法自动关闭该资源。在这种情况下，你需要在代码中手动管理资源的关闭。
