Java IO

IO流

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

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

Java对数据的操作是通过流的方式。Java用于操作流的对象都在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());      }}