java基础学习IO流2学习笔记

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

                                                                   流的操作规律

一、键盘录入

1、标准输入输出流

        System.in：对应的标准输入设备，键盘。

        Ssytem.out：对应的是标准的输出设备，控制台。

        System.in的类型是InputStream.

        System.out的类型是PrintStream是OutputStream的子类FilterOutputStream的子类。

2、整行录入

       当使用输入流进行键盘录入时，只能一个字节一个字节进行录入。为了提高效率，可以自定义一个数组将一行字节进行存储。当一行录入完毕，再将一行数据进行显示。这种正行录入的方式，和字符流读一行数据的原理是一样的。也就是readLine方法。

      那么能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？readLine方法是字符流BufferedReader类中方法。而键盘录入的read方法是字节流InputStream的方法。

      那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢？这就需要用到转换流了。

3、转换流

3.1 转换流的由来：

       a、字符流与字节流之间的桥梁

       b、方便了字符流与字节流之间的操作

转换流的应用：

      字节流中的数据都是字符时，转成字符流操作更高效。

3.2   InputStreamReader将字节流通向字符流

       a、获取键盘录入对象。

              InputStream in=System.in;

       b、将字节流对象转成字符流对象，使用转换流。

              InputStreamReaderisr=new InputStreamReader(in);

       c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

              BufferedReaderbr=new BufferedReader(isr);

       //键盘录入最常见写法

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

3.3   OutputStreamWriter字符流通向字节流

       字符通向字节：录入的是字符，存到硬盘上的是字节。步骤和InputStreamReader转换流一样。

示例：

/*
需求：将键盘录入的数据，显示在控制台，当输入over时，表示结束
源：键盘录入。
目的：控制台。


*/
import java.io.*;
class TransStreamDemo 
{
public static void main(String[] args)throws IOException
{
//获取键盘录入对象。
//InputStream in=System.in;
//将字节流对象转成字符流对象，使用转换流。
//InputStreamReader isr=new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
//BufferedReader br=new BufferedReader(isr);


//键盘录入最常见写法
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));


//字符流通向字节流
BufferedWriter bw =new BufferedWriter(new OutputStreamWriter(System.out));


String s=null;
while((s=in.readLine())!=null)
{
if("over".equals(s))
break;
bw.write(s.toUpperCase());//写入数据
bw.newLine();//换行
bw.flush();//刷新

}
bw.close();//关闭流资源
in.close();
}
}

二、流操作规律

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

1、异常的日志信息：

        当程序在执行的时候，出现的问题是不希望直接打印给用户看的，是需要作为文件存储起来，方便程序员查看，并及时调整的。

示例：

import java.io.*;
import java.text.*;
import java.util.*;
class  ExceptionInfo
{
public static void main(String[] args) 
{
try
{
int[] arr =new int[2];
System.out.println(arr[3]);


}
catch (Exception e)
{
try
{
Date d=new Date();//创建时间对象
//时间模块格式对象
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s=sdf.format(d);


PrintStream ps=new PrintStream("info.log");//打印流对象
System.setOut(ps);//修改输出流设备
ps.println(s);//输出时间

}
catch (IOException ex)
{
throw new RuntimeException("文件创建失败");
}
e.printStackTrace(System.out);//将异常信息输出指定输出流
}
}
}

2、系统属性信息存入文本

        获取系统信息：

                 Properties getProperties()

        将信息输出到指定输出流中

                 void list(PrintStream out)

        将输出流中数据存入指定文件中

                  new PrintStream("systeminfo.txt")

示例：

//将系统属性信息保存到指定文本中
import java.util.*;  
import java.io.*;  


class SystemInfo   
{  
   public static void main(String[] args)   
   {   
       PrintStream ps = null;  
       try  
       {  
          //获取系统信息：  
          Properties pop = System.getProperties();  
          //创建输出流对象，将输出流中数据存入指定文件中  
          ps = new PrintStream("systeminfo.txt");  
          //将属性列表输出到指定的输出流  
          pop.list(ps);  
       }  
       catch (Exception e)  
       {  
  throw new RuntimeException("获取系统信息失败。");  
       }  
    }  
}

   File类

一、概述

1、File类：文件和目录路径名的抽象表现形式

2、特点：

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

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

        3）File类的实例是不可变的；也就是说，一旦创建，File 对象表示的抽象路径名将永不改变

        4）File对象可以作为参数传递给流的构造函数

 

二、File对象创建

方式一：      

             File f =new File("a.txt");

        将a.txt封装成File对象。可以将已有的和未出现的文件或者文件夹封装成对象。

 方式二：

            File f2=newFile("c:\\abc","b.txt");

        将文件所在目录路径和文件一起传入，指定文件路径。

 方式三：

            File d=new File("c:\\abc");

             File f3=new File(d,"c.txt");

        将文件目录路径封装成对象。再创建文件对象。降低了文件于父目录的关联性。

小知识：

        File.separator表示目录分隔符，可以跨平台使用。相当于路径中的“\”（双斜杠\\在windows中表示表示转义后的分隔符，但是在linux系统中就不是）。

 

三、File类的常见方法

1、创建

        booleancreateNewFile();

        //在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立就创建文件。而且文件已经存在，会覆盖。

        boolean mkdir();//创建文件夹，只能创建一级文件夹

例：

        File dir=new File("abc");

        dir.mkdir();//创建abc这个文件夹

        boolean mkdirs();//创建多级文件夹

2、删除

        boolean delete();

        //删除文件或目录。文件存在，返回true；文件不存在或者正在被执行，返回false。    

        void deleteOnExit();//在程序退出时删除指定文件

3、判断

        boolean canExecute();//是否是可执行文件

        boolean exists();//文件是否存在

        boolean isFile();//是否是文件

        boolean isDirectory();//是否是文件夹

        boolean isHidden();//是否是隐藏文件

        boolean isAbsolute();//文件是否是绝对路径

记住：在判断文件对象是否是文件或者目录时，必须要判断该文件对象封装的内容是否存在。通过exists判断。

4、获取信息

        String getName();//获取文件名

        String getPath();

        //获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）

        String getParent();

        //获取文件父目录。返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。

        String getAbsolutePath();//获取文件的绝对路径      

        long lastModified();//返回文件最后一次被修改的时间

        long length();//返回文件长度

5、列出文件及文件过滤

        static File[] listRoots();//列出可用的文件系统根目录，即系统盘符

        String[] list();

        //列出当前目录下所有文件，包括隐藏。调用list方法的file对象必须是封装了一个目录。该目录还必须存在。

        String[]list(FilenameFilter filter);

        //返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。

        //FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(Filedir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。

        File[] listFiles();//返回一个抽象路径名数组，获取当前文件夹下的所有文件和文件夹

        File[] ListFiles(FilenameFilterfilter);//返回抽象路径名数组，获取目录中满足指定过滤器的文件或目录。

<span style="font-size:14px;">/*
练习：用String[] list(FilenameFilter filter)方法获取一个目录下所有的.java文件，其他文件不要。
思路：1、FilenameFilter是一个过滤器接口，用匿名内部类传入filter对象
 2、复写FilenameFilter接口的accept(File file,String name)方法，并判断name是否是java文件
 3、遍历String类型数组


示例：
import java.io.*;
class  GetJavaFile
{
public static void main(String[] args) 
{
File file=new File("E:\\Java Study\\Practice\\day07");
getJavaFile(file);
}
//获取一个目录下所有的.java文件方法
public static void getJavaFile(File dir)
{
//传入FilenameFilter匿名内部类子类对象，并复写accept方法
String[] javaFile=dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
return name.endsWith(".java");//判断文件名是否是以.java结尾
}
});


System.out.println("len:"+javaFile.length);
//遍历数组
for (String s : javaFile )
{
System.out.println(s);
}
}

}

递归

1、定义

       当函数内每一次循环还可以调用本功能来实现，也就是函数自身调用自身。这种表现形式，或者编程手法，称为递归。

2、递归注意事项

        a、限定条件。是来结束循环调用，否则是死循环。

        b、注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的方法，所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。

示例：

/*
需求：列出指定目录下文件或文件夹，包含子目录，即列出指定目录下所有内容（带层次的）。


分析，因为目录中还有目录，只有使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再调用本功能，这就是利用递归原理。


*/
import java.io.*;
class  RecursionDemo
{
public static void main(String[] args) 
{
//关联指定路径
File dir=new File("e:\\Java Study\\Practice");

        //列出关联路径中所有的.java文件
allFileList(dir,0);
}


//列出指定目录下的所以内容
public static void allFileList(File dir,int level)
{
//有层次的输出
System.out.println(getLevel(level)+dir);
level++;
File[] fileArr=dir.listFiles();//获取本目录下的所以文件和目录的抽象路径

        //遍历
for (File file : fileArr)
{
if(file.isDirectory())
{
//如果目录下还是目录，则继续调用本函数
allFileList(file,level);
}
else
System.out.println(getLevel(level)+file);//显示（列出）文件
}
}


//带层次的列表
public static String getLevel(int level)
{
StringBuilder sb=new StringBuilder();
sb.append("|--");
//每多一级目录，就多输出指定字符
for (int x=level;x>0 ; x--)
{
//sb.append("|--");
sb.insert(0,"|  ");
}
return sb.toString();
}
}

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)案例：
  读取数据，并判断修改数据，最后在保存数据。

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

示例：

import java.io.*;  

  

class  PrintStreamDemo  

{  

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

    {  

        //键盘录入   

        BufferedReader bufr =   

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

 

        //打印流关联文件，自动刷新   

        PrintWriter out = new PrintWriter(new FileWriter("a.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();  

      }     

}