Java⾃学第10期——File类与IO流（输⼊输出流、处理流、转换
流、缓冲流、Prope。。。
1、IO简介
IO（输⼊输出）通过java.io包下的类和接⼝来⽀持，包下包括输⼊、输出两种IO流，每种输⼊输出流⼜可分为字符流和字节流两⼤类。2、File类
File类是io包下与平台⽆关的⽂件和⽬录，File能新建、删除、重命名⽂件和⽬录，不能访问⽂件本⾝，后者需要使⽤输⼊输⼊流。2.1 构造⽅法
File类的构造⽅法：
File(File parent, String child) 参数：⽗路径，⼦路径
根据 parent 抽象路径名和 child 路径名字符串创建⼀个新 File 实例。
File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建⼀个新 File 实例。
File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建⼀个新 File 实例。
File(URI uri)
通过将给定的 file: URI 转换为⼀个抽象路径名来创建⼀个新的 File 实例。
2.2 静态⽅法
File类静态⽅法：
static String pathSeparator()
与系统有关的路径分隔符，为了⽅便，它被表⽰为⼀个字符串。
static char pathSeparatorChar()
与系统有关的路径分隔符。
static String separator()
与系统有关的默认名称分隔符，为了⽅便，它被表⽰为⼀个字符串。
static char separatorChar()
与系统有关的默认名称分隔符。
2.3 常⽤⽅法：
2.3.1 获取相关
public String getAbsolutePath()
返回此File的绝对路径名字符串。
public String getPath()
将此File转换为路径名字符串。
public String getName()
返回由此File表⽰的⽂件或⽬录的名称。
public long length()
返回由此File表⽰的⽂件的长度。不能获取⽂件夹⼤⼩，返回0。如果路径不存在则返回0。
//静态⽅法直接通过类名调⽤
public static void main(String[] args) {
System.out.println(File.pathSeparator);//打印 ;
System.out.println(File.pathSeparatorChar);//打印 ;
System.out.println(File.separator);//打印 \
System.out.println(File.separatorChar);//打印 \
File obj1 = new File("D:\\");//以⽂件结尾的路径
System.out.println("⽂件绝对路径：" + AbsolutePath());
System.out.println("⽂件构造路径：" + Path());
System.out.println("⽂件名：" + Name());
System.out.println("⽂件长度：" + obj1.length());
File obj2 = new File("D\\TEST");//以⽂件夹结尾的路径
System.out.println("⽬录绝对路径：" + AbsolutePath());
System.out.println("⽬录构造路径：" + Path());
System.out.println("⽬录名：" + Name());
System.out.println("⽬录长度：" + obj2.length());
/*
⽂件绝对路径：D:\
⽂件构造路径：D:\
⽂件名：
⽂件长度：3字节
⽬录绝对路径：D:\Coding\demo01\D\TEST
⽬录构造路径：D\TEST
⽬录名：
⽬录长度：0
*/
2.3.2 判断相关
boolean exists()
测试此抽象路径名表⽰的⽂件或⽬录是否存在。
boolean isFile()
测试此抽象路径名表⽰的是否是⽂件，⽽不是⽬录。
boolean isDirectory()
测试此抽象路径名表⽰的⽂件是否是⼀个⽬录。
boolean isAbsolute()
测试此抽象路径名是否为绝对路径名。
注意：路径必须存在，否则isFile()和isDirectory()都返回false。
2.3.3 操作相关
boolean createNewFile()
当次File对象对应的⽂件不存在时，新建⼀个该File对象所指定的新⽂件，创建成功返回true，反之false。boolean delete()
删除File对象对应的⽂件或路径。
boolean mkdir()
创建此抽象路径名指定的⽬录。
boolean mkdirs()
创建此抽象路径名指定的⽬录，包括所有必需但不存在的⽗⽬录。
2.3.4 遍历⽬录：
String[] list()
返回⼀个字符串数组，这些字符串指定此抽象路径名表⽰的⽬录中的⽂件和⽬录。
String[] list(FilenameFilter filter)
返回⼀个字符串数组，这些字符串指定此抽象路径名表⽰的⽬录中满⾜指定过滤器的⽂件和⽬录。
File[] listFiles()
返回⼀个抽象路径名（File）数组，这些路径名表⽰此抽象路径名表⽰的⽬录中的⽂件。
File[] listFiles(FileFilter filter)
返回抽象路径名（File）数组，这些路径名表⽰此抽象路径名表⽰的⽬录中满⾜指定过滤器的⽂件和⽬录。File[] listFiles(FilenameFilter filter)
返回抽象路径名（File）数组，这些路径名表⽰此抽象路径名表⽰的⽬录中满⾜指定过滤器的⽂件和⽬录。
注意：如果list()和listFiles()遍历的⽬录不存在，或者构造⽅法给的路径不是⽬录，
都会抛出空指针异常NullPointerEcxeption；该遍历⾮能获取到隐藏的⽂件或⽬录
路径分隔符：Windows下为分号; Linux下为冒号:
默认名称分隔符：Windows下为反斜杠\，Linux下为正斜杠/
public static void main(String[] args) {
File f1 = new File("D:\\TEST");
System.out.ists());
System.out.println(f1.isFile());
System.out.println(f1.isDirectory());
System.out.println(f1.isAbsolute());
File f2 = new File("E:\\FireFox");
String[] str1 = f2.list();//list()返回字符串数组
//增强for遍历字符串数组
for (String str:str1) {
System.out.println(str);
}
//返回的是File类型的数组
File[] file = f2.listFiles();
//遍历⽬录
for (File f : file){
System.out.println(f);
}
}
2.3.5 绝对路径和相对路径：
绝对路径：从盘符开始的路径
相对路径：相对于当前项⽬的根⽬录的路径
注意：路径不区分⼤⼩写；
2.4 递归
递归：
在当前⽅法调⽤⾃⼰
分类：
直接递归，间接递归（a调⽤b，b调⽤a）
要求：
1、必须要有条件限定结束⽅法，不认栈内存溢出
2、递归次数不能太多，不然也会内存溢出
3、构造⽅法不允许递归，创建的对象太多
使⽤前提：
调⽤⽅法时，⽅法的主体不变，但每次调⽤的参数在不断改变
如果仅仅是求1到n的和，建议⽤for循环，递归会导致频繁的创建调⽤销毁⽅法，效率低。
public static void main(String[] args) {
//递归累加求和
int min = 1;
int max = 4;
int sum = a(min,max);
System.out.println(sum);
//递归计算阶乘n!
int num = 4;
int sum2 = b(num);
System.out.println(sum2);
}
private static int a(int min,int max){
if ( max==1){
return 1;
}else {
return max + a(min, --max);
}
}
private  static int b(int num){
if (num == 1){
return 1;
}else {
return num * b(--num);
}
}
遍历多级⽂件夹，遇到⽂件直接打印路径，判断为⽂件夹则递归遍历这个⽂件夹，不断重复，停⽌条件为没有⽂件夹⽂件搜索，根据结尾扩展名，使⽤String类的endswith⽅法
public static void main(String[] args) {
File f = new File("D:\\Coding\\demo01\\demo1\\src");
//遍历所有⽂件
a(f);
System.out.println("______________");
//⽂件搜索
b(f);
}
private static void a(File f){
//返回路径⾥的所有File⽂件到数组⾥
File[] f1 =  f.listFiles();
/
/遍历
for (File f2 : f1) {
//是⽂件就直接打印路径
if (f2.isFile()){
System.out.println("⽂件名："+f2.getAbsolutePath());
}else {//是⽂件夹就对其进⾏递归，不断重复，知道都是⽂件
System.out.println("⽬录列表："+f2.getAbsolutePath());
a(f2);
}
}
}
private static void b(File f){
File[] f1 = f.listFiles();
for (File f2:f1) {
if (f2.isFile()){
//是⽂件就判断是不是.java后缀
//endswith判断后缀，因为是String类的⽅法要把f2转化（getname），toLowerCase是将JAVA这种⼤写后缀统⼀降为⼩写
if (f2.getName().toLowerCase().endsWith(".java")){
System.out.println(f2);
}
}else {
b(f2);
}
}
2.4.1 ⽂件过滤器：
File类的list⽅法可以接受FilenameFilter类型作参数，通过该参数可以进⾏筛选
FilenameFilter是接⼝，只有⼀个抽象⽅法accept，可以使⽤lambda表达式书写
boolean accept(File dir, String name)
对指定File⼦⽬录和⽂件迭代，如果符合条件则返回true，则list⽅法列出该⼦⽬录或者⽂件
public static void main(String[] args) {
File f = new File("D:\\Coding\\demo01\\demo1\\src\\Interface");
//        a(f);
//如果是以.java结尾，或者是⽂件夹，则返回true。
String[] nameList = f.list((dir,name) -> dsWith(".java") || new File(name).isDirectory());
for(String name : nameList){
System.out.println(name);
}
}
//    private static void a(File f){
//        File[] f1 = f.listFiles();
//        for (File f2 : f1){
//            if (f2.isDirectory()){
//                a(f2);
//            }
/
/            String[] f3 = f2.list((dir, name) -> LowerCase().endsWith(".java"));
//            for(String f4:f3){
//                System.out.println(f4);
//            }
//        }
//    }
3、流Stream
Java传统的流类型（类或抽象类）在java.io包中，Java把各种输⼊输出源抽象为流stream，流是从起源source到接收sink的数据
IO分为分为输⼊流（从外部读取到内存程序）和输出流（从程序到外部），各⾃⼜分为字符流和字节流（⼆者区别仅仅为操作的数据单元不同，字符16位，字节8位），
输⼊流两个基类：InputStream（字节流），Reader（字符流）
输出流两个基类：OutputStream（字节流），Writer（字符流）
如果处理⽂本内容，建议使⽤字符流，如果处理⼆进制内容，建议字节流。
自学java从哪里开始按照流的⾓⾊分类可以分为节点流(对直接和指定⽂件关联)和处理流，处理流是对节点流的⼀种封装
IO资源不属于内存，垃圾回收机制不回收，使⽤close⽅法⼿动关闭流,IO类都实现了AutoCloseable接⼝，都可通过trycatch关闭IO流
3.1 输⼊流
3.1.1 字节输⼊流抽象基类:InputStream：
int read()：从输⼊流中读取单个字节，返回字节数据
int read(byte[] b)：从输⼊流中最多读取b.length个字节，并存储在字节数组b中，返回读取的字节数
int read(byte[] b,int off,int len)：从输⼊流中最多读取b.length个字节的数据，存储在数组b中，不是从数组起点开始，⽽是从off位置开始，返回读取的字节数
void close()
关闭此输⼊流并释放与该流关联的所有系统资源。
3.1.2 字符输⼊流抽象基类:Reader：
int read()：从输⼊流中读取单个字节，返回字节数据
int read(char[] b)：从输⼊流中最多读取b.length个字节，并存储在字节数组b中，返回读取的字节数
int read(char[] b,int off,int len)：从输⼊流中最多读取b.length个字节的数据，存储在数组b中，不是从数组起点开始，⽽是从off位置开始，返回读取的字节数
void close()
关闭此输⼊流并释放与该流关联的所有系统资源。
⼆者⼏乎⼀样。
InputStream/Reader都是抽象类，不能直接创建实例，但他们有读取⽂件的输⼊流：
FileInputStream和FileReader，
⼆者都是节点流
3.1.3 字节输⼊流:FileInputStream
是抽象类InputStream的实现类，可以拿来创建对象。FileInputStream继承了InputStream的⽅法。
构造⽅法可以传路径：
FileInputStream(File file)
通过打开⼀个到实际⽂件的连接来创建⼀个 FileInputStream，该⽂件通过⽂件系统中的 File 对象 file 指定。
3.1.2 字符输⼊流:FileReader
是抽象类Reader的实现类，可以拿来创建对象。FileReader继承了Reader的⽅法。
构造⽅法可以传路径：
FileReader(File file)
在给定从中读取数据的 File 的情况下创建⼀个新 FileReader。
public static void main(String[] args) throws IOException {
//FileInputStream
//创建字节输⼊流，读取⾃⾝.name是路径名
FileInputStream fis = new FileInputStream("D:\\Coding\\demo01\\demo1\\src\\IO\\Demo06_IO.java");
//创建长度为24的⽵筒
byte[] b = new byte[1024];
//计数器
int i = 0;
//循环输⼊，只要还有数据就⼀直执⾏
while((i = ad(b)) >0){
//取出数据，将数组转换成字符串
System.out.println(new String(b,0,i));
}
//打印源代码
//使⽤close⽅法关闭输⼊流
fis.close();
//FileReader
try (
FileReader f = new FileReader("D:\\Coding\\demo01\\demo1\\src\\IO\\Demo06_IO.java");
){
char[] f1 = new char[32];
int f3 = 0;
while ((f3 = f.read(f1)) > 0) {
System.out.println(new String(f1, 0, f3));
}
}catch (IOException e){
e.printStackTrace();
}
}
3.2 输出流
输出流抽象基类：
抽象字节输出流OutputStream、抽象字符输出流Writer
⽅法与输⼊流基本相似，不过将read换成了write。
Writer还包换了额外⽅法：
void writer(String str): 将str字符串⾥的字符输出到指定输出流中
void write(String str,int off,int len): 将str字符串⾥从off开始，长为len的字符输出到指定输出流中
win下简体中⽂字符集默认GBK，linux下默认UTF-8

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。