Java中 IO操作

avatar 2017年10月21日17:09:27 5 1852 views
博主分享免费Java教学视频，B站账号：Java刘哥
本文主要介绍 Java IO 中几个常见的操作，读取字符，写入字符，复制文件，复制文件夹等。 直接上代码啦 因为读和写比较常用，尤其是按行读取，所以贴前面啦
  1. /**
  2.     * 从文件里读取内容
  3.     *
  4.     * @param filePath
  5.     * @return
  6.     */
  7.    private static String readFromFile(String filePath) {
  8.        // 使用ArrayList来存储每行读取到的字符串
  9.        StringBuilder sb = new StringBuilder();
  10.        try {
  11.            FileReader fr = new FileReader(filePath);
  12.            BufferedReader bf = new BufferedReader(fr);
  13.            String str;
  14.            // 按行读取字符串
  15.            while ((str = bf.readLine()) != null) {
  16.                sb.append(str + "\r\n");
  17.            }
  18.            bf.close();
  19.            fr.close();
  20.        } catch (IOException e) {
  21.            e.printStackTrace();
  22.        }
  23.        return sb.toString();
  24.    }
  26.    /**
  27.     * 往文件中写入内容
  28.     *
  29.     * @param outputFilePath 输出文件路径
  30.     * @param content
  31.     */
  32.    public static void writeToFile(String outputFilePath, String content) {
  33.        File file = new File(outputFilePath);
  34.        try {
  35.            FileWriter writer = new FileWriter(file);
  36.            writer.write(content);
  37.            writer.close();
  38.        } catch (IOException e) {
  39.            e.printStackTrace();
  40.        }
  41.    }
  其他的如下
  1. package com.liuyanzhao.file;
  3. import java.io.*;
  5. /**
  6.  * @author 言曌
  7.  * @date 2017/10/21 下午3:31
  8.  */
  10. public class Demo {
  12.     /**
  13.      * 创建文件
  14.      * @param file 文件
  15.      */
  16.     public static void createFile(File file) {
  17.         try {
  18.             file.createNewFile();
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  25.     /**
  26.      * 删除文件
  27.      * @param file 文件
  28.      */
  29.     public static void deleteFile(File file) {
  30.         file.delete();
  31.     }
  33.     /**
  34.      * 根据字节流读取文件内容
  35.      * @param file 文件
  36.      */
  37.     public static void readFileByInputStream(File file) {
  38.         try {
  39.             FileInputStream fis = new FileInputStream(file);
  40.             int length;
  41.             byte[] buf = new byte[1024];
  42.             while ((length = fis.read(buf)) != -1) {
  43.                 System.out.print(new String(buf, 0, length));
  44.             }
  45.             fis.close();
  46.         } catch (FileNotFoundException e) {
  47.             e.printStackTrace();
  48.         } catch (IOException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  53.     /**
  54.      * 根据字符流读取文件内容
  55.      *
  56.      * @param file 文件
  57.      */
  58.     public static void readFileByReader(File file) {
  59.         try {
  60.             FileReader reader = new FileReader(file);
  61.             char[] buf = new char[1024];
  62.             int length;
  63.             while ((length = reader.read(buf)) != -1) {
  64.                 System.out.print(new String(buf, 0, length));
  65.             }
  66.         } catch (FileNotFoundException e) {
  67.             e.printStackTrace();
  68.         } catch (IOException e) {
  69.             e.printStackTrace();
  70.         }
  71.     }
  73.     /**
  74.      * 往文件中写入内容(直接覆盖)
  75.      * @param file 文件
  76.      * @param content
  77.      */
  78.     public static void writeByWriter(File file, String content) {
  79.         try {
  80.             FileWriter writer = new FileWriter(file);
  81.             writer.write(content);
  82.             writer.close();
  83.         } catch (IOException e) {
  84.             e.printStackTrace();
  85.         }
  86.     }
  88.     /**
  89.      * 往文件中写入内容(直接覆盖)
  90.      * @param file
  91.      * @param content
  92.      */
  93.     public static void writeByOutputStream(File file, String content) {
  94.         try {
  95.             FileOutputStream fos = new FileOutputStream(file);
  96.             fos.write(content.getBytes());
  97.             fos.close();
  98.         } catch (FileNotFoundException e) {
  99.             e.printStackTrace();
  100.         } catch (IOException e) {
  101.             e.printStackTrace();
  102.         }
  103.     }
  105.     public static void main(String args[]) {
  106. //        File file = new File("/Users/liuyanzhao/Desktop/demo.txt");
  107. ////        readFileByInputStream(file);
  108. ////        readFileByReader(file);
  109. ////        writeByOutputStream(file,"hello saysky");
  110. ////        writeByWriter(file,"hello java");
  112.         File file = new File("/Users/liuyanzhao/Desktop");
  113.         for(File file1: file.listFiles()) {
  114.             System.out.println("名称："+file1.getName());
  115.             System.out.println("是否存在："+file1.exists());
  116.             System.out.println("绝对路径："+file1.getAbsolutePath());
  117.             System.out.println("父级目录："+file1.getParent());
  118.             System.out.println("大小："+file1.length()/1000+"kB");
  119.         }
  120.     }
  121. }
上面的代码只介绍了一些基本的简单的操作，以后遇到其他的再补充吧。最后再上一张结构图吧
历史上的今天
十月
21日
  • 微信
  • 交流学习，有偿服务
  • weinxin
  • 博客/Java交流群
  • 资源分享，问题解决，技术交流。群号：590480292
  • weinxin
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0