java文件读写操作之io流

File类方法：
File()：构造函数，一般是依据文件所在的指定位置来创建文件对象。
CanWrite()：返回文件是否可写。
CanRead()：返回文件是否可读。
CompareTo(File pathname)：检查指定文件路径间的顺序。
Delet()：从文件系统内删除该文件。
DeleteOnExit()：程序顺利结束时从系统中删除文件。
Equals(Object obj)：检查特定对象的路径名是否相等。
Exists()：判断文件夹是否存在。
GetAbsoluteFile()：返回文件的完整路径。
GetAbsolutePath()：返回文件的完整路径。
GetName()：返回文件名称。
GetParent()：返回文件父目录路径。
GetPath()：返回文件的潜在相对路径。
GetParentFile()：返回文件所在文件夹的路径。
HashCode()：返回文件哈希码。
IsDirectory()：判断该路径指示的是否是文件。
IsFile()：判断该路径指示的是否是文件。
LastModified() ：返回文件的最后修改时间标志。
Length()：返回文件长度。
List()：返回文件和目录清单。
Mkdir()：生成指定的目录。
RenameTo(File dest)：更名文件。
SetReadOnly()：将文件设置为可读。
ToString()：返回文件状态的字符串。
ToURL()：将文件的路径字符串转换成URL

File.GetCreationTime 读取创建时间
file.SetCreationTime 设置创建时间
File.GetLastAccessTime 读取最后访问时间
File.SetLastAccessTime 设置最后访问时间
File.GetLastWriteTime 读取最后修改时间
File.SetLastWriteTime 设置最后修改时间
File.GetAttributes 读取文件属性

File.SetAttributes 设置文件属性

字节输出输入流：

package io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/*
 * 字节输入输出流
 * 输出流:超类 OutputStre,对文件的写入使用子类的FileOutputStream
 * 输入流:超类 InputStre,对文件的读出使用子类的FileInputStream
 */
public class FileDome {

    //*************************out方法写入文件***************************
    private static void out() {
        File f1=new File("C:\\Users\\龙布天下\\Desktop\\box.txt");//确定目标文件

        try {
            //参数1为文件路径,参数2为是否追加文件到写入文件的末尾
            OutputStream out=new FileOutputStream(f1,true);//构建一个文件输出流对象

            String info="123ABCabc王文龙\r\n";//声明要写入out流文件中的数据

            byte[] s=info.getBytes();//写入数据的byte数组

            try {
                out.write(s);//写入out数据
                out.close();//关闭流
                System.out.println("写入数据成功");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //*************************In方法输出文件***************************
    public static void in() {
        File f1=new File("C:\\Users\\龙布天下\\Desktop\\box.txt");//确定目标文件
        try {
            InputStream in=new FileInputStream(f1);//构建一个文件输入流对象
            try {
                byte[] b=new byte[1024];
                StringBuffer sb=new StringBuffer();
                //把读到的数据写入到byte数组中
                while(in.read(b)!=-1) {
                    sb.append(new String(b));
                }
                in.close();//关闭流
                System.out.println(sb);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    public static void main(String[] args) {
        //File类表示一个文件或目录
        out();//调用写入文件流的方法
        in();//调入读出文件流的方法




    }

}

字符输入输出流：

package io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/*
 * 字符流
 * 字节输出流 Write  对文件的操作使用子类的 FileWrite
 * 字节输入流 Reader 对文件的操作使用子类的 FileReader
 * 
 * 字符流的好处:
 * 程序会一个一个字符进行读取,而不会出现中文乱码的问题
 *  因为一个中文字为一个字符而一个英文字符也是一个字符
 * 
 */

public class CharStreamDome {

    public static void out(){

        File f=new File("C:\\Users\\龙布天下\\Desktop\\box.txt");//声明指定文件
        try {
            Writer  out = new FileWriter(f);
            out.write("我是好孩子");//注意：！！！这回就不用写入字节数组了,直接写入String类型的字符
            out.close();
            System.out.println("写入成功！！！");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
    public static void in(){

        File f=new File("C:\\Users\\龙布天下\\Desktop\\box.txt");
        try {
            Reader in=new FileReader(f);
            char[] c=new char[1];//声明要读入的字符
            StringBuffer sb=new StringBuffer();
            try {
                //把每次读到的1个字符都添加到sb引用的字符缓冲区中
                while(in.read(c)!=-1) {
                    sb.append(new String(c));
                }
                System.out.println(sb);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
    public static void main(String[] args) {

        out();
        in();
    }
}

内容小结:

总之：对非文本文件进行io操作时 使用字节流
对文本文件进行io操作时 使用字符流是不会错的

通过源码分析字符流的内部实现还是字节流

字节字符转换流

package io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.Charset;

/*
 * 转换流
 * OutputStreamWriter: 可以将字符流转换为字节流的输入形式
 * InputtreamReader  : 可以将字节流转换为字符流的输出形式
 * 
 */

public class ChangeStreamDome {

    //将字节流转换为字符流的方法
    public static void in(InputStream in) {

        Reader reader=new InputStreamReader(in);
        char[] c=new char[1024];
        try {
            while(reader.read(c)!=-1) {
                System.out.println(new String(c));
            }
            reader.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    //将字符流转换为字节流的方法
    public static void out(OutputStream out) {

        Writer writer=new OutputStreamWriter(out);
        try {
            writer.write("今天是个好日子！！！");
            writer.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    //开始测试的main方法
    public static void main(String[] args) {
        //将字符流转换为字节流的out方法传参
        File f2=new File("C:\\Users\\龙布天下\\Desktop\\box.txt");
        OutputStream out = null;
        try {
            out = new FileOutputStream(f2);
        } catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        out(out);

        //*******************************************************

        //将字节流转换为字符流的in方法进行传参
        File f=new File("C:\\Users\\龙布天下\\Desktop\\box.txt");
        InputStream in = null;
        try {
            in = new FileInputStream(f);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        in(in);
        /*
         * 内容小结:
         * 
         * 字节流：
         *  输出字节流 超类：OutputStream 子类：FileOutputStream//从程序里写出文件
         *  
         *  输入字节流 超类 InputStream   子类：FileInputStrrema//从文件里读出内容
         *  
         *  字符流流：
         *  输出字符流 超类：Writer       子类 FileWriter
         *  输入字符流 超类  Reader          子类 FileReader
         *  
         *  
         *  字节字符转换流
         *  输出字符流 超类：Writer       子类OutputStreamWriter// 将字符流转后为字节流的形式
         *  输入字符流 超类  Reader          子类InputStreamReader // 将字节流转换为字符流的形式
         *
         * 
         */
    }
}

字节缓冲输入输出流

package io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/*
 *缓存的目的：
 *解决在写入问件时,频繁的操作文件所带来的性能降低的问题
 *BufferOutputStream 内部默认所缓存的大小是8KB,每次缓存到byte数组中的,当数据为满时,才会把数据写入到文件
 *
 */

public class BufferStreamDome {
    //字节输出缓冲流的方法
    public static void byteWriter() {
        File f=new File("C:\\Users\\龙布天下\\Desktop\\box.txt");
        try {
            OutputStream out=new FileOutputStream(f);
            //构造一个字节换成流
            BufferedOutputStream bos=new BufferedOutputStream(out);
            String info="小河流水哗啦啦！！！";
            byte[] b=info.getBytes();
            try {
                bos.write(b);
                System.out.println("写入成功！！！");
                //注意关闭流是有顺序的,要不然写不出去
                bos.close();
                out.close();

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    //字节输入缓冲流的方法
        public static void byteReader() {
            File f=new File("C:\\Users\\龙布天下\\Desktop\\box.txt");
            try {
                InputStream in=new FileInputStream(f);
                //构造一个字节换成流
                BufferedInputStream bis=new BufferedInputStream(in);

                try {
                    byte[] b=new byte[1024];
                    while(bis.read(b)!=-1) {
                        System.out.println(new String(b));
                    }

                    //注意关闭流是有顺序的,要不然读不出来
                    in.close();
                    bis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    public static void main(String[] args) {
        byteWriter();
        byteReader();
    }
}