IO流常用方法,流的用法,代码例子

/**
 * 一个汉字是一个字符,就是2个字节,就是16位,所以,要读取汉字,还得用字符流
 *-------------------------------------- 基础流----------------------------------------------
 */
FileInputStream ://(字节输入流,一次读取1个字节(就是8位))

    FileInputStream fis = new FileInputStream("文件路径");//字节输入流

FileOutputStream : //(字节输出流,一次读取1个字节(就是8位))

    FileOutputStream fis = new FileOutputStream("文件路径",true);//字节输出流 true不写默认为覆盖指定文件的内容,写了就是在内容后追加

FileReader : //(字符输入流,一次读取1个字符,就是2个字节(就是16位))
    
    FileReader fis = new FileReader("文件路径");//字符输入流

FileWriter : //(字符输出流,一次读取1个字符,就是2个字节(就是16位))
    
    FileWriter fis = new FileWeriter("文件路径,true");//字符输出流,true不写默认为覆盖指定文件的内容,写了就是在内容后追加

/**
 *-------------------------------------- 缓冲流----------------------------------------------
 */
BufferedInputStream : //(字节输入流的缓冲流)
    
    1.BufferedInputStream br = new BufferedInputStream( new FileInputStream("文件路径") );//字节输入流的缓冲流

    2.FileInputStream fis = new FileInputStream("文件路径");//创建原始流  
        BufferedInputStream br = new BufferedInputStream( fis );//缓冲流 这两种是一样的,不过上面的那个相对简单一些,就是简写版


BufferedOutputStream : //(字节输出流的缓冲流)

    1 BufferedOutputStream br = new BufferedOutputStream( new FileOutputStream("文件路径,true") );//字节输出流的缓冲流

    2.FileOutputStream fis = new FileOutputStream("文件路径,true");//创建原始流 true不写默认为覆盖指定文件的内容,写了就是在内容后追加
        BufferedOutputStream br = new BufferedOutputStream( fis );//缓冲流 这两种是一样的,不过上面的那个相对简单一些,就是简写版


BufferedReader : //(字符输入流的缓冲流)

    1 BufferedReader br = new BufferedReader( new FileReader("文件路径") );//字符输入流的缓冲流

    2.FileReader fis = new FileReader("文件路径");//创建原始流
        BufferedReader br = new BufferedReader( fis );//缓冲流 这两种是一样的,不过上面的那个相对简单一些,就是简写版

BufferedWriter : //(字符输出流的缓冲流)

    1 BufferedWriter br = new BufferedWriter( new FileWriter("文件路径,true") );//字符输出流的缓冲流

    2.FileWriter fis = new FileWriter("文件路径,true");//创建原始流 true不写默认为覆盖指定文件的内容,写了就是在内容后追加
        BufferedWriter br = new BufferedWriter( fis );//缓冲流 这两种是一样的,不过上面的那个相对简单一些,就是简写版

/**
 *-------------------------------------- 转换流----------------------------------------------
 */
InputStreamReader : //(将字节输入流转为字符输入流)

    1.InputStreamReader is = new InputStreamReader( new FileInputStream("文件路径") );//将字节输入流,转为字符输入流,是下面的简写
    
    2.FileInputStream fis = new FileInputStream("文件路径");//创建字节原始流
        InputStreamReader is = new InputStreamReader( fis );//转换为字符流

OutputStreamWriter : //(将字节输出流转为字符输出流)

    1.InputStreamWriter is = new InputStreamWriter( new FileOutputStream("文件路径,true") );//将字节输出流,转为字符输出流,是下面的简写,这里不写true,就是覆盖指定文件中的内容,写了就是内容内容后面追加
    
    2.FileOutputStream fis = new FileOutputStream("文件路径,true");//创建字节原始流
        InputStreamWriter is = new InputStreamWriter( fis );//转换为字符流

/**
 *------------------------------------------------------------------------------------------
 */

PrintStream :
    
    //打印流
    PrintStream ps = System.out;//(打印流)尽管没有new,是因为out是个静态成员变量(静态变量),在类加载的时候,成员类就被加载了,所以可以直接加载这个方法m

Geng_Gai_Wei_Zhi :
    System.setOut() : //更改输出位置

    System.setOut(new PrintStream(new FileOutputStream("./fos_tmp_01.txt")));//这里指定了系统默认输出位置,这里 是个jvm系统,会更改系统默认的位置

SimpleDateFormat :

        //日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

    lastModified :
        
        //最后的修改时间
        Date t = new Date(f1.lastModified());
        System.out.println( new SimpleDateFormat("yyy-MM-dd HH:mm:ss SSS").format(t) );//返回的是时间 , 年月日,时分秒,毫秒,也就是上面指定的格式


DataOutputStream :
    
    //(输出,输入,就是针对当前文件的进出,这里是输出,是把当前文件的东西,输出到指定的文件夹中,并加密,)

    DataOutputStream dos = new DataOutputStream(new FileOutputStream("./fos_tmp_01.txt"));//把添加进去的数据进行封装,就跟加密一样,要想查看,就要按照添加的顺序去查看
    
        byte b = 10;//变量(数据)
        short s = 11;
        int i = 12;
        long l = 100L;
        float f = 3.2f;
        double d = 2.3;
        boolean flag = false;
        char c = 'a';

        dos.writeByte(b);//添加数据
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(flag);
        dos.writeChar(c);

        dos.flush();//磕两下
        dos.close();//关闭资源

DataInputStream :
    
        //(输出,输入,就是针对当前文件的进出,这里是输入,是把外面的文件的东西,输入到当前,且 一定要按照上面输出的时候的顺序,来读取)
        DataInputStream dis = new DataInputStream(new FileInputStream("./fos_tmp_01.txt"));
        //读取:要使用这个类,必须要提前知道该文件的存储格式,和顺序
        //读的顺序必须和写的相同
        byte b = dis.readByte();//读取资源
        short s = dis.readShort();
        int i = dis.readInt();
        long l = dis.readLong();
        float f = dis.readFloat();
        double d = dis.readDouble();
        boolean flag = dis.readBoolean();
        char c = dis.readChar();

        System.out.println( b );//输出读取的资源
        System.out.println( s );
        System.out.println( i );
        System.out.println( l );
        System.out.println( f );
        System.out.println( d );
        System.out.println( flag );
        System.out.println( c  );

        dis.close();//关闭资源

File :
    
    //文件和目录路径名的抽象表示形式。(抽象就是没有的,这里说的是内存对象里面创建的,并不是硬盘创建的)
        
    File f1 = new File("E:/第二期学习课程总汇/java/day11_IO/IO_01_FileInputStream_01.java");// 构造函数并不是创建新文件用的,文件是在硬盘中的,但是这里只是把文件对象复制到内存而已,然后返回找到这个文件的路径;

    getAbsolutePath :
    
        //返回此抽象路径名的绝对路径名字符串
        getAbsolutePath() : //说白了,就是获得文件的全路径(绝对路径) 如 : ( E:/第二期学习课程总汇/java/day11_IO/IO_01_FileInputStream_01.java )
    getName :

        //返回由此抽象路径名表示的文件或目录的名称。
        getName() : //说白了就是只获得文件的文件名,和扩展名,如 : ( IO_01_FileInputStream_01.java )

    getParent :   

        //返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
        getParent() : //说白了,就是获得当前文件的目录,就是 ./ 如 : ( E:/第二期学习课程总汇/java/day11_IO )

    isFile :

        isFile();//判断是不是文件 返回值是boolean   true/false
        System.out.println( f1.isFile() );//判断f1是不是文件 true

    isDirectory :

        isDirectory();//判断是不是目录 返回值是boolean  true.false
        System.out.println( f1.isDirectory() ); //判断f1是不是目录 false

    createNewFile :

        createNewFile();//这个是创建文件(不是创建目录) 返回值是boolean  true/false 如果有这个文件,或者是没有这个目录,就返回false 如果有这个目录,没有这个文件,创建成功,返回true
        System.out.println( f1.createNewFile() );

    length :

        length();//获取文本的长度,返回值是文本的长度
        System.out.println( f1.length() );

    listFiles :
        
    File f2 = new File("E:/第二期学习课程总汇/java/day11_IO/");// 构造函数并不是创建新文件用的,文件是在硬盘中的,但是这里只是把文件对象复制到内存而已,然后返回找到这个文件的路径;
        //列出子文件 就是把指定的目录每一个文件添加到数组中,在遍历数组
        File[] fs = f2.listFiles();//创建一个数组,把指定的目录里面的文件都添加到数组,在遍历数组
         for(File f:fs){//foreach循环(for的增强版 只能遍历集合和数组)
            System.out.println( f.getAbsolutePath() );//返回文件的全路径(这里是遍历,就是把每个文件都输出全路径)
        }

    endsWith :

        endsWith();//筛选
        File[] fs = f2.listFiles();//创建一个数组,把指定的目录里面的文件都添加到数组,在遍历数组
        for(File f:fs){
            if (f.getAbsolutePath().endsWith(".java")) {//筛选,以.java结束的文件
                System.out.println( f.getAbsolutePath() );//获得文件的全路径
            }
        }


Wen_Jian_Fu_Zhi : //文件复制(数组)

    //输入流的方法 : FileInputStream
        1.read(); 2.read(bytes);//下面有方法的例子和解释

    //输出流的放法 : FileOutputStream
        3.writer(); 4.write(bytes,0,tmp);//下面有方法的例子和解释
        5. flush();//磕两下,往输出流里面添加懂东西了,就要磕两下,要么容易出错

    //字节(文本)复制
    FileInputStream :
    FileOutputStream :

    try(
            FileInputStream fis = new FileInputStream("./IO流.java");//输入流 , 把指定文件中的数据,读取(输入)到当前文件中
            FileOutputStream fos = new FileOutputStream("./新建文本文档.txt");//输出流 , 把指定的数据,输出到指定的文件中去
                ){
            byte[] bytes = new byte[1024];//动态声明一个byte数组,且1024个字节
            int tmp;//为什么用int声明?因为read(bytes);返回值是bytes这个数组中,添加元素的个数(字节数),如果达到了指定的个数(这里是1024),tmp就会为0,数组也会清空,然后依次循环,且 当读取到最后一位的时候,返回值为-1
            while((tmp = fis.read(bytes)) != -1){//这是判断语句,当输入流指定的文件中,读取到最后一位的时候,就会返回-1,然后这个tmp != -1 判断语句  就为false 就不在循环了
                fos.write(bytes,0,tmp);//将bytes数组,从下标为0开始,输出tmp个,(tmp就代表是数组里面已添加的字节个数)
            }
            fos.flush();//磕两下,往输出流指定的文件中添加东西,都要磕两下
        }catch(Exception e){//捕捉异常
            e.printStackTrace();//对异常进行打印追踪栈帧
        }

    read :
        
        read();//读取指定文件,默认一次读取1字节,并且返回值是下一个字节的值(因为读取的时候,读取指针是在顶端的,并不是在第一个字节)  如果到达最后一位字节的时候(就是最后的,后面没有了),就返回-1
        fis.read();//就读取指定文件的第一个字节

    read_Bytes :

        read(byte[] bytes);//返回值是bytes这个数组中,添加元素的个数(字节数),如果达到了数组指定的长度(字节数),(这里是1024),tmp就会为0,数组也会清空,然后接着当前读取的位置依次循环添加,一直到读取完最后一位,且 当读取到最后一位的时候,返回值为-1,(一般用于遍历,但是一次也是读取一个,只不过会一直读取,一直到数组满了(达到了指定的数组长度),然后再输出到指定的文件,然后数组清空,tmp为0,依次循环,一直到读取完指定文件的最后一个字节)
        fis.read(bytes);//就是读取第一个字节,并把这个字节存入到bytes数组中

    write :

        write();
        fos.write(添加);//把元素添加到输出流指定的文件中,可以是任何东西

    write_bytes_0_tmp :

        write(bytes,0,tmp);
        fos.write(bytes,0,tmp);//把bytes数组中的元素,从下标为0开始,添加tmp位(个)元素

    //纯文本字符流复制
    FileReader :
    FileWriter :
    
        try(
            FileReader fr = new FileReader("./IO流.java");//字符输入流 指定文件
            FileWriter fw = new FileWriter("./新建文本文档.txt");//字符输出流 指定文件
                ){           
                char[] chars = new char[512];//这里是char类型的数组,因为纯字符流复制,就是纯文本,一个汉字就是一个字符,就是两个字节,就是16位,所以这里用的是char字符型数组
                int tmp = 0;//和上面一样,这里为什么要用int声明?
                while(-1 != (tmp = fr.read(chars))){//遍历循环 将输出流指定的文件中的内容,先复制到char数组,
                    fw.write(chars,0,tmp);//把数组的内容,复制到输出流指定的文件中,并清空数组
                }
                fw.flush();//磕两下 输出流的方法
        }catch(Exception e){//捕捉异常
            e.printStackTrace();
        }

Wen_Jian_Fu_Zhi : //文件复制(缓冲流)
    
    BufferedReader : //字符输入缓冲流
        readLine :
            方法 : readLine();//一次读取一行
                //返回值 : 返回该行内容的字符串，不包含任何行终止符，如果已到达流末尾(最后的,没有东西了)，则返回 null
                
    BufferedWriter : //字符输出缓冲流
        newLine :
            方法 : newLine();//新建一行,相当于换行符,
    

     try(
            BufferedReader br = new BufferedReader(new FileReader("./IO流.java"));//字符输入流的缓冲流
            BufferedWriter bw = new BufferedWriter(new FileWriter("./新建文本文档.txt"));//字符输出流的缓冲流
                ){
                    String tmp = null;//为什么用String?因为里面都是字符串,读取一行,是以字符串的形式 ,所以要用String
                    int count = 0;//这里现在是判断作用,用于添加换行符(下面)
                    while(true){//while循环,如果不,判断语句是true 如果不终止,就是死循环把
                        count++;
                        tmp = br.readLine();//读取字符输入流指定文件的一行,并赋值给tmp
                        if (tmp == null) {//判断,如果tmp==null  就执行一下语句 当readLine()方法,读取到文件尾端的时候,读取完成,就返回null,所以,当读取完成后就要终止循环
                            break;//终止循环
                        }
                        //另起一行开始写,就是一个符号,在两行之间,显示的是换行
                        if (count > 1) {//这是判断,除了第一行,别的我们都需要换行,这里就是判断,如果大于1 那就是第二行,和以下行了,就需要换行
                            bw.newLine();//换行符,是在行首
                        }
                        bw.write(tmp);//添加(复制)到输出流指定的文件中,(一次是一行),然后数组清空
                    }
                    bw.flush();//添加(复制)完,就要磕两下
        }catch(Exception e){//捕捉异常
            e.printStackTrace();//处理异常(打印追踪栈帧)
        }

substring :
    
    substring();//返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。
        如 : String s = "12345";
                String s1 = s.substring(1);//是从原字符串的,下标为1的那位开始,至字符串的末尾,生成一个新的字符串
                s1就是"2345";
                String s2 = "A"+s.substring(1);
                s2就是"A2345";

exists :
    
    exists();//判断该路径是否存在,判断目标位置所在的盘是不是有这个目录(或文件),返回值为boolea  true/false
    File f = new File("E:/Zuo/You/Xia");//这个目录(文件)路径是在内存里面的,不是硬盘里面的
        f.exists();//这里是判断,硬盘里面是否有这个目录(或文件)(全路径)

mkdirs :
    
    mkdirs();//在硬盘中创建指定(抽象,也就是内存中)文件(或目录)的全路径
    f.mkdirs();//在硬盘中,就会创建一个跟内存(抽象的)中一样的文件(或目录)的全路径
    //注意，此操作失败时也可能已经成功地创建了一部分必需的父目录。
    //就是在硬盘中创建 E:/Zuo/You/Xia

mkdir :
    
    mkdir();//在硬盘中,创建指定文件(目录)的父路径,而不是全路径
    f.mkdir();//只会创建 Xia,但是前提得自己创建 E:/Zuo/You,否则不会创建,
    
/**
 * --------------------------序列化----------------------
 */

Serializable :
    
    //序列化
    java.io.Serializable;//实现这个接口的,在实例化的时候,就会同步封装逻辑
    transient :

        //如果序列化的时候,不想所有的数据都序列化,就在该数据前面加上:transient处理,就不会参与序列化
        如 :
            transient int age; //这个数据就不会被序列化

    serialVersionUID :

        序列化后,jvm会给对象文件和class文件都生成一个相同的serialVersionUID编号,这个编号是唯一的,如果对象文件(数据)和class(逻辑)文件的serialVersionUID编号对应不上,就会报错,如果序列化之后,没有更改class类文件对应的类里面的数据,就不会出现这种问题,但是如果改了,就不行了
        所以,这个serialVersionUID编码,可以指定,指定之后,就算我改了class文件对应的类的数据,也能对应的上,也能读取出来
    
    static final long serialVersionUID = 1L;//这样,不管更改没更改,每次生成的serialVersionUID编号,都会是1,就不会出现对应不上去这种错误
    //对象对应的文件 是保存的数据
    //类对象的class文件 是保存的逻辑
    //序列化就是把 对象 保存到 硬盘 中,
    User u1 = new User("aaa");//既然是序列化,那么这个User类必须实现与java.io.Serializable;(Serializable)这个接口


    往指定地方(硬盘)存储对象文件的,叫序列化
    从指定文件中(硬盘),读取对象文件的叫,反序列化

    ObjectOutputStream :

    //序列化
        需要有个实现Serializable接口的类,和往指定地方(硬盘)存放这个对象文件的类,也就是ObjectOutputStream类(这个类现用先写都行)
    writerObject();//输出对象流的方法 , 把指定的对象,添加到指定的文件中
    flush();//磕两下,输出流都有的方法

    //往指定地方(硬盘)存储对象文件的,叫序列化
    
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./xv_lie_hua"));//创建对象输出流 并把东西保存到指定的文件("./xv_lie_hua")
    oos.writeObject(u1);//这里就是把u1这个对象,输出到上面指定的文件中("./xv_lie_hua"),没有会创建
    oos.flush();//磕两下
    oos.close();//关闭资源

    ObjectInputStream :
        
        //反序列化
         //反序列化需要:
            对象文件,对象对应的class文件,反序列化类文件(这个类现写的都行)
        readObject();//输入对象流的方法 , 读出指定的对象文件
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./xv_lie_hua"));//创建对象输入流,把指定的对象文件,输入到当前页面,
        Object o = ois.readObject();//读取里面的对象,并赋值给用Object声明的 o 变量
        System.out.println( o );//输出o变量,就是输出了读取的对象
        ois.close();//关闭资源
    }