IO输入输出流

文章目录

• • IO流
  • • 主要内容
    • • java.io.File类的使用(File:计算机操作系统中的文件和文件夹)
      • • File类
        • 输出某一个路径所有的目录与文件全部遍历出来,不论层级有多深,要全部遍历出来
      • IO原理及流的分类
      • • Java IO原理
        • 流的分类
      • 文件流
      • 通过代码把一个文件里面的信息写入到新的文件里面
      • 缓冲流
    • BufferedInputStream
    • • 转换流
      • 标准输入/输出流
      • 打印流
      • 数据流
      • 对象流 ---涉及序列化、反序列化
      • 随机存取文件流(随意存取文件流)
      • 字符流 Reader/Writer
      • • 文件字符输入流(FileReader)
        • 缓冲字符输入流(BufferedReader)
        • 文件字符输chu流(FileWriter)
        • 缓冲字符输出流(BufferedWriter)

IO流

• 主要内容

• java.io.File类的使用(File:计算机操作系统中的文件和文件夹)

  • File类

  • java.io.Filelei:文件和目录路径名的抽象表示形式,与平台无关
  • File能新建、删除、重命名文件和目录，但File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
  • File对象可以作为参数传递给流的构造函数
  • File类的常见构造方法:
    • public File(String pathname)
      • 以pathname为路径创建File对象,可以是绝对路径或者相对路径,如果pathname是相对路径,则默认的当前路径在系统属性user.dir中存储.
    • public File(String parent,String child)
      • 以parent为父路径,child为子路径创建File对象.
    • File的静态属性String separator存储了当前系统的路径分隔符.
    • 在UNIX中,此字段为’/’,在Windows中,为’\\'
      

import java.io.File;

public class FileDemo {
    public static void main(String[] args) {
        //这个时候对象f就是tt.txt文件
        File f = new File("D:\\桌面\\java\\test\\tt.txt");
        File f2 = new File("D:\\桌面\\java\\test");
        //File f2 = new File("D:"+File.separator+"桌面\\java\\test\\tt.txt");
//        File f1 = new File("D:\\桌面\\java","test\\tt.txt");
        //注意,\在文件中是路径的分隔符,但是在java编程中一个\的意思是转意符,在java中\\或者/才是文件的分隔符
        //也可以File.separator作为文件分隔符
        //获取文件名,确实就是获取路径的最后一级
        System.out.println(f.getName());//tt.txt
        System.out.println(f2.getName());//test

        //获取当前路径
        System.out.println(f.getPath());//D:\桌面\java\test\tt.txt

        //通过相对路径输出完整路径
        File f5 = new File("java daima\\src\\OOP\\IO\\FileDemo.Java");//使用相对路径来创建File对象
        System.out.println(f5.getAbsolutePath());//D:\IDEA\java daima\java daima\src\OOP\IO\FileDemo.java
        System.out.println(f5.getPath());//java daima\src\OOP\IO\FileDemo.java

        //返回一个当前文件的绝对路径构建的file对象
        System.out.println(f5);//java daima\src\OOP\IO\FileDemo.java
        System.out.println(f5.getAbsoluteFile());//D:\IDEA\java daima\java daima\src\OOP\IO\FileDemo.Java

        //返回当前文件或者文件夹的父级路径
        System.out.println(f.getParent());

        //重命名由此抽象路径名表示的文件。只能进行一次
        //f.renameTo(new File("D:\\桌面\\java\\test\\hh.txt"));
        File file = new File("D:\\桌面\\java\\test\\hh.txt");
        f.renameTo(file);
        //判断文件夹或者文件夹是否存在
        System.out.println(file.exists());
        //判断文件是不是可读,
        System.out.println(file.canRead());
        System.out.println(file.canWrite());//判断文件是不是可写
        System.out.println(file.isFile());//判断File对象是不是一个文件
        System.out.println(file.isDirectory());//判断当前File对象是不是文件夹

        System.out.println(file.lastModified());//获取文件的最后修改时间,返回的是一个毫秒数
        System.out.println(file.length());//返回文件的长度,单位是字节数

        File file1 = new File("D:\\桌面\\java\\test\\zz.txt");
//        if (!file1.exists()) {
//            try {
//                file1.createNewFile();//创建新的文件
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
//        file1.delete();//删除文件
        File file2 = new File("D:\\桌面\\java\\test\\hzc");
        if (!file2.exists()) {
            file2.mkdir();//创建单层目录
        }
        file2.delete();
        File file3 = new File("D:\\桌面\\java\\test\\hzc\\13\\22");
        if (!file3.exists()) {
            file3.mkdirs();//创建多层目录
        }
        System.out.println("==========");
        String[] s = file2.list();//输出此目录下的文件和文件名
        for (String x:s) {
            System.out.println(x);
        }
        File[] a = file2.listFiles();//返回一个抽象路径名数组，输出此目录下的文件的路径和文件名的路径。
        for (File x:a
             ) {
            System.out.println(x);
        }
    }
}

输出某一个路径所有的目录与文件全部遍历出来,不论层级有多深,要全部遍历出来

import java.io.File;

public class FileTest {
    //遍历桌面下的test文件,把test文件夹下所有的目录与文件全部遍历出来,不论层级有多深,要全部遍历出来
    //使用递归
    public static void main(String[] args) {
        File file = new File("D:\\桌面\\java\\test");
        new FileTest().test(file);
    }
    public void test(File file){
        if (file.isFile() ) {
            System.out.println(file.getAbsolutePath()+"是文件");
        }else{
            System.out.println(file.getAbsolutePath()+"是文件夹");
            //如果是文件夹可能存在子目录
            File[] file1 = file.listFiles();
            if (file1 != null && file1.length>0) {
                for (File x:file1) {
                    test(x);
                }

            }


        }
    }
}

• IO原理及流的分类

  • Java IO原理

    • IO流用来处理设备之间的数据传输
    • Java程序中,对于数据的输入/输出操作以"流(stream)"的方式进行.
    • Java.IO包提供了各种"流"类和接口,用以获取不同种类的数据,并提供标准的方法输入或输出数据
    • 输入input:读取外部数据(磁盘、光盘等存储设备的数据)到程序（内存）中。
    • 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中

  • 流的分类

    • 按操作数据单位不同分为:字节流(8 bit),字符流(16 bit)
    • 按数据流的流向不同分为:输入流,输出流
    • 按流的角色的不同分为:节点流,处理流
    • 1.字节流:可以读取一切文件
    • **2.读取纯文本文件比较方便,已经帮助我们处理了乱码问题 **
      
    • Java的IO流共涉及40多个类,实际上非常规则,都是从如下4个抽象基类派生的.由这四个类派生出来的子类名称都是以其父类名作为子类名后缀.

• 文件流

  • FileInputStream / FileOutputStream / FileReader / FileWriter-
  • 字节输入流(FileInputStream )

import java.io.File;
import java.io.FileInputStream;

public class FileInputStreamDemo {
    public static void main(String[] args) {
        //1、 在文件和程序之间铺设管道
        try {
//            FileInputStream fis = new FileInputStream("D:\\桌面\\java\\test\\hh.txt");
            //下面这种方式好一些,因为你可以加判断,判断文件是不是存在,不存在则不需要去执行后面的代码,减少错误的出现
            File file = new File("D:\\桌面\\java\\test\\hh.txt");
            //判断文件是否存在,已经是否存在信息,字节码不为0
            if (file.exists() && file.length()>0 ) {
                FileInputStream fileInputStream = new FileInputStream(file);
                int ch = 0;
                byte[] shu = new byte[10];
                //read()读取到的数据会转变成int数据,当方法读取到最后一个字符时会返回-1也就代表着结束
//                while((ch=fileInputStream.read())!=-1){
//                    //输出的int字符,需要转换成 Unicode 字符
//                    System.out.print((char)ch);
//                }
                //需要注意的是read()方法是一个字节一个字节读取的,而中文是占两个字节的,所以fileInputStream是不能读取中文的,读取的数据会变成乱码
                while((ch=fileInputStream.read(shu))!=-1){
                    //输出的int字符,需要转换成 Unicode 字符
                    System.out.print(new String(shu,0,ch));
                }
                //一定一定要记得IO流要记得关闭
                fileInputStream.close();
            }

        } catch (Exception e) {
            System.out.println("文件找不到");
        }
    }
}

• 字节输出流

import java.io.FileOutputStream;

public class FileOutputStreamDemo {
    public static void main(String[] args) {


        try {
            //1.创建水厂
            String data = "hello world java";
            //铺设程序通往盘符的管道
            //append的值决定了,你新添加的数据是覆盖还是追加,如果是false则是覆盖,相反这是追加
            FileOutputStream fis = new FileOutputStream("D:\\桌面\\java\\test\\hzc.txt",false);
            //开水龙头,放水
            byte[] bytes= data.getBytes();
            fis.write(bytes);
            //关水龙头
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

通过代码把一个文件里面的信息写入到新的文件里面

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class IODemo {
    public static void main(String[] args) {
        //把文件复制一份
        try {
            long startTime = System.currentTimeMillis();//获取当前系统时间并转换成毫秒数
            System.out.println(startTime);
            File file = new File("D:\\桌面\\java\\test\\hh.txt");
            if (file.exists() && file.length()>0) {
                FileInputStream fis = new FileInputStream(file);
                FileOutputStream fos = new FileOutputStream("D:\\桌面\\java\\test\\hzc.txt");
                int ch = 0;
                while((ch=fis.read())!=-1){
                    fos.write(ch);
                }
                fis.close();
                fos.close();
                long endTime = System.currentTimeMillis();
                System.out.println(endTime);
            }


        } catch (Exception e) {
            System.out.println("文件不存在");
        }
    }
}

• 缓冲流

  • BufferedInputStream / BufferedOutputStream / BufferedReader / BufferedWriter

  • BufferedInputStream

  • 缓冲流输入的使用

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;

public class BufferedInputStreamDemo {
    public static void main(String[] args) {
        //.水厂(hh.txt)
        //.铺设管道
        try {
            long staryTime = System.currentTimeMillis();
            InputStream file = new FileInputStream("D:\\桌面\\java\\test\\hh.txt");
            BufferedInputStream bu = new BufferedInputStream(file);
            //3.开水龙头
            //创建一个数组把需要输入的数据存入数组
            byte[] cha= new byte[1024];
            int len = 0;
            while((len=bu.read(cha))!=-1){
                System.out.println(len);
            }
            bu.close();
            long endTime = System.currentTimeMillis();
            System.out.println("共消耗"+(endTime-staryTime)+"ms");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

// BufferedInputStream流 :字节缓冲输入流
//

• 使用缓冲流进行文件内容复制

package OOP.IO;

import java.io.*;

public class BufferedOutputStreamDemo {
    public static void main(String[] args) {
        try {
            long statTime = System.currentTimeMillis();
            File file1 = new File("D:\\桌面\\java\\test\\hh.txt");
            if (file1.exists() && file1.length()>0) {
                InputStream file = new FileInputStream("D:\\桌面\\java\\test\\hh.txt");
                BufferedInputStream bu = new BufferedInputStream(file);
                OutputStream fileOut = new FileOutputStream("D:\\桌面\\java\\test\\hyx.txt");
                BufferedOutputStream buff = new BufferedOutputStream(fileOut);
                byte[] cha = new byte[1024];
                int lea = 0;
                //将file中的字符通过read写入cha数组将返回值给到lea
                while ((lea = bu.read(cha)) != -1) {
                    //从下标0开始到lea个字符写入换缓冲字节流
                    buff.write(cha,0,lea);
                }
                bu.close();
                buff.close();
                long endTime = System.currentTimeMillis();
                System.out.println("一共"+(endTime-statTime)+"ms");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 转换流

• InputStreamReader / OutputStreamWriter

• 标准输入/输出流

• 打印流

  • PrintStream / PrintWriter

• 数据流

  • DataInputStream / DataOutputStream

• 对象流 —涉及序列化、反序列化

  • ObjectInputStream / ObjectOutputStream

• 随机存取文件流(随意存取文件流)

  • RandomAccessFile

• 字符流 Reader/Writer

• 文件字符输入流(FileReader)

import java.io.FileReader;

/**
 *
 */
public class FileReaderDemo {
    public static void main(String[] args) {
        try {
            long startTime = System.currentTimeMillis();
            FileReader fileReader = new FileReader("D:\\桌面\\java\\test\\hh.txt");
            char[] car= new char[1024];
            int a = 0;
            while((a=fileReader.read(car))!=-1){
                System.out.println(a);
                System.out.print(new String(car,0,a));
            }
            System.out.println(" ");
            long endTime = System.currentTimeMillis();
            System.out.println("一共"+(endTime-startTime)+"ms");
            fileReader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 缓冲字符输入流(BufferedReader)

• 文件字符输chu流(FileWriter)

• 缓冲字符输出流(BufferedWriter)