Java IO

曾经终败给现在 2022-06-09 09:27 69阅读 0赞

![stream][]

### IO流 ###

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。

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

Java对数据的操作是通过流的方式。Java用于操作流的对象都在IO包中。

流按方向分为：输入流、输出流，输入流和输出流相对于内存设备而言的。

*  将外设中的数据读取到内存中：输入。
 *  将内存的数写入到外设中：输出。

流按操作数据分为两种：字节流与字符流。

![IO流][IO]

字节流的抽象基类：InputStream，OutputStream。

字符流的抽象基类：Reader，Writer。

由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

### 字符流 ###

#### 字符流的由来 ####

其实就是：字节流读取文字字节数据后，不直接操作而是先查指定的编码表，获取对应的文字。再对这个文字进行操作。

简单说：字节流+编码表。

import java.io.FileWriter;
    import java.io.IOException;
    
    public class FileWriterDemo{ 
           public static void main(String[] args) throws IOException{
                 //创建一个可以往文件中写入字符数据的字符输出流对象
                 //既然是往一个文件中写入文字数据，那么在创建对象时就必须明确该文件（用于存储数据的目的地）
                 //如果文件不存在，则会自动创建
                 //如果文件存在，则会被覆盖
                FileWriter fw = new FileWriter("demo.txt" );
    
                //构造函数中加入true，可以实现对文件进行续写
                //FileWriter fw = new FileWriter("demo.txt" ,true);
    
                 //调用Writer对象中的write(string)方法，写入数据
                 //其实数据写入到临时存储缓冲区中
                fw.write( "abcde");
    
                 //进行刷新，将数据直接写入到目的地中
                fw.flush();
    
                 //关闭流，关闭资源，在关闭前会先调用flush刷新缓冲中的数据到目的地。
                fw.close();//close方法只能用一次。
                //流关闭以后不能，不能再调用write方法，否则会报异常
          }
    }
    
    public class IOExceptionDemo{ 
           public static void main(String[] args){
                FileWriter fw  = null;
                 try{
                      fw = new FileWriter("demo.txt" );
                      fw.write( "abcde");//此处有异常
                } catch(IOException e){
                      System.out.println(e.toString());
                } finally{
       //为防止代码异常导致流无法关闭，因此在finally中对流进行关闭
                       try{
                            fw.close();
                      } catch(IOException e){
                             throw new RuntimeException("关闭失败");
                      }
                }
          }
    }

#### 读取一个文本文件(两种方式) ####

import java.io.FileReader;
    import java.io.IOException;
    
    public class FileReaderDemo{ 
           public static void main(String[] args) throws IOException{
    
                FileReader fr = new FileReader("demo.txt" );
                //第一种读取方式：使用read()方法读取单个字符，到达末尾返回-1
                 int ch = 0;
                 while((ch = fr.read()) != -1){
                      System.out.println(( char)ch);
                }
    
                 //第二种读取方式：使用read(char[])读取多个字符。
                 //先创建字符数组
                 //char[] buf = new char[3];
                 //int len = 0;
                 //while((len = fr.read(buf)) != -1){ 
                 // System.out.println( new String(buf,0,len));
                 //}
                fr.close();
          }
    }

#### 字符流的缓冲区 ####

缓冲区的出现提高了对数据的读写效率。

缓冲区要结合流才可以使用。

作用：在流的基础上对流的功能进行了增强。

对应类：

*  BufferedWriter
 *  BufferedReader

提高读写效率，使用缓冲区

import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class BufferedWriterDemo{ 
           public static void main(String[] args) throws IOException{
                FileWriter fw = new FileWriter("buf.txt" );
    
                 //写入
                 //创建了一个字符写入流的缓冲区对象，并且指定与要被缓冲的流对象相关联
                BufferedWriter bufw = new BufferedWriter(fw);
                 for(int x = 1; x <= 4; x++){
                       //使用缓冲区的写入方法将数据先写入到缓冲区中
                      bufw.write( "abcdef" + x);
                       //写入内容换行方法：newLine();
                      bufw.newLine();
                }
                 //使用缓冲区的刷新方法将数据刷目的地中
                bufw.flush();
                 //关闭缓冲区，其实关闭的就是被缓冲的流对象
                fw.close();
    
                //读取
                FileReader fr = new FileReader("buf.txt" );
                //创建字符读取流的缓冲区对象
                BufferedReader bufr = new BufferedReader(fr);
                String line = null;
                //读取一行
                 while((line = bufr.readLine()) != null){
                      System.out.println(line);           
                }
                fr.close();
          }
    }

写入换行使用 BufferedWriter 类中的 newLine() 方法。  
读取一行数据使用 BufferedReader 类中的 readLine() 方法。

### 字节流 ###

基本操作与字符流类相同。但它不仅可以操作字符，还可以操作其他媒体文件。

import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class ByteStreamDemo{ 
           public static void main(String[] args) throws IOException {
                demo_write();
          }
    
           public static void demo_write() throws IOException {
                 //1、创建字节输出流对象，用于操作文件
                FileOutputStream fos = new FileOutputStream( "bytedemo.txt");
    
                 //2、写数据，直接写入到了目的地中
                fos.write( "abcdefg".getBytes());
    
                 //关闭资源动作要完成
                fos.close();
          }
    }

#### 字节流的缓冲区 ####

字节流的缓冲区：同样是提高了字节流的读写效率

使用缓冲，拷贝MP3 文件

import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class CopyMp3Test{ 
           public static void main(String[] args) throws IOException {
                copy_1();
                copy_2();
          }
    
           public static void copy_1() throws IOException {
                FileInputStream fis = new FileInputStream("0.mp3" );
                FileOutputStream fos = new FileOutputStream("1.mp3" );
    
                 byte[] buf = new byte[1024];
                 int len = 0;
                 while((len = fis.read(buf)) != -1){
                      fos.write(buf,0,len);
                }
                fis.close();
                fos.close();
          }
    
           public static void copy_2() throws IOException {
                FileInputStream fis = new FileInputStream("0.mp3" );
                BufferedInputStream bufis = new BufferedInputStream(fis);
    
                FileOutputStream fos = new FileOutputStream("2.mp3" );
                BufferedOutputStream bufos = new BufferedOutputStream(fos);
    
                 int ch = 0;
                 while((ch = bufis.read()) != -1){
                      bufos.write(ch);
                }
    
                bufis.close();
                bufos.close();
          }
    }

### 转换流 ###

#### 转换流的由来 ####

字符流与字节流之间的桥梁  
方便了字符流与字节流之间的操作

转换流的应用：  
字节流中的数据都是字符时，转成字符流操作更高效。

转换流：  
InputStreamReader：字节到字符的桥梁，解码。  
OutputStreamWriter：字符到字节的桥梁，编码。

InputStreamReader是字节流通向字符流的桥梁。

import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    
    public class TransStreamDemo{ 
    
           public static void main(String[] args) throws IOException {
                 //字节流,控制台输入
                InputStream in = System.in;
                 //将字节转成字符的桥梁，转换流
                InputStreamReader isr = new InputStreamReader(in);
                 //对字符流进行高效装饰，缓冲区
                BufferedReader bufr = new BufferedReader(isr);           
                String line = null;
                 //读取到了字符串数据
                 while((line = bufr.readLine()) != null){
                       if("over" .equals(line))
                             break;
                      System.out.println(line.toUpperCase());//转换成大写
                }
          }
    }

将文本复制到另一个文本中

import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    
    public class TransStreamDemo{ 
    
           public static void main(String[] args) throws IOException {
    
                BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
    
                BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("b.txt")));
    
                String line = null;
    
                 while((line = bufr.readLine()) != null){
                       if("over" .equals(line))
                             break;
    
                      bufw.write(line.toUpperCase());
                      bufw.newLine();
                      bufw.flush();
                }
          }
    }

### 流的操作规律 ###

要弄清楚这个规律，是因为流对象太多，开发时不知道用哪个对象合适。  
想要知道对象的开发时用到哪些对象，只要通过四个明确即可。  
  
1、明确源和目的  
 源：InputStream Reader  
 目的：OutputStream Writer

2、明确数据是否是纯文本数据  
 源：是纯文本：Reader  
 否：InputStream  
 目的：是纯文本：Writer  
 否：OutputStream  
 到这里，就可以明确需求中具体要使用哪个体系。

3、明确具体的设备  
 源设备：  
 硬盘：File  
 键盘：System.in  
 内存：数组  
 网络：Socket流  
 目的设备：  
 硬盘：File  
 控制台：System.out  
 内存：数组  
 网络：Socket流

4、是否需要其他额外功能  
 是否需要高效（缓冲区）：  
 是，就加上buffer

### File类 ###

File类用来将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作。

File对象可以作为参数传递给流的构造函数。

流只能操作数据，不能操作文件。

import java.io.File;
    
    public class FileDemo{ 
           public static void main(String[] args){
                constructorDemo();
          }
    
           public static void constructorDemo(){
                 //可以将一个已存在的，或者不存在的文件或者目录封装成file对象
                 //方式一
                File f1 = new File("d:\\demo\\a.txt" );
    
                 //方式二
                File f2 = new File("d:\\demo" ,"a.txt" );
    
                 //方式三
                File f = new File("d:\\demo" );
                File f3 = new File(f,"a.txt" );
    
                 //考虑到Windows和Linux系统通用
                File f4 = new File("d:" + File.separator + "demo" + File.separator + "a.txt" );
          }
    }

> File.separator是与系统有关的默认名称分隔符。在 UNIX 系统上，此字段的值为 ‘/’；在 Microsoft Windows 系统上，它为 ‘\\’。

#### File的常用操作 ####

##### 1、获取 #####

获取文件名称  
获取文件路径  
获取文件大小  
获取文件修改时间

import java.io.File;
    import java.text.DateFormat;
    import java.util.Date;
    
    public class FileMethodDemo{ 
           public static void main(String[] args){
                getDemo();
          }
    
           public static void getDemo(){
                File file1 = new File("a.txt" );
                File file2 = new File("d:\\demo\\a.txt" );
    
                String name = file2.getName();
                String absPath = file2.getAbsolutePath(); //绝对路径
                String path1 = file1.getPath();
                String path2 = file2.getPath();
                 long len = file2.length();
                 long time = file2.lastModified();
                 //相对路径不同，父目录不同
                 //如果此路径名没有指定父目录，则返回 null
                String parent1 = file1.getParent();
                String parent2 = file2.getParent();
    
                Date date = new Date(time);
                DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
                String str_time = df.format(date);
    
                System.out.println( "name:" + name);
                System.out.println( "absPath:" + absPath);
                System.out.println( "path1:" + path1);
                System.out.println( "path2:" + path2);
                System.out.println( "len:" + len);
                System.out.println( "str_time:" + str_time);
                System.out.println( "parent1:" + parent1);
                System.out.println( "parent2:" + parent2);
          }
    }

##### 2、创建和删除 #####

import java.io.File;
    import java.io.IOException;
    
    public class FileMethodDemo{ 
           public static void main(String[] args) throws IOException {
                createAndDeleteDemo();
          }
    
           public static void createAndDeleteDemo() throws IOException {
                File file = new File("file.txt" );
    
                 //和输出流不一样，如果文件不存在，则创建，如果文件存在，则不创建
                 boolean b1 = file.createNewFile();
                System.out.println( "b1 = " + b1);
    
                 //使用delete方法删除文件夹的时候，如果文件夹中有文件，则会删除失败
                 boolean b2 = file.delete();
                System.out.println( "b2 = " + b2);
    
                File dir = new File("abc\\ab" );
                 //使用mkdir可以创建多级目录
                 boolean b3 = dir.mkdir();//make directory
                System.out.println( "b3 = " + b3);
    
                 //最里层目录被干掉，dir代表的是最里层的目录
                 boolean b4 = dir.delete();
          }
    }

##### 3、判断 #####

import java.io.File;
    import java.io.IOException;
    
    public class FileMethodDemo{ 
           public static void main(String[] args) throws IOException {
                isDemo();
          }
    
           public static void isDemo() throws IOException {
                File f = new File("aaa.txt" );
    
                 boolean b = f.exists();
                System.out.println( "b = " + b);
    
                 if(!f.exists()){
                      f.createNewFile();
                }
    
                 //最好先判断是否存在
                 if(f.exists()){
                      System.out.println(f.isFile());
                      System.out.println(f.isDirectory());
                }
    
                f = new File("aa\\bb" );
    
                f.mkdirs();
                 if(f.exists()){
                      System.out.println(f.isFile());
                      System.out.println(f.isDirectory());
                }
          }
    }

##### 4、重命名 #####

import java.io.File;
    import java.io.IOException;
    
    public class FileMethodDemo{ 
           public static void main(String[] args) throws IOException {
                renameToDemo();
          }
    
           public static void renameToDemo() throws IOException {
                File f1 = new File("d:\\code\\day21\\0.mp3" );
                File f2 = new File("d:\\code\\day21\\1.mp3" );
    
                 boolean b = f1.renameTo(f2);
    
                System.out.println( "b = " + b);
          }
    }

##### 5、系统根目录和容量获取 #####

import java.io.File;
    import java.io.IOException;
    
    public class FileMethodDemo{ 
           public static void main(String[] args) throws IOException {
                listRootsDemo();
          }
    
           public static void listRootsDemo() throws IOException {
                File[] files = File.listRoots();
    
                 for(File file : files){
                      System.out.println(file);
                }
    
                File file = new File("d:\\" );
    
                System.out.println( "getFreeSpace:" + file.getFreeSpace());
                System.out.println( "getTotalSpace:" + file.getTotalSpace());
                System.out.println( "getUsableSpace:" + file.getUsableSpace());
          }
    }

[stream]: http://oslynwh8c.bkt.clouddn.com/image/hexo/stream.jpg
[IO]: http://oslynwh8c.bkt.clouddn.com/image/hexo/IO%E6%B5%81.png