IO（输入输出）

Wesley13
• 阅读 718

IO 流有很多种，按照操作数据的不同，可以分为字节流和字符流，按照数组传输方向的不同又可分为输入流和输出流。字节流的输入输出流分别用 java.io.InputStream 和 java.io.OutputStream表示，字符流的输入输出流分别用 java.io.Reader 和 java.io.Writer 表示。

IO（输入输出）

一、字节流

1、字节流的概念

   在计算机中，无论文本、图片、音频还是视频，所有的文件都是以二进制（字节）的形式存在，IO 流中针对自己的输入和输出提供了一系列的流，统称为字节流。

   字节流是程序中最常用的流，根据数据的传输方向可将其分为字节输入流和字节输出流，在 JDK 中提供了两个抽象类 InputStreanm 和 OutputStream ，他们是字节流的顶级父类，所有的字节输入流都继承自 InputStream，所有的字节输出流都是继承自 OutputStream。

  InputStream 的常用方法：

IO（输入输出）

   OutputStream 的常用方法：

IO（输入输出）

   InputStream 和 OutputStream 这两个类虽然提供了一系列和读写数据有关的方法，但是这两个类是抽象类，不能被实例化，因此针对不同的功能，InputStream 和 OutputStream 提供了不同的子类。

IO（输入输出）

2、字节流读取文件

   针对文件的读写，JDK 专门提供了两个类，分别是 FileInputStream 和 FileInputStream。FileInputStream 是 InputStream 的子类，它是操作文件的字节输入流，专门用于读取文件中的数据。

[java] view plain copy

  1. import java.io.*;  
  2. class StreamDemo1{  
  3.     public static void main(String[] args)throws Exception{  
  4.         FileInputStream in = new FileInputStream("test.txt");  
  5.         int b = 0;  
  6.         while(true){  
  7.             b = in.read();  
  8.             if(b == -1){  
  9.                 break;  
  10.             }  
  11.             System.out.println(b);  
  12.         }  
  13.         in.close();  
  14.     }  
  15. }

  

   需要注意的是，在读取文件数据时，必须保证文件是存在并且可读的，否则会抛出文件找不到异常 FileNotFoundException。

   与 FileInputStream 对应的是 FileOutputStream ，它是操作文件的字节输出流，专门用于把数据写入文件。

[java] view plain copy

  1. import java.io.*;  
  2. class StreamDemo2{  
  3.     public static void main(String[] args)throws Exception{  
  4.         FileOutputStream out = new FileOutputStream("test.txt");  
  5.         String str = "传智播客"；  
  6.         byte[] b = str.getBytes();  
  7.         for(int x=0;x<b.length;x++){  
  8.             out.write(b[x]);  
  9.         }  
  10.         out.close();  
  11.     }  
  12. }

  

   需要注意的是，如果是通过 FileOutputStream 向一个已经存在的文件中写入数据，那么该文件中的数据首先被清空，再写入新的数据。如果希望在已存在的文件内容之后追加新内容，则可以使用 FileOutputStream 的构造函数 FileOutputStream(String fileName,boolean append) 来创建文件输出流对象，并把 append 参数的值设置为 true。

[java] view plain copy

  1. import java.io.*;  
  2. class StreamDemo3{  
  3.     public static void main(String[] args)throws Exception{  
  4.         FileOutputStream out = new FileOutputStream("test.txt",true);  
  5.         String str = "欢迎你"；  
  6.         byte[] b = str.getBytes();  
  7.         for(int x=0;x<b.length;x++){  
  8.             out.write(b[x]);  
  9.         }  
  10.         out.close();  
  11.     }  
  12. }

  

   为了保证 IO 流的 close() 方法将无法得到执行，流对象所占用的系统资源将得不到释放，因此为了保证 IO 流的 close() 方法必须执行，通常将关闭流的操作写在 finally 代码块中。

[java] view plain copy

  1. FileInputStream in = null;  
  2. FileOutputStream out = null;  
  3. try{  
  4.     in = new FileInputStream("test.txt");  
  5.     out = new FileOutputStream("copy.txt");  
  6. }catch(Exception e){  
  7.     throw new RuntimeException("读写失败");  
  8. }finally{  
  9.     try{  
  10.         if(in != null)  
  11.             in.close();  
  12.     }catch(Exception e){  
  13.         e.printStackTrace();  
  14.     }  
  15.     try{  
  16.         if(out != null)  
  17.             out.close();  
  18.     }catch(Exception e){  
  19.         e.printStackTrace();  
  20.     }  
  21. }

  

3、文件拷贝

[java] view plain copy

  1. class StreamDemo4{  
  2.     public static void main(String[] args){  
  3.         //创建一个字节输入流，读取c盘下的mp3文件  
  4.         InputStream in = new FileInputStream("c:\\新不了情.mp3");  
  5.         //创建一个字节输出流，将读取的数据写入到d盘中  
  6.         OutputStream out = new FileOutputStream("d:\\xinbuliaoqing.mp3");  
  7.         int len;  
  8.         while((len=in.read())!=-1){  
  9.             out.write(len);  
  10.         }  
  11.         in.close();  
  12.         out.close();  
  13.     }  
  14. }

  

   当通过流的方式拷贝文件时，为了提高效率可以定义一个字节数组作为缓冲区，一次性读取多个字节的数据，并保存在字节数组中，然后将字节数组中的数据一次性写入文件。

[java] view plain copy

  1. class StreamDemo4{  
  2.     public static void main(String[] args){  
  3.         //创建一个字节输入流，读取c盘下的mp3文件  
  4.         InputStream in = new FileInputStream("c:\\新不了情.mp3");  
  5.         //创建一个字节输出流，将读取的数据写入到d盘中  
  6.         OutputStream out = new FileOutputStream("d:\\xinbuliaoqing.mp3");  
  7.         byte[] buff = new byte[1024];  
  8.         int len;  
  9.         while((len=in.read(buff))!=-1){  
  10.             out.write(buff,0,len);  
  11.         }  
  12.         in.close();  
  13.         out.close();  
  14.     }  
  15. }

  

4、装饰者模式

   装饰者模式就是通过包装一个类，动态地为它增加一种设计模式。

[java] view plain copy

  1. //比如买了一辆车，香味新车装一个倒车雷达，这就相当于为这辆汽车增加了新的功能。  
  2. class Car{  
  3.     private String carName;  
  4.     public Car(String carName){  
  5.         this.carName = carName;  
  6.     }  
  7.     public void show(){  
  8.         System.out.println("我是"+carName+",具备基本功能。");  
  9.     }  
  10. }  
  11. class RadarCar{  
  12.     public  Car myCar;  
  13.     public RadarCar(Car myCar){  
  14.         this.myCar = myCar;  
  15.     }  
  16.     public void show(){  
  17.         myCar.show();  
  18.         System.out.println("具备雷达功能");  
  19.     }  
  20. }

  

5、字节流缓冲区

   在 IO 包中提供了两个带缓冲区的字节流，他们分别是 BufferedInputStream 和 BufferedOutputStream ，这两个流使用了装饰者设计模式。他们的构造方法分别接受 InputStream 和 OutputStream 类型的参数作为被包装的对象，在读写数据时提供缓冲功能。

[java] view plain copy

  1. class StreamDemo5{  
  2.     public static void main(String[] args){  
  3.         BufferedInputStream buffin = new BufferedInputStream(new FileInputStream("src.txt"));  
  4.         BufferedOutputStream buffout = new BufferedOutputStream(new FileOutputStream("dex.txt"));  
  5.         int len;  
  6.         while((len=buffin.read())!=-1){  
  7.             buffout.write(len);  
  8.         }  
  9.         buffin.close();  
  10.         buffout.close();  
  11.     }  
  12. }

  

二、字符流

1、字符流简介

    字符流也有两个抽象的顶级父类 Reader 和 Writer，其中 Reader 是字符输入流，用于从某个原设备中读取字符，Writer 是字符输出流，用于向某个目标设备写入字符。

IO（输入输出）

2、字节流操作文件

   经常需要对文本文件的内容进行读取，如果从文件中直接读取字符便可以使用输入流FileReader ，通过此流可以从关联的文件周总读取一个或一组字符。

[java] view plain copy

  1. //使用FileReader读取reader.txt文件中的内容  
  2. class ReaderDemo{  
  3.     public static void main(String[] args){  
  4.         FileReader reader = new FileReader("reader.txt");  
  5.         int ch;  
  6.         while((ch=reader.read())!=-1){  
  7.             System.out.println((char)ch);  
  8.         }  
  9.         reader.close();  
  10.     }  
  11. }

  

   FileWriter 同 FileOutputStream 一样，如果指定的文件不存在，就会先创建文件，再写入数据，如果文件存在，则会首先清空文件中的内容荣，再进行写入。如果想要在我呢间末尾追加数据，同样需要调用重载的构造方法。

[java] view plain copy

  1. //使用FileWriter将字符串写入到writer.txt文件  
  2. class WriterDemo{  
  3.     public static void main(String[] args){  
  4.         FileWriter writer = new FileWriter("writer.txt");  
  5.         String str = "传智播客";  
  6.         writer.write(str);  
  7.         writer.close();  
  8.     }  
  9. }

  

   字符流同样提供了带缓冲区的包装流，分别是 BufferedReader 和 BufferedWriter，需要注意的是，在 BufferedReader 中有一个重要的方法 readeLine() ，该方法用于一次读取一行文本。

[java] view plain copy

  1. class BufferedReaderDemo{  
  2.     public static void main(String[] args){  
  3.         BufferedReader buffin = new BufferedReader(new FileReader("src.txt"));  
  4.         BufferedWriter buffout = new BufferedWriter(new FileWriter("des.txt"));  
  5.         String str;  
  6.         while((str=buffin.read())!=null){  
  7.             buffout.write(str);  
  8.             buffout.newLine();  
  9.         }  
  10.         buufin.close();  
  11.         buffer.close();  
  12.     }  
  13. }

  

3、LineNumberReader

   Java 程序在编译或运行时期经常会出现一些错误，在错误中通常会报告出错的行号，为了方便查找错误，需要在代码中加入行号。

[java] view plain copy

  1. class LineNumberReaderDemo{  
  2.     public static void main(String[] args){  
  3.         FileReader fr = new FileReader("src.txt");  
  4.         FileWriter fw = new FileWriter("dex.txt");  
  5.         LineNumberReader lr = new LineNumberReader(fr);  
  6.         lr.setLineNumber(0);  
  7.         String line = null;  
  8.         while((line=lr.readLine())!=null){  
  9.             fw.write(lr.getLineNumber()+":"+line);  
  10.         }  
  11.         lr.close();  
  12.         fw.close();  
  13.     }  
  14. }

  

4、转换流

   有时候字节流和字符流之间也需要进行转换，在 JDK 中提供了两个类可以将字节流转换为字符流，它们分别是 InputStreamReader 和 OutputStreamWriter。

   转换流也是一种包装流。

[java] view plain copy

  1. class InputStreamReaderDemo{  
  2.     public static void main(String[] args){  
  3.         BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("src.txt")));  
  4.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileInputStream("dex.txt")));  
  5.         String line;  
  6.         while((line=br.readLine())!=null){  
  7.             bw.write(line);  
  8.         }  
  9.         br.close();  
  10.         bw.close();  
  11.     }  
  12. }

  

三、其他 IO 流

1、ObjectInputStream 和 ObjectOutputStream

   程序运行时会在内存中创建多个对象，然后程序结束后，这些对象便被当做垃圾回收了。如果希望永久保存这些对象，则可以将对象转为字节数组写入到硬盘中，这个过程被称为对象序列化。

   JDK 提供了 ObjectOutputStream（对象输出流）来实现对象的实例化，当对象进行实例化时，必须保证该对象是想 Serializable 接口，否则程序会出现 NotSerializableException 异常。

[java] view plain copy

  1. class ObjectOutputStreamDemo{  
  2.     public static void main(String[] args){  
  3.         Person p = new Person("0001","zhangsan",26);  
  4.         FileOutputStream fos = new FileOutputStream("object.txt");  
  5.         ObjectOutputStream oos = new ObjectOutputStream(fos);  
  6.         oos.writeObject(p);  
  7.     }  
  8. }  
  9. class Person implements Serializable{  
  10.     private String id;  
  11.     private String name;  
  12.     private int age;  
  13.     public Person(String id,String name,int age){  
  14.         this.id = id;  
  15.         this.name = name;  
  16.         this.age = age;  
  17.     }  
  18.     public String getId(){  
  19.         return id;  
  20.     }  
  21.     public String getName(){  
  22.         return name;  
  23.     }  
  24.     public int getAge(){  
  25.         return age;  
  26.     }  
  27. }

  

   Person 对象被序列化后会生成二进制数据保存在“object.txt”文件中，通过这些二进制数据可以恢复序列化之前的 Java 对象，此过程称为反序列化。

   JDK 提供了 ObjectInputStream（对象输入流），它可以实现对象的反序列化。

[java] view plain copy

  1. class ObjectInputStreamDemo{  
  2.     public static void main(String[] args){  
  3.         FileInputStream fis = new FileInputStream("object.txt");  
  4.         ObjectOutputStream ois = new ObjectOutputStream(fis);  
  5.         Person p = (Person)ois.readObject();  
  6.         System.out.println(p.getId()+","+p.getName()+","+p.getAge());  
  7.     }  
  8. }  
  9. class Person implements Serializable{  
  10.     private String id;  
  11.     private String name;  
  12.     private int age;  
  13.     public Person(String id,String name,int age){  
  14.         this.id = id;  
  15.         this.name = name;  
  16.         this.age = age;  
  17.     }  
  18.     public String getId(){  
  19.         return id;  
  20.     }  
  21.     public String getName(){  
  22.         return name;  
  23.     }  
  24.     public int getAge(){  
  25.         return age;  
  26.     }  
  27. }

  

2、DataInputStream 和 DataOutputStream

   有的时候并不需要存储整个对象的信息，而只需要存储对象的成员数据，这些成员数据的类型又都是基本数据类型，这时不必使用对象 Object 相关的流，可以使用 IO 包中提供的另外两个操作流：DataInputStream 和 DataOuputStream。

   DataInputStream 和 DataOutputStream 是两个与平台无关的数据操作流，他们不仅提供了读写各种基本类型数据的方法，而且还提供了 readUTF() 和 writeUTF() 方法，DatinputStream 的 readUTF() 方法能够从输入流中读取采用 UTF-8 字符编码的字符串，DataOutputStream 的 writeUTF() 方法则可向输出流中写入采用 UTF-8 字符编码的字符串。

[java] view plain copy

  1. class DataInputStreamDemo{  

  2.     public static void main(String[] args){  

  3.         BufferedOutputStream bos = new BufferedInputStream(new FileOutputStream("d:\data.txt"));  

  4.         DataOutputStream dos = new DataOutputStream(bos);  

  5.         dos.writeByte(12);  

  6.         dos.writeChar("1");  

  7.         dos.writeBoolean(true);  

  8.         dos.writeUTF("你好");  

  9.         dos.close();  

  10.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\data.txt"));  

  11.         DataInputStream dis = new DataInputStream(bis);  

  12.         System.out.println(dis.readByte());  

  13.         System.out.println(dis.readChar());  

  14.         System.out.println(dis.readBoolean());  

  15.         System.out.println(dis.readUTF());  

  16.         dis.close();  

  17.     }  

  18. }

  

   需要注意的是，只有读取数据的顺序与写入的顺序保持一致，才能保证最终数据的正确性。

3、PrintStream

   PrintStream 提供了一系列用于打印数据的 print() 和 println() 方法，被称作打印流，可以实现将基本数据类型或引用数据类型的对象格式化成字符串后再输出。

[java] view plain copy

  1. class PrintStreamDemo{  
  2.     public static void main(String[] args){  
  3.         PrintStream ps = new PrintStream(new FileOutputStream("print.txt"),true);  
  4.         Student sru = new Student();  
  5.         ps.print("这是一个数字：");  
  6.         ps.println(19);  
  7.         ps.println(stu);  
  8.     }  
  9. }  
  10. class Studnet{  
  11.     public String toString(){  
  12.         return "我是一个学生";  
  13.     }  
  14. }

  

4、标准输入输出流

   在 System 类中定义了三个常量：in、out 和 err，它们被习惯性地称为标准输入输出流。其中，in 为 InputStream 类型，它是标准输入流，默认情况下用于读取键盘输入的数据；out 为 PrintStream 类型，它是标准输出流，默认将数据输出到命令行窗口；err 也是 PrintStream 类型，它是标准错误流，它和 out 一样也是将数据输出到控制台，不同的是 err 通常输出的是应用程序运行时的错误信息。

[java] view plain copy

  1. class InOutDemo{  
  2.     public static void main(String[] args){  
  3.         StringBuffer sb = new StringBuffer();  
  4.         int ch;  
  5.         while((ch=System.in.read())!=-1){  
  6.             if(ch=="\r" || ch=="\n")  
  7.                 break;  
  8.             sb.append((char)ch);  
  9.         }  
  10.         System.out.println(sb);  
  11.     }  
  12. }

  

   由于程序向命令行窗口输出大量的数据，，可以将标准输出流重新定向到其他的输出设备。

IO（输入输出）

[java] view plain copy

  1. class SetInOutDemo{  
  2.     public static void main(String[] args){  
  3.         System.setIn(new FileInputStream("src.txt"));  
  4.         System.setOut(new FileOutputStream("dex.txt"));  
  5.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
  6.         String line;  
  7.         while((line=br.readLine())!=null){  
  8.             System.out.println(line);  
  9.         }  
  10.     }  
  11. }

  

5、PipedInputStream 和 PipedOutputStream

   多个线程之间也可以通过 IO 流实现数据的传输，为此 JDK 提供了一种管道流，管道流分为管道输入流（PipedInputStream）和管道输出流（PipedOutputStream），它是一种比较特殊的流，必须先建立连接才能进行彼此间通信。

[java] view plain copy

  1. class PipedStreamDemo{  

  2.     public static void main(String[] args)throws Exception{  

  3.         final PipedInputStream pis = new PipedInputStream();  

  4.         final PipedOutputStream pos = new PipedOutputStream();  

  5.         pis.connect(pos);  

  6.         new Thread(new Runnable(){  

  7.                 public void run(){  

  8.                     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  

  9.                     PrintStream ps = new PrintStream(pos);  

  10.                     while(true){  

  11.                         try{  

  12.                             System.out.print(Thread.currentThread().getName()+"要输入的内容：");  

  13.                             ps.println(br.readLine());  

  14.                             Thread.sleep(1000);  

  15.                         }catch(Exception e){  

  16.                             e.printStackTrace();  

  17.                         }  

  18.                     }  

  19.                 }  

  20.             },"发送数据的线程").start();  

  21.         new Thread(new Runnable(){  

  22.                 public void run(){  

  23.                     BufferedReader br = new BufferedReader(new InputStream(pis));  

  24.                     while(true){  

  25.                         try{  

  26.                             System.out.print(Thread.currentThread().getName()+"收到的内容：");  

  27.                         }catch(Exception e){  

  28.                             e.printStackTrace();  

  29.                         }  

  30.                     }  

  31.                 }  

  32.             },"接收数据的线程").start();  

  33.     }  

  34. }

  

6、ByteArrayInputStream 和 ByteArrayOutputStream

   为了将文件临时存储到缓冲区，方便以后读取，ByteArrayOuputStream 类会在创建对象时就创建一个 byte 型数组的缓冲区，当想数组中写数据时，该对象会把所有的数据线写入缓冲区，最后一次性写入文件。

[java] view plain copy

  1. class ByteOutputStreamStreamDemo{  
  2.     public static void main(String[] args){  
  3.         FileInputStream fis = new FileInputStream("src.txt");  
  4.         ByteArrayOutputStream bos = new ByteArrayOutputStream();  
  5.         FileOutputStream fos = new FileOutputStream("target.txt");  
  6.         int b;  
  7.         while((b=fis.read())!=-1){  
  8.             bos.write(b);  
  9.         }  
  10.         in.xlose();  
  11.         bos.close();  
  12.         fos.write(bos.toByteArray());  
  13.         fos.close();  
  14.     }  
  15. }

  

   需要注意的是，如果读取的文件非常大，就不能使用这个类，否则会造成内存溢出。

   与 ByteArrayOutputStream 类似，ByteArrayInputStream 是从缓冲区读取数据。

[java] view plain copy

  1. class ByteInputStreamStreamDemo{  
  2.     public static void main(String[] args){  
  3.         byte[] buff = new byte[]{97,98,99,100};  
  4.         ByteArrayInputStream bis = new ByteArrayInputStream(buff);  
  5.         int b;  
  6.         while((b=bis.read())!=-1){  
  7.             System.out.println((char)b);  
  8.         }  
  9.     }  
  10. }

  

7、CharArrayReader 和 CharArrayWriter

   要想将字符型数据临时存入缓冲区中，还可以使用 JDK 提供的 CharArrayReader 和 CharArrayWriter，CharArrayReader 是从字符数组中读取数据，CharArrayWriter 是在内存中创建一个字符数组缓冲区，他们的功能与 ByteArrayInputStream 和 ByteArrayOutputStream 类似，只不过操作的数据是字符。

[java] view plain copy

  1. class ByteInputStreamStreamDemo{  

  2.     public static void main(String[] args){  

  3.         FileReader fr = new FileReader("src.txt");  

  4.         CharArrayWriter cw = new CharArrayWriter();  

  5.         int b;  

  6.         while((b=fr.read())!=-1){  

  7.             cw.write(b);  

  8.         }  

  9.         fr.close();  

  10.         cw.close();  

  11.         char[] c = cw.toCharArray();  

  12.         CharArrayReader cr = new CharArrayReader(c);  

  13.         int i;  

  14.         while((i=cr.read())!=-1){  

  15.             System.out.println((char)i);  

  16.         }  

  17.     }  

  18. }

  

8、SequenceInputStream

   如果希望多个流处理数据，这时需要将这些流合并，SquenceInputStream 类可以讲几个输入流传亮在一起，合并为一个输入流。

  • 合并两个流文件

[java] view plain copy

  1. class SequenceInputStreamStreamDemo1{  

  2.     public static void main(String[] args){  

  3.         FileInputStream in1 = new FileInputStream("src1.txt");  

  4.         FileInputStream in2 = new FileInputStream("src2.txt");  

  5.         SequenceInputStream sis = new SequenceInputStream(in1,in2);  

  6.         FileOutputStream out = new FileOutputStream("dex.txt");  

  7.         int len;  

  8.         byte[] buf = new byte[1024];  

  9.         while((len=sis.read(buf))!=-1){  

  10.             out.write(buf,0,len);  

  11.             out.write("\r\n".getBytes());  

  12.         }  

  13.         sis.close();  

  14.         out.close();  

  15.     }  

  16. }

  

  • 合并多个流文件

[java] view plain copy

  1. class SequenceInputStreamStreamDemo2{  

  2.     public static void main(String[] args){  

  3.         FileInputStream in1 = new FileInputStream("src1.txt");  

  4.         FileInputStream in2 = new FileInputStream("src2.txt");  

  5.         FileInputStream in3 = new FileInputStream("src3.txt");  

  6.         Vector vector = new Vector();  

  7.         vector.addElement(in1);  

  8.         vector.addElement(in2);  

  9.         vector.addElement(in3);  

  10.         Enumeration en = vector.elements();  

  11.         SequenceInputStream sis = new SequenceInputStream(en);  

  12.         FileOutputStream out = new FileOutputStream("dex.txt");  

  13.         int len;  

  14.         byte[] buf = new byte[1024];  

  15.         while((len=sis.read(buf))!=-1){  

  16.             out.write(buf,0,len);  

  17.         }  

  18.         sis.close();  

  19.         out.close();  

  20.     }  

  21. }

  

四、File 类

1、File 类的常用方法

   File 类用于封装一个路径，这个路径可以是从系统盘符开始的绝对路径，也可以是当前目录而言的相对路径。File 类内部封装的路径可以指向一个文件，也可以指向一个目录，在 File 类中提供了针对这些文件或目录的一些常规操作。

   File 类常用的构造方法：

IO（输入输出）

  File 类常用方法：

IO（输入输出）

[java] view plain copy

  1. class FileDemo{  
  2.     public static void main(String[] args){  
  3.         File file = new File("example.txt");  
  4.         System.out.println("文件名称："+file.getName());  
  5.         System.out.println("文件的相对路径："+file.getPath());  
  6.         System.out.println("文件的绝对路径："+file.getAbsolutePath());  
  7.         System.out.println("文件的父路径："+file.getParent());  
  8.         System.out.println(file.canRead()?"文件可读":"文件不可读");  
  9.         System.out.println(file.canWrite()?"文件可写":"文件不可写");  
  10.         System.out.println(file.isFile()?"是一个文件":"不是一个文件");  
  11.         System.out.println(file.isDirectory()?"是一个目录":"不是一个目录");  
  12.         System.out.println(file.isAbsolute()?"是绝对路径":"不是绝对路径");  
  13.         System.out.println("最后修改的时间为："+file.lastModified());  
  14.         System.out.println("文件大小为："+file.length()+"KB");  
  15.         System.out.println("是否成功删除文件"+file.delete());  
  16.     }  
  17. }

  

2、遍历目录下的文件

   File 类中有一个 list() 方法，该方法用于遍历某个指定目录下的所有文件的名称。

[java] view plain copy

  1. class FileDemo{  
  2.     public static void main(String[] args){  
  3.         File file = new File("d:\\java\\bin");  
  4.         if(file.isDirectory()){  
  5.             String[] names = file.list();  
  6.             for(String name:names)  
  7.                 System.out.println(name);  
  8.         }  
  9.     }  
  10. }

  

   有时候程序只需要指定类型的文件，针对这种需求，File 类提供了一个重载的 list(FilenameFilter filter) 方法。FilenameFilter 是一个接口，被称作文件过滤器，其中定义了一个抽象方法 accept(File dir,String name) ，在调用 list() 方法时，需要实现文件过滤器，在 accept() 方法中做出判断，从而获得指定类型的文件。

[java] view plain copy

  1. class FileDemo{  
  2.     public static void main(String[] args){  
  3.         File file = new File("d:\\java\\bin");  
  4.         FilenameFilter filter = new FilenameFileter(){  
  5.             public boolean accept(File dir,String name){  
  6.                 File currFile = new File(dir,name);  
  7.                 if(currFile.isFile() && name.endsWith(".java"))  
  8.                     return true;  
  9.                 else  
  10.                     return false;  
  11.             }  
  12.         };  
  13.         if(file.exists()){  
  14.             String[] lists = file.list(filter);  
  15.             for(String name:lists){  
  16.                 System.out.println(name);  
  17.             }  
  18.         }  
  19.     }  
  20. }

  

   在一个目录下，除了文件，还有子目录，如果想得到所有子目录下的 File 类型对象，需要使用 listFiles() 方法，该方法返回一个 File 对象数组。当对 数组中的元素进行遍历时，如果元素中还有子目录需要遍历，则需要使用递归。  

[java] view plain copy

  1. class FileDemo{  
  2.     public static void main(String[] args){  
  3.         File file = new File("d:\\java\\bin");  
  4.         fileDir(file);  
  5.     }  
  6.     public static void fileDir(File file){  
  7.         File[] files = file.listFiles();  
  8.         for(File file:files){  
  9.             if(file.isDirectory()){  
  10.                 fileDir(file);  
  11.             }  
  12.             System.out.println(file.getAbsolutePath());  
  13.         }  
  14.     }  
  15. }

  

3、删除文件及目录

   在操作文件时，经常需要删除一个目录下的某个我呢间或者删除整个目录，这时可以使用 File 类的 delete() 方法。

[java] view plain copy

  1. class FileDemo{  
  2.     public static void main(String[] args){  
  3.         File file = new File("d:\\java\\bin");  
  4.         if(file.exists())  
  5.             System.out.println(file.delete());  
  6.     }  
  7. }

  

   为什么会输出 false 呢？ 那是因为 File 类的 delete() 方法只是删除一个指定的文件，加入 File 对象嗲表目录，并且目录下包含子目录或文件，则 File 类的 delete() 方法不允许对这个目录直接删除。

   这种情况下，需要通过递归的方式将整个目录以及其中的文件全部删除。

[java] view plain copy

  1. import java.io.*;  
  2. class FileDemo{  
  3.     public static void main(String[] args){  
  4.         File file = new File("f:\\java\\bin");  
  5.         deleteDir(file);  
  6.     }  
  7.     public static void deleteDir(file){  
  8.         if(dir.exists()){  
  9.             File[] files = dir.listFiles();  
  10.             for(File file:files){  
  11.                 if(file.isDirectory()){  
  12.                     deleteDir(file);  
  13.                 }else{  
  14.                     file.delete();  
  15.                 }  
  16.             }  
  17.             dir.delete();  
  18.         }  
  19.     }  
  20. }

  

   需要注意的是，在 Java 中删除目录时从虚拟机直接删除而不走回收站，文件将无法恢复，因此在进行删除操作的时候需要格外小心。

五、RandomAccessFile

   RandomAccessFile 不属于流类，但是具有读写文件数据的功能，可以随机从文件的任何位置开始执行读写数据的操作。

   RandomAccessFile 的构造方法：

IO（输入输出）

  file或name指定关联的文件，mode参数指定访问文件的模式，mode有四个之，最常用的有两个，分别是r和rw，其中r表示以只读的方式打开文件，rw表示以读写的方式打开文件。

  RandomAccessFile类针对文件的随机操作，提供了一系列用于定位文件位置的方法：

IO（输入输出）

[java] view plain copy

  1. class RandomAccessFileDemo{  
  2.     public static void main(String[] args){  
  3.         RandomAccessFile raf = new RandomAccessFile("time.txt","rw");  
  4.         int times = 0;  
  5.         times = Integer.parseInt(raf.readLine());  
  6.         if(times<0){  
  7.             System.out.pritnln("您还可以试用"+ times-- +"次");  
  8.             raf.seek(0);  
  9.             raf.writeBytes(times+"");  
  10.         }else{  
  11.             System.out.println("软件试用已达到次数");  
  12.         }  
  13.         raf.close()；  
  14.     }  
  15. }

  

六、字符编码

1、常用字符集

   字符码表是一种可以方便计算机识别的特殊字符集，它是将每一个字符和一个唯一的数字对应而形成的一张表。

IO（输入输出）

2、字符编码和解码

   在Java中经常会出现字符转换为字节或字节转换为字符的操作，这两种操作设计到两个概念，编码（Encode）和解码（Decode）。一般来说，把字符串转换成计算机识别的自己序列称为编码，而把字节序列转换成普通人能够看懂的字符串称为解码。

  • 字节数组转字符串：String(byte[] bytes,String charsetName)
  • 字符串转字节数组：String类的getBytes(String charsetName)方法

[java] view plain copy

  1. class RandomAccessFileDemo{  

  2.     public static void main(String[] args){  

  3.         //解码  

  4.         String str = "传智播客";  

  5.         byte[] b1 = str.getBytes();  

  6.         byte[] b2 = str.getBytes("GBK");  

  7.         System.out.println(Arrays.toString(b1));  

  8.         System.out.println(Arrays.toString(b2));  

  9.         //编码  

  10.         byte[] b3 = str.getBytes("UTF-8");  

  11.         String result1 = new String(b1,"GBK");  

  12.         System.out.println(result1);  

  13.         String result2 = new String(b2,"GBK");  

  14.         System.out.println(result2);  

  15.         String result3 = new String(b3,"UTF-8");  

  16.         System.out.println(result3);  

  17.         String result4 = new String(b1,"ISO8859-1");  

  18.         System.out.println(result4);  

  19.     }  

  20. }

  

   在上述的例子中尝试使用ISO8859-1码表对GBK编码的数组进行解码，出现了乱码问题，那么乱码问题该如何解决呢？

   为了解决这种乱码问题，可以逆向思维，把乱码字符按照ISO8859-1进行编码，得到与第一次编码相同的字节，然后按照正确的码表GBK对字符进行解码。

IO（输入输出）

[java] view plain copy

  1. class RandomAccessFileDemo{  
  2.     public static void main(String[] args){  
  3.         String str = "传智";  
  4.         byte[] b = str.getBytes("GBK");  
  5.         //通过ISO8859-1解码，得到的字符串时乱码  
  6.         String temp = new String(b,"ISO8859-1");  
  7.         System.out.println(temp);  
  8.         //试用ISO8859-1对乱码进行编码  
  9.         byte[] b1 = temp.getBytes("ISO8859-1");  
  10.         //使用GBK将得到的字节数组解码得到正确的字符串  
  11.         String result = new String(b1,"GBK");  
  12.         System.out.rpitnln(result);  
  13.     }  
  14. }

  

3、字符传输

   通过构造函数InputStreamReader(InputStream in，String charsetName)和OuputStreamWriter(OutputStream out,String charsetName)创建流对象时，可以对需要读写的数据指定编码格式。

[java] view plain copy

  1. class RandomAccessFileDemo{  
  2.     public static void main(String[] args){  
  3.         Reader reader = new InputStreamReader(new InputStream("d:\\1.txt"),"GBK");  
  4.         Writer writer = new OutputStreamWriter(new OutputStream("f:\\2.txt"),"ISO8859-1");  
  5.         char[] chs = new char[100];  
  6.         int len;  
  7.         len = reader.read(chs);  
  8.         String str = new String(chs,0.len);  
  9.         writer.write(str);  
  10.         reader.close();  
  11.         writer.close();  
  12.     }  
  13. }
stringJavaJava
点赞
收藏
评论区
推荐文章
待兔 待兔
•
5个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
1137
0
0
Java架构没有996 Java架构没有996
•
3年前
面试避坑手册之 Java字节流和字符流总结IO流！
从接收输入值说起在日常的开发应用中，有时候需要直接接收外部设备如键盘等的输入值，而对于这种数据的接收方式，我们一般有三种方法：字节流读取，字符流读取，Scanner工具类读取。字节流读取直接看一个例子：cpublicclassDemo01SystemInpublicstaticvoidmain(Stringargs)throw
1781
0
0
Wesley13 Wesley13
•
3年前
java多种文件复制方式以及效率比较
1.背景java复制文件的方式其实有很多种,可以分为传统的字节流读写复制FileInputStream,FileOutputStream,BufferedInputStream,BufferedOutputStream传统的字符流读写复制FileReader,FileWriter,BufferWriter,Buffered
827
0
0
Wesley13 Wesley13
•
3年前
NIO入门
1、I/O输入输出，所有的IO都被视作是单个字节的移动，通过stream对象一次移动一个字节。流IO负责把对象转换为字节，然后再转换为对象。NIO提供了二套NIO，一套是针对标准输入输出NIO，另一套是网络编程NIO2、流与块的比较NIO和IO最大的区别是数据打包和传输方式，IO是以流的方式来处理数据，而NIO是以块的方式处理数据。面向块的IO
807
0
0
Wesley13 Wesley13
•
3年前
Java IO输入输出
学前知道Java的IO使用“流”的概念来表示。IO流涉及到数据源和目的地。流，是从源“流向”目的的数据流。Java将各种数据源和目标之间数据的传输统一抽象为流，通过对流对象的操作来完成I/O功能。输入输出实际都是对内存而言的。数据源可以是键盘、文件、应用程序、鼠标、网络连接。
949
0
0
Wesley13 Wesley13
•
3年前
Java输入输出流
1.什么是IO   Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库java.nio中采用的便是块IO。　　流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。   JavaIO模型 :   Java的IO
768
0
0
Wesley13 Wesley13
•
3年前
Java IO流
IO流框架!IO框架(https://oscimg.oschina.net/oscnet/d6baa9ffd0adc3ecffd9fef90e48936437f.png)IO流概述IO即输入与输出,Java把不同来源和目标的数据抽象为流,在此基础上对流进行数据操作IO流分类按流向分：
692
0
0
Wesley13 Wesley13
•
3年前
Java工作流引擎
1.关键字工作流开发框架权限设计、用户组、岗位、集团模式应用.java工作流程引擎,.net工作流引擎，工作流开发框架1.相关的表结构\相关组织\表结构。SELECTNo,Name,ParentNoFROMport\_dept;  部门。SELECTNo,Name,Adminer,AdminerNam
741
0
0
Wesley13 Wesley13
•
3年前
Java NIO之缓冲区
JavaNIO之Buffer　　Java传统的I/O模型是面向单个字节的，它将输入输出抽象为字节流或字符流。这种单个字节的读取或写入模型的效率比较低，而且不符合操作系统的I/O特点。操作系统的IO是面向字节块的，通常是直接从磁盘中读取一块数据到内存或写入一块数据到磁盘。JavaNIO提供了缓冲区来实现字节块的读写。
717
0
0
Wesley13 Wesley13
•
3年前
Java IO
概述Java中输入、输出的处理通过java.io包下的类和接口来支持，在这个包下主要包括输入、输出两种IO流，每种输入、输出流又可以分为字节流和字符流。字节流以字节为单位来处理输入输出，字符流则以字符为单位。除此之外，Java的IO流使用了一种装饰器设计模式，它将IO流分成底层节点流和上层处理流。节点流用于和底层物理存储节点直接关联，不同
656
0
0
Wesley13
Wesley13
Lv1
最大的安心是自律温柔和爱自己。
文章
1.2w
粉丝
22
获赞
1.7k
热门文章
JavPlayer：AI破坏马赛克，大量马赛克破坏版影片流出
2020年最新可用的磁力搜索引擎&种子搜索网站，持续整理分享
8个在线接收手机短信验证码的免费网络服务整理
IDM 激活破解工具
java.net.ConnectException：Connection timed out：connect 出现连接超时的问题？