黑马程序员——————IO （一

第一讲     IO概述

概述

1、IO流：即InputOutput的缩写。

2、特点：

        1）IO流用来处理设备间的数据传输。

        2）Java对数据的操作是通过流的方式。

        3）Java用于操作流的对象都在IO包中。

        4）流按操作数据分为两种：字节流和字符流。

        5）流按流向分为：输入流和输出流。

注意：流只能操作数据，而不能操作文件。

3、IO流的常用基类：

        1）字节流的抽象基流：InputStream、OutputStream

        2）字符流的抽象基流：Reader、Writer

注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream；Reader子类FileReader

 

第二讲    字符流

一、简述

        1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。

        2、字符流只用于处理文字数据，而字节流可以处理媒体数据。

        3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。查看API，找到一个专门用于操作文件的Writer子类对象：FileWriter。   后缀是父类名。前缀名是流对象的功能。该流对象一被初始化，就必须有被操作的文件存在。

 

二、字符流的读写

1、写入字符流步骤

        a、创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步就是在明确数据要存放的目的地。

        b、调用write(String s)方法，将字符串写入到流中。

        c、调用flush()方法，刷新该流的缓冲，

        d、调用close()方法，关闭流资源。但是关闭前会刷新一次内部的缓冲数据。

close()和flush()区别：

        flush()刷新后，流可以继续使用；

       而close()刷新后，将会关闭流，不可再写入字符流。

 示例：

[java]  view plain copy

1. import java.io.*;  
2.   
3. class FileWriterDemo   
4. {  
5.     public static void main(String[] args)   
6.     {  
7.         writerDemo("abcde");//写入数据  
8.         writerFrom("zheshi:\r\nshenma");//续写数据，并附换行操作  
9.     }  
10.   
11.     //在硬盘上创建一个文件并写入指定数据  
12.     public static void writerDemo(String s)  
13.     {  
14.         FileWriter fw=null;  
15.         try  
16.         {  
17.             fw=new FileWriter("demo.txt");//创建文件  
18.             fw.write(s);//将数据写入流  
19.         }  
20.         catch (IOException e)  
21.         {  
22.             throw new RuntimeException("写入失败");  
23.         }  
24.         finally  
25.         {  
26.             if(fw!=null)  
27.                 try  
28.                 {  
29.                     fw.close();//将写入流的数据刷到指定文件内，并关闭流资源  
30.                 }  
31.                 catch (IOException e)  
32.                 { 
33. throw new RuntimeException("关闭失败");   
34.                 }  
35.         }  
36.     }  
37.   
38.     //对已有文件的数据续写指定数据  
39.     public static void writerFrom(String s)  
40.     {  
41.         FileWriter fw=null;  
42.         try  
43.         {  
44.             fw=new FileWriter("demo.txt",true);//传递一个true参数，代表从结尾开始续写数据。  
45.             fw.write(s);  
46.         }  
47.         catch (IOException e)  
48.         {  
49.             throw new RuntimeException("写入失败");  
50.         }  
51.         finally  
52.         {  
53.             try  
54.             {  
55.                 if(fw!=null)  
56.                     fw.close();  
57.             }  
58.             catch (IOException e)  
59.             {  
60. throw new RuntimeException("关闭失败");
61.             }  
62.         }  
63.     }  
64. }  

2、读取字符流步骤

        1）创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常FileNotFoundException。

        2）调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。

              第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。

        3）读取后要调用close方法将流资源关闭。

示例：

[java]  view plain copy

1. import java.io.*;  
2. class  FileReaderDemo  
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         //第一种读取方式  
7.         singleCharReader();  
8.         //第二种读取方式  
9.         arrayCharReader();  
10.     }  
11.   
12.     //第一种读取方式，单个字符读取  
13.     public static void singleCharReader()  
14.     {  
15.         FileReader fr=null;  
16.         try  
17.         {  
18.               
19.             fr=new FileReader("demo.txt");//读取文件位置和文件名  
20.             for (int ch=0;(ch=fr.read())!=-1 ; )  
21.             {  
22.                 System.out.print((char)ch);  
23.             }  
24.         }  
25.         catch (IOException e)  
26.         {  
27.             throw new RuntimeException("读取失败");  
28.         }  
29.         finally  
30.         {  
31.             try  
32.             {  
33.                 if(fr!=null)  
34.                     fr.close();//关闭读取流资源  
35.             }  
36.             catch (IOException e)  
37.             {  
38.             }  
39.         }  
40.     }  
41.   
42.     //第二种读取方式，通过字符数组进行读取  
43.     public static void arrayCharReader()  
44.     {  
45.         FileReader fr=null;  
46.         char[] arr=new char[1024];//定义一个字符数组，用于临时存储读取的字符  
47.         try  
48.         {  
49.             //读取一个.java文件，并打印在控制台上。  
50.             fr=new FileReader("FileReaderDemo.java");  
51.             for (int len=0;(len=fr.read(arr))!=-1 ; )  
52.             {  
53.                 //显示字符数组的字符个数  
54.                 System.out.print(new String(arr,0,len));  
55.             }  
56.         }  
57.         catch (IOException e)  
58.         {  
59.             throw new RuntimeException("读取失败");  
60.         }  
61.         finally  
62.         {  
63.             if(fr!=null)  
64.                 try  
65.                 {  
66.                     fr.close();  
67.                 }  
68.                 catch (IOException e)  
69.                 {  
70.                 }  
71.         }  
72.     }  
73. }  

注意：

        1、定义文件路径时，可以用“/”或者“\\”。

        2、在创建一个文件时，如果目录下有同名文件将被覆盖。

        3、在读取文件时，必须保证该文件已存在，否则出异常。

小练习：文本文件的后缀名

	public static void FileDemo(){
		//方法一
		File f =null;
		try {
			//制定路径文件夹
			 f=new File("e:\\abc");
			//boolean  bool = f.createNewFile();
			// boolean bool1 = f.isFile();
			//if(bool1){
			 //将文件夹中的文件赋值给String数组
				File[] str = f.listFiles();
				for(File fe :str){
					//判断String数组中的带有什么后缀名的文件如果有就为true
					if(fe.getName().indexOf(".txt")!=-1){
					System.out.println(fe.getName());
					}
			//	}
			//}else{
				//System.out.println("创建失败");
		}
		} catch (Exception e) {
		   e.printStackTrace();
		}
	}
}