Java学习第九章(一)

计算机量子狗

已于 2022-04-13 21:43:44 修改

阅读量360

点赞数

分类专栏： JAVA学习(进阶班) 文章标签： java 开发语言学习

于 2022-03-23 15:32:46 首次发布

本文链接：https://blog.csdn.net/weixin_49883619/article/details/123623686

版权

JAVA学习(进阶班) 专栏收录该内容

16 篇文章 2 订阅

订阅专栏

视频链接：https://www.bilibili.com/video/BV1Rx411876f?p=1

视频范围P720 - P742

1.IO流概述

I：Input
O：Output
通过IO可以完成硬盘文件的读和写

图示分析：
在这里插入图片描述
注意：

Java中的IO流都已经写好了，不需要程序员关心
程序员最主要掌握在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有哪些
Java中所有的流都是在：java.io.*下
java中主要研究：怎么new对象，调用流对象的哪个方法是读，哪个方法是写

2.IO流分类

按照流的方向进行分类
以内存作为参照物：
往内存中去，叫做输入(Input)，或者叫做读(Read)
从内存中出来，叫做输出(Output),或者叫做写(Write)
按照读取数据方式不同进行分类
①有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位
这种流是万能的，什么类型的文件都可以读取，包括：文本文件，图片，声音文件，视频文件等等

举例：假设file1.txt  ：a中国bc张三fe
采用字节流的话是这样读的
第一次读：一个字节，正好读到'a'
第二次读：一个字节，正好读到'中'字符的一半
第三次读：一个字节，正好读到'中'字符的另外一半

②有的流是按照字符的方式读取数据，一次读取一个字符
这种流是为了方便读取普通文本文件而存在的，这种流不能读取：图片，声音，视频等文件
只能读取纯文本文件，连word文件都无法读取【word文件不是普通文档，不是.txt结尾】

举例：假设file1.txt  ：a中国bc张三fe
采用字符流的话是这样读的
第一次读：'a'字符('a'字符在windows系统中占用1个字节)
第二次读：'中'字符('a'字符在windows系统中占用2个字节)

综上：流的分类：输入流、输出流、字节流、字符流

3.IO流四大家族

四大家族：抽象类(abstract class)	备注
java.io.InputStream	字节输入流
java.io.OutputStream	字节输出流
java.io.Reader	字符输入流
java.io.Writer	字符输出流

注意：

在java中只要类名以“Stream”结尾的都是字节流；以“Reader/Writer”结尾的都是字符流
所有的流都实现了：java.io.Closeable接口，都是可关闭的，都有close()方法
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费或者占用很多资源
所有的输出流都实现了：java.io.Flushable接口，都是可刷新的，都有flush()方法
养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下，这个刷新表示将通道/管道当中剩余未输出的数据强行输出完(清空管道！)刷新的作用就是清空管道。
如果没有flush()可能会导致丢失数据

4.需要掌握的十六个流

文件专属

java.io.FileInputStream(掌握)
java.io.FileOutputStream(掌握)
java.io.FileReader
java.io.FileWriter

转换流（将字节流转换成字符流）

java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流专属

java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream

数据流专属

java.io.DataInputStream
java.io.DataOutputStream

标准输出流

java.io.PrintWriter
java.io.PrintStream(掌握)

对象专属流

java.io.objectInputStream(掌握)
java.io.objectOutputStream(掌握)

5.java.io.FileInputStream

文件字节输入流，万能的，任何类型的文件都可以采用这个流来读
字节的方式，完成输入的操作，完成读的操作（硬盘---->内存）

5.1 FileInputStream初步代码

temp.txt文件中内容：abcdef

package IO;

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

public class FileInputStreamTest01 {
    public static void main(String[] args) {

        FileInputStream fis = null;
        try {
            //创建文件字节输入流对象
            //文件路径：C:\Users\keith\IdeaProjects\temp.txt (IDEA会自动把\变成\\，因为java中\表示转义)
            //以下都是采用了：绝对路径的方式
            //FileInputStream fis = new FileInputStream("C:\\Users\\keith\\IdeaProjects\\temp.txt");
            //写出这个/也是可以的
            fis = new FileInputStream("C:/Users/keith/IdeaProjects/temp.txt");

            //开始读
            int readData = fis.read();//这个方法的返回值是：读取到的“字节”本身
            System.out.println(readData);//输出为：97

            readData = fis.read();
            System.out.println(readData);//输出为：98

            readData = fis.read();
            System.out.println(readData);//输出为：99

            readData = fis.read();
            System.out.println(readData);//输出为：100

            readData = fis.read();
            System.out.println(readData);//输出为：101

            readData = fis.read();
            System.out.println(readData);//输出为：102

            //读到文件的末尾了，再读的时候读取不到任何数据了，返回-1
            readData = fis.read();
            System.out.println(readData);//输出为：-1
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句块当中确保流一定关闭
            if (fis != null) {//避免空指针异常！
                //关闭流的前提是：流不是空，流是null的时候没必要关闭
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

5.2 FileInputStream循环读代码

temp.txt文件中内容：abcdef
对第一个程序进行改进，循环方式

package IO;

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

public class FileInputStreamTest02 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:/Users/keith/IdeaProjects/temp.txt");

            //开始读
            while (true){
                int readData = fis.read();
                if (readData == -1){
                    break;
                }
                System.out.println(readData);
            }

            //改造while循环
            int readData = 0;
            while ((readData = fis.read()) != -1){
                System.out.println(readData);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句块当中确保流一定关闭
            if (fis != null) {//避免空指针异常！
                //关闭流的前提是：流不是空，流是null的时候没必要关闭
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

总结：
以上程序的缺点：一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上面了。

5.3 IDEA中的当前路径

temp.txt文件中内容：abcdef
工程Project的根就是IDEA的默认当前路径

package IO;

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

public class FileInputStreamTest03 {
    public static void main(String[] args) {
        FileInputStream fis = null;

        try {
            //相对路径一定是从当前所在的位置作为起点开始找！
            //工程Project的根就是IDEA的默认当前路径
            fis = new FileInputStream("temp.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5.4 int read(byte[ ] b)

temp.txt文件中内容：abcdef
一次最多读取b.length个字节，减少硬盘和内存的交互，提高程序的执行效率，往byte[ ]数组当中读

package IO;

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

public class FileInputStreamTest03 {
    public static void main(String[] args) {
        FileInputStream fis = null;

        try {
            fis = new FileInputStream("temp.txt");

            //开始读，采用byte数组，一次读取多个字节，最多读取”数组.length“个字节
            byte[] bytes = new byte[4];//准备一个4个长度的byte数组，一次最多读取4个字节
            //这个方法的返回值是：读取到的字节数量(不是字节本身)
            int readCount = fis.read(bytes);
            System.out.println(readCount);//输出为：4  //第一次读到了4个字节
            //将字节数组全部转换成字符串
            //System.out.println(new String(bytes));//输出为：abcd
            System.out.println(new String(bytes,0,readCount));//输出为：abcd

            readCount = fis.read(bytes);//第二次读到了2个字节
            System.out.println(readCount);//输出为：2
            //将字节数组全部转换成字符串
            //System.out.println(new String(bytes));//输出为：efcd
            //不应该全部都转换，应该是读取了多少个字节，转换多少个
            System.out.println(new String(bytes,0,readCount));//输出为：ef

            readCount = fis.read(bytes);//第三次1个字节都没有读取到返回-1
            System.out.println(readCount);//输出为：-1

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

5.5 FileInputStream最终版

temp.txt文件中内容：

public class HelloWorld{
     public static void main(String[ ] agrs){
            System.out.println("hello world!");
     }
}

运行代码：

package IO;

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

public class FileInputStreamTest04 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("temp.txt");
            //准备一个byte数组
            byte[] bytes = new byte[4];
            while (true){
                int readCount = fis.read(bytes);
                if (readCount == -1){
                    break;
                }
                //将byte数组转换成字符串，读到多少个转换多少个
                System.out.print(new String(bytes,0,readCount));
            }

            //换一种循环的方式
            int readCount = 0;
            while ((readCount = fis.read(bytes)) != -1){
                System.out.print(new String(bytes,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：

在这里插入图片描述

5.6 FileInputStream其它常用方法

int available()：返回流当中剩余的没有读到的字节数量
long skip(long n)：跳过几个字节不读

5.6.1 int available()

temp.txt文件中内容：abcdef

package IO;

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

public class FileInputStreamTest05 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("temp.txt");
            System.out.println("总字节数量：" + fis.available());
            //读1个字节
            int readByte = fis.read();
            //还剩下可以读的字节数量
            System.out.println("剩下多少个字节没有读：" + fis.available());
            
            //available()作用
            //这种方式不太适合太大的文件，因为byte[]数组不能太大
            byte[] bytes = new byte[fis.available()];
            //不需要循环了，直接读一次就行了
            int readCount = fis.read(bytes);
            System.out.println(new String(bytes));
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5.6.2 long skip(long n)

temp.txt文件中内容：abcdef

package IO;

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

public class FileInputStreamTest05 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("temp.txt");
            System.out.println("总字节数量：" + fis.available());

            //skip跳过几个字节不读取，这个方法也可能以后会用
            fis.skip(3);
            System.out.println(fis.read());//输出为：100

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

6.java.io.FileOutputStream

文件字节输出流，负责写的，从内存到硬盘。
temp.txt文件中内容：abcdef

package IO;

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

public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //myfile文件不存在的时候会自动新建！
            //这种方式谨慎使用，这种方式会先将原文件清空，然后重新写入
            //fos = new FileOutputStream("myfile");

            //以追加的方式在文件末尾写入，不会清空原文件内容
            fos = new FileOutputStream("myfile",true);
            //开始写
            byte[] bytes = {97,98,99,100};
            //将byte数组全部写出
            fos.write(bytes);
            //将byte素组的一部分写出！
            fos.write(bytes,0,2);//再写出ab

            //字符串
            String s = "我是一个中国人，我骄傲！！！";
            //将字符串转换成byte数组
            byte[] bs = s.getBytes();
            //写
            fos.write(bs);

            //写完之后，最后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

7.文件复制

使用FileInputStream和FileOutputStream完成文件的拷贝
拷贝的过程应该是一边读，一边写
使用以上的字节流拷贝文件的时候，文件类型随意，万能的，什么样的文件都能拷贝

内存演示：

在这里插入图片描述
代码演示：

package IO;

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

public class Copt01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            //创建一个输入流对象
            fis = new FileInputStream("D:\\压缩\\temp.txt");
            //创建一个输出流对象
            fos = new FileOutputStream("D:\\temp.txt");

            //最核心的：一边读，一边写
            byte[] bytes = new byte[1024 * 1024];//1MB(一次最多拷贝1MB)
            int readCount = 0;
            while ((readCount = fis.read(bytes)) != -1){
                fos.write(bytes,0,readCount);;
            }

            //刷新：输出流最后要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //分开try，不要一起try
            //一起try的时候，其中一个出现异常，可能会影响到另一个流的关闭
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

8.FileReader的使用

文件字符输入流，只能读取普通文本，读取文本内容时，比较方便，快捷

package IO;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderTest {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            //创建文件字符输入流
            reader = new FileReader("temp.txt");
            
            //开始读
            char[] chars = new char[4];//一次读取4个字符
            int readCount = 0;
            while ((readCount = reader.read(chars)) != -1){
                System.out.print(new String(chars,0,readCount));
            }

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

使用遍历方式：
temp.txt文件中内容：abcdef清澈的爱只为中国！

package IO;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderTest {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            //创建文件字符输入流
            reader = new FileReader("temp.txt");

            //准备一个char数组
            char[] chars = new char[4];
            //往char数组中读
            reader.read(chars);//按照字符的方式读取
            for (char c :chars){
                System.out.println(c);
            }

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

运行结果：

在这里插入图片描述

9.FileWriter的使用

文件字符输出流，写，只能输出普通文本【不能处理world或者音频，图片等等】

package IO;

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterTest {
    public static void main(String[] args) {
        FileWriter out = null;
        try {
            //创建文件字符输出流对象
            //out = new FileWriter("file");
            out = new FileWriter("file",true);//不清空了，直接追加到后面

            //开始写
            char[] chars = {'我','是','中','国','人'};
            out.write(chars);//最终效果：我是中国人
            out.write(chars,2,3);//最终效果：我是中国人中国人

            out.write("我是一名java软件工程师！");//最终效果：我是中国人中国人我是一名java软件工程师！
            //写出一个换行符
            out.write("\n");
            out.write("hello world!");
            //刷新
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.复制普通文本文件

使用FileReader和FileWriter进行拷贝的话，只能拷贝“普通文本”为文件

package IO;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Copy02 {
    public static void main(String[] args) {
        FileReader in = null;
        FileWriter out = null;

        try {
            //读
            in = new FileReader("temp.txt");
            //写
            out = new FileWriter("copy2");

            //一边读一边写
            char[] chars = new char[1024 * 512];//1MB
            int readCount = 0;
            while ((readCount = in.read(chars)) != -1){
                out.write(chars,0,readCount);
            }

            //刷新
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

11. 缓冲流专属

11.1 BufferedReader

带有缓冲区的字符输入流，使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组，自带缓冲
temp.txt文件中内容：

abcdef清澈的爱只为中国！
飞洒发
答发
放大发撒
打算的撒
范德萨f的

实例代码：

package IO;

import java.io.BufferedReader;
import java.io.FileReader;

public class BufferedReaderTest01 {
    public static void main(String[] args) throws Exception{
        FileReader reader = new FileReader("temp.txt");
        //当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流
        //外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流
        //像当前这个程序来说：FileReader就是一个节点流，BufferedReader就是包装流/处理流
        BufferedReader br = new BufferedReader(reader);

        //读一行
        //br.readLine()方法读取一个文本行，但不带换行符
        String firstLine = br.readLine();
        System.out.println(firstLine);//输出为：abcdef清澈的爱只为中国！

        //循环读取
        String s = null;
        while ((s = br.readLine()) != null){
            System.out.println(s);
        }

        //关闭流
        //对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭(可以看源代码)
        br.close();
    }
}

11.2 InputStreamReader

package IO;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class BufferedReaderTest02 {
    public static void main(String[] args) throws Exception{
        //字节流
        FileInputStream in = new FileInputStream("temp.txt");

        //通过转换流转换(InputStreamReader将字节流转换成字符流)
        //in是节点流，reader是包装流
        InputStreamReader reader = new InputStreamReader(in);

        //这个构造方法只能传一个字符流，不能传字节流
        //reader是节点流，br是包装流
        BufferedReader br = new BufferedReader(reader);

        //将上面进行合并
        //BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("temp.txt")));

        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        //关闭最外层
        br.close();
    }
}

11.3 BufferedWriter

带有缓冲的字符输出流

package IO;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;

public class BufferedWriterTest {
    public static void main(String[] args) throws Exception{
        //带有缓冲区的字符输出流
        //BufferedWriter out = new BufferedWriter(new FileWriter("temp.txt"));
        //
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("temp.txt",true)));
        //开始写
        out.write("hello world!");
        out.write("\n");
        out.write("hello kitty!");
        //刷新
        out.flush();
        //关闭最外层
        out.close();
    }
}

12. 数据流专属

12.1 DataOutputStream

数据专属的流，这个流可以将数据连同数据的类型一并写入文件
注意：这个文件不是普通文本文档(这个文件使用记事本打不开)

package IO;

import java.io.DataOutputStream;
import java.io.FileOutputStream;

public class DataOutputStreamTest {
    public static void main(String[] args) throws Exception{
        //创建数据专属的字节输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));

        //写数据
        byte b = 100;
        short s = 200;
        int i = 300;
        long l = 400L;
        float f = 3.0F;
        double d = 3.14;
        boolean sex = false;
        char c = 'a';

        //写
        dos.writeByte(b);//把数据以及数据的类型一并写入到文件当中
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(sex);
        dos.writeChar(c);


        //刷新
        dos.flush();
        //关闭最外层
        dos.close();
    }
}

12.2 DataInputStream

数据字节输入流
DataOutputStream写的文件，只能使用DataInputStream去读，并且读的时候你需要提前知道写入的顺序，读的顺序需要和写的顺序一致，才可以正常取出数据

package IO;

import java.io.DataInputStream;
import java.io.FileInputStream;

public class DataInputStreamTest {
    public static void main(String[] args) throws Exception{
        DataInputStream dis = new DataInputStream(new FileInputStream("data"));

        //开始读
        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 sex = dis.readBoolean();
        char c = dis.readChar();

        System.out.println(b);
        System.out.println(s);
        System.out.println(i + 1000);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(sex);
        System.out.println(c);
    }
}

运行结果：

在这里插入图片描述

13.标准输出流 PrintStream

标准的字节输出流，默认输出到控制台

package IO;

import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintStreamTest {
    public static void main(String[] args) throws Exception{
        //联合起来写
        System.out.println("hello world!");

        //分开写
        PrintStream ps = System.out;
        ps.println("hello zhangsan");
        ps.println("hello lisi");
        ps.println("hello wangwu");

        //标准输出流不需要手动close()关闭

        //这些是之前System类使用过的方法和属性
       /* System.gc();
        System.currentTimeMillis();
        System.exit(0);
        System.arraycopy(....);*/

        //标准输出流不再指向控制台，指向“log”文件
        PrintStream printStream = new PrintStream(new FileOutputStream("log"));
        //修改输出方向，将输出方向修改到“log”文件
        System.setOut(printStream);
        //再输出
        System.out.println("hello zhangsan");
        System.out.println("hello lisi");
        System.out.println("hello wangwu");
    }
}

运行结果：

在这里插入图片描述

14.日志工具

工具类：

package IO;

import javax.xml.crypto.Data;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

public class logger {
    //记录日志的方法
    public static void log(String msg) {
        try {
            //指向一个日志文件
            PrintStream out = new PrintStream(new FileOutputStream("log.txt",true));
            //改变输出方向
            System.setOut(out);
            //日期当前时间
            Date nowTime = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String strTime = sdf.format(nowTime);

            System.out.println(strTime + ":" + msg);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

测试类：

package IO;

public class LogTest {
    public static void main(String[] args) {
        //测试工具类是否好用
        logger.log("调用了System类的gc()方法，建议启动垃圾回收");
        logger.log("调用了UserService的doSome()方法");
        logger.log("用户尝试进行登录，验证失败");

    }
}

运行结果：

在这里插入图片描述

计算机量子狗

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习第九章(一)

IO流的概述，分类和四大家族、主要掌握的十六个流、FileInputStream、FileOutputStream、文件复制、FileReader、FileWriter、缓冲流专属(BufferedReader、InputStreamReader、BufferedWriter)、数据流专属(DataOutputStream、DataInputStream)、标准输出流PrintStream、日志工具
复制链接

扫一扫