Java基础---IO(二)--Properties类、打印流、序列流、对象操作流、数据输入输出流

第一讲： Java IO 的一般使用原则：

一、按数据来源（去向）分类：

1 、是文件： FileInputStream, FileOutputStream,FileReader, FileWriter

2 、是 byte[] ： ByteArrayInputStream,ByteArrayOutputStream

3 、是 Char[]:CharArrayReader, CharArrayWriter

4 、是 String:StringBufferInputStream,StringReader, StringWriter

5 、网络数据流： InputStream,OutputStream, Reader, Writer

二、按是否格式化输出分：

1 、要格式化输出： PrintStream,PrintWriter

三、按是否要缓冲分：

1 、要缓冲： BufferedInputStream,BufferedOutputStream,BufferedReader, BufferedWriter

四、按数据格式分：

1 、二进制格式（只要不能确定是纯文本的） :InputStream,OutputStream 及其所有带 Stream 结束的子类

2 、纯文本格式（含纯英文与汉字或其他编码方式）； Reader,Writer 及其所有带 Reader,Writer 的子类

五、按输入输出分：

1 、输入： Reader,InputStream 类型的子类

2 、输出： Writer,OutputStream 类型的子类

六、特殊需要：

1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader,OutputStreamWriter

2 、对象输入输出： ObjectInputStream,ObjectOutputStream

3 、进程间通信： PipeInputStream,PipeOutputStream,PipeReader, PipeWriter

4 、合并输入： SequenceInputStream

5 、更特殊的需要： PushbackInputStream,PushbackReader,LineNumberInputStream, LineNumberReader

 

六、决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要） ：

第一，考虑最原始的数据格式是什么：是否为文本？

第二，是输入还是输出 ?

第三，是否需要转换流： InputStreamReader,OutputStreamWriter?

第四，数据来源（去向）是什么：文件？内存？网络？

第五，是否要缓冲： bufferedReader （特别注明：一定要注意的是 readLine() 是否有定义，有什么比 read,write 更特殊的输入或输出方法）

第六，是否要格式化输出： print?

 

第二讲     Properties类

一、概述

1、Properties是Hashtable的子类，它具备Map集合的特点。而且它里面还有存储的键值对，都是字符串，无泛型定义。是集合中和IO技术想结合的集合容器。

2、特点：

       1）可用于键值对形式的配置文件

       2）在加载时，需要数据有固定的格式，常用的是：键=值

 

二、特有方法

1、设置

       Object setProperty(String key,String value);

       //设置键和值，调用Hashtable的方法put

2、获取

       String getProperty(String key);

       //指定key搜索value

       Set stringPropertyName();

       //返回属性列表的键集，存入Set集合

3、加载流和存入流

       void load(InputStream ism);

       //从输入字节流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。

        voidload(Readerreader);

       //从输入字符流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。

        voidlist(PrintStreamout);//将属性列表输出到指定的输出流

        voidstore(OutputStreamout,String comments);

       //对应load(InputStream )将属性列表（键值对）写入输出流。comments属性列表的描述。

        voidstore(Writerwriter, String comments);

       //对应load(Reader)将属性列表（键值对）写入输出流。comments属性列表的描述。

示例

[java]  view plaincopy

1.    // 演示，如何将流中的数据存储到集合中。   

2.        // 想要将 info.txt 中键值数据存到集合中进行操作。   

3.         /*  

4.           1, 用一个流和 info.txt 文件关联。  

5.            2 ，读取一行数据，将该行数据用 "=" 进行切割。  

6.           3 ，等号左边作为键，右边作为值。存入到 Properties 集合中即可。  

7.     

8.       */   

9.             // 将文件数据存储进 Properties 集合方法   

10.       public static void  method() throws  IOException  

11.       { 

12.           // 使用字符读取缓冲流关联文件   

13.           BufferedReader bufr =  new  BufferedReader( new  FileReader( "info.txt" )); 

14.    

15.           String line =  null ;  

16.           // 定义 Properties 集合   

17.           Properties prop =  new  Properties(); 

18.    

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

20.          {  

21.               String[] arr = line.split( "=" ); // 将一行数据以 “=” 号进行分割   

22.               // 将 = 左边作为键存入，将 = 右边作为值存入   

23.               prop.setProperty(arr[ 0 ],arr[ 1 ]);  

24.          }  

25.     

26.          bufr.close(); // 关流   

27.     

28.          System.out.println(prop); 

29.       } 

练习：

[java]  view plaincopy

1.    /*  

2.   练习：用于记录应用程序运行次数。如果使用次数已到，那么给出注册提示。  

3.          

4.   分析：  

5.    很容易想到的是：计数器。可是该计数器定义在程序中，随着该应用程序的退出，该计数器也在内存中消失了。  

6.   所以要建立一个配置文件，用于记录该软件的使用次数。该配置文件使用键值对的形式。键值对数据是 map 集合。数据是以文件形式存储。使用 io 技术。那么 map+io——>Properties 。  

7.     

8.   思路： 1 、用读取流关联文本信息文件。如果存在则读取，如果不存在，则创建  

9.          2 、每次运行，将文件数据存入集合中，读取值，判断次数，如果小于等于 5 次，则次数增加 1 次，如果大于则输出提示信息。  

10.        3 、将值小于等于 5 次的信息数据存入文件中  

11.   */   

12.  import  java.util.*;  

13.   import  java.io.*;  

14.    

15.   class   RunCount  

16.  {  

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

18.      {  

19.            int  count=runCount(); 

20.           if (count> 5 ) // 如果程序被使用了超过 5 次，则终止使用，并提示   

21.           { 

22.              System.out.println( " 次数到了，交钱！！！！！ " );  

23.                return  ; 

24.          }  

25.            else   

26.              System.out.println( " 程序第 " +count+ " 次 Run ！ " );  

27.       } 

28.       // 获取程序运行的次数   

29.        public static int  runCount() throws  IOException  

30.      {  

31.           Properties ps= new  Properties(); // 创建集合对象   

32.    

33.           File file= new  File( "info.ini" ); // 将文件进行封装   

34.           if (!file.exists()) // 判断是否存在   

35.               file.createNewFile(); 

36.          FileReader fr= new  FileReader(file); // 将文件于读取流进行关联   

37.            

38.          ps.load(fr); // 加载流中的文件数据到集合中   

39.     

40.           int  count= 0 ; // 定义计数器   

41.           String value=ps.getProperty( "time" ); // 获取次数值   

42.            

43.            if (value!= null ) // 如过值不等于 null ，则将其赋值给 count   

44.          {  

45.               count=Integer.parseInt(value); 

46.          }  

47.           count++; // 每启动一次自增   

48.          ps.setProperty( "time" ,count+ "" ); // 将次数记录住集合   

49.     

50.          FileWriter fw= new  FileWriter(file);  

51.           ps.store(fw, "" ); // 将集合中的数据存入硬盘文件中   

52.            

53.           fr.close(); // 关流   

54.          fw.close(); 

55.     

56.           return  count; // 返回程序启动的次数   

57.       } 

58.  }  

 

第三讲    打印流

一、概述

       1、打印流包括：PrintStream和PrintWriter

       2、该流提供了打印方法，可将各种类型的数据都原样打印。

 

二、字节打印流：PrintStream

构造方法中可接收的参数类型：

       1、File对象。File

       2、字符串路径：String

       3、字符输出流：OutputStream

 

三、字符串打印流：PrintWriter

构造方法中可接受的参数类型

       1、File对象：File

       2、字符串路径：String

       3、字节输出流：OutputStream

       4、字符输出流：Writer

示例

[java]  view plaincopy

1.    import  java.io.*; 

2.     

3.    class   PrintStreamDemo  

4.   {  

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

6.       {  

7.             // 键盘录入   

8.           BufferedReader bufr =  

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

10.    

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

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

13.     

14.          String line =  null ;  

15.     

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

17.           { 

18.               if ( "over" .equals(line)) // 结束字符   

19.                    break ;  

20.              out.println(line.toUpperCase()); 

21.                //out.flush();   

22.          }  

23.            

24.           // 关流   

25.           out.close(); 

26.          bufr.close(); 

27.     

28.      }     

29.   } 

 

第四讲    序列流

一、概述

1、SequenceInputStream对多个流进行合并。也被称为合并流。

2、常用构造函数

      SequenceInputStream(Enumeration e)

 

二、常见合并多个流文件步骤

       1、创建集合，并将流对象添加进集合

       2、创建Enumeration对象，将集合元素加入。

       3、创建SequenceInputStream对象，合并流对象

       4、创建写入流对象，FileOutputStream关联写入文件

       5、利用SequenceInputStream对象和FileOutputStream对象读数据进行反复读写操作。

示例：

[java]  view plaincopy

1.    /*  

2.   SequenceInputStream  

3.    合并流  

4.   需求：将三个文本文件中的数据合并到一个文本文件中  

5.    思路： 1 、创建一个 Vector 集合，将三个文本文件字节流添加到集合中  

6.         2 、创建 Enumeration 对象，创建 SequnceInputStream 对象关联 Enumeration  

7.          3 、输出流关联新文本文件  

8.         4 、反复读写操作  

9.    */   

10.  import  java.util.*;  

11.   import  java.io.*;  

12.    

13.   class   SequenceInputStreamDemo  

14.  {  

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

16.      {  

17.           Vector ve= new  Vector(); // 创建 vector 集合，并添加相关流对象   

18.          ve.add( new  FileInputStream( "1.txt" ));  

19.           ve.add( new  FileInputStream( "2.txt" ));  

20.          ve.add( new  FileInputStream( "3.txt" ));  

21.     

22.          Enumeration en=ve.elements(); // 创建枚举对象   

23.           SequenceInputStream sis= new  SequenceInputStream(en); // 合并流   

24.    

25.           FileOutputStream fos= new  FileOutputStream( "4.txt" ); // 关联写入文件   

26.            

27.            // 反复读写操作   

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

29.            int  len= 0 ;  

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

31.           { 

32.              fos.write(buf, 0 ,len); 

33.           } 

34.            

35.            // 关流   

36.          fos.close(); 

37.           sis.close(); 

38.      }  

39.   } 

练习：

[java]  view plaincopy

1.    /*  

2.   切割文件  

3.    需求：将一个 mp3 文件按 1M 大小切割成几部分  

4.   思路： 1 、使用文件字节流关联 mp3 文件  

5.          2 、定义一个容器存储 1M 大小的数据，当存储满时，写入一个新文件中  

6.    

7.    */   

8.   import  java.util.*;  

9.    import  java.io.*;  

10.    

11.   class   SplitFile  

12.  {  

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

14.      {  

15.            // 指定要切割的文件   

16.          File file= new  File( "C:\\Users\\asus\\Desktop\\ 苏芮  -  一样的月光 .mp3" );  

17.            // 将指定文件进行切割   

18.          splitFile(file); 

19.     

20.           // 指定要合并到的文件   

21.           File file1= new  File( "E:\\Java Study\\Practice\\day20\\splitFile\\ 一样的月光 .mp3" );  

22.           // 将部分文件进行合并指定文件中   

23.           merge(file1); 

24.    

25.       } 

26.       // 接收一个文件，将其按 1M 大小进行切割   

27.        public static void  splitFile(File file) throws  IOException 

28.      {  

29.            // 关联要切割的文件   

30.          BufferedInputStream bis= new  BufferedInputStream( new  FileInputStream(file)); 

31.            

32.          BufferedOutputStream bos= null ;  

33.     

34.           // 定义 1M 大小存储容器   

35.            byte [] buf= new byte [ 1024 * 1024 ];  

36.           int  len= 0 ,x= 0 ;  

37.            while  ((len=bis.read(buf))!=- 1 )  

38.          {  

39.                // 每满 1M 就写入一个新文件中   

40.              bos= new  BufferedOutputStream( new  FileOutputStream( "E:\\Java Study\\Practice\\day20\\splitFile\\"+(++x)+" .part"));  

41.               bos.write(buf, 0 ,len);  

42.              bos.close(); // 没写完一个文件要记得关流   

43.           } 

44.           // 关流   

45.           bis.close(); 

46.      }  

47.     

48.       // 将部分文件合并为一个可执行文件   

49.        public static void  merge(File file) throws  IOException  

50.      {  

51.            // 定义一个集合存储这些部分文件关联路径数据   

52.          ArrayList al= new  ArrayList();  

53.     

54.           for  ( int  x= 1 ;x<= 6  ; x++) 

55.           { 

56.              al.add( new  FileInputStream( "E:\\Java Study\\Practice\\day20\\splitFile\\"+x+" .part"));  

57.           } 

58.            

59.            // 因为 Enumeration 是 Vector 特有的迭代方法，所以这里创建一个 Enumeration 类型的匿名内部类   

60.           final   ListIterator it=al.listIterator(); 

61.           Enumeration en= new  Enumeration() 

62.          {  

63.                public boolean  hasMoreElements()  

64.              { 

65.                    return  it.hasNext(); 

66.              } 

67.     

68.               public  FileInputStream nextElement()  

69.               { 

70.                   return  it.next();  

71.               } 

72.          };  

73.     

74.           // 关联枚举对象   

75.           SequenceInputStream sis= new  SequenceInputStream(en); 

76.    

77.            // 将合并的文件数据写入指定文件中   

78.          FileOutputStream fos= new  FileOutputStream(file);  

79.            

80.           // 定义临时存储数据的数组   

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

82.           int  len= 0 ;  

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

84.          {  

85.               fos.write(buf, 0 ,len); // 写数据   

86.          }  

87.     

88.           // 关流   

89.           fos.close(); 

90.          sis.close(); 

91.     

92.      }  

93.     

94.  }  

 

第五讲：对象操作流ObjectOutputStream

1.什么是对象操作流ObjectOutputStream

 1、该流可以将一个对象写出, 或者读取一个对象到程序中. writeObject

 2、FileInputStream, FileWriter  都不能直接写对象， 而 ObjectOutputStream. writeObject() 可以。

  案例: 1.写字符串 ,2.写自定义对象   

  注意：Serializable也就是执行了序列化和反序列化的操作.

 序列化:从内存保存到硬盘 

 反序列化: 从硬盘读取到内存  

 *

   ObjectInputStream :  可以读取 一个对象 的  

   readObject();  返回的是一个 Object  

   

 * 2.使用方式

 * 写出: new ObjectOutputStream(OutputStream), writeObject()

例子1：

public class Demo1 {
public static void main(String[] args) throws IOException,
ClassNotFoundException {
// 创建对象 ObjectOutputStream
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
"obj1.txt"));


// 写出数据


// oos.write(100);
// oos.write(100000);
oos.writeObject(100);
oos.writeObject(100000);
oos.writeObject("Object");
oos.close();


// 读取
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
"obj1.txt"));


Object readObject = ois.readObject();
System.out.println(readObject);
readObject = ois.readObject();
System.out.println(readObject);
readObject = ois.readObject();
System.out.println(readObject);
}
}

 

 

例子2：

packagecn.itcast_03_object;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

 * 

 * 1. 创建了 n 个对象   

 * 2. 你把 n 个对象 保存的集合中  

 * 3.writeObject( 集合 );

 * 5. 遍历集合就可以 , 获取对象了 .  

public class Demo2 {
public static void main(String[] args) throws IOException,
ClassNotFoundException {
// 创建 User
User u1 = new User("江流儿", 8);
User u2 = new User("傻丫头", 2);
// 创建 ObjectOutputStream
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj2.txt"));
// 写对象
oos.writeObject(u1);// Not Serializable Exception:
oos.writeObject(u2);
// 关流
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj2.txt"));
// 读取对象
Object o1 = ois.readObject();
System.out.println(o1.toString());
User o2 = (User) ois.readObject(); // 强转
System.out.println(o2.toString());
System.out.println(o2.getName() + "--" + o2.getAge());

User o3 = (User) ois.readObject(); // 强转java.io.EOFException End Of File
//System.out.println(o3.toString());
ois.close();
}
}

 

第六讲：数据输入输出流DataInputStream,DataOutputStream

1.什么是 数据输入输出流

* DataInputStream, DataOutputStream 可以按照基本数据类型大小读写数据

* 例如按 Long 大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照 Long 类型读取, 一次读取8个字节.

* 2.使用方式

写入和读取 

p public class Demo {

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

                   

                   DataOutputStream dos = new DataOutputStream(newFileOutputStream("data.txt"));

                   dos.writeInt(100);

                   dos.writeInt(10000);

                   dos.writeInt(1000000);

                   

                   dos.close();

                   

                   DataInputStream dis = new DataInputStream(newFileInputStream("data.txt"));

                   

                   int i1= dis.readInt();

                   int i2= dis.readInt(); 

                   int i3= dis.readInt();

                   System.out.println(i1);

                   System.out.println(i2);

                   System.out.println(i3);

                   

                   dis.close();

                   

         }

}