第十三章 IO流（尚硅谷最新版Java零基础编程_2019版笔记）

最新推荐文章于 2024-08-06 10:22:43 发布

quanquanya

最新推荐文章于 2024-08-06 10:22:43 发布

阅读量223

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/quanquanya/article/details/105225781

版权

第十三章 IO流

JUnit单元测试步骤：

1.配置方法:参考1或参考2

使用@Test可能会报错，解决方法：选择Add “JUnit4” to classpath

2.创建Java类，进行单元测试

Java类要求：此类是public的；此类提供公共的无参构造器

3.此类中声明单元测试方法

单元测试方法要求：方法的权限是public；没有返回值；没有形参

4.此单元测试方法上需要声明注解：@Test，并在单元测试类中导入：import org.junit.Test;

5.声明好单元测试方法后，就可以在方法体内测试相关的代码

6.写完代码后，左键选中单元测试方法名 -> 右键 -> run ‘方法名’
```
package com.atguigu.java;

import org.junit.Test;

/**
 * @author quanquan
 * @create 2020-03-29-18:51
 */
public class JUnitTest {
    @Test
    public void Test1(){
        System.out.println("Test");
    }
}
```
File类的使用
- File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
- File类声明在java.io包下
- 创建File类的构造器
  - File(String filePath)
  - File(String parentPath,String childPath)
  - File(File parentPath,String childPath)
- 相对路径：相较于某个路径下，指明的路径
  
  绝对路径：包含盘符在内的文件或文件目录的路径
  
  注意：windows和DOS系统默认使用 “\” 来表示路径分隔符
  
  UNIX和URL使用 “/” 来表示
- File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
- 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点"。

package com.atguigu.java;

import org.junit.Test;

import java.io.File;

/**
 * @author quanquan
 * @create 2020-03-29-20:15
 */
public class FileTest {
    @Test
    public void test1(){
        //构造器1
        File file1 = new File("hello.txt"); //相对于当前的module
        File file2 = new File("D:\\IDEA-workspace\\JavaSenior\\pro13\\he.txt");
        System.out.println(file1);
        System.out.println(file2);

        //构造器2
        File file3 =new File("D:\\IDEA-workspace","JavaSenior");
        System.out.println(file3);

        //构造器3
        File file4 = new File(file3,"hi.txt");
        System.out.println(file4);
    }
}

File类方法
- public String getAbsolutePath()：获取绝对路径
- public String getPath() ：获取路径
- public String getName() ：获取名称
- public String getParent()：获取上层文件目录路径。若无，返回null
- public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
- public long lastModified() ：获取最后一次的修改时间，毫秒值
- 如下的两个方法适用于文件目录：
  public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
  public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组
public boolean renameTo(File dest):把文件重命名为指定的文件路径
比如：file1.renameTo(file2)为例：
要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。（成功后file1不存在而file2存在了）
- public boolean isDirectory()：判断是否是文件目录
- public boolean isFile() ：判断是否是文件
- public boolean exists() ：判断是否存在
- public boolean canRead() ：判断是否可读
- public boolean canWrite() ：判断是否可写
- public boolean isHidden() ：判断是否隐藏
创建硬盘中对应的文件或文件目录
- public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
- public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
- public boolean mkdirs() ：创建文件目录。如果此文件目录存在，就不创建了。如果上层文件目录不存在，一并创建
删除磁盘中的文件或文件目录
- public boolean delete()：删除文件或者文件夹（注意：Java中的删除不走回收站）
- 删除文件夹要想成功，文件目录下不能有子目录
流的分类：字节流和字符流，输入流和输出流，节点流和处理流

（抽象基类）	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

流的体系结构

抽象基类	节点流（或文件流）	缓冲流（处理流的一种）
InputStream	FileInputStream (read(byte[] buffer))	BufferedInputStream (read(byte[] buffer))
OutputStream	FileOutputStream (write(byte[] buffer,0,len)	BufferedOutputStream (write(byte[] buffer,0,len) / flush()
Reader	FileReader (read(char[] cbuf))	BufferedReader (read(char[] cbuf) / readLine())
Writer	FileWriter (write(char[] cbuf,0,len)	BufferedWriter (write(char[] cbuf,0,len) / flush()

DAY24

使用 FileReader 读取文件
- read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
- 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
- 读入的文件一定要存在，否则就会报FileNotFoundException。

	 @Test
    public void testFileReader() {
        FileReader fr = null;

        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt"); //相较于当前Module
            //main方法中的File file = new File("hello.txt"); 相较于当前工程
            //2.提供具体的流
            fr = new FileReader(file);

//        方式一
//        3.数据的读入
//        //read():返回读入的一个字符。如果达到文件末尾，返回-1
//        int data = fr.read();
//        while(data != -1){
//            System.out.print((char) data);
//            data = fr.read();
//        }

            //方式二：语法上针对方式一的修改
            int data;
            while((data = fr.read()) != -1){
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
            try { if(fr != null){
                fr.close();
            }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

对read()操作升级：使用read的重载方法

	@Test
    public void testFileReader1()  {
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file = new File("hello.txt");

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf)) != -1){
                //方式一：
                //错误的写法
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }
                //正确的写法
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }
                //方式二：
                //错误的写法,对应着方式一的错误的写法
//                String str = new String(cbuf);
//                System.out.print(str);
                //正确的写法
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
                //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                
            }  
        }
        
    }

从内存中写出数据到硬盘的文件里
- 输出操作，对应的File可以不存在的。并不会报异常
- File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
- File对应的硬盘中的文件如果存在：
  - 如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
  - 如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容

    @Test
    public void testFileWriter() {
        FileWriter fw = null;
        try {
            //1.提供File类的对象，指明写出到的文件
            File file = new File("hello1.txt");

            //2.提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(file,false);

            //3.写出的操作
            fw.write("I have a dream!\n");
            fw.write("you need to have a dream!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流资源的关闭
            if(fw != null){

                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理

对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)，使用字节流处理
- 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写 B 来表示,1B（byte,字节）= 8bit（位）
- 字符：是指计算机中使用的字母、数字、字和符号
  - UTF-8编码：1个英文字符 = 1个字节
    英文标点 = 1个字节
    中文标点 = 3个字节
测试FileInputStream和FileOutputStream的使用

public class FileInputOutputStreamTest {
    @Test
    public void testFileInputOutputStream() {
        //1
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File srcFile = new File("picture1.jpg");
            File destFile = new File("picture2.jpg");
            //2
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            //3.复制过程
            byte[] buffer = new byte[5];
            int len;
            while ((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

缓冲流的使用
- 作用：提供流的读取、写入的速度
  
  提高读写速度的原因：内部提供了一个缓冲区
- 处理流，就是“套接”在已有的流的基础上

/*
    实现非文本文件的复制
     */
    @Test
    public void BufferedStreamTest() throws FileNotFoundException {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            //1.造文件
            File srcFile = new File("爱情与友情.jpg");
            File destFile = new File("爱情与友情3.jpg");
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream((srcFile));
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);

//                bos.flush();//刷新缓冲区

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
        }

    }

使用BufferedReader和BufferedWriter实现文本文件的复制

//读写操作
            //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf)) != -1){
//                bw.write(cbuf,0,len);
//                //bw.flush();
//            }

            //方式二：使用String
            String data;
            while((data = br.readLine()) != null){
                //方法一：
//                bw.write(data + "\n");//data中不包含换行符
                //方法二：
                bw.write(data);//data中不包含换行符
                bw.newLine();//提供换行的操作

            }

练习3:获取文本上字符出现的次数,把数据写入文件

package com.atguigu.java;

import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 练习3:获取文本上字符出现的次数,把数据写入文件
 *
 * 思路：
 *  * 1.遍历文本每一个字符
 *  * 2.字符出现的次数存在Map中
 * @author quanquan
 * @create 2020-03-30-22:37
 */
public class Test3 {
    public static void main(String[] args) {

        FileReader fr = null;
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {

            fr = new FileReader("dbcp.txt");
            fw = new FileWriter("dbcpout.txt");

            Map<Character, Integer> map = new HashMap<Character, Integer>();
            int c;
            while((c = fr.read()) != -1){
                char ch = (char) c;
                if(map.get(ch) == null){
                    map.put(ch,1);
                }else{
                    map.put(ch,map.get(ch)+1);
                }
            }

            bw = new BufferedWriter(fw);
            Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
            for(Map.Entry<Character, Integer> entry : entrySet){
                switch (entry.getKey()) {
                    case ' ':
                        bw.write("空格=" + entry.getValue());
                        break;
                    case '\t'://\t表示tab 键字符
                        bw.write("tab键=" + entry.getValue());
                        break;
                    case '\r'://
                        bw.write("回车=" + entry.getValue());
                        break;
                    case '\n'://
                        bw.write("换行=" + entry.getValue());
                        break;
                    default:
                        bw.write(entry.getKey() + "=" + entry.getValue());
                        break;
                }
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
}

处理流之二：转换流：属于字符流
- InputStreamReader：将一个字节的输入流转换为字符的输入流
- OutputStreamWriter：将一个字符的输出流转换为字节的输出流
- 作用：提供字节流与字符流之间的转换
  - 解码：字节、字节数组 —>字符数组、字符串
  - 编码：字符数组、字符串 —> 字节、字节数组

//参数2指明了字符集，具体使用哪个字符集，取决于fis所指的的File保存时使用的字符集
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集

字符集
- ASCII：美国标准信息交换码。
  用一个字节的7位可以表示。
- ISO8859-1：拉丁码表。欧洲码表
  用一个字节的8位表示。
- GB2312：中国的中文编码表。最多两个字节编码所有字符
- GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
- Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
- UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
标准的输入、输出流
- System.in:标准的输入流，默认从键盘输入
- System.out:标准的输出流，默认从控制台输出
- System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流。
打印流：PrintStream 和PrintWriter
数据流：DataInputStream 和 DataOutputStream
- 作用：用于读取或写出基本数据类型的变量或字符串
- 注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
对象流
- ObjectInputStream 和 ObjectOutputStream
- 作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源
- 对象序列化机制：允许把内存中的 Java 对象转换成平台无关的二进制流，从而允许把这种二进制流
  
  持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。
  
  当其它程序获取了这种二进制流，就可以恢复成原来的 Java 对象

DAY25

要想一个java对象是可序列化的，需要满足相应的要求。
- 需要实现接口：Serializable
- 当前类提供一个全局常量：serialVersionUID
- 除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化）
- 补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

public class Person implements Serializable{

    public static final long serialVersionUID = 475463534532L;

    private String name;
    private int age;
    private int id;
    private Account acct;

    public Person(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public Person(String name, int age, int id, Account acct) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.acct = acct;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                ", acct=" + acct +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    public Person() {

    }
}

class Account implements Serializable{
    public static final long serialVersionUID = 4754534532L;
    private double balance;

    @Override
    public String toString() {
        return "Account{" +
                "balance=" + balance +
                '}';
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public Account(double balance) {

        this.balance = balance;
    }
}

s随机存取文件流：RandomAccessFile
- RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
- RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
- 构造器
  
  public RandomAccessFile(File file , String mode)
  public RandomAccessFile(String name, String mode)
  - 创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：
    r: 以只读方式打开
    rw ：打开以便读取和写入
    rwd 打开以便读取和写入；同步文件内容的更新
    rws 打开以便读取和写入；同步文件内容和元数据的更新
- 如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
  
  如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）
- void seek(long pos) 将文件记录指针定位到 pos 位置
- 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果

quanquanya

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第十三章 IO流（尚硅谷最新版Java零基础编程_2019版笔记）

第十三章 IO流JUnit单元测试步骤：1.配置方法:参考1或参考2 使用@Test可能会报错，解决方法：选择Add “JUnit4” to classpath2.创建Java类，进行单元测试 Java类要求：此类是public的；此类提供公共的无参构造器3.此类中声明单元测试方法单元测试方法要求：方法的权限是public；没有返回值；没有形参4.此单元测试方法上需要声...
复制链接

扫一扫