黑马程序员_java之IO流

------- android培训、 java培训、期待与您交流！ ----------

IO流：

字符流：输入流和输出流

字节流：输入流和输出流

1、File的功能（File类在IO包下）：

   （1）创建文件：boolean creatNewFile()：如果文件存在，创建失败；

                                                                          如果不存在，就创建文件。

   （2）创建文件夹：boolean mkdir()：创建单级目录

                                     boolean mkdirs()：创建多级目录

   （3）删除功能：boolean delete()
  

   （4）判断功能： boolean exists()：文件或者文件夹是否存在
                                  boolean isFile()：是否是文件
                                  boolean isDirectory()：是否是目录
   （5）获取功能：String getAbsolutePath:获取绝对路径
                                 String getName:获取文件名称

2、相对路径：不以盘符开始（“a.txt”）

      绝对路径：以盘符开始（“D:\\b.txt”）

3、File构造方法：

（1）File（File parent,String child）

（2）File（String pathname）

（3）File（String parent,String child）

4、File的删除功能特殊介绍：既可以删除文件，也可以删除文件夹

当删除文件夹时，一定要保证该文件夹没有内容（文件或者 文件夹），先删清里面的，再删外面的。

5、递归：方法定义内部调用方法本身的现象被称为递归

代码体现：

void show（）{

show();

}

举例：

public class DiGui {

public static void main(String[] args) {

DiGui dg = new DiGui();

System.out.println(dg.jc(5));

}

//方法一：用for循环实现阶乘

int sum=1;

for(int i=1;i<6;i++){

sum*=i;

System.out.println(sum);

}

//方法二：用递归

//当n等于1的时候，结果就是1. 当n不等于1的时候，结果是:n*(n-1)!

public int jc(int i){

if(i==1||i==2){

return 1;

}else if(i==3){

return 2;

}else{

return  jc(i-1)+jc(i-2)+jc(i-3);

}

}

}

注意：递归一定要有出口条件，递归的次数不能过多。

6、File类的重要获取功能：

（1）static File[],listRoots()：列出可用的文件系统根

（2）String[],list()：返回的是指定目录下的所有文件和文件夹名称的数组

（3）File[]，listFiles()：返回的是指定目录下的所有文件和文件夹对象的数组

7、文件名称过滤器的使用：

（1）String[],list(FilenameFilter filter)

（2）File[],listFiles(FilenameFilter filter)

8、对IO流进行操作：

字符流：字符输入流----Reader

                字符输出流----Writer

字节流：字节输入流----InputStream

                字节输出流----OutputStream

字符流：

字符输出流：Writer----FileWriter

1、FileWriter构造方法：

（1）FileWriter(File file)：指定写入的文件对象

（2）FileWriter(String fileName)：写入的文件对象的路径和文件名称

2、代码步骤：

（1）创建对象：FileWriter fw = new FileWriter(“d:\\......”);

（2）写数据：void write(String str)

（3）刷新缓冲区，把数据组合完毕后写入文件：void flush()

（4）释放资源：void close()

3、flush和close的区别：

（1）flush只刷新缓冲区；close先刷新缓冲区，再释放资源；

（2）flush刷新缓冲区后，流对象还可以继续使用；close，流对象不能再使用。

字符输入流：Reader----FileReader

1、FileReader构造方法：

（1）FileReader(File file)：指定读出的文件对象

（2）FileReader(String fileName)：读出的文件对象的路径和文件名称

2、代码步骤：

（1）创建对象：FileReader fw = newFileReader(“d:\\......”);

（2）写数据：int read()//读取单个字符，每次读取一个字符

（3）释放资源：void close()

3、文件读取的代码体现：

//一次读写一个字符代码如下：
   FileReader fr = new FileReader("fw.txt");
   
   //一次读写一个字符
   int num = 0;
   while((num=fr.read())!=-1)
   {
    System.out.print((char)num);
   }

   fr.close();

   //一次读写一个字符数组代码如下：
   FileReader fr = new FileReader("fw.txt");
   
   //一次读写一个字符数组
   char[] chs = new char[1024]; //1024的整数倍
   int len = 0; //存储读取的实际长度
   while((len=fr.read(chs))!=-1)
   {
    System.out.print(new String(chs,0,len));
   }

   fr.close();

4、文件的复制
  数据源：
   来源：a.txt
   FileReader -- 读取数据
  目的地：
   目的：b.txt
   FileWriter -- 写入数据

  代码体现：
   方式1：每次读写一个字符
    
    FileReader fr = new FileReader("a.txt");
    FileWriter fw = new FileWriter("b.txt");
    int num = 0;
    while((num=fr.read())!=-1)
    {
     fw.write(num)
    }

    fw.close();
    fr.close();

   方式2：每次读写一个字符数组
    FileReader fr=new FileReader("a.txt");
    FileWriter fw=new FileWriter("b.txt");
    char [] chs=new char[1024];
    int len=0;
    while((len=fr.read(chs))!=-1){
     fw.write(chs,0,len);
     fw.flush();
    }
    fw.close();
   fr.close();

带缓冲的字符流对象
1、字符流体系图:
  Reader的功能
   read()
   read(char[] chs)
   close()
   
   FileReader:没有特殊方法
   BufferReader:readLine()

   Writer的功能
   write(int ch)
   write(String str)
   write(String str,int start,int end)
   write(char[] chs)
   write(char[] chs,int start,int end)
   flush()
   close()
   
   FileWriter:没有特殊方法
   BufferedWriter:newLine()
2、字符缓冲输出流写入数据
   代码体现：

   BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

   bw.write("hello!");
   bw.newLine();
   bw.flush();

bw.close();

3、字符缓冲输入流读取数据
   代码体现：
   
   方式1：一次读取一个字符
    BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

    int num = 0;
    while((num=br.read())!=-1)
    {
     System.out.print((char)num);
    }

br.close();

   方式2：一次读取一个字符数组
    BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

    char[] chs = new char[1024];
    int len = 0;
    while((len=br.read(chs))!=-1)
    {
     System.out.print(new String(chs,0,len));
    }

br.close();
   

方式3：一次读取一行数据
    BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

    String line = null;
    while((line=br.readLine())!=null)
    {
     System.out.println(line);
    }

br.close();

 4、字符缓冲流复制文本文件
  代码体现:
   public class CopyFileTest5 {
   public static void main(String[] args) throws IOException {
   BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\a.txt"));
   BufferedReader br = new BufferedReader(new FileReader("E:\\b.txt"));

  方式1:
   int num = 0;
   while ((num = br.read()) != -1) {
     bw.write(num);
   }

方式2：
   char [] chs=new char[1024];
   int len=0;
   while((len=br.read(chs))!=-1){
    bw.write(chs,0,len);
    bw.flush();
   }

方式3：
   String line = null;
   while ((line = br.readLine()) != null) {
     bw.write(line);
     bw.newLine();
     bw.flush();
   }

   bw.close();
   br.close();
   }
  }

装饰设计模式：
定义：对现有的功能进行了包装，可能还会提供更多的功能供我们使用。

1、模拟BufferedReader的readLine()方法
2、模拟LineNumberReader的获取和设置行号的方法

字节流：

字节输入流：InputStream----read()/read(bys)

字节输出流：OutputStream----write(int bys)/write(bys,start,end)

键盘录入数据：

标准输入输出流：----键盘录入：System.in

                ----控制台输出：System.out

打印流：提供了多种打印数据的方式，并且是操作多种数据类型的。基本类型可以，引用类型也可以。

字符打印流：PrintWriter：使用println、printf、format方法自动刷新，自动   换行（println）

字节打印流：PrintStream

IO流总结：

A：字符流：（记事本能够打开能够看懂的就是字符流操作）

数据源----目的地：Reader----Writer

B：字节流：（图片、视频、MP3等）

数据源----目的地：InputStream----OutputStream

几种转换类型:

A：文本文件（“a.txt”）----文本文件（“b.txt”）

数据源：FilerReader----BufferedReader

目的地：FileWriter----BufferedWriter

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

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

    String line = null;

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

{

bw.write(line);

bw.newLine();

bw.flush();

}

bw.close();

br.close();

B：键盘录入（System.in）----文本文件（“system.txt”）

数据源：System.in----InputStreamReader----BufferedReader

目的地：FileWriter----BufferedWriter

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

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

String line = null;

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

{

if("over".equals(line)

{

break;

}

bw.write(line);

bw.newLine();

bw.flush();

}

bw.close();

br.close();

C：文本文件（“system.txt”）----控制台输出（System.out）

数据源：FileReader----BufferedReader

目的地：System.out----BufferedWriter----FileWriter

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

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter

  (System.out));

String line = null;

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

{

bw.write(line);

bw.newLine();

bw.flush();

}

bw.close();

br.close();

D：键盘录入（System.in）----控制台输出（System.out）

数据源：System.in----InputStreamReader----BufferedReader

目的地：System.out----OutputStreamWriter----BufferedWriter

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

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter

                                         (System.out));

String line = null;

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

{

if("over".equals(line))

{

break;

}

bw.write(line);

bw.newLine();

bw.flush();

}

bw.close();

br.close();

E：键盘录入 -- 文本文件(a.txt) -- 文本文件(b.txt) -- 控制台输出

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

BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

String line = null;

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

{

if("over".equals(line)

{

break;

}

bw.write(line);

bw.newLine();

bw.flush();

}

bw.close();

br.close();

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

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

String line = null;

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

{

bw2.write(line);

bw2.newLine();

bw2.flush();

}

bw2.close();

br2.close();

BufferedReader br3 = new BufferedReader(new FileReader("b.txt"));

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

String line = null;

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

{

bw3.write(line);

bw3.newLine();

bw3.flush();

}

bw3.close();

br3.close();

操作对象流：

写对象的流：ObjectOutputStream

读对象的流：ObjectInputStream
写入多个对象PK读取多个对象：

1、用循环，然后把异常隐藏

2、把多个对象存储到集合中，把集合看成一个对象

序列化：把对象按照流的方式写入文件或者在网络中传输

反序列化：把对象从文件或者网络中读取

类通过实现java.io.serializable接口以启用其序列化功能这个接口就是一个标识接口，就是告诉你，这个对象可以被对象流操作。也就是说，只有实现了序列化接口的对象才可以被对象流操作。

Properties

1、Properties是集合和io结合的类。

2、要掌握的功能：

A:list（集合-- 写--文件）

void list(PrintStream out)

void list(PrintWriter out)

把当前集合中的数据直接通过参数类型的流对象写入到指定的文件中。

B:load（文件--读--集合）

void load(InputStream inStream)

void load(Reader reader)

把文件中的数据通过流对象加载到集合中；应用：游戏进度加载。

C:store

void store(OutputStream out,String comments)

void store(Writer writer,String comments)

把数据通过流对象保存到指定的文件；应用：游戏进度保存。

3、案例：

读取数据，并判断修改数据，最后在保存数据。

对应着：我们的游戏的进度加载，和保存进度。

*IO的一个案例（重点背也要背下来）

把指定目录下指定后缀的所有文件的路径写入到一个文本文件中。

public class Demo{

public static void main(String[] args){

//指定目录

File file = new File("e:\\if语句")；

//创建集合对象，存储指定路径

ArrayList<File> array = new ArrayList<File>();

//调用方法

getAllFile(file,array);

//创建输出流对象，将指定路径写入到新建文本文件中

BufferedWriter bw = new BufferedWriter(new FileWriter

("homework"));

//遍历

for(File f:array){

//得到指定目录下的所有绝对路径

bw.write(f.getAbsolutePath());

bw.flush();

bw.newLine();

}

bw.close();

}

private static void getAllFile(File file,ArrayList array){

//遍历集合中获取到的绝对路径判断是否是正确目录

File[] fileArray = file.listFiles();

for(File f:fileArray){

if(f.isDirectory()){

getAllFile(f,array);

}else{

if(f.getName().endsWith(".java")){

array.add(f);

}

}

}

}

}