IO总结

举报
AI浩 发表于 2022/04/13 20:04:51 2022/04/13
【摘要】 一、概念:IO流用来处理设备之间的数据传输   Java对数据的操作是通过流的方式   Java用于操作流的对象都在IO包中   流按操作数据分为两种:字节流与字符流。   流按流向分为:输入流,输出流。二、IO流常用基类字节流的抽象基类:• InputStream , OutputStream。字符流的抽象基类:• Reader , Writer。注:由这四个类派生出来的子类名称都是以其父...

一、概念:IO流用来处理设备之间的数据传输
   Java对数据的操作是通过流的方式
   Java用于操作流的对象都在IO包中
   流按操作数据分为两种:字节流与字符流。
   流按流向分为:输入流,输出流。

二、IO流常用基类

  • 字节流的抽象基类:

• InputStream , OutputStream。

  • 字符流的抽象基类:

• Reader , Writer。

注:由这四个类派生出来的子类名称都是

以其父类名作为子类名的后缀。

• 如: InputStream的子类FileInputStream。

• 如: Reader的子类FileReader

三、字符流——创建文件

创建流对象,建立数据存放文件

• FileWriter fw = new FileWriter(“Test.txt”);

 调用流对象的写入方法,将数据写入流

• fw.write(“text”);

 关闭流资源,并将流中的数据清空到文件中。

• fw.close();

1、写文件

例:package aaa;

import java.io.FileWriter;

import java.io.IOException;

public class FileWriterDemo {

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

                  //创建一个可以往文件中写入字符数据的字符输出流对象。

                  /*

                   * 既然是往一个文件中写入文字数据,那么在创建对象时,就必须明确该文件(用于存储数据的目的地)。

                   * 如果文件不存在,则会自动创建。

                   * 如果文件存在,则会被覆盖。

                   * 如果构造函数中加入true,可以实现对文件进行续写!

                   */

                  FileWriter fWriter = new FileWriter("D:demo.txt",true);

                  /*

                   * 调用Writer对象中的write(string)方法,写入数据。

                   * 其实数据写入到临时存储缓冲区中。

                   */

                  fWriter.write("adfsadfsafa");

                  fWriter.flush();//进行刷新,将数据直接写到目的地中。

                  fWriter.write("dtrdtrd");//关闭流,关闭资源。在关闭前会先调用flush刷新缓冲中的数据到目的地。

                  fWriter.close();

         }

}

完整的写法:

private static final String LINE_SEPARATOR = System.getProperty("line.separator");//换行

public static void main(String[] args) {

                  FileWriter fw = null;

                  try {

                          fw = new FileWriter("k:\\demo.txt");

                          fw.write("abcde" + LINE_SEPARATOR + "hahaha");

                  } catch (IOException e) {

                          System.out.println(e.toString());

                  } finally {

                          if (fw != null)

                                   try {

                                            fw.close();

                                   } catch (IOException e) {

                                            // code....

                                            throw new RuntimeException("关闭失败");

                                   }

                  }

         }

四、字符流——读取文件

  • 建立一个流对象,将已存在的一个文件加载进

流。

• FileReader fr = new FileReader(“Test.txt”);

  • 创建一个临时存放数据的数组。

• char[] ch = new char[1024];

  • 调用流对象的读取方法将流中的数据读入到数组

中。

• fr.read(ch);

2、读文件:需求:读取一个文本文件。将读取到的字符打印到控制台.

//第一种写法

package cn.itcast.p3.io.filereader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

public class FileReaderDemo {

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

                  //1,创建读取字符数据的流对象。

                  /*

                   * 在创建读取流对象时,必须要明确被读取的文件。一定要确定该文件是存在的。

                   * 用一个读取流关联一个已存在文件。

                   */

                  FileReader fr = new FileReader("demo.txt");

                  int ch = 0;

                  while((ch=fr.read())!=-1){

                          System.out.println((char)ch);


这两种写法的区别:第一种一次只能读取一个字符,第二种写法一次能读取多个字符,减少循环。所以第二种写法更有优势。

                  }


                  fr.close();

         }

}

//第二种写法:

package cn.itcast.p3.io.filereader;

import java.io.FileReader;

import java.io.IOException;

public class FileReaderDemo2 {

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

                  FileReader fr = new FileReader("demo.txt");

                  /*

                   * 使用read(char[])读取文本文件数据。

                   * 先创建字符数组。

                   */

                  char[] buf = new char[1024];

                  int len = 0;

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

                          System.out.println(new String(buf,0,len));

                  }

                  fr.close();

         }

}

完整代码

public class FileWriterDemo {

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

                  FileReader fr = null;

                  try {

                          fr = new FileReader("c:\\test.txt");

                          char[] buf = new char[1024];

                          int len = 0;

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

                                   System.out.println(new String(buf, 0, len));

                          }

                  } catch (IOException e) {

                          System.out.println("read-Exception :" + e.toString());

                  } finally {

                          if (fr != null) {

                                   try {

                                            fr.close();

                                   } catch (IOException e) {

                                            System.out.println("close-Exception :" + e.toString());

                                   }

                          }

                  }

         }

}

注意:

  • 定义文件路径时,可以用“/”或者“\\”。
  • 在创建一个文件时,如果目录下有同名文

件将被覆盖。

  • 在读取文件时,必须保证该文件已存在,

否则出异常。

练习:将D的文件复制到E盘

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;


//练习:将D的文件复制到E盘

//第一种  一个一个的读

public class CopyText {


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

                  // TODO Auto-generated method stub

                  FileReader fr = new FileReader("D:\\1.txt");

                  FileWriter fw = new FileWriter("e:\\2.txt");

                  int ch = 0;

                  while ((ch = fr.read()) != -1) {

                          fw.write(ch);

                  }

                  fr.close();

                  fw.close();

         }

}


import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

//第二种 一次读多个放到数组里面

//练习:将D的文件复制到E盘

public class CopyText {

         private static final int BUFFER_SIZE = 1024;


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

                  FileReader fr = null;

                  FileWriter fw = null;

                  try {

                          fr = new FileReader("D:\\1.txt");

                          fw = new FileWriter("e:\\2.doc");

                          char[] buf=new char[BUFFER_SIZE];//缓冲区 创建一个临时容器,用于缓存读取到的字符

                          int len=0;

                          while((len=fr.read(buf))!=-1){fw.write(buf, 0, len);}

                  } catch (Exception e) {

           throw new RuntimeException("读写失败");

                  } finally {

                          if (fw != null) {

                                   try {

                                            fw.close();

                                   } catch (IOException e) {

                                            e.printStackTrace();

                                   }

                          }

                          if (fr != null) {

                                   try {

                                            fr.close();

                                   } catch (IOException e) {

                                            e.printStackTrace();

                                   }

                          }

                  }

         }

}

五、字符流的缓冲区

缓冲区的出现提高了对数据的读写效率

对应类: BufferWriter  BufferReader

缓冲区要结合流才可以使用,是在流的就出上对流的功能进行了增强。

1、BufferReader举例:

import java.io.FileReader;

import java.io.BufferedReader;

import java.io.IOException;

public class CopyText {

        

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

         FileReader fr=new FileReader("D:\\1.txt");

         BufferedReader bufr=new BufferedReader(fr);

         String line=null;

         while((line=bufr.readLine())!=null)

                  System.out.println(line);

         bufr.close();

         }

}

2、BufferedWriter写入举例:

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

public class BufferedWriterDemo {

         private static final String LINE_SEPARATOR = System

                          .getProperty("line.separator");

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

                  // TODO Auto-generated method stub

                  FileWriter fw = new FileWriter("buf.txt");

                  //为了提高写入效率,使用字符流的缓冲区,创建了一个字符写入流的缓冲区对象,并额指定要缓冲的流对象相关联

                  BufferedWriter bufw = new BufferedWriter(fw);

                  for (int i = 0; i < 4; i++) {

                          bufw.write("asdfghjk" + i);

                          bufw.newLine();

                          bufw.flush();

                  }

                  bufw.close();

         }

}

练习:利用BufferedReader和BufferedWriter复制文件

import java.io.*;

public class CopyTextByBufTest {

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

                  // TODO Auto-generated method stub

                  FileReader fr = new FileReader("buf.txt");

                  BufferedReader bufr = new BufferedReader(fr);

                  FileWriter fw = new FileWriter("buf_Copy.txt");

                  BufferedWriter bufw = new BufferedWriter(fw);

                  String line = null;

                  while ((line = bufr.readLine()) != null) {

                          bufw.write(line);

                          bufw.newLine();

                          bufw.flush();

                  }

                  bufw.close();

                  bufr.close();

         }

}

六、装饰者模式

  • 对原有类进行了功能的改变,增强。

例:

public class PersonDemo {

         public static void main(String[] args) {

                  Person p = new Person();

                  p.chiFan();

                  NewPerson p1 = new NewPerson(p);

                  p1.chiFan();

         }

}

class Person {

         void chiFan() {

                  System.out.println("吃饭");

         }

}

// 这个类的出现是为了增强Person而出现的。

class NewPerson {

         private Person p;

         NewPerson(Person p) {

                  this.p = p;

         }

         public void chiFan() {

                  System.out.println("开胃酒");

                  p.chiFan();

                  System.out.println("甜点");

         }

}

利用LineNumberReader装饰类设置行号。

import java.io.*;

public class LineNumberReaderDemo {

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

                  // TODO Auto-generated method stub

                  FileReader fr = new FileReader("buf.txt");

                  LineNumberReader lnr = new LineNumberReader(fr);

                  String line = null;

                  lnr.setLineNumber(100);

                  while ((line = lnr.readLine()) != null) {

                          System.out.println(lnr.getLineNumber() + ":" + line);

                  }

                  lnr.close();

         }

}

七、字节流

  1. 基本操作与字符流相同,但是它不仅可以操作字符,还可以操作其他媒体文件
  2. FileInputStream 读取流 ,FileOutputStream 输出流。

1、读取流举例:

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.FileNotFoundException;

public class ByteStreamDemo {

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

                  // TODO Auto-generated method stub

                  demo_read();

         }

         static void demo_read() throws IOException {

                  FileInputStream fis = new FileInputStream("IO.txt");

                  System.out.println(fis.available());

                  //第一种读取方式

                  byte[] buf = new byte[fis.available()];

                  fis.read(buf);

                  System.out.println(new String(buf));

                  //第二种读取方式,建议使用这种

                  byte[] buf1=new byte[1024];

                  int len=0;

                  while((len=fis.read(buf1))!=-1)

                  {

                          System.out.print(new String(buf1,0,len));

                  }

                  //第三种,一个字节的读

         /*     int ch=0;

                  while((ch=fis.read())!=-1)

                  {

                          System.out.print((char)ch);

                  }*/

                  fis.close();

         }

}

2、FileOutputStream 输出流举例

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.FileNotFoundException;

public class ByteStreamDemo {

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

                  // TODO Auto-generated method stub

                  //demo_read();

                  demo_write();

         }

public static void demo_write() throws IOException {  

                  //1,创建字节输出流对象。用于操作文件.如果没有就创建新的文件

                  FileOutputStream fos = new FileOutputStream("bytedemo.txt");

                  //2,写数据。直接写入到了目的地中。

                  fos.write("abcdefg".getBytes());    

                  fos.close();//关闭资源动作要完成。

         }

}

八、字节流的缓冲区

同样是提高了字节流的读写效率。

BufferedInputStream和BufferedOutputStream

几种读取文件的效率举例:

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class CopyMp3Test {

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

                  copy_4();

         }

//     千万不要用,效率没有!

         public static void copy_4() throws IOException {

                  FileInputStream fis = new FileInputStream("c:\\0.mp3");             

                  FileOutputStream fos = new FileOutputStream("c:\\4.mp3");

                  int ch = 0;

                  while((ch =fis.read())!=-1){

                          fos.write(ch);

                  }

                  fos.close();

                  fis.close();

         }

         //不建议。

         public static void copy_3() throws IOException {

                  FileInputStream fis = new FileInputStream("c:\\0.mp3");             

                  FileOutputStream fos = new FileOutputStream("c:\\3.mp3");

                  byte[] buf = new byte[fis.available()];

                  fis.read(buf);

                  fos.write(buf);

                  fos.close();

                  fis.close();

         }

         public static void copy_2() throws IOException {

                  FileInputStream fis = new FileInputStream("c:\\0.mp3");    

                  BufferedInputStream bufis = new BufferedInputStream(fis);

                  FileOutputStream fos = new FileOutputStream("c:\\2.mp3");

                  BufferedOutputStream bufos = new BufferedOutputStream(fos);

                  int ch = 0;

                  while((ch=bufis.read())!=-1){

                          bufos.write(ch);

                  }

                  bufos.close();

                  bufis.close();

         }

         public static void copy_1() throws IOException {

                  FileInputStream fis = new FileInputStream("c:\\0.mp3");             

                  FileOutputStream fos = new FileOutputStream("c:\\1.mp3");

                  byte[] buf = new byte[1024];

                  int len = 0;

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

                          fos.write(buf,0,len);

                  }

                  fos.close();

                  fis.close();

         }

}

九、转换流

  1. InputStreamReader :字节到字符的桥梁。解码。
  2. OutputStreamWriter:字符到字节的桥梁。编码。
  3. 转换流的由来:1、字符流与字节流之间的桥梁。2、方便了字符流与字节流之间的操作
  4. 转换流的应用:字节流中的数据都是字符时,转成字符流操作更高效。

例:获取键盘输入的字符

import java.io.IOException;

import java.io.InputStream;

public class ReadKey {

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

                  // TODO Auto-generated method stub

                  StringBuilder sb = new StringBuilder();

                  InputStream in = System.in;

                  int ch = 0;

                  //read()方法是阻塞式方法

                  while ((ch = in.read()) != -1) {

                          if (ch == '\r')

                                   continue;

                          if (ch == '\n') {

                                   String temp = sb.toString();

                                   if ("over".equals(temp))

                                            break;

                                   System.out.println(temp.toUpperCase());

                                   sb.delete(0, sb.length());

                          } else {

                                   sb.append((char) ch);

                          }

                  }

         }

}

例2:利用转换流实现读取键盘的操作,一次读取一行。

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

public class TransStreamDemo {

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

                  InputStream in = System.in;//字节流

                  InputStreamReader isr = new InputStreamReader(in);//将字节转成字符的桥梁。转换流。

                  BufferedReader bufr = new BufferedReader(isr);//字符流

                  OutputStream out = System.out;

                  OutputStreamWriter osw = new OutputStreamWriter(out);

                  BufferedWriter bufw = new BufferedWriter(osw);

                  String line = null;

                  while ((line = bufr.readLine()) != null) {

                          if ("over".equals(line))

                                   break;

                          bufw.write(line.toUpperCase());

                          bufw.newLine();

                          bufw.flush();

                  }

         }

}

例2的简化版:

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

public class TransStreamDemo2 {

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

                  // TODO Auto-generated method stub

                  BufferedReader bufr = new BufferedReader(new InputStreamReader(

                                   System.in));

                  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(

                                   System.out));

                  String line = null;

                  while ((line = bufr.readLine()) != null) {

                          if ("over".equals(line))

                                   break;

                          bufw.write(line.toUpperCase());

                          bufw.newLine();

                          bufw.flush();

                  }

         }

}

例3:将输入的字符,存到文件里。

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

public class TransStreamDemo2 {

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

                  // TODO Auto-generated method stub

                  BufferedReader bufr = new BufferedReader(new InputStreamReader(

                                   System.in));

                  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("buf.txt")));

                  String line = null;

                  while ((line = bufr.readLine()) != null) {

                          if ("over".equals(line))

                                   break;

                          bufw.write(line.toUpperCase());

                          bufw.newLine();

                          bufw.flush();

                  }

                  bufw.close();

         }

}

例3:将文件中的字符读取到控制台

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

public class TransStreamDemo2 {

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

                  // TODO Auto-generated method stub

                  BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("buf.txt")));

                  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

                  String line = null;

                  while ((line = bufr.readLine()) != null) {

                          if ("over".equals(line))

                                   break;

                          bufw.write(line.toUpperCase());

                          bufw.newLine();

                          bufw.flush();

                  }

                  bufw.close();

         }

}

例4:将一个文件中的内容复制到另一个文件中

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

public class TransStreamDemo2 {

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

                  // TODO Auto-generated method stub

                  BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("buf.txt")));

                  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("buf_Copy.txt")));

                  String line = null;

                  while ((line = bufr.readLine()) != null) {

                          if ("over".equals(line))

                                   break;

                          bufw.write(line.toUpperCase());

                          bufw.newLine();

                          bufw.flush();

                  }

                  bufw.close();

         }

}

九、字符编码

  1. 字符流的出现为了方便操作字符。
  2. 更重要是的加入了编码转换。
  3. 通过子类转换流来完成。

• InputStreamReader

• OutputStreamWriter

  1. 在两个对象进行构造的时候可以加入字符

集。

常见的编码表:

1、ASCII:美国标准信息交换码。 用一个字节的7位可以表示。

2、ISO8859-1:拉丁码表,欧洲码表。用一个字节的8位表示。

3、GB2312:中国的中文编码表。

4、GBK:中国的中文编码表升级,融合了更多的中文文字符

号。

5、Unicode:国际标准码,融合了多种文字。 所有文字都用两个字节来表示,Java语言使用的就是unicode

7、UTF-8:最多用三个字节来表示一个字符。

  1. 转换流的编码应用:

1、可以将字符以指定编码格式存储。

2、可以对文本数据指定编码格式来解读。

3、指定编码表的动作由构造函数完成。

  1. 字符编码: 编码:字符串→字节数组  解码:字节数组→字符串

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

public class TransStreamDemo3 {

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

                  // TODO Auto-generated method stub

                  write_1();

                  writeText_2();

                  writeText_3();// UTF-8编码写入

                  readText_1();

                  readText_2();//用UTF-8编码读取GBK编码的文件

         }

         public static void readText_2() throws IOException {

                  InputStreamReader isr = new InputStreamReader(new FileInputStream(

                                   "gbk_1.txt"), "utf-8");

                  char[] buf = new char[10];

                  int len = isr.read(buf);

                  String str = new String(buf, 0, len);

                  System.out.println(str);

                  isr.close();

         }

         public static void readText_1() throws IOException {

                  FileReader fr = new FileReader("gbk_1.txt");

                  char[] buf = new char[10];

                  int len = fr.read(buf);

                  String str = new String(buf, 0, len);

                  System.out.println(str);

                  fr.close();

         }

         public static void writeText_3() throws IOException {

                  OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("u8_1.txt"), "UTF-8");

                  osw.write("你好");

                  osw.close();

         }

         public static void writeText_2() throws IOException {

                  OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(

                                   "gbk_3.txt"), "GBK");

                  // 等同于FileWriter fw=new FileWriter("gbk_3.txt"); 系统默认是 GBK

                  /*

                   * 这两句代码的功能是等同的。 FileWriter:其实就是转换流指定了本机默认码表的体现。而且这个转换流的子类对象,可以方便操作文本文件。

                   * 简单说:操作文件的字节流+本机默认的编码表。 这是按照默认码表来操作文件的便捷类。

                   *

                   * 如果操作文本文件需要明确具体的编码。FileWriter就不行了。必须用转换流。

                   */

                  osw.write("你好");

                  osw.close();

         }

         public static void write_1() throws IOException {

                  FileWriter fw = new FileWriter("gbk_1.txt");

                  fw.write("你好");

                  fw.close();

         }


}

十、File

1、用来将文件或者文件夹封装成对象

2、方便对文件与文件夹的属性信息进行操作。

3、File对象可以作为参数传递给流的构造函数。

4、了解File类中的常用方法。

例:初始化File类的几种方式

import java.io.File;

public class FileDemo {

         public static void main(String[] args) {

                  // TODO Auto-generated method stub

                  constructorDemo();

         }

         public static void constructorDemo()

         {

                  File f1=new File("D:\\1.txt");

                  System.out.println(f1.exists());

                  File f2=new File("D:\\","1.txt");

                  System.out.println(f2.exists());

                  File f3=new File("D:\\");

                  File f4=new File(f3,"a.txt");

                  System.out.println(f4.exists());

                  File f5=new File("D:"+File.separator+"1.txt");

                  System.out.println(f5);

         }

}

File类常用的方法举例:

import java.io.File;

import java.io.IOException;

import java.text.DateFormat;

import java.util.Date;


public class FileMethodDemo {


         public static void main(String[] args) {

                  /*

                   * File对象的常见方法。

                   *

                   * 1,获取。 1.1 获取文件名称。 1.2 获取文件路径。 1.3 获取文件大小。 1.4 获取文件修改时间。

                   *

                   * 2,创建与删除。

                   *

                   * 3,判断。

                   *

                   * 4, 重命名

                   */

                  getDemo();

                  // createAndDeleteDemo();

                  // isDemo();

                  // renameToDemo();

                  // listRootsDemo();

         }


输出结果:

parent:null

name:C:\Users\WH\Workspaces\MyEclipse Professional 2014\Test\IO.txt

path:IO.txt

len:8543

time:1470094643508

str_time:201682 上午073723

         private static void getDemo() {


                  // TODO Auto-generated method stub

                  File file = new File("IO.txt");

                  String name = file.getName();

                  String absPath = file.getAbsolutePath();// 绝对路径

                  String path = file.getPath();

                  long len = file.length();

                  long time = file.lastModified();// 最后修改时间

                  Date date = new Date(time);

                  DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG,

                                   DateFormat.LONG);

                  String str_time = dateFormat.format(date);

                  System.out.println("parent:" + file.getParent());

                  System.out.println("name:" + absPath);

                  System.out.println("path:" + path);

                  System.out.println("len:" + len);

                  System.out.println("time:" + time);

                  System.out.println("str_time:" + str_time);

         }

}

private static void createAndDeleteDemo() {

       //创建单级文件夹


输出结果:

false

true

true

       File dir = new File("D:\\abc");


       boolean b = dir.mkdir();

       System.out.println(b);

       System.out.println(dir.delete());

       //创建多级文件夹

       File dir1=new File("D:\\sds\\ds\\adsa\\sa\\as\\a");

       dir1.mkdirs();

        System.out.println(dir1.delete());//虽然输出结果True,但只能删除最底层的文件夹

}

public static void isDemo() throws IOException{

         File f = new File("aaa");


输出结果:

b=true

true

false

         f.createNewFile();


boolean b = f.exists();             

     System.out.println("b="+b);

         // 最好先判断是否存在。

         System.out.println(f.isFile());

         System.out.println(f.isDirectory());


输出结果:getFreeSpace:419413291008

getTotalSpace:429492695040

getUsableSpace:419413291008

C:\

D:\

E:\

H:\

}


public static void listRootsDemo() {

         File file = new File("d:\\");               

         System.out.println("getFreeSpace:"+file.getFreeSpace());

         System.out.println("getTotalSpace:"+file.getTotalSpace());

System.out.println("getUsableSpace:"+file.getUsableSpace());   

         File[] files  = File.listRoots();         

         for(File file1 : files){

                  System.out.println(file1);

         }

}

public static void renameToDemo() {

         File f1 = new File("c:\\9.mp3");

         File f2 = new File("d:\\aa.mp3");

         boolean b = f1.renameTo(f2);//将f1的文件重命名为f2的文件名

         System.out.println("b="+b);

}

FileFilter应用举例:

import java.io.File;

import java.io.FileFilter;

public class FilterByHidden implements FileFilter {

public boolean accept(File pathname) {

          return !pathname.isHidden();

}

}

import java.io.File;

import java.io.FilenameFilter;

public class FilterByJava implements FilenameFilter {

@Override

public boolean accept(File dir, String name) {

          System.out.println(dir+"---"+name);

          return name.endsWith(".txt");

}

}

import java.io.File;

import java.io.FilenameFilter;

public class SuffixFilter implements FilenameFilter{

private String suffix ;

public SuffixFilter(String suffix) {

          super();

          this.suffix = suffix;

}

@Override

public boolean accept(File dir, String name) {

          return name.endsWith(suffix);

}

}

import java.io.File;

public class FistListDemo {

public static void main(String[] args) {

          // TODO Auto-generated method stub

          listDemo();

          listDemo_2();

          listDemo_3();

          listDemo_4();

}

/**

 * 查找C下不是隐藏的文件

 */

public static void listDemo_3() {

          File dir = new File("c:\\");

          File[] files = dir.listFiles(new FilterByHidden());

          for(File file : files){

                   System.out.println(file);

          }

}

/**

 * 查找D盘下所有的文件和文件夹

 */

public static void listDemo() {

          /*

           * 获取当前目录下的文件以及文件夹的名称,包含隐藏文件。 调用list方法的File对象中封装的必须是目录。

           * 否则会发生NullPointerException 如果访问的系统级目录也会发生空指针异常。

           * 如果目录存在但是没有内容,会返回一个数组,但是长度为0.

           */

          File file = new File("D:\\");

          String[] names = file.list();

          System.out.println(names.length);

          for (String name : names) {

                   System.out.println(name);

          }

}

/**

 * 筛选出后缀为.txt的文件

 */

public static void listDemo_2() {

          File dir = new File("D:\\");

          String[] names = dir.list(new SuffixFilter(".txt"));

          for (String name : names) {

                   System.out.println(name);

          }

}


/**

 * FileFilter 过滤文件:先遍历,找符合条件的再放到数组中输出出来

 */

public static void listDemo_4() {

          File dir = new File("D:\\");

          String[] names = dir.list(new FilterByJava());

          for (String name : names) {

                   System.out.println(name);

          }

}

}

十一、递归:函数自己调用自己。

 注意:递归时一定要明确结束条件。

应用场景: 当某一功能要重复使用时。

注意:

               * 1,递归一定明确条件。否则容易栈溢出。

               * 2,注意一下递归的次数。

例:读取文件夹下的所有文件

import java.io.File;

public class FileTest {

      public static void main(String[] args) {

              // TODO Auto-generated method stub

              File dir = new File("D:");

              listAll(dir, 0);

      }

      public static void listAll(File dir, int level) {

              System.out.println(getSpace(level) + dir.getName());

              // 获取指定目录下当前的所有文件夹或者文件对象。

              level++;

              File[] files = dir.listFiles();

              for (int x = 0; x < files.length; x++) {

                       if (files[x].isDirectory()) {

                                listAll(files[x], level);

                       } else

                                System.out.println(getSpace(level) + files[x].getName());

              }

      }

      private static String getSpace(int level) {

              StringBuilder sb = new StringBuilder();

              sb.append("|--");

              for (int x = 0; x < level; x++) {

                       sb.insert(0, "|  ");

              }

              return sb.toString();

      }

}

例:递归删除文件夹下所有的文件和文件夹

import java.io.File;

public class RemoveDirTest {

      public static void main(String[] args) {

              // TODO Auto-generated method stub

              File dir = new File("D:\\脚本复制\\ewwe");

              dir.delete();

              removeDir(dir);

      }

      public static void removeDir(File dir) {

              File[] files = dir.listFiles();

              for (File file : files) {

                       if (file.isDirectory()) {

                                removeDir(file);

                       } else {

                                System.out.println(file + ":" + file.delete());

                       }

              }

              System.out.println(dir+":"+dir.delete());

      }

}

例:递归举例,计算数的和

public class DiGuiDemo {

      /**

       * @param args

       */

      public static void main(String[] args) {

              /*

               * 递归:

               * 函数自身直接或者间接的调用到了自身。

               * 一个功能在被重复使用,并每次使用时,参与运算的结果和上一次调用有关。

               * 这时可以用递归来解决问题。  

               * 注意:

                * 1,递归一定明确条件。否则容易栈溢出。

               * 2,注意一下递归的次数。

               */

              int sum = getSum(9000);

              System.out.println(sum);

      }

      public static int getSum(int num){

              int x = 9;

              if(num==1)

                       return 1;

              return num+getSum(num-1);

      }

}

十二、Properties集合

     特点:

               1,该集合中的键和值都是字符串类型。

               2,集合中的数据可以保存到流中,或者从流获取。

               通常该集合用于操作以键值对形式存在的配置文件。

例:

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintStream;

import java.util.Properties;

import java.util.Set;

/*

 * Map

 *         |--Hashtable

 *                  |--Properties:

 * Properties集合:

 * 特点:

 * 1,该集合中的键和值都是字符串类型。

 * 2,集合中的数据可以保存到流中,或者从流获取。

 *

 * 通常该集合用于操作以键值对形式存在的配置文件。

*/

public class PropertiesDemo {

      /**

       * @param args

       * @throws IOException

       */

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

          PropertiesUpDateAndAdd();

              methodDemo_2();

              methodDemo_3();

              methodDemo_4();

              PropertiesReadAndUpdate();

      }

      /**

       * 对已有的配置文件中的信息进行修改。 思路:读取这个文件。 并将这个文件中的键值数据存储到集合中。 在通过集合对数据进行修改。

       * 在通过流将修改后的数据存储到文件中。

       * @throws IOException

       */

      public static void PropertiesReadAndUpdate() throws IOException {

              File file = new File("info.txt");

              if (!file.exists()) {

                       file.createNewFile();

              }

              FileReader fr = new FileReader(file);

              // 创建集合存储配置信息

              Properties prop = new Properties();

              // 将流中信息存储到集合中。

              prop.load(fr);

              prop.setProperty("wangwu", "16");

              FileWriter fw = new FileWriter(file);

              prop.store(fw, "");

              prop.list(System.out);

              fw.close();

              fr.close();

      }

      /**

       * 读取保存到本地的Properties文件

       * @throws IOException

       */

      public static void methodDemo_4() throws IOException {

              Properties prop = new Properties();

              // 集合中的数据来自于一个文件。

              // 注意;必须要保证该文件中的数据是键值对。需要使用到读取流。

              FileInputStream fis = new FileInputStream("info.txt");

              // load方法

              prop.load(fis);

              prop.list(System.out);

      }

      /**

       * 集合中的字符串键值信息持久化存储到文件中

       * @throws IOException

       */

      public static void methodDemo_3() throws IOException {

              Properties prop = new Properties();

              // 存储元素。

              prop.setProperty("zhangsan", "30");

              prop.setProperty("lisi", "31");

              prop.setProperty("wangwu", "36");

              prop.setProperty("zhaoliu", "20");

      // 想要将这些集合中的字符串键值信息持久化存储到文件中。需要关联输出流。

              FileOutputStream fos = new FileOutputStream("info.txt");

              prop.store(fos, "info");

              fos.close();

      }

      /**

       * 演示Properties集合和流对象相结合的功能。

       */

      public static void methodDemo_2() {

              Properties prop = System.getProperties();

              prop.list(System.out);

      }

      /**

       * Properties集合的修改和增加

       */

      public static void PropertiesUpDateAndAdd() {

              Properties prop = new Properties();

              // 存储元素

              prop.setProperty("张三", "30");

              prop.setProperty("lisi", "31");

              prop.setProperty("wangwu", "36");

              prop.setProperty("zhaoliu", "20");

              // 修改元素

              prop.setProperty("wangwu", "26");

              Set<String> names = prop.stringPropertyNames();

              for (String name : names) {

                       String value = prop.getProperty(name);

                       System.out.println(name + ":" + value);

              }

      }

}

练习:定义功能,获取一个应用程序运行的次数,如果超过5次,给出使用次数已到请注册的提示。并不要在运行程序。

思路:

 1,应该有计数器。

 每次程序启动都需要计数一次,并且是在原有的次数上进行计数。

  2,计数器就是一个变量。 突然冒出一想法,程序启动时候进行计数,计数器必须存在于内存并进行运算。

  可是程序一结束,计数器消失了。那么再次启动该程序,计数器又重新被初始化了。

  而我们需要多次启动同一个应用程序,使用的是同一个计数器。

  这就需要计数器的生命周期变长,从内存存储到硬盘文件中。

  3,如何使用这个计数器呢?

   首先,程序启动时,应该先读取这个用于记录计数器信息的配置文件。

  获取上一次计数器次数。 并进行试用次数的判断。

  其次,对该次数进行自增,并自增后的次数重新存储到配置文件中。

  4,文件中的信息该如何进行存储并体现。

   直接存储次数值可以,但是不明确该数据的含义。 所以起名字就变得很重要。

    这就有了名字和值的对应,所以可以使用键值对。

   可是映射关系map集合搞定,又需要读取硬盘上的数据,所以map+io = Properties.

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Properties;

public class PropertiesTest {

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

              getAppCount();

      }

      /**

       * @throws IOException

       */

      public static void getAppCount() throws IOException {

              File conFile = new File("count.properties");

              if (!conFile.exists()) {

                       conFile.createNewFile();

              }

              FileInputStream fis = new FileInputStream(conFile);

              Properties prop = new Properties();

              prop.load(fis);

              String value = prop.getProperty("time");

              int count = 0;

              if (value != null) {

                       count = Integer.parseInt(value);

                       if (count >= 5) {

                                throw new RuntimeException("使用次数已到,请注册,给钱!");

                       }

              }

              count++;

              //将改变后的次数重新存储到集合中

              prop.setProperty("time", count+"");

              FileOutputStream fos=new FileOutputStream(conFile);

              prop.store(fos, "count");

              fos.close();

              fis.close();

      }

}

练习: 获取指定目录下,指定扩展名的文件(包含子目录中的)

这些文件的绝对路径写入到一个文本文件中。简单说,就是建立一个指定扩展名的文件的列表。  思路:

 1,必须进行深度遍历。

 2,要在遍历的过程中进行过滤。将符合条件的内容都存储到容器中。

 3,对容器中的内容进行遍历并将绝对路径写入到文件中。

 package Test23;


import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.FilenameFilter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

public class Test {

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

              // TODO Auto-generated method stub

              File dir = new File("C:\\Users\\WH\\Workspaces\\MyEclipse Professional 2014\\Test");

              FilenameFilter filter = new FilenameFilter() {

                       @Override

                       public boolean accept(File dir, String name) {

                                return name.endsWith(".java");

                       }

              };

              List<File> list = new ArrayList<File>();

              getFiles(dir, filter, list);

              File destFile = new File(dir, "javalist.txt");

              write2File(list, destFile);

      }

      /**

       * 对指定目录中的内容进行深度遍历,并按照指定过滤器,进行过滤, 将过滤后的内容存储到指定容器List中。

       * @param dir

       * @param filter

       * @param list

       */

      public static void getFiles(File dir, FilenameFilter filter, List<File> list) {

              File[] files = dir.listFiles();

              for (File file : files) {

                       if (file.isDirectory()) {

                                // 递归啦!

                                getFiles(file, filter, list);

                       } else {

                                // 对遍历到的文件进行过滤器的过滤。将符合条件File对象,存储到List集合中。

                                if (filter.accept(dir, file.getName())) {

                                         list.add(file);

                                }

                       }

              }

      }

      public static void write2File(List<File> list, File destFile)

                       throws IOException {

              BufferedWriter bufw = null;

              try {

                       bufw = new BufferedWriter(new FileWriter(destFile));

                       for (File file : list) {

                                bufw.write(file.getAbsolutePath());

                                bufw.newLine();

                                bufw.flush();

                       }

              }

              finally {

                       if (bufw != null)

                                try {

                                         bufw.close();

                                } catch (IOException e) {

                                         throw new RuntimeException("关闭失败");

                                }

              }

      }

}

总结:流的操作规律:

之所以要弄清楚这个规律,是因为流对象太多,开发时不知道用哪个对象合适。

想要知道开发时用到哪些对象。只要通过四个明确即可。

1,明确源和目的(汇)

         源:InputStream  Reader

         目的:OutputStream  Writer

2,明确数据是否是纯文本数据。

         源:是纯文本:Reader

                  否:InputStream

         目的:是纯文本 Writer

                  否:OutputStream

         到这里,就可以明确需求中具体要使用哪个体系。

3,明确具体的设备。

         源设备:

                  硬盘:File

                  键盘:System.in

                  内存:数组

                  网络:Socket流

         目的设备:

                  硬盘:File

                  控制台:System.out

                  内存:数组

                  网络:Socket流

4,是否需要其他额外功能。

         1,是否需要高效(缓冲区);

                  是,就加上buffer.

         2,转换。

         需求1:复制一个文本文件。

         1,明确源和目的。

                  源:InputStream Reader

                  目的:OutputStream  Writer

         2,是否是纯文本?

                  是!

                  源:Reader

                  目的:Writer

         3,明确具体设备。

                  源:

                          硬盘:File

                  目的:

                          硬盘:File

                  FileReader fr = new FileReader("a.txt");

                  FileWriter fw = new FileWriter("b.txt");

         4,需要额外功能吗?

                  需要,需要高效。

                  BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));

                  BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));

================================================

需求2:读取键盘录入信息,并写入到一个文件中。

         1,明确源和目的。

                  源:InputStream Reader

                  目的:OutputStream  Writer

         2,是否是纯文本呢?

                  是,

                  源:Reader

                  目的:Writer

         3,明确设备

                  源:

                          键盘。System.in

                  目的:

                          硬盘。File

                  InputStream in = System.in;

                  FileWriter fw = new FileWriter("b.txt");

                  这样做可以完成,但是麻烦。将读取的字节数据转成字符串。再由字符流操作。

         4,需要额外功能吗?

                  需要。转换。        将字节流转成字符流。因为名确的源是Reader,这样操作文本数据做便捷。

                          所以要将已有的字节流转成字符流。使用字节-->字符 。InputStreamReader

                  InputStreamReader isr = new InputStreamReader(System.in);

                  FileWriter fw = new FileWriter("b.txt");

                  还需要功能吗?

                  需要:想高效。

                  BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

                  BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));

===================================================

需求3:将一个文本文件数据显示在控制台上。

         1,明确源和目的。

                  源:InputStream Reader

                  目的:OutputStream  Writer

         2,是否是纯文本呢?

                  是,

                  源:Reader

                  目的:Writer

         3,明确具体设备

                  源:

                          硬盘:File

                  目的:

                          控制台:System.out

                         

                  FileReader fr = new FileReader("a.txt");

                  OutputStream out = System.out;//PrintStream

         4,需要额外功能吗?

                  需要,转换。

                  FileReader fr= new FileReader("a.txt");

                  OutputStreamWriter osw = new OutputStreamWriter(System.out);

                  需要,高效。

                  BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));

                  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

================================================================

需求4:读取键盘录入数据,显示在控制台上。

         1,明确源和目的。

                  源:InputStream Reader

                  目的:OutputStream  Writer

         2,是否是纯文本呢?

                  是,

                  源:Reader

                  目的:Writer

         3,明确设备。

                  源:

                          键盘:System.in

                  目的:

                          控制台:System.out

                  InputStream in = System.in;

                  OutputStream out = System.out;

         4,明确额外功能?

                  需要转换,因为都是字节流,但是操作的却是文本数据。

                  所以使用字符流操作起来更为便捷。

                  InputStreamReader isr = new InputStreamReader(System.in);

                  OutputStreamWriter osw = new OutputStreamWriter(System.out);

                  为了将其高效。

                  BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

                  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

============================================================

5,将一个中文字符串数据按照指定的编码表写入到一个文本文件中.

         1,目的。OutputStream,Writer

         2,是纯文本,Writer。

         3,设备:硬盘File

         FileWriter fw = new FileWriter("a.txt");

         fw.write("你好");

         注意:既然需求中已经明确了指定编码表的动作。

         那就不可以使用FileWriter,因为FileWriter内部是使用默认的本地码表。

         只能使用其父类。OutputStreamWriter.

         OutputStreamWriter接收一个字节输出流对象,既然是操作文件,那么该对象应该是FileOutputStream

         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName);

         需要高效吗?

         BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));

什么时候使用转换流呢?

         1,源或者目的对应的设备是字节流,但是操作的却是文本数据,可以使用转换作为桥梁。

                  提高对文本操作的便捷。

         2,一旦操作文本涉及到具体的指定编码表时,必须使用转换流 。

十三、IO包中的其他类

打印流

• PrintWriter与PrintStream

• 可以直接操作输入流和文件。

PrintStream:

1,提供了打印方法可以对多种数据类型值进行打印。并保持数据的表示形式。

2,它不抛IOException.

         构造函数,接收三种类型的值:

                   * 1,字符串路径。

                   * 2,File对象。

                   * 3,字节输出流。

例:

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.PrintStream;

public class PrintStreamDemo {

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

                  PrintStream out = new PrintStream("print.txt");

//              int by = read();

//              write(by);

//              out.write(610);//只写最低8位,

//              out.print(97);//将97先变成字符保持原样将数据打印到目的地。

                  out.close();

         }

}

PrintWriter:字符打印流。

         构造函数参数:

                  1,字符串路径。

                  2,File对象。

                  3,字节输出流。

                  4,字符输出流。

例:

import java.io.BufferedReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

public class PrintWriterDemo {

         /**

          * @param args

          * @throws IOException

          */

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

                  BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

                  PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true);

                  String line =  null;

                  while((line=bufr.readLine())!=null){

                          if("over".equals(line))

                                   break;

                          out.println(line.toUpperCase());

//                       out.flush();

                  }

                  out.close();

                  bufr.close();

         }

}

序列流

• SequenceInputStream

• 对多个流进行合并。

例:

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.SequenceInputStream;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Enumeration;

import java.util.Iterator;

public class SequenceInputStreamDemo {

         /**

          * @param args

          * @throws IOException

          */

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

                  /*

                   * 需求:将1.txt 2.txt 3.txt文件中的数据合并到一个文件中。

                   */

                  ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

                  for(int x=1; x<=3; x++){

                          al.add(new FileInputStream(x+".txt"));

                  }

                  Enumeration<FileInputStream> en = Collections.enumeration(al);

                  SequenceInputStream sis = new SequenceInputStream(en);

                  FileOutputStream fos = new FileOutputStream("1234.txt");

                  byte[] buf = new byte[1024];

                  int len = 0;

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

                          fos.write(buf,0,len);

                  }

                  fos.close();

                  sis.close();

         }

}

切割文件举例:

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Properties;

public class SplitFileDemo {

         private static final int SIZE = 1024 * 1024;

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

                  // TODO Auto-generated method stub

                  File file = new File("D:\\重庆测试数据.zip");

                  splitFile(file);

         }

         private static void splitFile(File file) throws IOException {

                  FileInputStream fis = new FileInputStream(file);

                  byte[] buf = new byte[SIZE];

                  FileOutputStream fos = null;

                  int len = 0;

                  int count = 1;

                  /*

                   * 切割文件时,必须记录住被切割文件的名称,以及切割出来碎片文件的个数。 以方便于合并。

                   * 这个信息为了进行描述,使用键值对的方式。用到了properties对象

                   *

                   */

                  Properties prop = new Properties();

                  File dirFile = new File("D:\\partFiles");

                  if (!dirFile.exists())

                          dirFile.mkdir();

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

                  fos=new FileOutputStream(new File(dirFile,(count++)+".part"));

                  fos.write(buf,0,len);

                  fos.close();

                  }

                  prop.setProperty("partCount", count+"");

                  prop.setProperty("fileName", file.getName());

                  fos=new FileOutputStream(new File(dirFile,count+".properties"));

                  prop.store(fos, "Save file Info");

                  fos.close();fis.close();

         }

}

将切割的文件合并,合并信息从配置文件中获取:

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.SequenceInputStream;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Enumeration;

import java.util.Properties;

public class MergerFile {

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

                  // TODO Auto-generated method stub

                  File dir = new File("D:\\partFiles");

                  mergeFile_2(dir);

         }

         public static void mergeFile_2(File dir) throws IOException {

                  // 获取指定目录下的配置文件对象。

                  File[] files = dir.listFiles(new SuffixFilter(".properties"));

                  if (files.length != 1)

                          throw new RuntimeException(dir + ",该目录下没有Properties扩展名的文件或者不唯一");

         //记录文件对象。

                  File conFile=files[0];

                  //获取该文件中的信息

                  Properties properties=new Properties();

                  FileInputStream fis=new FileInputStream(conFile);

                  properties.load(fis);

                  String fileName=properties.getProperty("fileName");

                  int count=Integer.parseInt(properties.getProperty("partCount"));

                  //获取该目录下的所有碎片文件。

                  File[] partFiles=dir.listFiles(new SuffixFilter(".part"));

                  if (partFiles.length!=(count-1)){

                  throw new RuntimeException("碎片文件不符合要求,个数不对!应该"+count+"个");

                  }

                  ArrayList<FileInputStream> a1=new ArrayList<FileInputStream>();

                  for (int i = 0; i < partFiles.length; i++) {

                          a1.add(new FileInputStream(partFiles[i]));

                  }

                  Enumeration<FileInputStream> en=Collections.enumeration(a1);

                  SequenceInputStream sisStream=new SequenceInputStream(en);

                  FileOutputStream fos=new FileOutputStream(new File(dir,fileName));

                  byte[] buf=new byte[1024];

                  int len=0;

                  while((len=sisStream.read(buf))!=-1)

                  {

                          fos.write(buf,0,len);                 

                  }

                  fos.close();

                  sisStream.close();

         }

}

操作对象

• ObjectInputStream与ObjectOutputStream

• 被操作的对象需要实现Serializable (标记接口);

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

举报
请填写举报理由
0/200