Java IO

最新推荐文章于 2023-02-20 15:09:50 发布

Deemons

最新推荐文章于 2023-02-20 15:09:50 发布

阅读量1.2k

点赞数

分类专栏： java基础文章标签： java io流字符流数据

本文链接：https://blog.csdn.net/Deemons/article/details/77800609

版权

java基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

stream

IO流

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

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

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