Java 学习（9）：java Stream & File & IO

Java 流(Stream)、文件(File)和IO

• Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
• Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个 源读取数据，输出流表示向一个 目标写数据。

Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

---

读取控制台输入: Java 的控制台输入由 System.in 完成

为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。语法：

BufferedReader br = new BufferedReader(new   InputStreamReader(System.in)); 
//BufferedReader 对象创建后，我们便可以使用 read() 方法从控制台读取一个字符，或者用 readLine() 方法读取一个字符串。

• 从控制台读取多字符输入：从 BufferedReader 对象读取一个字符要使用 read() 方法，它的语法如下：int read( ) throws IOException

  /*每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回。 当流结束的时候返回 -1。该方法抛出 IOException。  */
  例子：read() 方法从控制台不断读取字符直到用户输入 "q"， 使用 BufferedReader 在控制台读取字符
  
  import java.io.*;
  
  public class BRRead {
    public static void main(String args[]) throws IOException {
      char c;
  
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  // 使用 System.in 创建 BufferReader
      System.out.println("输入字符, 按下 'q' 键退出。");
  
      do {  //读取字符
         c = (char) br.read();
         System.out.println(c);
      } while(c != 'q');
    }
  }

• 从控制台读取字符串：从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法，它的一般格式如下：String readLine( ) throws IOException

  /* 读取和显示字符行直到你输入了单词"end"   */
  
  // 使用 BufferedReader 在控制台读取字符
  import java.io.*;
  public class BRReadLines {
    public static void main(String args[]) throws IOException {
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 使用 System.in 创建 BufferReader
      String str;
      System.out.println("Enter lines of text.");
      System.out.println("Enter 'end' to quit.");
      do {
         str = br.readLine();
         System.out.println(str);
      } while(!str.equals("end"));
    }
  }

• JDK 5 后的版本我们也可以使用 Java Scanner 类来获取控制台的输入，创建 Scanner 对象的基本语法：Scanner s = new Scanner(System.in);

  接下来我们演示一个最简单的的数据输入，并通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据。
  next 方法：默认遇到空格结束

  import java.util.Scanner; 
  
  public class ScannerDemo {
      public static void main(String[] args) {
          Scanner scan = new Scanner(System.in);  // 从键盘接收数据  
  
          System.out.println("next方式接收：");
  
          if(scan.hasNext()){   // 判断是否还有输入
            String str1 = scan.next();   //next方式接收字符串
            System.out.println("输入的数据为："+str1);
          }  
  
      }
  }

  使用 next 方法- ScannerDemo.java

  nextLine：默认回车结束

  import java.util.Scanner; 
  
  public class ScannerDemo {
      public static void main(String[] args) {
          Scanner scan = new Scanner(System.in);   // 从键盘接收数据  
  
          System.out.println("nextLine方式接收：");
  
          if(scan.hasNextLine()){   // 判断是否还有输入
            String str2 = scan.nextLine();    //nextLine方式接收字符串
            System.out.println("输入的数据为："+str2);
          }  
  
      }
  }

  nextLine 方法 - ScannerDemo.java

  next() 与 nextLine() 区别

  next():

  • 1、一定要读取到有效字符后才可以结束输入。
  • 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
  • 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • 4、next() 不能得到带有空格的字符串。

  nextLine()：

  • 1、以 Enter 为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
  • 2、可以获得空白。

如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取：

import java.util.Scanner;  

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
    // 从键盘接收数据
        int i =  ;
        float f = 0.0f ;
        System.out.print("输入整数：");
        if(scan.hasNextInt()){
      // 判断输入的是否是整数
            i = scan.nextInt() ;
      // 接收整数
            System.out.println("整数数据：" + i) ;
        }else{
      // 输入错误的信息
            System.out.println("输入的不是整数！") ;
        }
        System.out.print("输入小数：");
        if(scan.hasNextFloat()){
      // 判断输入的是否是小数
            f = scan.nextFloat() ;
      // 接收小数
            System.out.println("小数数据：" + f) ;
        }else{
      // 输入错误的信息
            System.out.println("输入的不是小数！") ;
        }
    }
}

/*输入如下：
$ javac ScannerDemo.java
$ java ScannerDemo
输入整数：12
整数数据：12
输入小数：1.2
小数数据：1.2
*/

输入单个数据：输入 int 或 float 类型的数据 - ScannerDemo.java

以下实例我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入 非数字 来结束输入并输出执行结果：

import java.util.Scanner; 

class ScannerDemo
{
    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in);  

        double sum = ;
        int m = ;  

        while(scan.hasNextDouble())
        {
            double x = scan.nextDouble();
            m = m + ;
            sum = sum + x;
        }  

        System.out.println(m+"个数的和为"+sum);
        System.out.println(m+"个数的平均值是"+(sum/m));
    }
}

/*输入如下：
$ javac ScannerDemo.java
$ java ScannerDemo
12
23
15
21.4
end
4个数的和为71.4
4个数的平均值是17.85
*/

输入多个数据： ScannerDemo.java

---

控制台输出： 控制台的输出由 print( ) 和 println() 完成。

• 这些方法都由类 PrintStream 定义，System.out 是该类对象的一个引用。
• PrintStream 继承了 OutputStream类，并且实现了方法 write()。这样，write() 也可以用来往控制台写操作，语法：void write(int byteval)  //该方法将 byteval 的低八位字节写到流中。

  import java.io.*;
  
  // 演示 System.out.write().
  public class WriteDemo {
     public static void main(String args[]) {
        int b;
        b = 'A';
        System.out.write(b);
        System.out.write('\n');
     }
  }

  用 System.out.write() 把字符 "A" 和紧跟着的换行符输出到屏幕

  注意：write() 方法不经常使用，因为 print() 和 println() 方法用起来更为方便。

  • print()：是函数，可以返回一个值，只能有一个参数
  • println()： 与 print 唯一的区别是 println 换行输出。
  • sprintf()：跟 printf 相似，但不打印，而是返回格式化后的文字，其他的与printf一样。

    public class TestHello {
        public static void main(String[] args) {
            int i = ;
            double j = ;
            System.out.print("用print输出i:"+ i);
            System.out.println( "用println输出i:"+ i);
            System.out.printf("i的值为%d,j的值为%f", i,j);
        }
    }
    /* 用print输出i:4用println输出i:4
        i的值为4,j的值为5.000000 */

---

读写文件：

如前所述，一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。

下图是一个描述输入流和输出流的类层次图。

下面将要讨论的两个重要的流是 FileInputStream 和 FileOutputStream：

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

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

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

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

  File f = new File("C:/java/hello");
  InputStream out = new FileInputStream(f);

  创建了InputStream对象，就可以使用下面的方法来读取流或者进行其他的流操作

      public void close() throws IOException{}
  关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
      protected void finalize()throws IOException {}
  这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
      public int read(int r)throws IOException{}
  这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-。
      public int read(byte[] r) throws IOException{}
  这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-。
      public int available() throws IOException{}
  返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。

  读取流或者进行其他的流操作方法

  除了 InputStream 外，还有一些其他的输入流，如下，其构造方法用来创建数据输入流对象：

  • ByteArrayInputStream: 构造器-创建输入流对象：

    字节数组输入流 在 内存 中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中。创建字节数组输入流对象有以下几种方式
    构造方法-接收字节数组 作为参数创建：
     ByteArrayInputStream bArray = new ByteArrayInputStream(byte [] a);
    构造方法-接收一个字节数组，和两个整形变量 off、len。off表示第一个读取的字节，len表示读取字节的长度：
     ByteArrayInputStream bArray = new ByteArrayInputStream(byte []a,  int off,  int len);

     public int read()：从此输入流中读取下一个数据字节。
     public int read(byte[] r, int off, int len)：将最多 len 个数据字节从此输入流读入字节数组。
     public int available()：返回可不发生阻塞地从此输入流读取的字节数。
     public void mark(int read)：设置流中的当前标记位置。
     public long skip(long n)：从此输入流中跳过 n 个输入字节。

    对流进行读操作或其他操作方法

    import java.io.*;
    
    public class ByteStreamTest {
    
       public static void main(String args[])throws IOException {
    
          ByteArrayOutputStream bOutput = new ByteArrayOutputStream();
    
          while( bOutput.size()!=  ) {
             bOutput.write(System.in.read());      // 获取用户输入值
          }
    
          byte b [] = bOutput.toByteArray();
          System.out.println("Print the content");
          for(int x=  ; x < b.length; x++) {
             System.out.print((char)b[x]  + "   ");    // 打印字符
          }
          System.out.println("   ");
    
          int c;
    
          ByteArrayInputStream bInput = new ByteArrayInputStream(b);
    
          System.out.println("Converting characters to Upper case " );
          for(int y =  ; y < ; y++ ) {
             while(( c= bInput.read())!= -) {
                System.out.println(Character.toUpperCase((char)c));
             }
             bInput.reset();
          }
       }
    }

    ByteArrayInputStream 和 ByteArrayOutputStream的使用

  • DataInputStream，构造器+-创建输入流对象：

    构造方法：
     DataInputStream dis = new DataInputStream(InputStream in);
    另一种创建方式是接收一个字节数组，和两个整形变量 off、len，off表示第一个读取的字节，len表示读取字节的长度。类似 ByteArrayInputStream

      public final int read(byte[] r, int off, int len)throws IOException
    从所包含的输入流中将 len 个字节读入一个字节数组中。如果len为-，则返回已读字节数。
      Public final int read(byte [] b)throws IOException
    从所包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
      public final Boolean readBooolean()throws IOException,
    public final byte readByte()throws IOException,
    public final short readShort()throws IOException
    public final Int readInt()throws IOException
    从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。
      public String readLine() throws IOException
    从输入流中读取下一文本行。

    对流进行读操作或其他操作方法

    /*该例从文本文件test.txt中读取5行，并转换成大写字母，最后保存在另一个文件test1.txt中。*/
    import java.io.*;
    
    public class Test{
       public static void main(String args[])throws IOException{
    
          DataInputStream d = new DataInputStream(new
                                   FileInputStream("test.txt"));
    
          DataOutputStream out = new DataOutputStream(new
                                   FileOutputStream("test1.txt"));
    
          String count;
          while((count = d.readLine()) != null){
              String u = count.toUpperCase();
              System.out.println(u);
              out.writeBytes(u + "  ,");
          }
          d.close();
          out.close();
       }
    }

    DataInputStream和DataOutputStream的使用

• FileOutputStream：该类用来创建一个文件 并向 文件中写数据（即 写文件）。如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。有两个构造方法可以用来创建 FileOutputStream 对象。

  方法1： 使用字符串类型的文件名来创建一个输出流对象：

  OutputStream f = new FileOutputStream("C:/java/hello")

  方法2： 可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

  File f = new File("C:/java/hello");
  OutputStream f = new FileOutputStream(f);

  创建 OutputStream 对象完成后，就可以使用以下方法来写入流或者进行其他的流操作：

    public void close() throws IOException{}： 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
    protected void finalize()throws IOException {}： 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
    public void write(int w)throws IOException{}： 这个方法把指定的字节写到输出流中。
    public void write(byte[] w)： 把指定数组中w.length长度的字节写到OutputStream中。

  写入流或者进行其他的流操作方法

  除了OutputStream外，还有一些其他的输出流，更多的细节参考下面链接：

  • ByteArrayOutputStream

    import java.io.*;
    public class ByteStreamTest {
       public static void main(String args[])throws IOException {
          ByteArrayOutputStream bOutput = new ByteArrayOutputStream();
          while( bOutput.size()!=  ) {
             // 获取用户输入
             bOutput.write(System.in.read());
          }
          byte b [] = bOutput.toByteArray();
          System.out.println("Print the content");
          for(int x=  ; x < b.length; x++) {
             // 打印字符
             System.out.print((char)b[x]  + "   ");
          }
          System.out.println("   ");
          int c;
          ByteArrayOutputStream bInput = new ByteArrayOutputStream(b);
          System.out.println("Converting characters to Upper case " );
          for(int y =  ; y < ; y++ ) {
             while(( c= bInput.read())!= -) {
                System.out.println(Character.toUpperCase((char)c));
             }
             bInput.reset();
          }
       }
    }

    ByteArrayInputStream 和 ByteArrayOutputStream的使用 实例

  • DataOutputStream

    import java.io.*;
    
    public class Test{
       public static void main(String args[])throws IOException{
    
          DataInputStream d = new DataInputStream(new
                                   FileInputStream("test.txt"));
    
          DataOutputStream out = new DataOutputStream(new
                                   FileOutputStream("test1.txt"));
    
          String count;
          while((count = d.readLine()) != null){
              String u = count.toUpperCase();
              System.out.println(u);
              out.writeBytes(u + "  ,");
          }
          d.close();
          out.close();
       }
    }

    DataInputStream 和 DataOutputStream 的使用 实例

/*该程序首先创建文件test.txt，并把给定的数字以二进制形式写进该文件，同时输出到控制台上, 该代码由于是二进制写入，可能存在乱码*/
import java.io.*;

public class fileStreamTest{
  public static void main(String args[]){
    try{
      byte bWrite [] = {,,,,};
      OutputStream os = new FileOutputStream("test.txt");
      for(int x=; x < bWrite.length ; x++){
      os.write( bWrite[x] ); // writes the bytes
    }
    os.close();

    InputStream is = new FileInputStream("test.txt");
    int size = is.available();

    for(int i=; i< size; i++){
      System.out.print((char)is.read() + "  ");
    }
      is.close();
    }catch(IOException e){
      System.out.print("Exception");
    }
  }
}

InputStream 和 OutputStream 用法的例子 -- 给定的数字以二进制写入文件

//文件名 :fileStreamTest2.java
import java.io.*;

public class fileStreamTest2{
  public static void main(String[] args) throws IOException {

    File f = new File("a.txt");
    FileOutputStream fop = new FileOutputStream(f);
    // 构建FileOutputStream对象,文件不存在会自动新建

    OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
    // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk

    writer.append("中文输入");
    // 写入到缓冲区

    writer.append("\r\n");
    //换行

    writer.append("English");
    // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入

    writer.close();
    //关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉

    fop.close();
    // 关闭输出流,释放系统资源

    FileInputStream fip = new FileInputStream(f);
    // 构建FileInputStream对象

    InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
    // 构建InputStreamReader对象,编码与写入相同

    StringBuffer sb = new StringBuffer();
    while (reader.ready()) {
      sb.append((char) reader.read());
      // 转成char加到StringBuffer对象中
    }
    System.out.println(sb.toString());
    reader.close();
    // 关闭读取流

    fip.close();
    // 关闭输入流,释放系统资源

  }
}

解决以上乱码问题

---

文件和I/O：

还有一些关于文件和I/O的类，我们也需要知道：

• File Class(类): 该类主要用于文件和目录的创建、文件的查找和文件的删除等。File 对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象:

  法1： 通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。
   File(File parent, String child);
  法2： 通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。
   File(String pathname)
  法3： 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
   File(String parent, String child)
  法4： 通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。
   File(URI uri) 

      public String getName()
  返回由此抽象路径名表示的文件或目录的名称。
      public String getParent()、
   返回此抽象路径名的父路径名的路径名字符串，如果此路径名没有指定父目录，则返回 null。
      public File getParentFile()
  返回此抽象路径名的父路径名的抽象路径名，如果此路径名没有指定父目录，则返回 null。
      public String getPath()
  将此抽象路径名转换为一个路径名字符串。
      public boolean isAbsolute()
  测试此抽象路径名是否为绝对路径名。
      public String getAbsolutePath()
  返回抽象路径名的绝对路径名字符串。
      public boolean canRead()
  测试应用程序是否可以读取此抽象路径名表示的文件。
      public boolean canWrite()
  测试应用程序是否可以修改此抽象路径名表示的文件。
      public boolean exists()
  测试此抽象路径名表示的文件或目录是否存在。
      public boolean isDirectory()
  测试此抽象路径名表示的文件是否是一个目录。
      public boolean isFile()
  测试此抽象路径名表示的文件是否是一个标准文件。
      public long lastModified()
  返回此抽象路径名表示的文件最后一次被修改的时间。
      public long length()
  返回由此抽象路径名表示的文件的长度。
      public boolean createNewFile() throws IOException
  当且仅当不存在具有此抽象路径名指定的名称的文件时，原子地创建由此抽象路径名指定的一个新的空文件。
      public boolean delete()
   删除此抽象路径名表示的文件或目录。
      public void deleteOnExit()
  在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
      public String[] list()
  返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。
      public String[] list(FilenameFilter filter)
  返回由包含在目录中的文件和目录的名称所组成的字符串数组，这一目录是通过满足指定过滤器的抽象路径名来表示的。
      public File[] listFiles()
    返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。
      public File[] listFiles(FileFilter filter)
  返回表示此抽象路径名所表示目录中的文件和目录的抽象路径名数组，这些路径名满足特定过滤器。
      public boolean mkdir()
  创建此抽象路径名指定的目录。
      public boolean mkdirs()
  创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。
      public boolean renameTo(File dest)
   重新命名此抽象路径名表示的文件。
      public boolean setLastModified(long time)
  设置由此抽象路径名所指定的文件或目录的最后一次修改时间。
      public boolean setReadOnly()
  标记此抽象路径名指定的文件或目录，以便只可对其进行读操作。
      public static File createTempFile(String prefix, String suffix, File directory) throws IOException
  在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
      public static File createTempFile(String prefix, String suffix) throws IOException
  在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
      public int compareTo(File pathname)
  按字母顺序比较两个抽象路径名。
      public int compareTo(Object o)
  按字母顺序比较抽象路径名与给定对象。
      public boolean equals(Object obj)
  测试此抽象路径名与给定对象是否相等。
      public String toString()
   返回此抽象路径名的路径名字符串。

  操作文件方法

  import java.io.File;
  public class DirList {
     public static void main(String args[]) {
        String dirname = "/java";
        File f1 = new File(dirname);
        if (f1.isDirectory()) {
           System.out.println( "Directory of " + dirname);
           String s[] = f1.list();
           for (int i=; i < s.length; i++) {
              File f = new File(dirname + "/" + s[i]);
              if (f.isDirectory()) {
                 System.out.println(s[i] + " is a directory");
              } else {
                 System.out.println(s[i] + " is a file");
              }
           }
        } else {
           System.out.println(dirname + " is not a directory");
      }
    }
  }

  File对象的使用

• FileReader Class(类)：FileReader类从InputStreamReader类继承而来。该类按字符读取流中数据。可以通过以下几种构造方法创建需要的对象：

  法1： 在给定从中读取数据的 File 的情况下创建一个新 FileReader。
   FileReader(File file)
  法2： 在给定从中读取数据的 FileDescriptor 的情况下创建一个新  FileReader。
   FileReader(FileDescriptor fd)
  法3： 在给定从中读取数据的文件名的情况下创建一个新 FileReader。
   FileReader(String fileName) 

      public int read() throws IOException
  读取单个字符，返回一个int型变量代表读取到的字符
      public int read(char [] c, int offset, int len)
  读取字符到c数组，返回读取到字符的个数

  操作文件方法

  import java.io.*;
  public class FileRead{
     public static void main(String args[])throws IOException{
        File file = new File("Hello1.txt");
        // 创建文件
        file.createNewFile();
        // creates a FileWriter Object
        FileWriter writer = new FileWriter(file);
        // 向文件写入内容
        writer.write("This\n is\n an\n example\n");
        writer.flush();
        writer.close();
        // 创建 FileReader 对象
        FileReader fr = new FileReader(file);
        char [] a = new char[];
        fr.read(a); // 读取数组中的内容
        for(char c : a)
            System.out.print(c); // 一个一个打印字符
        fr.close();
     }
  }

  FileReader 实例

• FileWriter Class(类)：FileWriter类从OutputStreamReader类继承而来。该类按字符向流中写入数据。可以通过以下几种构造方法创建需要的对象：

  法1： 在给出 File 对象的情况下构造一个 FileWriter 对象。
   FileWriter(File file)
  法2： 在给出 File 对象的情况下构造一个 FileWriter 对象。
   FileWriter(File file, boolean append)
  法3： 构造与某个文件描述符相关联的 FileWriter 对象。
   FileWriter(FileDescriptor fd)
  法4： 在给出文件名的情况下构造 FileWriter 对象，它具有指示是否挂起写入数据的 boolean 值。
  FileWriter(String fileName, boolean append)

      public void write(int c) throws IOException
  写入单个字符c。
      public void write(char [] c, int offset, int len)
  写入字符数组中开始为offset长度为len的某一部分。
      public void write(String s, int offset, int len)
  写入字符串中开始为offset长度为len的某一部分。

  操作文件方法

  import java.io.*;
  public class FileRead{
     public static void main(String args[])throws IOException{
        File file = new File("Hello1.txt");
        // 创建文件
        file.createNewFile();
        // creates a FileWriter Object
        FileWriter writer = new FileWriter(file);
        // 向文件写入内容
        writer.write("This\n is\n an\n example\n");
        writer.flush();
        writer.close();
        //创建 FileReader 对象
        FileReader fr = new FileReader(file);
        char [] a = new char[];
        fr.read(a); // 从数组中读取内容
        for(char c : a)
            System.out.print(c); // 一个个打印字符
        fr.close();
     }
  }

  FileWriter 实例

---

Java中的目录

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

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

    import java.io.File;
    
    public class CreateDir {
      public static void main(String args[]) {
        String dirname = "/tmp/user/java/bin";
        File d = new File(dirname);
        d.mkdirs();     // 现在创建目录
      }
    }

    创建 "/tmp/user/java/bin"文件夹

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

• 读取目录：一个目录其实就是一个 File 对象，它包含其他文件和文件夹。如果创建一个 File 对象并且它是一个目录，那么调用 isDirectory() 方法会返回 true。可以通过调用该对象上的 list() 方法，来提取它包含的文件和文件夹的列表：

  import java.io.File;
  
  public class DirList {
    public static void main(String args[]) {
      String dirname = "/tmp";
      File f1 = new File(dirname);
      if (f1.isDirectory()) {
        System.out.println( "目录 " + dirname);
        String s[] = f1.list();
        for (int i=; i < s.length; i++) {
          File f = new File(dirname + "/" + s[i]);
          if (f.isDirectory()) {
            System.out.println(s[i] + " 是一个目录");
          } else {
            System.out.println(s[i] + " 是一个文件");
          }
        }
      } else {
        System.out.println(dirname + " 不是一个目录");
      }
    }
  }

  使用 list() 方法来检查一个文件夹中包含的内容

• 删除目录/文件： 删除文件可以使用 java.io.File.delete() 方法。以下代码会删除目录/tmp/java/，即便目录不为空：

  import java.io.File;
  
  public class DeleteFileDemo {
    public static void main(String args[]) {
        // 这里修改为自己的测试目录
      File folder = new File("/tmp/java/");
      deleteFolder(folder);
    }
  
    //删除文件及目录
    public static void deleteFolder(File folder) {
      File[] files = folder.listFiles();
          if(files!=null) {
              for(File f: files) {
                  if(f.isDirectory()) {
                      deleteFolder(f);
                  } else {
                      f.delete();
                  }
              }
          }
          folder.delete();
      }
  }

  delete() 删除目录或文件

Pre-article：Java 学习（8）：java 方法

Next：Java 学习（10）：java 异常处理