Java基础 IO流——第一部分

 

新博客地址：Temi

 

                                                               第一讲：IO流(概述)

一，IO流的概述：

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

二，IO流经常使用基类：

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

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

                                                                                      第二讲：IO流(FileWriter)

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

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

二，写入字符流的步骤：

1. 建立一个FileWriter对象。 FileWriter  fw=new FileWriter("Demo.txt");   ==注：初始化该对象时必须明确指出要操做的文件，且该目录下若是已有同名文件，则同名文件将被覆盖。若指定文件不存在则建立文件。若指定文件的父目录不存在则抛出异常。===
2. 对IO操做过程当中所产生的异常进行处理。 public static void main(String args[])  throws IOException   ==用  try  语句捕捉，或者方法声明抛出===
3. 调用 FileWriter 对象的 write() 方法进行写数据。 fw.write("HelloWorld");  ===注：此时写入动做只是写入到了内存当中，即写入到了“流”当中去了，并无真正写入文件===
4. 调用 FileWriter 对象的 flush() 方法刷新流——将数据写入到文件中。fw.flush();     
5. 调用 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 异常处理的一些说明：

1. 只要是发生于设备之间数据处理的动做都会发生 IO  异常。不管都仍是写。以及建立。
2. 一系列的读写操做的异常处理应当放到一个 try 语句快中。
3. 对于必定要执行的动做例如流的关闭，锁的释放，应当放到 finally 语句块中。
4. 在  try 语句外部创建对象的引用，在 try 语句内部进行对象的初始化。  ====避免超出对象做用范围=========
5. 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流(文件的续写)

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

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

二，知识点扩充：

1. 对于续写时换行的操做：window系统中换行用两个字符来表示（\r\n)换行，linux系统中用（\n）换行。
2. 文件分隔符： 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类的了解：

1. FileReader 类的定义： public class FileReader extends InputStreanReader   ===用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。====
2. FileReader 类的构造方法：public FileReader(File file) throws FileNotFoundException ===当指定的文件不存在时抛出FileNotFoundException====
                    public FileReader(File file) throws FileNotFoundException 
3. 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   读取字符，此方法被屡次重载，能够向字符数组中读取。

二，文本文件读取过程：

1. 以指定名称的文件，建立一个文件读取流对象。  FileReader  fr=new FileReader("Demo.txt");====若文件不存在抛出FileNotFoundException 异常======
2. 调用读取流对象的 read() 方法     int  ch=fr.read();  ===read() 方法一次读取一个字符，返回字符的整形编码，且会自动往下读。若想一次读取多个字符可经过字符数组进行读取===
3. 当读取函数返回-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流(文本文件读取方式二)

一，用到的方法：

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

二，注意事项：

1. 当在使用字符数组中读取的字符串时，应当注意读取个数问题，避免重复取。new String (cbuf,0,num);  其中num表明读取的字符个数。
2. 一般状况下，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流(文本文件读取练习)

一，练习要求：

1. 读取一个 .java 文件并打印到控制台上。
2. 将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 }