黑马程序员_java IO学习笔记

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

1:IO概述： 

 (1)就是指程序和设备进行数据交换。
  设备有很多种，所有，io流对象也有很多。
  java提供了一个包java.io包下的类供我们使用。
 (2)IO流的分类
  A:数据的流向
   程序 -- 设备 输出流
   设备 -- 程序 输入流
  B:数据的类型
   字节流
   字符流 为了方便对文本的操作。
          用记事本可以打开并能够读懂的你就可以用字符流。
   
   字节输入流
   字节输出流
   字符输入流
   字符输出流
 (3)java中对数据的常见操作就是存储在硬盘的文件，为了方便我们对文件的操作，
    java就提供了一个类供我们使用。File类。
 (4)学习File类
  A:构造方法
   **File file = new File("d:\\a.txt");
   **File file = new File("d:\\","a.txt");
   **File file = new File("d:\\");
     File file2 = new File(file,"a.txt");
  B:功能方法
   创建功能：
    boolean createNewFile()
    boolean mkdir()
    boolean mkdirs()
   删除功能：
    boolean delete()
   判断功能：
    boolean exists()：文件或者文件夹是否存在
    boolean isFile()：是否是文件
    boolean isDirectory()：是否是目录
   获取功能：
    String getAbsolutePath:获取绝对路径
    String getName:获取文件名称
   高级获取功能：
    String[] list() 返回的是指定目录下的所有文件和文件夹名称的数组
    File[] listFiles() 返回的是指定目录下的所有文件和文件夹对象的数组
   
   带文件名称过滤器的使用：
    String[] list(FilenameFilter filter)
    File[] listFiles(FilenameFilter filter)

   案例：
    获取指定目录下以java结尾的文件

    File file = new File("指定目录");

    String[] strArray = file.list(new FilenameFilter(){
     public boolean accept(File dir,String name)
     {
      return new File(dir,name).isFile() && name.endsWith(".java");
     }
    });

    for(String str : strArray)
    {
     System.out.println(str);
    }
 (5)递归
  A:在方法定义内使用方法本身的现象就是递归。
    注意事项：
   递归一定要有出口
   递归的次数不能过多
  B:案例：
   递归求斐波纳契数列的第二十项的值
   // 递归求斐波纳契数列第几项目的值
   public int re(int n) {
   if (n == 1||n==2) {
    return 1;
    } else if(n==3){
    return 2;
    }else{
    return re(n-1) + re(n-2)+re(n-3);
    }
  
   }
  }

2:IO的分类及应用

 (1)IO流的四个基类
  A:字节流
   字节输入流
    InputStream
   字节输出流
    OutputStream
  B:字符流
   字符输入流
    Reader
   字符输出流
    Writer

  这四个都是抽象类。
  输入流：读取数据
  输出流：写入数据
 (2)文件的写入数据
  对文本文件写入数据：
   Writer -- FileWriter
  
  FileWriter的构造方法：
   FileWriter(File file)
   FileWriter(String name)
   FileWriter(File file,boolean append)
   FileWriter(String name,boolean append)

  字符输出流写入数据的基本步骤：
   A:创建字符输出流对象
   B:调用该对象的write方法
   C:释放资源

  代码体现：
   FileWriter fw = new FileWriter("fw.txt");

   fw.write("hello,io,我来了");
   fw.flush();

   fw.close();

   FileWriter fw = new FileWriter("fw.txt");做了：
    创建了字符输出流对象
    把字符输出流对象指向了要写入数据的文件对象
    调用系统资源，创建文件对象(不管文件是否存在，都会创建)

   flush和close的区别：
    flush刷新缓冲区，close刷新缓冲区，并释放资源。
    flush刷新缓冲区后，流对象还可以继续使用，close释放资源后，
     流对象不能被使用。

   流操作一定要调用close方法的原因：
    创建字符输出流对象的时候：不仅仅是在堆内存创建了java对象，
    并且使用了系统资源创建了文件对象，当程序结束后，java的对象
    会自动变成垃圾，被回收。 而系统的资源就一直在被使用，所以，
    我们需要调用close方法，就是去通知系统，你创建文件时候使用的
    资源可以释放了。

  两个小知识点：
   如何追加数据，而不是覆盖数据：
    使用带两个参数的构造方法，第二个参数表示是否是追加数据，写为true即可。

   数据追加或者写入的时候，如何换行:
    换行在不同的操作系统中，对应的字符不一样：
    windows: \r\n
    linux: \n

    有些软件，对不同的换行都是识别的，比如：editplus
    但是，windows自带的记事本只能识别\r\n。
    
  加入异常处理：
    public class FileReaderTest4 {
    public static void main(String[] args) {
     FileWriter fw = null;
     try {
     fw = new FileWriter("fx.txt");
     fw.write("hello,我是张雄");
     fw.flush();
     } catch (IOException e) {
      e.printStackTrace();
     } finally {
     if(fw!=null){
     try {
     fw.close();
     } catch (IOException e) {
     e.printStackTrace();
        }
       }
      }
     }
    }
 (3)文件的读取数据
  对文本文件读取数据：
   Reader -- FileReader
  
  FileReader的构造方法：
   FileReader(File file)
   FileReader(String name)

  字符输入流读取数据的基本步骤：
   A:创建字符输入流对象
   B:调用该对象的read方法
   C:释放资源

  代码体现：
   
   一次读写一个字符代码如下：
   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();

3:带缓冲的字符流对象

 (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("哈哈,该下课了");
   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"));
   int num = 0;
   while ((num = br.read()) != -1) {
    bw.write(num);
   }

   bw.close();
   br.close();
   }
  }
   方式2：
   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"));
   char [] chs=new char[1024];
   int len=0;
   while((len=br.read(chs))!=-1){
    bw.write(chs,0,len);
    bw.flush();
   }
   bw.close();
   br.close();
  }
 }
   方式3：
   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"));
   String line = null;
   while ((line = br.readLine()) != null) {
    bw.write(line);
    bw.newLine();
    bw.flush();
   }
   bw.close();
   br.close();
  }
 }

4:装饰设计模式

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

5:IO 字节流

 (1)字节流的结构图
  字节输入流：
   InputStream
    read()
    read(bys)

    FileInputStream
    BufferedInputStream
    
  字节输出流：
   OutputStream
    write(int by)
    write(bys,start,end)

    FileOutputStream
    BufferedOutputStream
 (2)FileOutputStream写入数据
  步骤：
   创建字节输出流对象
   使用该对象的write方法
   释放资源

  代码体现：

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

   fos.write("hello,io".getBytes());
   fos.flush();

   fos.close();
 (3)FileInputStream读取数据
  步骤：
   创建字节输入流对象
   使用该对象的read方法
   释放资源

  代码体现：

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

   //方式1
   int num = 0;
   while((num=fis.read())!=-1)
   {
    System.out.print((char)num);
   }

   //方式2
   byte[] bys = new byte[1024];
   int len = 0;
   while((len=fis.read(bys))!=-1)
   {
    System.out.print(new String(bys,0,len));
   }

   fis.close();
 (4)用字节流实现复制
  A:复制文本文件(最好使用字符流)(自己补齐)
  B:复制图片
   FileInputStream fis = new FileInputStream("d:\\mn.jpg");
   FileOutputStream fos = new FileOutputStream("mn.jpg");

   byte[] bys = new byte[1024];
   int len = 0;
   while((len=fis.read(bys))!=-1)
   {
    fos.write(bys,0,len);
   }

   //释放资源
   fos.close();
   fis.close();

6:键盘录入数据

 (1)标准的输入输出流
  键盘录入 System.in
  控制台输出 System.out
 (2)为了让字节流和字符流能够进行相互转换，java提供了转换流
  A:InputStreamReader
   
   InputStreamReader isr = new InputStreamReader(InputStream is);
   //System.in
   //FileInputStream

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

  B:OutputStreamWriter

   OutputStreamWriter osw = new OutputStreamWriter(OutputStream os);
   //System.out
   //FileOutputStream

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

7:流的操作规律

 A:明确数据源和目的地的操作的流对象
  数据源:
   读取数据
   Reader
   InputStream
  目的地:
   写入数据
   Writer
   OutputStream
 B:明确数据源和目的地的数据类型
  数据源:
   字节流
    InputStream
   字符流
    Reader
  目的地:
   字节流
    OutputStream
   字符流
    Writer

  记事本能够打开并能够看懂的就是字符流操作。
 C:明确数据源和目的地设备
  数据源:
   硬盘文件 
    是文本文件：FileReader
    不是文本文件：FileInputStream
   键盘录入
    System.in
    如果想转成字符流，就使用转换流
    InputStreamReader
   内存
  目的地:
   硬盘文件
    是文本文件：FileWriter
    不是文本文件：FileOutputStream
   控制台显示
    System.out
    如果想转成字符流，就使用转换流
    OutputStreamWriter
   内存
 D:是否需要高效读写
  是：就用带Buffer的流
  否：不用带Buffer的流

8:通过流的规律，分析如下操作

 A:文本文件(a.txt)--文本文件(b.txt)
 数据源：FileReader
 目的地：FileWriter
   是：就用带Buffer的流
    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();

   否：不用带Buffer的流

    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();

 B:键盘录入--文本文件
  键盘录入一定要控制结束。

  代码体现：
  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:文本文件--控制台输出
  数据源：FileReader -- BufferedReader
  目的地：System.out -- OutputStreamWriter -- BufferedWriter

  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 -- 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();

9:键盘录入 -- 文本文件(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();

10:Runtime类

 A:没有构造方法
   里面提供一个静态的方法返回该类的对象。
   使用的是单例设计模式。
 B:要掌握的方法
  exec(String pathName); 路径
 线程异常：
  InterruptedException
  IllegalArgumentException
10:常用API中类的总结
 A:String
  getBytes():将字符串(String)转换成字节(Byte)数组
  toCharArray():将字符串(String)转换为一个新的字符数组
  charAt():返回指定索引处的 char 值
  length():  返回此字符串的长度
  equals(): 将此字符串与指定的对象比较
  compareToIgnoreCase(): 按字典顺序比较两个字符串，不考虑大小写
  compareTo(): 按字典顺序比较两个字符串
  contains():  当且仅当此字符串包含指定的 char 值序列时，返回 true
  substring():返回一个新的字符串，它是此字符串的一个子字符串
  endsWith():测试此字符串是否以指定的后缀结束
  startsWith():测试此字符串是否以指定的前缀开始
  trim(): 返回字符串的副本，忽略前导空白和尾部空白。
  valueOf():返回 Object 参数的字符串表示形式。
  split():根据给定正则表达式的匹配拆分此字符串
  replace(char oldChar, char newChar):返回一个新的字符串，它是通过用 newChar
       替换此字符串中出现的所有 oldChar 得到的
  indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
  indexOf(int ch, int fromIndex) :返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
 B:StringBuilder
  append():将 *参数的字符串表示形式追加到序列
  insert():将 *参数的字符串表示形式插入此序列中
  delete()： 移除此序列的子字符串中的字符
  reverse()：将此字符序列用其反转形式取代
 C:Integer
  parseInt()：将字符串参数作为有符号的十进制整数进行解析
 D:Math
  pow():返回第一个参数的第二个参数次幂的值
  abs():返回一个数的绝对值
  ceil()：返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
  floor()：返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数
  round()： 返回最接近参数的 *型值
  random()：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
 E:Random
  nextInt()：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值
  nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和
   指定值（不包括）之间均匀分布的 int 值
 F:Scanner
  nextLine()：此扫描器执行当前行，并返回跳过的输入信息
  nextInt()：将输入信息的下一个标记扫描为一个 int。
 G:Runtime
  getRuntime()：返回与当前 Java 应用程序相关的运行时对象
  exec()：在单独的进程中执行指定命令
 H:System
  exit()：终止当前正在运行的 Java 虚拟机
  currentTimeMillis()：返回以毫秒为单位的当前时间
 I:Arrays
  sort()：对指定的*型数组按数字升序进行排序
  binarySearch()：使用二分搜索法来搜索指定类型数组的范围，以获得指定对象。
  toString()：返回指定数组内容的字符串表示形式
 J:Collections
  sort()：根据元素的自然顺序 对指定列表按升序进行排序
  binarySearch()： 使用二分搜索法搜索指定列表，以获得指定对象。
  reverse()：反转指定列表中元素的顺序。

12:PrintWriter

 (1)打印流
  特点：可以操作任意类型数据
        它是可以直接操作文件
        它还可以自动刷新，并换行。前提：启动自动刷新，并且使用println方法。
 (2)代码体现：
  键盘录入数据存入到文本文件中，使用打印流写。

  //封装数据源
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  //封装目的地
  PrintWriter pw = new PrintWriter(new FileWriter("pw.txt"),true);

  String line = null;
  while((line=br.readLine())!=null)
  {
   if("over".equals(line))
   {
    break;
   }
   pw.println(line);
  }

  pw.close();
  br.close();

13:操作对象的流

 (1)对象流,序列化流
  ObjectInputStream: Object readObject()
  ObjectOutputStream: void writeObject(Object obj)
 (2)代码体现：
  
  注意：如果一个对象按照流的操作来使用，就必须实现序列化接口。

  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
  oos.writeObject(new Person("haha",40));
  oos.close();

  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
  Person p = (Person)ois.readObject();

  System.out.println(p.getName()+":"+p.getAge());
  ois.close();
 (3)存储多个对象
  把多个放到集合中存储，然后读取。
 (4)Person类中的序列化id值
  如果写入到文件中，这个文件中会写入一个序列化的id值，
  这个值要和class文件一一对应。
  为了保证这个对应关系，我们会默认给出一个类中的序列化id值。

14:Properties

 (1)Properties是集合和io结合的类。
 (2)要掌握的功能：
  A:list
  B:load
  C:store
 (3)案例：
  读取数据，并判断修改数据，最后在保存数据。

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