JavaSE复习巩固

最新推荐文章于 2024-08-11 20:00:32 发布

编程玩家1号

最新推荐文章于 2024-08-11 20:00:32 发布

阅读量175

点赞数

分类专栏： javaSE基础文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/m0_53757041/article/details/121803900

版权

javaSE基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

第九天：IO流

File类

1.1 File概述

打开API，搜索File类。阅读其描述：File文件和目录路径名的抽象表示形式。即，Java中把文件或者目录（文件夹）都封装成File对象。也就是说如果我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可,那么我们就要研究研究File这个类中都有那些功能可以操作文件或者文件夹呢

我们对文件进行创建和删除操作。

IO:作用---是用来操作数据用的

内存(java程序)与硬盘之间进行读和写数据要使用一个媒介，我们称之为流。

通过数据的传输方式不一样，把流分为两类，分别:

输入流：把硬盘中的数据读到内存中来（把文件中的内容读到内存中）---导出

输出流：把内存中的数据写到硬盘中去（从程序中往文件中写数据）----导入

通过传输的数据类型不同，我们名义上可以把流分为：

字节流

字符流：字符流的底层还是字节流

字符通过码表转换为字节，字符=字节+码表

流的具体细分：

字节输入流：InputStream （抽象类不能直接实例化，可以使用多态，用实现类（子类））FileInputStream

字节输出流：OutputStream FileOutputStream

字符输入流：Reader FileReader

字符输出流：Writer FileWriter

字节流

1.从文件中读数据

第一种方式

例子：

package com.swlz.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class IODemo1 {
    public static void main(String[] args) throws IOException {
        //计算机只能识别二进制数0和1
        //使用流进行进行传输数据的时候，最终都会转换为二进制数传输
//        String s="詹栈";//把字符转换为二进制数这个过程称为编码
        //使用字节输入流把文件中的数据读出来
        //创建字节输入流对象
        InputStream is=new FileInputStream("D:\\aaa\\e.txt");
        //一次读一个字节
        //从此输入流中读取一个字节数据
        //如果达到文件数据的末尾没有数据了。则会返回-1，说明已经到文件的末尾了没有数据了
          int read;
        while ((read=is.read())!=-1){//读到一个字节就强转为字符
            System.out.print((char)read);//打印字符a  转换为打印字符a  强转类型
        }
//        int read = is.read();
//        System.out.println(read);//97 a在Ascall码表中的位置
//        System.out.println((char)read);//打印字符a  转换为打印字符a  强转类型

    }
}

第二种方式：

package com.swlz.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class IODemo2 {
    public static void main(String[] args) throws IOException {
        //使用字节输入流一次读一个字节的第二中方式：读一个字节就把它存在字节数组中去
       byte[] arr=new byte[1024];//字节数组
       InputStream is=new FileInputStream("D:\\aaa\\e.txt");
//        int read = is.read();
//        byte b=(byte)read;//强转为byte类型
//        arr[0]=b;//读到的字节放到字节数组中先存起来
        int read;
        int i=0;
        while ((read=is.read())!=-1){
            //读把读到的字节一个一个的存在字节数组中
            arr[i]=(byte)read;//arr[0]  arr[i]  读到末尾为止
            i++;
        }
//        把读到所有字节转为字符串
        String s = new String(arr, 0, i);//0到i，从开始0到最后末尾i去读  读的是arr数组里面的字节
        System.out.println(s);//打印字符串
    }

}

2.往文件中写数据

例子：

package com.swlz.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class IODemo3 {
    public static void main(String[] args) throws IOException {
        //往文件里面写数据
        //创建流对象  要想在文件后面追加数据要append：true
        OutputStream os=new FileOutputStream("D:\\aaa\\y.txt",true);
        //要写入文件的数据
        String s="zhanjuzhang";
        //得到字节数组   一个字节一个字节的往文件写数据
        byte[] bytes = s.getBytes();
        //开始写数据
        os.write(bytes);
    }
}

3.扩展：文件的复制

package com.swlz.io;

import java.io.*;

public class IODemo4 {
    public static void main(String[] args) throws IOException {
        InputStream is=null;
        OutputStream os=null;
        try {
            //文件的复制
            //创建输入流对象 读数据出来
         is=new FileInputStream("D:\\aaa\\a.txt");
            //创建输出流对象 写数据 写操作
        os=new FileOutputStream("D:\\aaa\\d.txt");
            //创建字节数据 暂时存储读出来的文件数据 字节全部存在这个字节数组中
            int length;
            byte[] arr=new byte[1024];
//        边读
            while ((length=is.read(arr))!=-1){
                os.write(arr,0,length);//边写
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            //在不为null情况，释放资源
            if(is!=null) {
                is.close();
            }
            if(is!=null) {
                os.close();
            }
        }

    }
}

记得关闭流，释放资源。

2.字符流

缓冲区就在内存中

缓冲区的大小只有8kb

超出8kb就会溢出去

2.1使用字符输入流读数据

例子：

public class ReaderDemo {
    public static void main(String[] args) throws Exception{
        /*
            使用字符输入流读数据
            Reader---FileReader
        * */
           //创建字符输入流读对象
        Reader rd=new FileReader("D:\\b.txt");
        //一次读一个字符
       /* int read = rd.read();
        System.out.println((char)read);*/
             /*int read;
             while ((read=rd.read())!=-1){
                 System.out.print((char)read);
             }*/

             //一次读一个字符第二种方式
                    /* char[] chs=new char[1024];
                          int  i=0;
                          int read;
                          while((read=rd.read())!=-1){
                              chs[i]=(char)read;
                              i++;
                          }

                    String s = new String(chs, 0, i);
                    System.out.println(s);*/


                    //读数据的第三种方式---一次读一个字符数组
                      char[] chs=new char[1024];
                          int length;
                        while((length=rd.read(chs))!=-1){
                            String s = new String(chs, 0, length);
                            System.out.println(s);
                        }

    }
}

2.2 使用字符输出流写数据

public class WriterDemo {
    public static void main(String[] args) throws Exception{
        /*使用字符输出流写数据
        *  Writer-----FileWriter
        * */
        //创建字符输出流对象
        Writer wt=new FileWriter("a.txt");
        String   s="wobuaini";
       /* char[] chs = s.toCharArray();
        //直接写字符数组
            wt.write(chs);*/

       //第二种方式---直接写字符串
            wt.write(s);

//            wt.flush();---刷新缓冲区
        //字符流关流的操作  具有刷新缓冲区的功能
        wt.close();
    }
}

2.3 使用字符流实现文件复制：

代码如下：

public class CopyDemo {
    public static void main(String[] args) throws Exception{
        /*使用字符串进行文件的复制*/

             //创建字符输入流对象
        Reader    rd=new FileReader("D:\\CC.txt");

        //创建字符输出流对象
        Writer   wt=new FileWriter("a.txt");
              char[]  chs=new char[1024];
                int  length;
                while((length=rd.read(chs))!=-1){
                    wt.write(chs,0,length);
                }
                rd.close();
                wt.close();


    }
}

3.转换流

1.1 基本概述

转换流是字节流通向字符流的一个桥梁

转换流能够将我们的字节流转换成字符流，在操作一些文本文件的时候，能够以字符流的形式去使用此流

1. InputStreamReader ：字节输入流-----字符输入流

能够完成字节输入流到字符输入流的转换

public class InputStreamReaderDemo {
    public static void main(String[] args) throws Exception{
        InputStream is=new FileInputStream("a.txt");
        //把给定的字节流转换成字符流  --转换流可以解决中文乱码问题
        InputStreamReader isr=new InputStreamReader(is);
        char[]   chs=new char[1024];
        int length;
        while((length=isr.read(chs))!=-1){
            String s = new String(chs, 0, length);
            System.out.println(s);
        }
        isr.close();
    }
}

2.OutputStreamWriter

是字符流通向字节流的桥梁

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的charset将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集

例子：

 public static void main(String[] args) throws Exception{
        /*转换流:------字节流转换成字符流
        *
        *    只有一个字节输入流inputStream,使用的是字符流操作文本文件
        * */
//        method1();
             //创建字节输出流
        OutputStream  os=new FileOutputStream("a.txt");

        //创建转换流对象
        OutputStreamWriter  osw=new OutputStreamWriter(os);
              //写数据
        osw.write("nihao,shuaige");
        osw.close();
    }

4.缓冲流

经过分析我们发现，无论是字节流还是字符流，在操作数据的时候，都是一个字节一个字节（一个字符一个字符的操作），每一次操作都需要和硬件资源打交道

使用缓冲流可以解决这个问题

缓冲流会自带缓冲区（内存中一块区域），从磁盘获取或者写入数据的时候，能够一次性获取过个数据，以后再通过流去操作的时候，就是直接从缓冲区中获取数据了，从而能够减少内存与硬盘交互的次数，提高性能

1.使用缓冲流可以解决这个问题

1 字节流

InputStream BufferedInputStream

OutputStream BufferedOutputStream

1. BufferedInputStream

例子：

public class BufferedInputSteamDemo1 {
    public static void main(String[] args) throws Exception{
        //创建字节输入缓冲流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\b.txt"));
        //     虽然看上去还是一个字节一个字节读，但是先放到缓冲区，然后一次性读出来
                  /* int read;
                   while ((read=bis.read())!=-1){
                       System.out.print((char)read);
                   }*/
                  byte[]  arr=new byte[1024];
                  int length;
                  while((length=bis.read(arr))!=-1){
                      String s = new String(arr, 0, length);
                      System.out.println(s);
                  }
    }
}

2.BufferedOutputStream

例子：

public class BufferedOutPutStreamDemo {
    public static void main(String[] args) throws Exception{
        //创建字节输出缓冲流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
               //写数据
        bos.write("hello".getBytes());
        //字节输出缓冲流写数据的时候一定要记得刷新，因为使用缓冲区比之前的普通流多了一个缓冲区
        bos.close();
    }
}

3.BufferedReader

例子：

public class BufferedReaderDemo1 {
    public static void main(String[] args) throws Exception{
        /*缓冲流（高效率）四个
                Reader            BufferedReader
               Writer            BufferedWriter
        *  InputStream        BufferedInputStream
           OutputStream      BufferedOutputStream
        *
        * */
                //创建字符输入流对象
     Reader  rd=new FileReader("d:\\b.txt");
             //创建字符输入缓冲流对象
        /*BufferedReader(Reader in)
          创建一个使用默认大小输入缓冲区的缓冲字符输入流。*/

        BufferedReader br=new BufferedReader(rd);
        /*如果已到达流末尾，则返回 null
         */
        String  s;
        while ((s=br.readLine())!=null){
            System.out.println(s);
        }
        //关闭了外层流相当于一起把内层流也关闭
        br.close();

        /*String s = br.readLine();
        System.out.println(s);
        String s1 = br.readLine();
        System.out.println(s1);
        String s2 = br.readLine();
        System.out.println(s2);
        String s3 = br.readLine();
        System.out.println(s3);//null是readLine()的临界点*/

    }
}

4.BufferedWriter
例子：

public class BufferedWriterDemo1 {
    public static void main(String[] args) throws Exception{
        /*创建字符输出缓冲流对象*/
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
        //写数据
          bw.write("nihao");
//          bw.write("\r\n");
        //换行的方法
        bw.newLine();//牛栏
          bw.write("java");
          //记得刷新
        bw.close();
    }
}

3.文件复制：

public class BufferedCopyDemo{
    public static void main(String[] args) throws Exception{
        //创建字符输入缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("d:\\b.txt"));
        //创建字符输出缓冲流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\bb.txt"));

           //边读编写
            String  s;
            while((s=br.readLine())!=null){
                bw.write(s);
                //每写一行newline（）一下。
                bw.newLine();
            }
            //关流
            br.close();
            bw.close();
    }
}

总结：

1.IO Input(输入) Output（输出）流

IO流分类：

1. 流向

输入流读取数据 FileReader Reader

输出流写出数据 FileWriter Writer

数据类型

2. 字节流

字节输入流读取数据 InputStream

字节输出流写出数据 OutputStream

3. 字符流

字符输入流读取数据 Reader

字符输出流写出数据 Writer

4.转换流

5.缓存流

    Reader             BufferedReader
    Writer             BufferedWriter
    InputStream        BufferedInputStream
    OutputStream       BufferedOutputStream

今日学习感受：学习的日子在清楚自己的目标，清楚自己在干什么，虽然偶尔会犯困，一天一定到睡满8小时左右，睡眠质量要好，不然会影响一天的状态，无法保持良好的学习状态，对学习的效率会大打折扣，坚持下去，会看见属于自己的光。最后一句话：不积跬步无以至千里，不积小流无以成江海。

编程玩家1号

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE复习巩固

第九天：IO流File类1.1File概述打开API，搜索File类。阅读其描述：File文件和目录路径名的抽象表示形式。即，Java中把文件或者目录（文件夹）都封装成File对象。也就是说如果我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可,那么我们就要研究研究File这个类中都有那些功能可以操作文件或者文件夹呢我们对文件进行创建和删除操作。IO:作用---是用来操作数据用的内存(java程序)与硬盘之间进行读和写数据要使用一个媒介，我们称之为流。通过数据的传输.
复制链接

扫一扫