java成神之——文件IO

  • 文件I/O

    • Path
    • Files
    • File类
    • File和Path的区别和联系
    • FileFilter
    • FileOutputStream
    • FileInputStream
    • 利用FileOutputStream和FileInputStream复制文件
    • FileWriter
    • FileReader
    • BufferedWriter
    • BufferedReader
      • 基本用法
      • StringWriter
      • InputStreams转换成字符串
    • BufferedInputStream
    • ObjectOutputStream
    • ObjectInputStream
    • PrintWriter
    • 利用PrintWriter复制文件
    • PrintStream
    • Channel
      • 配合Buffer读文件
      • 写文件
    • 利用Channel复制文件
    • System.out和System.err流重定向
    • 访问zip文件
      • 读
      • 创建
  • 结语

文件I/O

Path

resolve                 拼接路径
normalize               格式化
getFileName             获取文件名
getNameCount            获取路径段个数
getName(0)              获取指定路径段的名称
getParent               获取父级目录

Path path = Paths.get("C:\\Users\\26401\\Desktop\\");
Path path1 = Paths.get("demo.txt");
path.resolve(path1).normalize().toString(); // "file:///C:/Users/26401/Desktop/demo.txt"

Files

Path path = Paths.get("C:\\Users\\26401\\Desktop\\demo.txt");
Files.exists(path);
Files.notExists(path);
Files.isDirectory(path);     // 是否是目录
Files.isRegularFile(path);   // 是否是文件
Files.isReadable(path);      // 是否可读
Files.isWritable(path);      // 是否可写
Files.isExecutable(path);    // 是否可执行
Files.isHidden(path);        // 是否可隐藏
Files.probeContentType(path);// 获取MIME类型
Files.readAllLines(path, StandardCharsets.UTF_8); // 读取所有行

List<String> lines = Arrays.asList("First line", "Second line", "Third line");
Files.write(path, lines);    // 一行行写

byte[] data = Files.readAllBytes(path); // 读取所有字节

File类

String separator = File.pathSeparator;                                      // 文件路径分隔符
String separator = File.separator;                                          // 文件名分隔符

File file = new File("C:\\Users\\26401\\Desktop\\java");
File file = new File("C:\\Users\\26401\\Desktop\\java", "demo.txt");

File fileFather = new File("C:\\Users\\26401\\Desktop\\java");
File file = new File(fileFather, "demo.txt");

try {
    boolean b = file.createNewFile();                                       // 创建文件
    boolean b = file.mkdir();                                               // 创建文件夹
    boolean b = file.mkdirs();                                              // 创建多级文件夹
    boolean b = file.delete();                                              // 删除文件或者文件夹
    String s = file.getName();                                              // 获取文件或者文件夹名
    String s = file.getPath();                                              // 获取文件或者文件夹路径
    long s = file.length();                                                 // 获取文件大小
    String s = file.getAbsolutePath();                                      // 获取文件或者文件夹绝对路径
    File s = file.getAbsoluteFile();                                        // 获取文件或者文件夹绝对路径
    File s = file.getParentFile();                                          // 获取文件或者文件夹父路径
    boolean b = file.exists();                                              // 判断文件或者文件夹是否存在
    boolean b = file.isDirectory();                                         // 判断文件夹是否存在
    boolean b = file.isFile();                                              // 判断文件是否存在
    String[] arr = file.list();                                             // 获取文件夹下的文件名和文件夹名
    File[] arr = file.listFiles();                                          // 获取文件夹下的文件和文件夹
} catch (Exception e) {
    e.printStackTrace();
}

File和Path的区别和联系

文件路径操作
    path：
        Path path = new File("demo.txt").toPath();
    file：
        File file = Paths.get("demo.txt").toFile();

删除文件
    file：
        file.delete();
    path：
        Files.deleteIfExists(path);

写数据
    file：
        FileOutputStream outputStream = new FileOutputStream(file);
        outputStream.write("写入数据".getBytes(StandardCharsets.UTF_8));

    path：
        OutputStream outputStream = Files.newOutputStream(path, StandardOpenOption.WRITE);
        outputStream.write("写入数据".getBytes(StandardCharsets.UTF_8));

遍历目录
    file：
        for (File selectedFile : folder.listFiles()) {
            System.out.println((selectedFile.isDirectory() ? "d" : "f") + " " + selectedFile.getAbsolutePath());
        }
        或者
        DirectoryStream<Path> paths = Files.newDirectoryStream(Paths.get("...."));
        for (Path path : paths) {
            if (Files.isDirectory(path)) {
                System.out.println(path.getFileName());
            }
        }

    path：
        Files.walkFileTree(path, EnumSet.noneOf(FileVisitOption.class), 1, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult preVisitDirectory(Path selectedPath, BasicFileAttributes attrs) throws IOException {
                System.out.println("d " + selectedPath.toAbsolutePath());
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFile(Path selectedPath, BasicFileAttributes attrs) throws IOException {
                System.out.println("f " + selectedPath.toAbsolutePath());
                return FileVisitResult.CONTINUE;
            }
        });

正则
    path：
        Path dir = Paths.get(filepath);
        PathMatcher imageFileMatcher = FileSystems.getDefault().getPathMatcher("regex:.*(?i:jpg|jpeg|png|gif|bmp|jpe|jfif)");
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, entry -> imageFileMatcher.matches(entry.getFileName()))) {
            for (Path path : stream) {
                System.out.println(path.getFileName());
            }
        }

读图片
    file：
        Image img = ImageIO.read(new File("demo.png"));

FileFilter

过滤文件
    class myFilter implements FileFilter {
        public boolean accept(File pathname) {
            String name = pathname.getName();
            return name.endsWith(".txt");
        }
    }

    File fileFather = new File("C:\\Users\\26401\\Desktop\\java");
    File file = new File(fileFather, "demo");
    try {
        File[] arr = file.listFiles(new myFilter());
        for (File file2 : arr) {
            System.out.println(file2);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

FileOutputStream

写入数据

    FileOutputStream f = null;
    try {
        f = new FileOutputStream("C:\\Users\\26401\\Desktop\\java\\demo\\demo.txt");            // 创建并覆盖文件
        f = new FileOutputStream("C:\\Users\\26401\\Desktop\\java\\demo\\demo.txt", true);      // 续写文件流
        f.write(100);                                                                           // 写一个字节

        byte[] bs = {49, 48, 48};
        f.write(bs);                                                                            // 写字节数组

        f.write("abc".getBytes());                                                              // 写字节数组

        f.write("a\r\nb\r\nc".getBytes());                                                      // \r\n换行
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if(f != null) f.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

FileInputStream

读取数据

    一个一个字节读
        try(FileInputStream f  = new FileInputStream("C:\\Users\\26401\\Desktop\\java\\demo\\demo.txt")) {
            int i;
            while((i = f.read()) != -1) {
                System.out.println((char)i);
            }
        } 

    利用字节数组缓冲区读
        try(FileInputStream f  = new FileInputStream("C:\\Users\\26401\\Desktop\\java\\demo\\demo.txt")) {
            int len;
            byte[] b = new byte[1024];

            while((len = f.read(b)) != -1) {
                System.out.println(new String(b, 0, len));
            }
        }

利用FileOutputStream和FileInputStream复制文件

try(
    FileInputStream fi  = new FileInputStream("C:\\Users\\26401\\Desktop\\java\\demo\\demo.txt");
    FileOutputStream fo = new FileOutputStream("C:\\Users\\26401\\Desktop\\java\\demo\\demo1.txt")
) {
    int len;
    byte[] b = new byte[1024];

    while((len = fi.read(b)) != -1) {
        fo.write(b, 0, len);
    }
}

FileWriter

try(FileWriter fo = new FileWriter("C:\\Users\\26401\\Desktop\\java\\demo\\demo1.txt")){
    byte[] b = {‘a‘, ‘b‘, ‘c‘};
    fo.write(new String(b, 0, 2, "UTF-8"));
}

FileReader

try(FileReader fo = new FileReader("C:\\Users\\26401\\Desktop\\java\\demo\\demo1.txt")){
    char[] b = new char[1];
    while((fo.read(b)) != -1) {
        System.out.println(new String(b));
    }
}

BufferedWriter

Path path = Paths.get("C:\\Users\\26401\\Desktop\\demo.txt");
String str = "写入一行数据";

try (BufferedWriter bw = Files.newBufferedWriter(path)) {
    bw.write(str);
    bw.newLine();
    bw.write(str);
    bw.flush();
}

或者是BufferedWriter bw = new BufferedWriter(new FileWriter("path"));

BufferedReader

基本用法

try (BufferedReader br = Files.newBufferedReader(path)) {
    char[] b = new char[20];
    while((br.read(b)) != -1) {
        System.out.println(new String(b));
    }
}

或者是BufferedReader br = new BufferedReader(new FileReader("path"));

BufferedReader 用来读字符，可以一次读一行

    用法一
    int ch;
    while ((ch = br.read()) != -1) {
        ...
    }

    用法二
    String line = null;
    while ((line = reader.readLine) != null) {
        ...
    }

    用法三
    按行生成集合
    br.lines().collect(Collectors.toList());

StringWriter

StringWriter writer = new StringWriter();
char[] ary = new char[1024];
BufferedReader buffer = new BufferedReader(new InputStreamReader(new FileInputStream("...");, "UTF-8"));
int x;
while ((x = buffer.read(ary)) != -1) {
    writer.write(ary, 0, x);
}
writer.toString();

InputStreams转换成字符串

StringWriter writer = new StringWriter();
char[] buffer = new char[1024];
try (Reader reader = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\26401\\Desktop\\demo.txt"), "UTF-8"))) {
    int n;
    while ((n = reader.read(buffer)) != -1) {
        writer.write(buffer, 0, n);
    }
}
writer.toString();

BufferedInputStream

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..."))) {
    byte data;
    while ((data = (byte) bis.read()) != -1) {
        System.out.println((char) data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

ObjectOutputStream

序列化对象

    class Demo implements Serializable {
        String Name;
        int Age;
        static transient String Sex;                        // transient禁止实例序列化，static是类属性，实例无法序列化
        static final long serialVersionUID = 1243543523L;   // 自定义类唯一序列号标识
        public void fn() {
            System.out.println(this.Name + "|" + this.Age + "|" + this.Sex);
        }
        public Demo(String Name, int Age, String Sex) {
            this.Name = Name;
            this.Age = Age;
            this.Sex = Sex;
        }
    }

    try(
        FileOutputStream fo = new FileOutputStream("C:\\Users\\26401\\Desktop\\java\\demo.txt");
        ObjectOutputStream foo = new ObjectOutputStream(fo);
    ){
        Demo d = new Demo("叶家伟", 18, "女");
        foo.writeObject(d);
    }

ObjectInputStream

反序列化对象

    try(
        FileInputStream fi =  new FileInputStream("C:\\Users\\26401\\Desktop\\java\\demo.txt");
        ObjectInputStream fii = new ObjectInputStream(fi)
    ){
        Demo d = (Demo)fii.readObject();
        System.out.println(d.Age);
    }

PrintWriter

用法一：

    try(
        PrintWriter pw = new PrintWriter("C:\\Users\\26401\\Desktop\\java\\demo.txt")
    ){
        pw.println("affsddfq");
        pw.flush();
    }

用法二：

    try(
        FileOutputStream fo = new FileOutputStream("C:\\Users\\26401\\Desktop\\java\\demo.txt");
        PrintWriter pw = new PrintWriter(fo)
    ){
        pw.println("wrqr3");
        pw.flush();
    }

用法三：

    try(
        FileOutputStream fo = new FileOutputStream("C:\\Users\\26401\\Desktop\\java\\demo.txt");
        PrintWriter pw = new PrintWriter(fo, true); // 第二个参数，表示自动刷新，也就是可以省略flush语句
    ){
        pw.println("wrqr3");
    }

利用PrintWriter复制文件

try(
    BufferedReader fo = new BufferedReader(new FileReader("C:\\Users\\26401\\Desktop\\java\\demo.txt"));
    PrintWriter pw = new PrintWriter(new FileWriter("C:\\Users\\26401\\Desktop\\java\\demo1.txt"), true)
){
    String line = null;
    while((line = fo.readLine()) != null) {
        pw.println(line);
    }
}

PrintStream

写数据

try(PrintStream ps = new PrintStream(filepath)){
    ps.println("...");
    ps.println();
    ps.println("I love Java!");
    ps.printf("Today is: %1$tm/%1$td/%1$tY", LocalDate.now());
    ps.flush();
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

Channel

配合Buffer读文件

FileInputStream fis = new FileInputStream("C:\\Users\\26401\\Desktop\\demo.txt");
FileChannel fileChannel = fis.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (fileChannel.read(buffer) > 0) {
    buffer.flip();  // 重置指针位置
    while (buffer.hasRemaining()) {
        byte b = buffer.get();
        System.out.print((char) b);
    }
    buffer.clear();
}
fileChannel.close();

写文件

FileOutputStream fos = new FileOutputStream(outputFile);
FileChannel fileChannel = fos.getChannel();
ByteBuffer buffer = ByteBuffer.wrap(text.getBytes());
fileChannel.write(buffer);

利用Channel复制文件

File sourceFile = new File("C:\\Users\\26401\\Desktop\\demo.txt");
File destFile = new File("C:\\Users\\26401\\Desktop\\demo1.txt");
if (!sourceFile.exists() || !destFile.exists()) {
    System.out.println("Source or destination file doesn‘t exist");
}
try (
    FileChannel sourceChannel = new FileInputStream(sourceFile).getChannel();
    FileChannel destChanel = new FileOutputStream(destFile).getChannel()
) {
    sourceChannel.transferTo(0, sourceChannel.size(), destChanel);
}

System.out和System.err流重定向

System.setOut(new PrintStream(new FileOutputStream(new File("C:\\Users\\26401\\Desktop\\demo.txt"))));
System.setErr(new PrintStream(new FileOutputStream(new File("C:\\Users\\26401\\Desktop\\demo1.txt"))));
System.out.println("输出数据1");
System.out.println("输出数据2");
System.err.println("错误数据1");
System.err.println("错误数据2");

访问zip文件

读

Path pathToZip = Paths.get("file.zip");
try(FileSystem zipFs = FileSystems.newFileSystem(pathToZip, null)) {
    Path root = zipFs.getPath("/");
    ...
} catch(IOException ex) {
    ex.printStackTrace();
}

创建

Map<String, String> env = new HashMap<>();
env.put("create", "true"); //required for creating a new zip file
env.put("encoding", "UTF-8"); //optional: default is UTF-8
URI uri = URI.create("jar:file:/path/to/file.zip");
try (FileSystem zipfs = FileSystems.newFileSystem(uri, env)) {
    Path newFile = zipFs.getPath("/newFile.txt");
    Files.write(newFile, "Hello world".getBytes());
} catch(IOException ex) {
    ex.printStackTrace();
}

结语

本文章是java成神的系列文章之一

如果你想知道，但是本文没有的，请下方留言

我会第一时间总结出来并发布填充到本文

原文地址：https://www.cnblogs.com/ye-hcj/p/9750328.html

时间： 2024-11-07 14:31:38

java成神之——文件IO的相关文章

java成神之——注释修饰符

注释修饰符 自定义注释 元注释 通过反射在runtime访问注释 内置注释 多注释实例 错误写法 使用容器改写 使用@Repeatable元注释 注释继承 使用反射获取注释 获取类的注释 获取方法的注释 结语 注释修饰符 自定义注释 元注释 用来注释自定义注释的注释 @Target 限定注释允许加载的目标 @Target(ElementType.METHOD) 只能用于方法 @Target({ElementType.FIELD, ElementType.TYPE}) 可以用于字段和类型 ANNO

java成神之——properties,lambda表达式,序列化

Properties 加载defaults.properties文件 写Properties到xml文件 读Properties从xml文件 Lambda表达式 自定义 内置 sort方法中使用Lambada 序列化 文件序列化 Gson序列化 Jackson序列化 Comparable和Comparator Comparable对象排序 Comparator对象排序 结语 Properties 加载defaults.properties文件 defaults.properties内容如下 la

java成神之——Stream和Optional

Stream流 基本使用 流关闭 平行流 流重用 iterator转换成流 分组计数 无限流 流转集合 压缩流 统计数值流 集合转换流遍历 流拼接 reduce 使用流生成随机字符串 流的包装流 几种包装流 包装流写字符到文件 加密和压缩数据 Optional Optional的常用方法 Optional的基本使用 原始数据类型 结语 Stream流 基本使用 Stream<String> myStream = Stream.of("a", "", &q

2016，Java成神初年

时间2016.12.31 01:51 地点K9004 5号车厢 1号下铺 此刻 深夜 不眠 回想 反思 规划! 工作快四年了,每年经历不同,心思不同!2013,从学生到职场人的转变,在长沙工作半年,第一感觉轻松和新鲜!但我觉得长沙不适合我,我要离开,所以告诉自己我要去深圳!2014,年初八杀入深圳,开始自己的苦逼人生,来到创业公司,各种加班,各种出差.2014最大收获是交了媳妇.2015,坑爹一年,心浮躁了,没有好好学习,工作很忙,各种加班,进步很小,年底感觉不能在呆了.2016,年初9立马辞职

java成神之——java中string的用法

java中String的用法 String基本用法 String分割 String拼接 String截取 String换行符和format格式化 String反转字符串和去除空白字符 String获取指定位置字符和replace的使用 StringBuffer的使用 字符串转换 基本类型的转换 添加字符编码 Base64的编码和解码 结语 java中String的用法 String基本用法 字符串一旦创建在堆中就不可变 字符串声明 String str = "你好"; String s

java成神之——enum枚举操作

枚举 声明 枚举遍历 枚举在switch中使用 枚举比较 枚举静态构造方法 使用类来模拟枚举 枚举中定义抽象方法 枚举实现接口 单例模式 使用静态代码快 EnumSet EnumMap 结语 枚举 声明 基本使用 public enum ChineseNumber { YI, ER, SAN, SI } ChineseNumber.values(); // ["YI","ER","SAN","SI"] 枚举遍历 for (Ch

java成神之——正则表达式基本使用

正则表达式 常用匹配规则 基本使用 标记符的使用 部分正则标记 正则表达式在字符串方法中的使用 结语 正则表达式 常用匹配规则 [abc] abc其中一个 [^abc] abc之外的一个 [a-z] a和z之间的一个 . 表示任意字符 \d 表示一个数字 \D 非数字 \w 表示a-zA-Z0-9_ \W 非a-zA-Z0-9_ ^ 开头 $ 结尾 \b 英文单词边界 ? 一次或者0次 * 零次或者多次 + 一次或者多次 {n} 出现制定n次 {n,} 至少n次 {n,m} >=n <=m 次

java成神之——HttpURLConnection访问api

HttpURLConnection 访问get资源 访问post资源 访问Delete资源 获取状态码 结语 HttpURLConnection 访问get资源 HttpURLConnection connection = (HttpURLConnection)new URL("http://ip/test").openConnection(); int responseCode = connection.getResponseCode(); InputStream inputStre

java成神之——Fork/Join基本使用

Fork/Join 大任务分小任务,小任务结果合并 ForkJoinPool pool = new ForkJoinPool(); RecursiveTask<Integer> task1 = new RecursiveTask<Integer>() { @Override public Integer compute() { return 100 + 100; } }; RecursiveTask<Integer> task2 = new RecursiveTask&