Java基础 IO流——第一部分

新博客地址：Temi

第一讲：IO流(概述)

一，IO流的概述：

IO流用来处理设备间的数据传输。 ===注：设备包括硬盘文件，和内存数据=======
Java对数据的操作是通过流的方式。
Java用于操作流的对象都在IO（java.io)包中。===注： nio 是java nonblocking(非阻塞) IO 的简称，在jdk1.4 里提供的新api。(在包java.nio中).====
流按操作数据分为两种：字节流和字符流。 ===注：无论是内存中的数据还是硬盘中的，他们的体现形式都是二进制形式，即：字节。字符流：字符流的产生是为了方便于处理文本数据，字符流内部融合和字符的编码表。使处理字符变得更加方便简单。字符流只用于处理文字数据，而字节流可以处理媒体数据====
流按流向分为：输入流和输出流。

二，IO流常用基类：

字节流抽象基类：InputStream ,OutputStream。
字符流抽象基类：Reader , Writer。

=========注：由这四个基类派生出的子类名称都是以父类名称作为后缀的，例如FileInputStream 是 InputStream 类的子类 FileWriter 是Writer 类的子类。前缀名是流对象的功能=========

第二讲：IO流(FileWriter)

一，Writer类的基本了解（查阅API)：

Writer 类的定义：public abstract class Writerextends Object implements Appendable, Closeable,Flushable
构造方法： protected Writer() ===注：构造方法私有化，不能被直接实例化====
常用方法：    public abstract void close() throws IOException       ——关闭流，关闭之前刷新流。
                        public abstract void flush() throws IOException      ——刷新流。
                       public void write(char[] cbuf) throws IOException   ——向流中写数据。===注：此方法针对 int 类型 String 类型都有重载。

二，写入字符流的步骤：

创建一个FileWriter对象。 FileWriter fw=new FileWriter("Demo.txt"); ==注：初始化该对象时必须明确指出要操作的文件，且该目录下如果已有同名文件，则同名文件将被覆盖。若指定文件不存在则创建文件。若指定文件的父目录不存在则抛出异常。===
对IO操作过程中所产生的异常进行处理。 public static void main(String args[]) throws IOException ==用 try 语句捕捉，或者方法声明抛出===
调用 FileWriter 对象的 write() 方法进行写数据。 fw.write("HelloWorld"); ===注：此时写入动作只是写入到了内存当中，即写入到了“流”当中去了，并没有真正写入文件===
调用 FileWriter 对象的 flush() 方法刷新流——将数据写入到文件中。fw.flush();
调用 FileWriter 对象的 close() 方法关闭流。 ===注：关闭流时同样会触发流的刷新。close() 方法和 flush() 方法的区别在于 flush 之后流任然可以继续使用。========

===知识点扩展：Java语言本身是不能往硬盘里面写数据的（不同系统写入数据方式不同）。Java的数据写入会调用系统的写入资源。系统资源使用后必须关闭===

三，代码练习：

 1 //导入需要用到的包。
 2 import java.io.*;
 3 
 4 public class FileWriterDemo{
 5                    public static void main(String args[]) throws IOException{
 6                                
 7 
 8                     //创建一个 FileWriter 对象
 9                     FileWriter fw=new FileWriter("Demo.txt");
10 
11                     //调用Writer 方法写入数据
12                      fw.writer("HelloWorld");
13 
14                      //刷新流
15                      fw.flush();
16 
17                      //关闭流，同样会触发刷新
18                      fw.close();
19                      }
20 }

第三讲：IO流(IO异常处理方式)

一，对于 IO 异常处理的一些说明：

只要是发生于设备之间数据处理的动作都会发生 IO 异常。无论都还是写。以及创建。
一系列的读写操作的异常处理应当放到一个 try 语句快中。
对于一定要执行的动作例如流的关闭，锁的释放，应当放到 finally 语句块中。
在 try 语句外部建立对象的引用，在 try 语句内部进行对象的初始化。 ====避免超出对象作用范围=========
finally 语句中在进行资源关闭之前应当先判断对象是否为空，避免发生空指针异常。

二，代码练习：

 1 import java.io.*;
 2 
 3 public class FileWriterDemo2{
 4                     public static void main(String args[]){
 5                           
 6                      //在 try 语句外面建立对象引用
 7                       FileWriter fw=null;
 8 
 9 
10                     //try 语句捕获异常
11                       try{
12 
13 
14                             //try 内部进行对象初始化
15                             fw=new FileWriter("Demo.txt");
16                              
17                             //写入数据
18                              fw.write("HelloHeiMa");
19                            }catch (IOException e){
20                                 System.out.println(e.toString());
21                            }finally{
22 
23 
24                                        //关闭动作同样进行  try 处理
25                                        try{
26                                                //判断 fw 是否为空
27                                               if(fw!=null)
28                                                        fw.close();
29                                             }catch (IOException e){
30                                                System.out.println(e.toSring());
31                                             }
32                    }
33 }

第四讲：IO流(文件的续写)

一，进行数据续写思路的分析：

分析之前代码覆写操作的发生。即：FileWriter fw=new FileWriter("Demo.txt"); 此操作目的文件若存在会覆盖。
寻找解决办法。查阅 API 找到 FileWriter 类的构造方法：FileWriter(String fileName,boolean append);
解决问题： FileWriter fw=new FileWriter("Demo.txt",true);

二，知识点扩充：

对于续写时换行的操作：window系统中换行用两个字符来表示（\r\n)换行，linux系统中用（\n）换行。
文件分隔符： window 系统下文件分割可以使用“\\"表示，其中第一个”\“ 表示转义。也可以用”/“作为文件分割符。

三，代码练习：

 1 import java.io.*;
 2 
 3 
 4 public class FileWriterDemo3 {
 5              public static void main(String args[]){
 6                   
 7                      //声明FileWriter对象
 8                      FileWriter fw=null;
 9                      try{
10                          
11                          //以追加方式实例化FileWriter对象，
12                          fw=new FileWriter("E:/demo.txt",true);
13                          
14                          //向文件中追加数据
15                          fw.write("abcd\r\nHeiMa");
16                      }catch(IOException e){
17                          System.out.println("内容写入失败");
18                      }finally{
19                          
20                          
21                          //关闭系统资源
22                           try{
23                               if(fw!=null)
24                                   fw.close();
25                           }catch(IOException e){
26                               System.out.println("关闭流操作失败");
27                           }
28                      }
29              }
30 }

第五讲：IO流(文本文件读取方式一)

一，FileReader类的了解：

FileReader 类的定义： public class FileReader extends InputStreanReader ===用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。====
FileReader 类的构造方法：public FileReader(File file) throws FileNotFoundException ===当指定的文件不存在时抛出FileNotFoundException==== public FileReader(File file) throws FileNotFoundException
FileReader 类的常用方法： public void close()    关闭流。
                                     public void mark   (int readAheadLimit) throws IOException    标记流中的当前位置。
                                     public long skip   (long n) throws IOException           跳过字符。
                                     public void reset() throws IOException       重置该流。
                                     public int read() throws IOException   读取字符，此方法被多次重载，可以向字符数组中读取。

二，文本文件读取过程：

以指定名称的文件，创建一个文件读取流对象。 FileReader fr=new FileReader("Demo.txt");====若文件不存在抛出FileNotFoundException 异常======
调用读取流对象的 read() 方法 int ch=fr.read(); ===read() 方法一次读取一个字符，返回字符的整形编码，且会自动往下读。若想一次读取多个字符可通过字符数组进行读取===
当读取函数返回-1时表示达到文件末尾，此时应该关闭流。fr.close();

三，代码练习：

 1 import java.io.*;
 2 
 3 
 4 public class FileWriterDemo4 {
 5                public static void main(String args[]){
 6                    
 7                    
 8                    //声明文件读写对象
 9                    FileReader fr=null;
10                    
11                    
12                    //实例化对象，进行文件读写
13                    try{
14                        
15                        //若文件不存在抛出FileNotFoundException异常
16                        fr=new FileReader("E:\\demo.txt");
17                        
18                        //定义int 变量ch 接受读取结果
19                        int ch;
20                        
21                        //若读取结果为-1则表示到达文件末尾，读取结束
22                        while((ch=fr.read())!=-1)
23                            System.out.println("ch"+(char)ch);
24                        System.out.println("读取完毕");
25                        
26                        
27                        //文件不存在的异常处理
28                    }catch(FileNotFoundException e){
29                        System.out.println("指定的文件不存在");
30                    }catch(IOException e){
31                        System.out.println("读取文件发生错误");
32                    }finally{
33                        
34                        //关闭系统资源
35                        try{
36                            if(fr!=null)
37                                fr.close();
38                        }catch(IOException e){
39                            System.out.println("关闭文件发生错误");
40                        }
41                    }
42                }
43 }

第六讲：IO流(文本文件读取方式二)

一，用到的方法：

public int read(char[] cbuf) throws IOException 将字符读入数组。==注意此时的返回值，此时返回的 int 值并不是字符的编码，而是读入字符数组中的字符数量。如果已到达流的末尾，则返回 -1==
public int read(char[] cbuf,int off,int len) throws IOException 将字符读入数组的某一部分。off--开始下标（包括），len (读取长度）。如果已到达流的末尾，则返回 -1

二，注意事项：

当在使用字符数组中读取的字符串时，应当注意读取个数问题，避免重复取。new String (cbuf,0,num); 其中num代表读取的字符个数。
通常情况下，char数组的大小定义为 1024 的整数倍。char[] cbuf=new char[1024];

三，代码练习：

 1 import java.io.*;
 2 
 3 
 4 public class FileWriterDemo4 {
 5                public static void main(String args[]){
 6                    
 7                    
 8                    //声明文件读写对象
 9                    FileReader fr=null;
10                    
11                    
12                    //实例化对象，进行文件读写
13                    try{
14                        
15                        //若文件不存在抛出FileNotFoundException异常
16                        fr=new FileReader("E:\\demo.txt");
17                        
18                        //定义整形变量表示读取到的字符数量
19                        int ch;
20                        
21                        
22                        //定义字符数组向里读取字符
23                        char[] cbuf=new char[1024];
24                        
25                        //若读取结果为-1则表示到达文件末尾，读取结束
26                        while((ch=fr.read(cbuf))!=-1)
27                            
28                            //截取有效的字符数
29                            System.out.println(new String(cbuf,0,ch));
30                        System.out.println("读取完毕");
31                        
32                        
33                        //文件不存在的异常处理
34                    }catch(FileNotFoundException e){
35                        System.out.println("指定的文件不存在");
36                    }catch(IOException e){
37                        System.out.println("读取文件发生错误");
38                    }finally{
39                        
40                        //关闭系统资源
41                        try{
42                            if(fr!=null)
43                                fr.close();
44                        }catch(IOException e){
45                            System.out.println("关闭文件发生错误");
46                        }
47                    }
48                }
49 }

第七讲：IO流(文本文件读取练习)

一，练习要求：

读取一个 .java 文件并打印到控制台上。
将C盘一个文本文件复制到D盘。 ====复制的原理：读一次写一次=========

二，实现代码：

1，打印文件：

package com.examp.ch18;


import java.io.*;


public class FileWriterDemo4 {
               public static void main(String args[]){
                   
                   
                   //声明文件读写对象
                   FileReader fr=null;
                   
                   String filename="E:\\test.java";
                   
                   //判断文件名是否为.java 结尾。
                   if(!filename.endsWith(".java")){
                       System.out.println("目标文件后坠名不是.java");
                       return;
                   }
                       
                   //实例化对象，进行文件读写
                   try{
                       
                       //若文件不存在抛出FileNotFoundException异常
                       fr=new FileReader(filename);
                       
                       //定义整形变量表示读取到的字符数量
                       int ch;
                       
                       
                       //定义字符数组向里读取字符
                       char[] cbuf=new char[1024];
                       
                       //若读取结果为-1则表示到达文件末尾，读取结束
                       while((ch=fr.read(cbuf))!=-1)
                           
                           //截取有效的字符数
                           System.out.println(new String(cbuf,0,ch));
                       System.out.println("读取完毕");
                       
                       
                       //文件不存在的异常处理
                   }catch(FileNotFoundException e){
                       System.out.println("指定的文件不存在");
                   }catch(IOException e){
                       System.out.println("读取文件发生错误");
                   }finally{
                       
                       //关闭系统资源
                       try{
                           if(fr!=null)
                               fr.close();
                       }catch(IOException e){
                           System.out.println("关闭文件发生错误");
                       }
                   }
               }
}

2，复制文件：

 1 import java.io.*;
 2 
 3 
 4 public class FileWriterDemo4 {
 5                public static void main(String args[]){
 6                    if(copy("E:\\test.java","F:\\demo.txt"))
 7 
 8 
 9                            //复制成功给出提示
10                        System.out.println("复制成功");
11                }
12                
13                
14                public  static boolean copy(String srcfile,String dest){
15 
16                        //声明读文件对象以及写文件对象的引用。
17                        FileReader fr=null;
18                        FileWriter fw=null;
19                        
20                        
21                        //定义int变量表示读取的字符数
22                        int ch;
23 
24                        //定义字符数组，用来读取
25                        char[] cbuf=new char[1024];
26                        try{
27 
28                            //分别实例化源文件的读对象，以及目的文件的写对象
29                            fr=new FileReader(srcfile);
30                            fw=new FileWriter(dest);
31                            
32 
33                           //边读边写，实现文件复制
34                            while((ch=fr.read(cbuf))!=-1){
35                                fw.write(cbuf, 0, ch);
36                            }
37                            
38                            
39                            //复制成功返回true
40                            return true;
41                        }catch(FileNotFoundException e){
42                          
43                             //产生异常，给出提示，返回false
44                            System.out.println(e.toString());
45                            return false;
46                        }catch(IOException e){
47 
48 
49                            //产生异常，给出提示，返回false
50                            System.out.println("复制文件产生错误");
51                            return false;
52                        }finally{
53 
54                            //释放系统资源
55                            try{
56                                if(fr!=null)
57                                    fr.close();
58                                if(fw!=null)
59                                    fw.close();
60                            }catch(IOException e){
61 
62 
63                                    //产生异常，给出提示。                                                       System.out.println("关闭文件产生错误！");
64                            }
65                        }
66                }
67 }

posted @ 2014-10-22 14:14 小虫伯爵阅读(1529) 评论(4) 编辑收藏举报

刷新页面返回顶部

小虫伯爵

Java基础 IO流——第一部分

公告