IO流查漏补缺加复习

哦吼~

于 2020-02-16 12:37:58 发布

阅读量124

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/qq_42727102/article/details/102559264

版权

JAVA 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1.File类：File类只能操作文件本身，但是不能操作文件的内容，就像你可以把别人的笔记本放到任何地方，但是你不能看他到底写了什么内容。

//获取f盘下a文件夹下abc文件夹下的tt.txt文件
public class Demo1 {
    public static void main(String[] args) {
        //这时候对象f就是tt.txt文件
        File f = new File("F:\\a\\abc\\tt.txt");
        //注意：\在文件中是路径的分隔符，但是在java编程中一个\的意思是转义符，在java中\\或者/才是文件的分隔符
        File f2 = new File("F:/a/abc/tt.txt");
        //也可以用File.separator作为文件分隔符
        File f3 = new File("F:"+File.separator+"a/abc/tt.txt");
        File f1 = new File("F:\\a\\abc","tt.txt");//同上，这种方式使用较少

        File f4 = new File("F:\\test\\abc");//这是个目录
        //获取文件名
        System.out.println(f.getName());
        //获取当前的目录（文件夹）名
        System.out.println(f4.getName());
        //获取文件或者文件夹当前路径,就是new file时候写的路径
        System.out.println(f.getPath());

        File f5 = new File("/src/main/java/xiangdui/xiangduilujing.java");//使用相对路径创建file对象
        //获取文件或者文件夹当前路径,就是new file时候写的路径
        System.out.println(f5.getPath());
        //获取当前文件的绝对路径
        System.out.println(f5.getAbsolutePath());

        //就是new file时候写的路径
        System.out.println(f5);
        //返回一个用当前文件的绝对路径构建的file对象
        System.out.println(f5.getAbsoluteFile());

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

        //给文件或文件夹重命名
        f.renameTo(new File("F:\\a\\abc\\tt1.txt"));

        //判断文件或者文件夹是否存在
        File f6 = new File("F:\\a\\abc\\tt1.txt");
        System.out.println(f6.exists());//true
        File f7 = new File("F:\\a\\abc\\tt2.txt");
        System.out.println(f7.exists());//false

        //判断文件是否可读/写
        System.out.println(f6.canRead());//true
        System.out.println(f6.canWrite());//true

        //判断当前的file对象是不是文件
        System.out.println(f6.isFile());//true
        //判断当前的file对象是不是一个文件夹(目录)
        System.out.println(f6.isDirectory());//false

        //获取文件的最后修改时间，返回的是一个毫秒数
        System.out.println(f6.lastModified());

        //返回文件的长度,单位是字节数
        System.out.println(f6.length());

        //创建一个新文件
        File f8 = new File("F:\\a\\abc\\tt2.txt");
        if (!f8.exists()){//tt2.txt文件不存在
            try{
                f8.createNewFile();
            }catch(Exception e){
                System.out.println(e.getMessage());
            }
        }

        //删除一个文件
        if (f8.exists()){
            f8.delete();
        }

        //创建单层目录，如果使用这种方式创建多层目录，只能一层一层的执行mkdir
        //File f9 = new File("F:\\a\\abc\\cc");
        File f9 = new File("F:\\a\\abc\\cc\\dd");
        f9.mkdir();
        //创建多级目录
        File f10 = new File("F:\\a\\abc\\dd\\ee");
        f10.mkdirs();

        //返回当前文件夹的子集的名称，包括目录和文件
        File f11 = new File("F://a");
        String[] list = f11.list();
        for (String s:list) {
            System.out.println(s);
        }
        //返回的是当前文件夹的子集的file对象，包括目录和文件
        File[] lists = f11.listFiles();
        for (File s:lists) {
            System.out.println(s);
        }
    }
}

2.练习

//遍历f盘下a文件夹，并将其所有目录和文件打印出来
public class Demo1lianxi {
    public static void test(File file){
        if (file.isFile()){
            System.out.println(file.getAbsolutePath()+"是文件");
        }else{
            System.out.println(file.getAbsolutePath()+"是一个文件夹");
            //如果是文件夹，这个文件夹里就可能有子文件夹或者文件
            File[] fs = file.listFiles();//这是获取当前文件夹下的子文件夹或者文件的file对象
            if (fs!=null&&fs.length>0){//有东西
                for (File ff:fs) {
                    /*if (ff.isFile()){
                        System.out.println(file.getAbsolutePath()+"是文件");
                    }else{
                        System.out.println(file.getAbsolutePath()+"是一个文件夹");
                    }*/
                    test(ff);
                }
            }
        }
    }

    public static void main(String[] args) {
        File file = new File("F:\\a");
        test(file);
    }
}

3.无论是输入还是输出，都指的是计算机

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LfHD9RD7-1571069762701)(C:\Users\xuan\AppData\Roaming\Typora\typora-user-images\1571039599205.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WcWE9M51-1571069762701)(C:\Users\xuan\AppData\Roaming\Typora\typora-user-images\1571039731050.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Va1yz8OE-1571069762702)(C:\Users\xuan\AppData\Roaming\Typora\typora-user-images\1571039815045.png)]$

3.1文件字节流

/*
注意：文件字节流非常通用，可以用来操作字符的文档，还可以操作任何的其他
类型文件（如图片，压缩包等等），因为字节流直接使用的是二进制
 */
public class Demo1 {
    public static void main(String[] args) throws Exception {
       //testFileInputStream();
        // testFileOutputStream();
        //copyFile("F:\\a\\abc\\tt2.txt","F:\\a\\abc\\cc\\tt2.txt");
        copyFile("F:\\a\\abc\\img.png","F:\\a\\abc\\cc\\img.png");//复制图片
    }

    //文件字节输入流
    public static void testFileInputStream() throws Exception{
        FileInputStream in = new FileInputStream("F:/a/abc/tt1.txt");
        byte[] b = new byte[100];//设置一个byte数组接收读取的文件的内容
        //in.read(b);//将读出来的东西存入b,返回读取的长度，如果读取到最后一个数据，还会向后读一个，
        //也就意味着当in.read()的返回值是-1的时候整个文件就读取完毕了，也就是你文件中如果有多条
        //数据，只能读取到第一条
        int len = 0;//接收它读取的长度
        while((len = in.read(b))!=-1){
            System.out.println(new String(b,0,len));
            //new String(b,0,len);参数1是缓冲数据的数组，参数2是从数组的哪个位置开始转化字符串，参数3是总共转化几个字节
        }
        //System.out.println(new String(b));
        in.close();//注意：流在使用完毕之后一定要关闭
    }

    //文件字节输出流
    public static void  testFileOutputStream() throws Exception {
        FileOutputStream out = new FileOutputStream("F:/a/abc/tt2.txt");//指定向tt4.txt输出数据,没有此文件的话它会自动创建
        String str = "666666";
        out.write(str.getBytes());//把数据写到内存中
        out.flush();//把内存中的数据刷写到硬盘上
        out.close();
    }

    //练习：将tt1.txt文件复制到cc文件夹下
    public static void copyFile(String inPath,String outPath){
        try{
            FileInputStream in = new FileInputStream(inPath);//读取的源文件
            FileOutputStream out = new FileOutputStream(outPath);//复制到哪

            byte[] b = new byte[100];
            int len = 0;
            while ((len = in.read(b))!=-1){
                out.write(b,0,len);//参数1是写的缓冲数组，参数2是从数组的哪个位置开始，参数3是写的总长度
            }
            out.flush();
            out.close();
            in.close();
        }catch(Exception e){
            System.out.println(e.getMessage());
        }
    }
}

3.2文件字符流

/*
注意：定义文件路径时，可以使用"/"或者"\\"
在写入一个文件时，如果目录下有同名文件将被覆盖//字节流和字符流都有这种情况
在读取文件时，必须保证该文件已经存在，否则出异常
 */
public class Demo2 {
    public static void main(String[] args) throws Exception {
        //testFileReader("F:/a/abc/tt1.txt");
        testFileWriter("F:/a/abc/tt2.txt");
    }

    //文件字符输入流
    public static void testFileReader(String inPath) throws Exception {
        FileReader fr = new FileReader(inPath);//创建文件字符输入流对象
        char[] c = new char[100];//创建临时存放数据的字符数组
        int len = 0;//定义一个输入流的读取长度
        while((len = fr.read(c))!=-1){
            System.out.println(new String(c,0,len));
        }
        fr.close();//关闭流
    }

    //文件字符输出流
    public static void testFileWriter(String outPath) throws Exception {
        FileWriter fw = new FileWriter(outPath);
        String str = "777";
        fw.write(str);//写入
        fw.write("6666");
        fw.write("\r\n");
        fw.append(str);//拼接到后面
        fw.flush();//把内存的数据刷到硬盘
        fw.close();
    }
}

3.3处理流：缓冲流：为了提高数据读写的速度，而上面两种都是计算机与硬盘之间发生的IO操作，而硬盘的读写速度是比较慢的，所以也就有了缓冲流。缓冲流是套接在相应的节点流之上的，对读写的数据提供了缓冲的功能，提高了读写的效率，对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush（）方法将内存中的数据立刻写出。即与内存IO，然后在全部给硬盘。

public class Demo3 {
    public static void main(String[] args) throws Exception {
        //testBufferedInputStream();
        //testBufferedOutputStream();
        //testBufferedReader();
        testBufferedWriter();
    }

    //缓冲字节输入流
    public static void  testBufferedInputStream() throws Exception{
        //文件字节输入流对象
        FileInputStream in = new FileInputStream("F:/a/abc/tt1.txt");
        //缓冲字节输入流对象,将文件字节输入流对象放入到缓冲字节输入流中
        BufferedInputStream br = new BufferedInputStream(in);
        byte[] b = new byte[100];
        int len = 0;
        while((len=br.read(b))!= -1){
            System.out.println(new String(b,0,len));
        }
        //关闭流的时候，后开的先关，依次关掉
        br.close();
        in.close();
    }

    //缓冲字节输出流
    public static void  testBufferedOutputStream() throws Exception{
        //文件字节输出流对象
        FileOutputStream out = new FileOutputStream("F:/a/abc/tt2.txt");
        //缓冲字节输出流对象,将文件字节输出流对象放入到缓冲字节输出流中
        BufferedOutputStream bo = new BufferedOutputStream(out);
        String str = "hello world";
        bo.write(str.getBytes());//写到内存中
        bo.flush();//刷新到硬盘上
        //关闭流的时候，后开的先关，依次关掉
        bo.close();
        out.close();
    }

    //缓冲字符输入流
    public static void testBufferedReader() throws Exception {
        FileReader r = new FileReader("F:/a/abc/tt1.txt");
        BufferedReader br = new BufferedReader(r);
        char[] c = new char[100];
        int len = 0;
        while ((len=br.read(c))!=-1){//读到文件的最后一个字符的下一位，返回值就是-1
            System.out.println(new String(c,0,len));
        }
        br.close();
        r.close();
    }

    //缓冲字符输出流
    public static void testBufferedWriter() throws Exception {
        FileWriter r = new FileWriter("F:/a/abc/tt1.txt");
        BufferedWriter br = new BufferedWriter(r);
        String s = "666666";
        br.write(s);
        br.flush();
        br.close();
        r.close();
    }
}

3.4处理流：转换流

public class Demo4 {
    public static void main(String[] args) throws Exception {
        //所有文件都是有编码格式
        //对于我们来说，txt和java文件一般来讲有三种编码
        //ISO8859-1，西欧编码，是纯粹的英文编码，不适合中文
        //GBK和UTF-8，这两种是适用于中文和英文的
        //一般使用UTF-8编码
        //testInputStreamReader();
        testOutputStreamWriter();
    }

    //转换字节输入流为字符输入流
    //注意：在转换字符流的时候，设置的字符集编码要与读取的文件的数据的编码一致，否则就会出现乱码
    public static void testInputStreamReader() throws Exception {
        FileInputStream fs = new FileInputStream("src\\main\\java\\tt5.txt");
        //把字节流转换为字符流,参数1是字节流，参数2是编码
        InputStreamReader in = new InputStreamReader(fs,"UTF-8");
        char[] c = new char[100];
        int len = 0;
        while((len=in.read(c))!=-1){
            System.out.println(new String(c,0,len));
        }
        in.close();
        fs.close();
    }

    //转换字节输出流为字符输出流
    public static void testOutputStreamWriter() throws Exception{
        FileOutputStream out = new FileOutputStream("src\\main\\java\\tt6.txt");
        //注意：在转换字符流的时候，设置的字符集编码要与读取的文件的数据的编码一致，否则就会出现乱码
        OutputStreamWriter os = new OutputStreamWriter(out,"UTF-8");
        os.write("你好！");
        os.flush();
        os.close();
        out.close();
    }
}

3.5处理流：标准输入输出流

System.in和System.out分别代表了系统标准的输入和输出设备，默认输入设备设键盘，输出设备是显示器

System.in的类型是InputStream

System.out的类型是PrintStream，其是OutputStream的子类FilterOutputStream的子类

3.5.1System.in

public class Demo5{
    public static void main(String[] args) throws IOException {
    //testSystemIn();
        writeToTxt();
    }

    //标准输入流
    public static void testSystemIn() throws IOException {
        //创建一个接受键盘输入数据的输入流
        InputStreamReader is = new InputStreamReader(System.in);
        //把输入流放到缓冲流中
        BufferedReader br = new BufferedReader(is);

        String str = "";//定义一个临时接收数据的字符串
        while((str=br.readLine())!= null){
            System.out.println(str);
        }
        br.close();
        is.close();
    }

    //练习：把控制台输入的内容写到指定的txt文件中，但接收到over就结束
    public static void writeToTxt() throws IOException {
        //创建一个接受键盘输入数据的输入流
        InputStreamReader is = new InputStreamReader(System.in);
        //创建一个输入缓冲流
        BufferedReader br = new BufferedReader(is);
        BufferedWriter out = new BufferedWriter(new FileWriter("src\\main\\java\\tt5.txt"));
        String line="";
        while((line=br.readLine())!=null){
            if (line.equals("over")){
                break;
            }
            //读取每一行并写到指定的txt文件
            out.write(line);
            out.newLine();//换行
        }
        out.flush();
        out.close();
        br.close();
        is.close();
    }
}

3.5.2System.out

PrintStream（字节打印流）和PrintWriter（字符打印流）提供了一系列重载的print和println方法，用于多种数据类型的输出，他们两个流的输出都不会抛出异常并且都有自动flush功能，System.out返回的是PrintStream的实例

3.6处理流：数据流：专门用来方便操作基本数据类型的数据

DataInputStream和DataOutputStream 分别套接在InputStream和OutputStream节点流上

public class Demo6 {
    public static void main(String[] args) throws Exception {
        //testDataOutputStream();
        testDataInputStream();
    }

    //数据输出流
    /*
    用数据输出流写到文件中的基本数据类型的数据，是乱码的，不能直接辨认出来，需要数据输入流读取出来
     */
    public static void testDataOutputStream() throws Exception {
        //创建一个数据输出流对象
        DataOutputStream out = new DataOutputStream(new FileOutputStream("src\\main\\java\\tt6.txt"));
        //out.writeBoolean(true);
        //out.writeDouble(1.35d);
        out.writeInt(100);
        out.flush();
        out.close();
    }

    /*
    数据输入流
    用数据输出流写到文件中的基本数据类型的数据，是乱码的，不能直接辨认出来，需要数据输入流读取出来
     用数据输入流读取数据输出流写到文件中的数据时，要保证使用和当时写的数据类型一致，否则得不到想要的数据
     */
    public static void testDataInputStream() throws Exception{
        DataInputStream in = new DataInputStream(new FileInputStream("src\\main\\java\\tt6.txt"));
        System.out.println(in.readInt());
        in.close();
    }
}

3.7处理流：对象流

ObjectInputStream和ObjectOutputStream：用于存储和读取对象的处理流。它的强大之处就是可以把java中的对象写入到数据源中，也能把对象从数据源中还原回来。

正是因为保存对象到硬盘（对象的持久化）和对象的网络传输，需要做这两件事，就产生了输入与输出流。

序列化（Serialize）：用ObjectOutputStream类将一个java对象写入IO流中

反序列化（Deserialize）：用ObjectInputStream类从IO流中恢复该java对象

序列化与反序列化针对的是对象的各种属性，不包括类的属性。

ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

Person.java

/*
可以序列化与反序列化的对象
 */
public class Person implements Serializable {
    /*
    一个表示序列化版本标识符的静态变量
    用来表明类的不同版本间的兼容性
     */
    private static final long serialVersionUID = 1L;

    String name;
    int age;
}

test.java

/*
序列化与反序列化
注意：对象的序列化与反序列化使用的类要严格一致，包名，类名，类结构等等都要一致
 */
public class test {
    public static void main(String[] args) throws Exception {
        //testSerialize();//序列化
        testDeserialize();//反序列化
    }
    /*
    对象序列化
     */
    public static void testSerialize() throws Exception{
        //定义对象的输出流，把对象序列化之后的流放到指定的文件中
        ObjectOutputStream  out = new ObjectOutputStream(new FileOutputStream("src\\main\\java\\tt6.txt"));

        Person p = new Person();
        p.age = 18;
        p.name ="HAHA";
        out.writeObject(p);
        out.flush();
        out.close();
    }

    /*
    对象的反序列化
     */
    public static void testDeserialize() throws Exception{
        //创建对象输入流对象，从指定的文件中把对象的序列化后的值读取出来
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("src\\main\\java\\tt6.txt"));
        Object obj = in.readObject();
        Person p = (Person)obj;
        System.out.println(p.name);
        System.out.println(p.age);
        in.close();
    }
}

3.8RandomAccessFile类

RandomAccessFile类支持“随机访问”的方式，程序可以直接跳转到文件的任意地方来读，写文件

支持只访问文件的部分内容

可以向已存在的文件后追加内容

RandomAccessFile对象包含一个记录指针，用以标示当前读写处的位置

RandomAccessFile对象可以自由移动记录指针

long getFilePointer():获取文件记录指针的当前位置

void seek(long pos):将文件记录指针定位到pos位置

/*
文件的随机读写：程序可以直接跳到文件的任意地方来读、写文件
 */
public class test {
    public static void main(String[] args) throws Exception {
        //testRandomAccessFileRead();
        testRandomAccessFileWrite();
    }
    /*
    随机读文件
     */
    public static void testRandomAccessFileRead() throws Exception{
        //RandomAccessFile的构造有两个参数，参数1是读写的文件的路径
        //参数2是指定RandomAccessFile的访问模式
        //r：以只读方式打开
        //rw：打开以便读取和写入
        //rwd：打开以便读取和写入；同步文件内容的更新
        //rws：打开以便读取和写入；同步文件内容和元数据的更新
        RandomAccessFile ra = new RandomAccessFile("src\\main\\java\\tt5.txt","r");

        //ra.seek(0);//设置读取文件内容的起始点,以字符为单位
        ra.seek(8);
        byte[] b = new byte[1024];
        int len = 0;
        while((len=ra.read(b))!=-1){
            System.out.println(new String(b,0,len));
        }
        ra.close();
    }

    /*
    随机写文件
     */
    public static void testRandomAccessFileWrite() throws Exception{
        RandomAccessFile ra = new RandomAccessFile("src\\main\\java\\tt5.txt","rw");
        //ra.seek(6);//设置写的起始点,0代表从开头写
        //注意：如果是在文件开头或者中间的某个位置开始写的话，就会用写的内容覆盖掉等长度的原内容
        ra.seek(ra.length());//设置写的起始点，ra.length()代表从文件的最后结尾写，也就是文件的追加

        ra.write("你好".getBytes());
        ra.close();

    }
}

哦吼~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流查漏补缺加复习

1.File类：File类只能操作文件本身，但是不能操作文件的内容，就像你可以把别人的笔记本放到任何地方，但是你不能看他到底写了什么内容。//获取f盘下a文件夹下abc文件夹下的tt.txt文件public class Demo1 { public static void main(String[] args) { //这时候对象f就是tt.txt文件 ...
复制链接

扫一扫

专栏目录