黑马程序员——JAVA学习笔记——IO

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

JAVA IO

JAVA IO操作主要指的是使用JAVA进行输入、输出操作，JAVA中的所有操作类都存放在JAVA.io包中，在使用时必须导入该包。

  在java.io包中重点为5个类和一个接口。5个类指的是：File、OutputStream、InputStream、Writer、Reader;一个接口指的是：Serializable

 

1、操作文件的类： File

在整个io 包中，唯一与文件本身有关的的类就是File.使用File类可以进行创建或删除文件等操作；

      File类的构造方法：

  public File(String pathname)   ---->实例化File类时，必须设置好路径

 

File 类中的常用方法：

   ||-表示路径的分隔符，如Windows为：“；”—>public static final String pathSeparator ;

   ||-表示路径的分隔符，如Windows为：“\”------>public static final String separator

   ||-创建新文件：public boolean createNewFile() throws IOException

   ||-删除文件：public boolean delete()

   ||-判断文件是否存在：public boolean exists()

   ||-判断给定的路径是否是一个路径：public boolean isDirectory()

   ||-返回文件的大小：Public long length()

   ||-列出指定目录的全部内容，只列出名称：public String[] list()

   ||-列出指定目录的全部内容，会列出路径：Public File[] listFiles()

   ||-创建一个目录：public boolean mkdir()

   ||-为已有的文件重命名：public boolean renameTo(File dest)

练习所列举的方法： 

列出指定目录的全部内容;

import java.io.File ;

import java.io.IOException ;

public class Test{

public static void main(String args[]){

        File my = new File("d:" + File.separator) ;  // 操作路径

        print(my) ;

}

public static void print(File file){  // 递归调用

        if(file!=null){  // 判断对象是否为空

               if(file.isDirectory()){     // 如果是目录

                      File f[] = file.listFiles() ;       // 列出全部的文件

                      if(f!=null){     // 判断此目录能否列出

                             for(int i=0;i<f.length;i++){

                                    print(f[i]) ;      // 因为给的路径有可能是目录，所以，继续判断

                             }

                      }

               }else{

                      System.out.println(file) ;       // 输出路径

               }

        }

}

};

1.1使用RandomAccessFile类对文件读取：

  RandomAccessFile主要对文件内容进行读取，其读取规则属于随机读取类，它可以随机的读取一个文件中指定位置的数据。

RandomAccessFile类中的常用方法：

   ||-接收File类的对象，指定操作路径，但是在设置时需要设置模型，r为只读；w为只写；rw为读写--------->public RandomAccessFile(File file,String mode) throws FileNotFoundException

   ||-关闭操作：public void close() throws IOException

   ||-将内容读取到一个Byte数组中：public int read(Byte[] b)throws IOException

   ||-从文件中读取整形数据：public final int readInt()throws IOException

注意：在使用mode是如果是用的“rw”操作则会自动创建新文件

代码样板测试：

1、 写入文件：

import java.io.File ;

import java.io.RandomAccessFile ;

public class RandomAccessFileDemo01{

// 所有的异常直接抛出，程序中不再进行处理

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

        File f = new File("d:" + File.separator + "test.txt") ;   // 指定要操作的文件

        RandomAccessFile rdf = null ;           // 声明RandomAccessFile类的对象

        rdf = new RandomAccessFile(f,"rw") ;// 读写模式，如果文件不存在，会自动创建

        String name = null ;

        int age = 0 ;

        name = "zhangsan" ;                   // 字符串长度为8

        age = 30 ;                                  // 数字的长度为4

        rdf.writeBytes(name) ;        // 将姓名写入文件之中

        rdf.writeInt(age) ;                // 将年龄写入文件之中

        name = "lisi    " ;               // 字符串长度为8

        age = 31 ;                                  // 数字的长度为4

        rdf.writeBytes(name) ;        // 将姓名写入文件之中

        rdf.writeInt(age) ;                // 将年龄写入文件之中

        name = "wangwu  " ;                 // 字符串长度为8

        age = 32 ;                                  // 数字的长度为4

        rdf.writeBytes(name) ;        // 将姓名写入文件之中

        rdf.writeInt(age) ;                // 将年龄写入文件之中

        rdf.close() ;                         // 关闭

}

};

代码运行之后会在d盘下创建一个test.txt文件，并且写入了内容“zhangsan    30  lisi   31   wangwu   32 ”

 

2、 读取文件内容：

import java.io.File ;

import java.io.RandomAccessFile ;

public class Test{

// 所有的异常直接抛出，程序中不再进行处理

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

        File f = new File("d:" + File.separator + "test.txt") ;   // 指定要操作的文件

        RandomAccessFile rdf = null ;           // 声明RandomAccessFile类的对象

        rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件

        String name = null ;

        int age = 0 ;

        byte b[] = new byte[8] ;       // 开辟byte数组

        // 读取第二个人的信息，意味着要空出第一个人的信息

        rdf.skipBytes(12) ;        // 跳过第一个人的信息

        for(int i=0;i<b.length;i++){

               b[i] = rdf.readByte() ;   // 读取一个字节

        }

        name = new String(b) ; // 将读取出来的byte数组变为字符串

        age = rdf.readInt() ;      // 读取数字

        System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

        // 读取第一个人的信息

        rdf.seek(0) ;   // 指针回到文件的开头

        for(int i=0;i<b.length;i++){

               b[i] = rdf.readByte() ;   // 读取一个字节

        }

        name = new String(b) ; // 将读取出来的byte数组变为字符串

        age = rdf.readInt() ;      // 读取数字

        System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

        rdf.skipBytes(12) ; // 空出第二个人的信息

        for(int i=0;i<b.length;i++){

               b[i] = rdf.readByte() ;   // 读取一个字节

        }

        name = new String(b) ; // 将读取出来的byte数组变为字符串

        age = rdf.readInt() ;      // 读取数字

        System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

        rdf.close() ;                         // 关闭

}

};

2、字节流与字符流基本操作：

在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据时使用输入流读取数据，而当程序需要将一些数据保存起来时，就要使用输出流、

  而在java.io包中流的操作主要有字节流、字符流两大类，在字节流中使用OutputStream 进行数据输出，InputStream进行数据输入；在字符流中使用Writer类完成，输入主要是使用Reader类完成

不过大体步骤是一样：

l         使用一个File类打开一个文件

l         通过字节流或字符流的子类指定输出的位置

l         进行读/写操作

l         关闭输入/输出

 

2.1字节输出流：OutputStream

定义格式;  public abstract class OutputStream extends Object implements Closeable,Flushable

常用的方法：

   ||-关闭输出流：public void close() throws IOException

   ||-刷新缓存区：public void flush() throws IOException

   ||-将一个byte数组写入数据流：public void write(byte[] b) throws IOException

   ||-将一个指定范围的byte数组写入流:public void write(byte[] b,int off,int len) throws IOException

   ||-将一个字节流数据写入数据流：public abstract void write(int b) throws IOException

因为OutputStream类是一个抽象类，如果要使用此类，则必须使用其子类实例化对象；如：使用FileOutputStream类操作一个文件。

实例操作一：向文件中写入字符串

import java.io.File ;

import java.io.OutputStream ;

import java.io.FileOutputStream ;

public class Test{

       public static void main(String args[]) throws Exception{   // 异常抛出，不处理

              // 第1步、使用File类找到一个文件

              File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象

              // 第2步、通过子类实例化父类对象

              OutputStream input = null ;   // 准备好一个输入的对象

              input = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化

              // 第3步、进行读操作

              String str="hello world!!!";

              byte b[] = str.getBytes() ;            // 所有的内容都读到此数组之中

              input.write(b) ;             // 读取内容

              // 第4步、关闭输出流

              input.close() ;                                    // 关闭输出流

              System.out.println("内容为：" + new String(b)) ;     // 把byte数组变为字符串输出

       }

};

实例操作二：在之前的文本中追加内容

采用方法：public FileOutputStream(File file, boolean appeand) throws FileNotFoundException

此时在构造方法中，如果修改append 的值设置为true ,则表示在文件的末尾追加内容。

import java.io.File ;

import java.io.OutputStream ;

import java.io.FileOutputStream ;

public class Test{

       public static void main(String args[]) throws Exception{   // 异常抛出，不处理

              // 第1步、使用File类找到一个文件

              File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象

              // 第2步、通过子类实例化父类对象

              OutputStream out = null ;     // 准备好一个输出的对象

              out = new FileOutputStream(f,true)  ;       // 此处表示在文件末尾追加内容

              // 第3步、进行写操作

              String str = "Hello World!!!" ;             // 准备一个字符串

              byte b[] = str.getBytes() ;                   // 只能输出byte数组，所以将字符串变为byte数组

              for(int i=0;i<b.length;i++){           // 采用循环方式写入

                     out.write(b[i]) ;      // 每次只写入一个内容

              }

              // 第4步、关闭输出流

              out.close() ;                                       // 关闭输出流

       }

};

如果需要换行！可以使用”\r\n”，如：String str=”\r\n Hello World!!!”

2.2、字节输入流：InputStream

  定义方法：public abstract class InputStream extends Object implements Closeable,

  常用的方法：

    ||-取得输入文件的大小; public int  available() throws IOException

    ||-关闭输入流：Public void close() throws IOException

    ||-读取内容，以数字的方式读取：public abstract int  read() throws IOException

    ||-将内容读到byte数组中，同时返回读入的个数： public int read(byte[] b)throws IOException

   同样以FileInputStream类为其实例化对象；

实例操作一:从文件中读取内容；

import java.io.File ;

import java.io.InputStream ;

import java.io.FileInputStream ;

public class Test{

       public static void main(String args[]) throws Exception{   // 异常抛出，不处理

              // 第1步、使用File类找到一个文件

              File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象

              // 第2步、通过子类实例化父类对象

              InputStream input = null ;     // 准备好一个输入的对象

              input = new FileInputStream(f)  ;      // 通过对象多态性，进行实例化

              // 第3步、进行读操作

              byte b[] = new byte[1024] ;         // 所有的内容都读到此数组之中

              int len=input.read(b) ;           // 读取内容

              // 第4步、关闭输出流

              input.close() ;                                    // 关闭输出流

       System.out.println(“读入数据的长度：”+len)

              System.out.println("内容为：" + new String(b)) ;     // 把byte数组变为字符串输出

       }

};

实例操作二：开辟指定大小的byte数组

 使用File类中的length()方法获取一个文件的大小

import java.io.File ;

import java.io.InputStream ;

import java.io.FileInputStream ;

public class Test{

       public static void main(String args[]) throws Exception{   // 异常抛出，不处理

              // 第1步、使用File类找到一个文件

              File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象

              // 第2步、通过子类实例化父类对象

              InputStream input = null ;     // 准备好一个输入的对象

              input = new FileInputStream(f)  ;      // 通过对象多态性，进行实例化

              // 第3步、进行读操作

              byte b[] = new byte[(int)f.length()] ;          // 数组大小由文件决定

              int len = input.read(b) ;         // 读取内容

              // 第4步、关闭输出流

              input.close() ;                                    // 关闭输出流\

              System.out.println("读入数据的长度：" + len) ;

              System.out.println("内容为：" + new String(b)) ;     // 把byte数组变为字符串输出

       }

};

3、字符流

 在程序中一个字符等于两个字节，JAVA提供了Writer类和Reader类进行操作

3.1 字符输出流Writer

  定义格式;  public abstract class Writer extends Object implements Appendale ,Closeable.Flushable

常用的方法;

||-关闭输出流：public abstract void close() throws IOException

||-将字符串输入：public void write(String str) throws IOException

||-将字符数组输出：public void write(char[] cbuf) throws IOException

||-强制性清空缓存：public abstract void flush() throws IOException

实例操作一：向文件中写入数据

import java.io.File ;

import java.io.Writer ;

import java.io.FileWriter ;

public class Test{

       public static void main(String args[]) throws Exception{   // 异常抛出，不处理

              // 第1步、使用File类找到一个文件

              File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象

              // 第2步、通过子类实例化父类对象

              Writer out = null ;  // 准备好一个输出的对象

              out = new FileWriter(f)  ;    // 通过对象多态性，进行实例化

              // 第3步、进行写操作

              String str = "Hello World!!!" ;             // 准备一个字符串

              out.write(str) ;                                          // 将内容输出，保存文件

              // 第4步、关闭输出流

              out.close() ;                                       // 关闭输出流

       }

};

实例操作二;：使用FileWriter追加文件的内容

public FileWriter(File file,boolean append) throws IOException

 

import java.io.File ;

import java.io.Writer ;

import java.io.FileWriter ;

public class Test{

       public static void main(String args[]) throws Exception{   // 异常抛出，不处理

              // 第1步、使用File类找到一个文件

              File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象

              // 第2步、通过子类实例化父类对象

              Writer out = null ;  // 准备好一个输出的对象

              out = new FileWriter(f,true)  ;    // 通过对象多态性，进行实例化

              // 第3步、进行写操作

              String str = "\r\nCSDN\r\nHello World!!!" ;              // 准备一个字符串

              out.write(str) ;                                          // 将内容输出，保存文件

              // 第4步、关闭输出流

              out.close() ;                                       // 关闭输出流

       }

};

3.2、字符输入流Reader

定义;  public abstract class Reader extends Object  implements Readable,Closeable

可以使用FileReader子类为其实例化，

其中FileReader 的构造方法为：

public FileReader(File file) throws FileNotFoundException

常用的方法：

  ||-关闭输出流：public abstract void close() throws IOException

  ||-读取单个字符：public int read() throws IOException

  ||-将内容读到字符数组中，返回读入的长度:public int read(char[]  cbuf)throws IOException

实例操作一: 从文件中读取内容

import java.io.File ;

import java.io.Reader ;

import java.io.FileReader ;

public class Test{

       public static void main(String args[]) throws Exception{   // 异常抛出，不处理

              // 第1步、使用File类找到一个文件

              File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象

              // 第2步、通过子类实例化父类对象

              Reader input = null ;     // 准备好一个输入的对象

              input = new FileReader(f)  ;       // 通过对象多态性，进行实例化

              // 第3步、进行读操作

              char c[] = new char[1024] ;        // 所有的内容都读到此数组之中

              int len = input.read(c) ;         // 读取内容

              // 第4步、关闭输出流

              input.close() ;                                    // 关闭输出流

              System.out.println("内容为：" + new String(c,0,len)) ;    // 把字符数组变为字符串输出

       }

};

实例操作二：使用循环的方式读取内容

import java.io.File ;

import java.io.Reader ;

import java.io.FileReader ;

public class Test{

       public static void main(String args[]) throws Exception{   // 异常抛出，不处理

              // 第1步、使用File类找到一个文件

              File f= new File("d:" + File.separator + "test.txt") ;    // 声明File对象

              // 第2步、通过子类实例化父类对象

              Reader input = null ;     // 准备好一个输入的对象

              input = new FileReader(f)  ;       // 通过对象多态性，进行实例化

              // 第3步、进行读操作

              char c[] = new char[1024] ;        // 所有的内容都读到此数组之中

              int temp = 0 ;  // 接收每一个内容

              int len = 0 ;            // 读取内容

              while((temp=input.read())!=-1){

                     // 如果不是-1就表示还有内容，可以继续读取

                     c[len] = (char)temp ;

                     len++ ;

              }

              // 第4步、关闭输出流

              input.close() ;                                    // 关闭输出流

              System.out.println("内容为：" + new String(c,0,len)) ;    // 把字符数组变为字符串输出

       }

};

4、字节流和字符流的区别：

 字节流在操作时本身不会用到缓存区（内存），是文件本身直接操作，而字符流在操作时使用了缓存区，通过缓存区在操作文件,如下图;

 

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------