javaIO流学习

转x33g5p2x  于2021-11-25 转载在 Java  
字(6.3k)|赞(0)|评价(0)|浏览(463)

先从之前用到过的控制台输入流读取开始讲解：

1：BufferedReader：创建

  1. BufferedReader br = new BufferedReader(new 
  2.                       InputStreamReader(System.in));

读取输入的多个字符直到按下q退出:

  1. package 任务11IO流;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  8. /** * @author ${范涛之} * @Description * @create 2021-11-25 1:16 */
  9. public class Test1 {
  10.     public static void main(String[] args) throws IOException {
  11.         char c;
  12.         BufferedReader bufferedReader = new BufferedReader(new  InputStreamReader(System.in));
  13.         System.out.println("输入字符，按下q退出程序");
  14.         do {
  15.             c = (char)bufferedReader.read();
  16.             System.out.println(c);
  17.         }while (c!='q');
  19.     }
  20. }

读取输入的字符串：

  1. package 任务11IO流;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  8. /** * @author ${范涛之} * @Description * @create 2021-11-25 1:16 */
  9. public class Test1 {
  10.     public static void main(String[] args) throws IOException {
  12.         /** * 读取字符 */
  13. // char c;
  14.         BufferedReader bufferedReader = new BufferedReader(new  InputStreamReader(System.in));
  15. // System.out.println("输入字符，按下q退出程序");
  16. // do {
  17. // c = (char)bufferedReader.read();
  18. // System.out.println(c);
  19. // }while (c!='q');
  21.         /** * 读取字符串 */
  23.         String str;
  24.         System.out.println("请输入字符串");
  25.         do {
  26.             str = bufferedReader.readLine();
  27.             System.out.println(str);
  28.         }while (!str.equals("end"));
  30.     }
  31. }

读取文件：

两个重要的流是 FileInputStream 和 FileOutputStream：

1：FileInputStream：

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。

有多种构造方法可用来创建对象。

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

  1. InputStream f = new FileInputStream("C:/java/hello");

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

  1. File f = new File("C:/java/hello");
  2. InputStream in = new FileInputStream(f);
  1. package 任务11IO流;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.InputStream;
  8. /** * @author ${范涛之} * @Description * @create 2021-11-25 1:54 */
  9. public class Test2 {
  11.     public static void main(String[] args) throws FileNotFoundException {
  13.         File f = new File("F:/my.txt");
  14.         InputStream in = new FileInputStream(f);
  15.         System.out.println(in);
  16.     }
  17. }
  19. // 第二种方法：
  21. package 任务11IO流;
  23. import java.io.File;
  24. import java.io.FileInputStream;
  25. import java.io.FileNotFoundException;
  26. import java.io.InputStream;
  28. /** * @author ${范涛之} * @Description * @create 2021-11-25 1:54 */
  29. public class Test2 {
  31.     public static void main(String[] args) throws FileNotFoundException {
  33. // File f = new File("F:/my.txt");
  34. // InputStream in = new FileInputStream(f);
  35. // System.out.println(in);
  36.         InputStream f = new FileInputStream("F:/my.txt");
  37.         System.out.println(f);
  39.     }
  40. }

截图：

FileOutputStream:

  • 该类用来创建一个文件并向文件中写数据。
  • 如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
  • 有两个构造方法可以用来创建 FileOutputStream 对象。
  • 使用字符串类型的文件名来创建一个输出流对象：
  1. OutputStream f = new FileOutputStream("C:/java/hello")
  • 也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：
  1. File f = new File("C:/java/hello");
  2. OutputStream fOut = new FileOutputStream(f);
  1. package 任务11IO流;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.OutputStream;
  7. /** * @author ${范涛之} * @Description * @create 2021-11-25 2:02 */
  8. public class Test3 {
  9.     public static void main(String[] args) throws FileNotFoundException {
  11.         OutputStream f = new FileOutputStream("F:/hello");
  12.         System.out.println(f);
  14.     }
  15. }

运行截图：

实例

下面是一个演示 InputStream 和 OutputStream 用法的例子：fileStreamTest.java 文件代码：

  1. import java.io.*;
  2.  
  3. public class fileStreamTest {
  4.     public static void main(String[] args) {
  5.         try {
  6.             byte bWrite[] = { 11, 21, 3, 40, 5 };
  7.             OutputStream os = new FileOutputStream("test.txt");
  8.             for (int x = 0; x < bWrite.length; x++) {
  9.                 os.write(bWrite[x]); // writes the bytes
  10.             }
  11.             os.close();
  12.  
  13.             InputStream is = new FileInputStream("test.txt");
  14.             int size = is.available();
  15.  
  16.             for (int i = 0; i < size; i++) {
  17.                 System.out.print((char) is.read() + " ");
  18.             }
  19.             is.close();
  20.         } catch (IOException e) {
  21.             System.out.print("Exception");
  22.         }
  23.     }
  24. }
  • 上面的程序首先创建文件test.txt，并把给定的数字以二进制形式写进该文件，同时输出到控制台上。
  • 以上代码由于是二进制写入，可能存在乱码，你可以使用以下代码实例来解决乱码问题：

fileStreamTest2.java 文件代码：：

  1. //文件名 :fileStreamTest2.java
  2. import java.io.*;
  3.  
  4. public class fileStreamTest2 {
  5.     public static void main(String[] args) throws IOException {
  6.  
  7.         File f = new File("a.txt");
  8.         FileOutputStream fop = new FileOutputStream(f);
  9.         // 构建FileOutputStream对象,文件不存在会自动新建
  10.  
  11.         OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
  12.         // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
  13.  
  14.         writer.append("中文输入");
  15.         // 写入到缓冲区
  16.  
  17.         writer.append("\r\n");
  18.         // 换行
  19.  
  20.         writer.append("English");
  21.         // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
  22.  
  23.         writer.close();
  24.         // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
  25.  
  26.         fop.close();
  27.         // 关闭输出流,释放系统资源
  28.  
  29.         FileInputStream fip = new FileInputStream(f);
  30.         // 构建FileInputStream对象
  31.  
  32.         InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
  33.         // 构建InputStreamReader对象,编码与写入相同
  34.  
  35.         StringBuffer sb = new StringBuffer();
  36.         while (reader.ready()) {
  37.             sb.append((char) reader.read());
  38.             // 转成char加到StringBuffer对象中
  39.         }
  40.         System.out.println(sb.toString());
  41.         reader.close();
  42.         // 关闭读取流
  43.  
  44.         fip.close();
  45.         // 关闭输入流,释放系统资源
  46.  
  47.     }
  48. }

Java中的目录：

创建目录：

File类中有两个方法可以用来创建文件夹：

mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。

mkdirs()方法创建一个文件夹和它的所有父文件夹。

下面的例子创建 "/tmp/user/java/bin"文件夹：

  1. import java.io.File;
  2.  
  3. public class CreateDir {
  4.     public static void main(String[] args) {
  5.         String dirname = "/tmp/user/java/bin";
  6.         File d = new File(dirname);
  7.         // 现在创建目录
  8.         d.mkdirs();
  9.     }
  10. }

注意： Java 在 UNIX 和 Windows 自动按约定分辨文件路径分隔符。如果你在 Windows 版本的 Java 中使用分隔符 (/) ，路径依然能够被正确解析。

读取目录：

  • 一个目录其实就是一个 File 对象，它包含其他文件和文件夹。

  • 如果创建一个 File 对象并且它是一个目录，那么调用 isDirectory() 方法会返回 true。

  • 可以通过调用该对象上的 list() 方法，来提取它包含的文件和文件夹的列表。

  • 下面展示的例子说明如何使用 list() 方法来检查一个文件夹中包含的内容：

DirList.java 文件代码：

  1. import java.io.File;
  2.  
  3. public class DirList {
  4.     public static void main(String args[]) {
  5.         String dirname = "/tmp";
  6.         File f1 = new File(dirname);
  7.         if (f1.isDirectory()) {
  8.             System.out.println("目录 " + dirname);
  9.             String s[] = f1.list();
  10.             for (int i = 0; i < s.length; i++) {
  11.                 File f = new File(dirname + "/" + s[i]);
  12.                 if (f.isDirectory()) {
  13.                     System.out.println(s[i] + " 是一个目录");
  14.                 } else {
  15.                     System.out.println(s[i] + " 是一个文件");
  16.                 }
  17.             }
  18.         } else {
  19.             System.out.println(dirname + " 不是一个目录");
  20.         }
  21.     }
  22. }
  26. 目录 /tmp
  27. bin 是一个目录
  28. lib 是一个目录
  29. demo 是一个目录
  30. test.txt 是一个文件
  31. README 是一个文件
  32. index.html 是一个文件
  33. include 是一个目录

我这里尝试递归一下自己F盘：

  1. package 任务11IO流;
  3. import java.io.File;
  5. /** * @author ${范涛之} * @Description * @create 2021-11-25 2:13 */
  6. public class Test4 {
  7.     public static void main(String[] args) {
  8.         String dirname = "F:/";
  9.         File f1 = new File(dirname);
  10.         if (f1.isDirectory()){
  11.             System.out.println("目录"+dirname);
  12.             String[] s = f1.list();
  13.             for (int i = 0; i <s.length; i++) {
  14.                 File f = new File(dirname+"/"+s[i]);
  15.                 if (f.isDirectory()) {
  16.                     System.out.println(s[i] + " 是一个目录");
  17.                 }else {
  18.                     System.out.println(s[i] + " 是一个文件");
  19.                 }
  20.             }
  22.         }else {
  23.             System.out.println(dirname + " 不是一个目录");
  24.         }
  25.     }
  27. }

结果：

成功读出，暂时休息---------------------------------------------

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/justleavel/article/details/121528776

内容来源于网络，如有侵权，请联系作者删除！

Java后端开发语言java学习

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    目录

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com