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<String> 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<?extendsFileInputStream> 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<InputStream> ve=new Vector<InputStream>();//创建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<InputStream> 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<FileInputStream> al=new ArrayList<FileInputStream>();  

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<FileInputStream> it=al.listIterator(); 

61.          Enumeration<FileInputStream> en=new Enumeration<FileInputStream>() 

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.使用方式

写入和读取 

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

                   

         }

}