2021-09-11

最新推荐文章于 2024-09-12 23:58:52 发布

etherealiu

最新推荐文章于 2024-09-12 23:58:52 发布

阅读量114

点赞数

文章标签： java 数据库

本文链接：https://blog.csdn.net/qq_54336887/article/details/120238133

版权

IO流（1）

上一篇太乱了，所以好好整理了一下

1.Java I/O是什么？

   Java中I/O是以流为基础进行数据的输入输出的，所有数据被串行化(所谓串行化就是数据要按顺序进行输入输出)写入流，并输出。通俗点讲就是通过java通过数据流方式和外部设备进行通讯。

   Java I/O中对数据的操作是通过流的方式，我们可以把数据流看成水流一样，他可以从一个源头端流入到另一个目的端，且水流不是一次全部到达，而且连续的（串行化）的流入目的端。I是指从外部设备的数据流流入java程序中的流。O是指从java程序中把数据流输出到其他设备中的流。

2.Java I/O的应用？

  在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流。

 例子1：比如你用java开发的程序需要从网上下载图片，图片就是通过流的方式从网络上流入到你程序中，然后再从你的程序中流出到你的硬盘中。

例子2：你要用java程序把本地的一个文件从d盘拷贝到e盘。这个过程我们也用到了Java 的I/O。首先程序会去d盘找你指定的源端文件，并把文件的数据通过java的输入流串行化的读取到程序中，然后把程序中依次读入的数据流数据通过输出流串行化的输出到e盘的指定文件中，直到所有数据传输完成。这样就把d盘指定文件拷贝到了e盘。
原文链接：https://blog.csdn.net/fubo1990/article/details/82861228

3.什么是数据源

数据源Data Source, 提供数据的原始媒介。常见的数据源有：数据库，文件，其他程序，内存，网络，IO设备。

数据源分为：源设备，目标设备。

源设备：为程序提供数据，一般对应输入流

目标设备：程序数据的目的地，一般对应输出流

4. 什么是流？

流是一个抽象的概念。当Java程序需要从数据源读取数据时，会开启一个到数据源的流，数据源可以是文件、内存或者网络等。同样，当程序需要输出数据到目的地时也一样会开启一个流，数据目的地也可以使文件、内存或者网络等。流的创建是为了更方便地处理数据的输入输出。

5. java io_四大抽象类

InputStream 字节输入流的父类
OutputStream 字节输出流的父类
Reader 字符输入流的父类
Writer 字符输出流的父类

FileInputStream流被称为文件字节输入流，意思指对文件数据以字节的形式进行读取操作如读取图片视频等

如果不会使用IDEA自动导包，就看(https://www.bilibili.com/video/BV1Tf4y157Xs?spm_id_from=333.999.0.0)，下面的代码都没有导包。

字符输出不是文本

public class FirstDemo_01 {
    public static void main(String[] args) {
//        创建字节输入流对象
//        文件中只有abc三个字母
        FileInputStream fls = null;
        try{
            fls = new FileInputStream("E:\\a.txt");
            int s1 = fls.read();
            int s2 = fls.read();
            int s3 = fls.read();
            int s4 = fls.read();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);//读取完毕返回-1

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

        }finally {
            if(fls != null) {
                try{
                    fls.close();

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

                }
            }
        }

    }
}

改造

public class SecondDemo_02 {
    public static void main(String[] args) {
        FileInputStream fls = null;
        try{
            fls = new FileInputStream("E:\\a.txt");
            StringBuffer sb = new StringBuffer();
            /*
            输出Unicode值，并返回多对应的字母
             */
            int temp = 0;
            while ((temp = fls.read()) != -1){
                System.out.println(temp);
                sb.append(temp);
            }
            System.out.println(sb);

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fls !=  null) {
                    fls.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

File文件的基本使用

public class DirectoryDemo {
    public static void main(String[] args) {
        File file = new File("E:\\j\\k\\l");
//        创建一个目录
//        System.out.println(file.mkdir());
//        创建多级目录
//        System.out.println(file.mkdirs());
//        判断是否指向一个文件
//        System.out.println(file.isFile());
//        判断是否为一个目录
//        System.out.println(file.isDirectory());
//        System.out.println(file.exists());
//        返回父级目录的名字  （返回值就不同啊。getParentFile()的返回值是File型的。而getParent() 的返回值是String型的）
//        System.out.println(file.getParentFile().getName());
//        返回父级目录名字
//        System.out.println(file.getParent());
//        获取E盘下面的所有文件
        File file2 = new File("E:\\");
//          以数组的方式展现出来
//        String[] arr = file2.list();
//        for (String s : arr) {
//            System.out.println(s);
//        }
//        带绝对路径的所有文件
        File[] arr2 = file2.listFiles();
        for (File o : arr2) {
            System.out.println(o);

        }
    }
}

public class FileDemo_03 {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\b.txt");
//        创建一个文件
//        System.out.println(file.createNewFile());
//        删除一个文件
//        System.out.println(file.delete());
//        判断一个文件是否存在
//        System.out.println(file.exists());
//        绝对路径
//        System.out.println(file.getAbsolutePath());
//        相对路径
//        System.out.println(file.getPath());
//        获取文件名字
//        System.out.println(file.getName());
//        是不是一个隐藏文件
//        System.out.println(file.isHidden());

    }
}

图片所对应的字节转换文

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

        try{
//            创建文件字节流输入对象
            fis = new FileInputStream("E:\\tu.JPG");

            int temp = 0;
            while ((temp = fis.read()) != -1){
                System.out.println(temp);
            }

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

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

    }
}

文件字节输出流（高端复制图片）

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

        try{
//            创建文件字节流输入对象
            fis = new FileInputStream("E:\\tu.JPG");
//            创建文件字节流输入对象
            fos = new FileOutputStream("E:\\pi.JPG");
            int temp = 0;
            while ((temp = fis.read()) != -1){
               fos.write(temp);
            }
//            数据将内存写入磁盘中
            fos.flush();

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

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

    }
}

通过缓冲区读写效率

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

        try{
//            创建文件字节流输入对象
            fis = new FileInputStream("E:\\tu.JPG");
//            创建文件字节流输入对象
            fos = new FileOutputStream("E:\\pi.JPG");
//            创建一个缓存区，提高读写效率
            byte[] buff = new byte[1024];
            int temp = 0;
            while ((temp = fis.read(buff)) != -1){
                fos.write(buff,0,temp);
            }
//            数据将内存写入磁盘中
            fos.flush();

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

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

    }
}

图片小适用，不是太大不是太小

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

        try{
//            创建文件字节流输入对象
            fis = new FileInputStream("E:\\tu.JPG");
//            创建文件字节流输入对象
            fos = new FileOutputStream("E:\\pio.JPG");
//            创建一个缓存区，提高读写效率
            byte[] buff = new byte[fis.available()];
            fis.read(buff);
//            数据将内存写入磁盘中
            fos.write(buff);

            fos.flush();

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

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

通过字节缓冲流提高读写效率

public class FileStreamBuffered03Demo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
//            缓冲区中，byte数组长度默认为8192
            fis = new FileInputStream("E:\\tu.JPG");
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream("E:\\uji.JPG");
            bos = new BufferedOutputStream(fos);
            int temp = 0;
            while ((temp = bis.read()) != -1){
                bos.write(temp);
            }
            bos.flush();

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

        }finally {
            try {
                if (bis != null){
                    bis.close();
                }
                if (fis != null){
                    fis.close();
                }
                if (bos != null){
                    bos.close();
                }
                if (fos != null){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

定义文件拷贝工具类

public class FileCopyTools_9 {
    public static void main(String[] args) {
        copyFile("E:\\tu.JPG","E:\\opw.JPG");

    }
    public static void copyFile(String src, String des){
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos =null;
        BufferedOutputStream bos = null;
        try{
            bis = new BufferedInputStream(new FileInputStream(src));
            bos = new BufferedOutputStream(new FileOutputStream(des));
            int temp = 0;
            while ((temp = bis.read()) != -1){
                bos.write(temp);
            }
            bos.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bis != null){
                    bis.close();
                }
                if (fis != null){
                    fis.close();
                }
                if (bos !=null){
                    bos.close();
                }
                if (fos != null){
                    fos.close();
                }

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

    }
}

文件字符输入流

public class FileReaderDemo_10 {
    public static void main(String[] args) {
        FileReader frd = null;
        try {
//            创建文件输入流对象
            frd = new FileReader("E:\\a.txt");
            int temp = 0;
            while ((temp = frd.read()) != -1){
                System.out.println((char) temp);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (frd != null){
                    frd.close();
                }

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

文件字节输出流

public class FileWriteDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        FileWriter fw1 = null;
        try {
            fw  = new FileWriter("E:\\h.txt");
            fw.write("你好未来的你\r\n");
            fw.write("希望你成功\r\n");
            fw.flush();
//           是否追加
            fw1 = new FileWriter("E:\\h.txt",true);
            fw1.write("你好过去的你\r\n");
            fw1.write("告诉你，你已经成功");
            fw1.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fw != null){
                    fw.close();
                }
                if (fw1 != null){
                    fw1.close();
                }

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

    }
}

使用字符流拷贝文本文件

public class FileCopyDemo02_11 {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("E:\\h.txt");
            fw = new FileWriter("E:\\lps.txt");
            int temp = 0;
            char[] buffer = new char[1024];
            while ((temp = fr.read(buffer)) != -1){
                fw.write(buffer,0,temp);

            }
            fw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (fr != null){
                    fr.close();
                }
                if (fw != null){
                    fw.close();
                }

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

字符缓冲流

public class BufferedReaderDemo_14 {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        try {
            fr = new FileReader("E:\\h.txt");
            br = new BufferedReader(fr);
            String temp = "";
            while ((temp = br.readLine()) != null){
                System.out.println(temp);

            }

        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (br != null){
                    br.close();
                }
                if (fr != null){
                    fr.close();
                }

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

    }
}

字符输出缓冲流

public class BufferedWriteDemo_15 {
    public static void main(String[] args) {
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fw = new FileWriter("E:\\h1.txt");
            bw = new BufferedWriter(fw);
            bw.write("加油自己");
            bw.write("不能失败");
            bw.newLine();
            bw.write("为了自己");
            bw.write("绝不后退");
            bw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bw != null){
                    bw.close();
                }
                if (fw != null){
                    fw.close();
                }

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

通过字符缓冲流实现文本文件的拷贝

public class FileCopyTools_16 {
    public static void main(String[] args) {
        copyFile("E:\\a.txt","E:\\hwcsdx.txt");

    }
    public static void copyFile(String src,String des){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader(src));
            bw = new BufferedWriter(new FileWriter(des));
            String temp = "";
            while ((temp = br.readLine()) != null){
                bw.write(temp);
                bw.newLine();
            }
            bw.flush();

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

        }finally {
            try {
                if (br != null){
                    br.close();
                }
                if (bw != null){
                    bw.close();
                }

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

通过字符缓冲流为文件中的内容添加行号

public class LineNumberDemo_17 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader("E:\\hwcsdx.txt"));
            bw = new BufferedWriter(new FileWriter("E:\\hwcsdxdwqw.txt"));
            String temp = "";
            int i = 1;
            while ((temp = br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }
            bw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bw != null){
                    bw.close();
                }
                if (br != null){
                    br.close();
                }

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

通过转化流实现键盘输入屏幕输出

public class CovertStream {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            bw = new BufferedWriter(new OutputStreamWriter(System.out));

            while (true) {
                bw.write("请输入");
                bw.flush();
                String input = br.readLine();
                if ("exit".equals(input)){
                    break;
                }
                bw.write("你输入的是"+input);
                bw.newLine();
                bw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bw != null){
                    bw.close();
                }
                if (br != null){
                    br.close();
                }

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

    }
}

通过字节流读取文本文件并添加行号

public class LineNumberDem_19 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\hwcsdx.txt")));
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:\\hwcsdxdwads.txt")));
            String temp = "";
            int i = 1;
            while ((temp = br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i=i+1;
            }
            bw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (bw != null){
                    bw.close();
                }
                if (br != null){
                    br.close();
                }

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

字符输出流

public class LineNumberDemo_20 {
    public static void main(String[] args) {
        BufferedReader br = null;
        PrintWriter pw = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\hwcsdx.txt")));
            pw = new PrintWriter("E:\\xu.txt");
            String temp = "";
            int i = 1;
            while ((temp = br.readLine()) != null){
                pw.println(i+","+temp);
                i++;
            }
            
        }catch (Exception e){

        }finally {
            try {
                if (pw != null){
                    pw.close();
                }
                if (br != null){
                    br.close();
                }

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

字节数组流

ByteArrayInputStream和ByteArrayOutputStream经常用在需要流和数组之间转化的情况

public class ByteInputStreamDemo_21 {
    public static void main(String[] args) {
        byte[] arr = "abcdefg".getBytes();
        ByteArrayInputStream bis = null;
        StringBuilder sb = new StringBuilder();

        try {
            bis = new ByteArrayInputStream(arr);
            int temp = 0;
            while ((temp = bis.read()) != -1){
                sb.append((char) temp);

            }
            System.out.println(sb.toString());


        }finally {

            try {
                bis.close();
            }catch (Exception e){
                e.printStackTrace();

            }
        }
    }
}

字节数组输出流

ByteArrayOutputStream流对象是将流中的数据写入到字节数组中

public class ByteArrayOutputDemo_22 {
    public static void main(String[] args) {
        ByteArrayOutputStream bos = null;

        try {
            StringBuilder sb = new StringBuilder();
            bos =new ByteArrayOutputStream();
            bos.write('a');
            bos.write('b');
            bos.write('c');
            byte[] arr = bos.toByteArray();
            for (int i = 0; i < arr.length; i++) {
//                System.out.println(arr[i]);
                sb.append((char) arr[i]);
            }
            System.out.println(sb.toString());

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bos != null){
                    bos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

数据流 DataInputStream和DataOutStream

public class DataOutputDemo {

    public static void main(String[] args) {
        DataOutputStream dos = null;

        try {
            dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("E:\\lio.txt")));
            dos.writeChar('a');
            dos.writeDouble(Math.random());
            dos.writeInt(123);
            dos.writeBoolean(true);
            dos.writeChars("未来的你加油");
            dos.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (dos != null){
                    dos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

数据输入流

public class DataInputDemo_24 {
    public static void main(String[] args) {
        DataInputStream dis = null;
        try {
            dis = new DataInputStream(new BufferedInputStream(new FileInputStream("E:\\lio.txt")));
            System.out.println(dis.readChar());
            System.out.println(dis.readDouble());
            System.out.println(dis.readInt());
            System.out.println(dis.readBoolean());
//            System.out.println(dis.readUTF());

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (dis != null){
                    dis.close();
                }

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

对象流：写出基本数据类型数据

public class ObjectOutputStreamBasicTypeDemo_25 {
    public static void main(String[] args) {
        ObjectOutputStream oss = null;
        try {
            oss = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("E:\\jik.txt")));
            oss.writeUTF("希望你成功");
            oss.writeInt(13);
            oss.writeDouble(Math.random());
            oss.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (oss != null){
                    oss.close();
                }

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

读取基本数据类型数据

public class ObjectInputStreamBasicTypeDemo_26 {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("E:\\jik.txt")));
            System.out.println(ois.readUTF());
            System.out.println(ois.readInt());
            System.out.println(ois.readDouble());

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (ois != null){
                    ois.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

将对象序列化到文件中

public class ObjectOutputStreamObjectTypeDemo_27 {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("E:\\1.txt"));
            User_27 user = new User_27(1,"liu","23");
            oos.writeObject(user);
            oos.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (oos != null){
                    oos.close();
                }

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

随机访问流

RandomAccessFile可以实现两个作用：

实现对一个文件做读和写的操作
可以实现访问文件的任意位置，不像其他流只能按照先后顺序读取

public class RandomAccessFileDemo_28 {
    public static void main(String[] args) {
        RandomAccessFile raf = null;
        try {
            raf = new RandomAccessFile("E:\\1.txt","rw");
            int[] arr = new int[]{1,2,3,45,6,7,8,90,345,365,};
            for (int i = 0; i < arr.length; i++) {
                raf.writeInt(arr[i]);
                
            }
            raf.seek(4);
            System.out.println(raf.readInt());
//            跳一个读一个
            for (int i = 0; i < 10; i+=2) {
                raf.seek(i*4);
                System.out.print(raf.readInt()+"\t");
                
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {

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

File类在IO中的作用

public class FileIoDemo_29 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader(new File("E:\\jik.txt")));
            bw = new BufferedWriter(new FileWriter(new File("E:\\ik.txt")));
            String temp = "";
            int i = 0;
            while ((temp =br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }
            bw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (br != null){
                    br.close();
                }
                if (bw != null){
                    bw.close();
                }

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

etherealiu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-09-11

IO流（1）上一篇太乱了，所以好好整理了一下1.Java I/O是什么？ Java中I/O是以流为基础进行数据的输入输出的，所有数据被串行化(所谓串行化就是数据要按顺序进行输入输出)写入流，并输出。通俗点讲就是通过java通过数据流方式和外部设备进行通讯。 Java I/O中对数据的操作是通过流的方式，我们可以把数据流看成水流一样，他可以从一个源头端流入到另一个目的端，且水流不是一次全部到达，而且连续的（串行化）的流入目的端。I是指从外部设备的数据流流入java程序中的流。O是指从java
复制链接

扫一扫