关于Java中流的学习

最新推荐文章于 2024-03-21 23:27:33 发布
最新推荐文章于 2024-03-21 23:27:33 发布
阅读量317 收藏 1
点赞数 1
文章标签： java intellij-idea 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45401910/article/details/122529537
版权

  1. 流的分类

    输入流和输出流是以内存为参照物的，读入内存是输入流，内存中存到硬盘叫输出流。
输入流 ：把数据从其他设备上读取到内存中的流。
输出流 ：把数据从内存 中写出到其他设备上的流。

按照读取或写入数据方式不同分为字节流和字符流。
字节流 ：以字节为单位，读写数据的流。
字符流 ：以字符为单位，读写数据的流。

我们必须明确一点的是，一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

Java中所有的流都是在java.io包中，有四大类,这四个都是抽象类。
字节输入流：java.io.InputStream
字节输出流：java.io.OutputStream
字符输入流：java.io.Reader
字符输出流：java.io.Writer
(Stream结尾的是字节流，Reader和Writer结尾的都是字符流)
所有的流都实现了closeable（）接口用完的时候要记得close（）,所有的输出流都实现了flushable（）接口。用完的时候要flush（）刷新一下。

2.要掌握的16个流
注意：IDEA默认的当前路径是工程Project的根目录
文件专属：
java.io.FileInputStream:万能的，任何类型的文件都可以读。
java.io.FileOutputStream
java.io.FileReader
java.io.FileWriter

转换流：
java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流：
java.io.BufferedInputStream
java.io.BufferedOutputStream
java.io.BufferedReader
java.io.BufferedWriter

数据流：
java.io.DataInputStream
java.io.DataOutputStream

标准输出流：
java.io.PrintStream
java.io.PrintWriter

对象专属流：
java.io.ObjectInputStream
java.io.ObjectOutputStream

package IO;

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

public class Test01_FileInputStream {
    public static void main(String[] args) {
        FileInputStream inputStream = null;
        try {
            //inputStream = new FileInputStream("src/static/1.txt");
            //read方法，依次读取一个字节，返回值是这个字节的ascii值
            // 读完了之后返回的-1。
            //int a = inputStream.read();
            //System.out.println(String.valueOf((char)a));


            /**
             * read方法可以传入一个byte数组，读取文件中的内容到这个数组中，
             * 返回值是读取到的字符个数。
             * 建议使用这种方式读取，这样可以减少读取的次数，上面那种方法读取次数太多很耗时。
             */
            /**
             * 这种读取方式不太合适，只是用来测试，实际中，我们不知道问价的字符个数，所以实际上要循环读取
             * 中间要做判断什么时候结束。
             */
//            inputStream = new FileInputStream("src/static/2.txt");
//            byte[] bytes = new byte[250];
//            int a = inputStream.read(bytes);
            //System.out.println(a);
            //new String()可以传入一个byte数组，后面还可以在跟两个参数，不跟的话默认是
            //全部转换成字符串，跟的第一个参数是起始下标，后面一个是转换多少个字符
            //System.out.println(new String(bytes,0,a));

            //available()方法返回这个流当中未读取的字节数量
            //skip方法表示跳过几个字节不读,这个会导致available()返回值减小
            inputStream = new FileInputStream("src/static/2.txt");
            System.out.println(inputStream.available());
            inputStream.skip(2);
            System.out.println(inputStream.available());

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


package IO;

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

public class Test02_FileOutputStream {
    public static void main(String[] args) {
        FileOutputStream outputStream= null;

        try {
//            outputStream = new FileOutputStream("src/static/3.txt");
            outputStream = new FileOutputStream("src/static/3.txt",true);
            byte[] bytes = new byte[5];
            for (Byte i = 0; i < bytes.length; i++) {
                bytes[i]=(byte) (i+97);
            }

            /**
             * 文件字节输出流的write方法,后面参数可以是一个byte数组，
             * 但是这个write方法要注意会根据你这个流的属性选择
             * 先清空原来的文件中的内容还在直接追加
             *
             */
            //outputStream.write(bytes);

            outputStream.write(bytes);

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


package IO;

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

public class Test03_FileCopy {
    public static void main(String[] args) {
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;

        try {
            inputStream = new FileInputStream("src/static/1.txt");
            outputStream = new FileOutputStream("src/static/4.txt");

            byte[] bytes = new byte[1024];
            int a =0;
            try {
                while (a!=-1){
                    a = inputStream.read(bytes);
                    outputStream.write(bytes,0,a);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }


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


package IO;

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

public class Test04_FileReader {
    public static void main(String[] args) {
        /**
         * 字符输入流，专门用来读取文本文件的
         */

        FileReader reader = null;
        char[] chars = new char[1024];
        int a = 0;

        try {
             reader = new FileReader("D:\\word文档\\电子版练习册\\JAVA\\00-JAVA基础\\project\\src\\static/1.txt");

            try {
                while ((a=reader.read(chars))!=-1){

                    System.out.print(new String(chars,0,a));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

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


package IO;

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

public class Test05_FileWriter {
    public static void main(String[] args) {
        FileWriter writer = null;

        try {
            writer = new FileWriter("src/static/5.txt",true);
            writer.write("你好，世界！");

            writer.flush();

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

    }
}


package IO;

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

public class Test06_BufferedReader {
    public static void main(String[] args) throws Exception{
        /**
         * 被传进去的流叫做节点流，外边的流是包装流也叫做处理流
         * 关闭的时候，我们只需要关闭最外层的流，里面的节点流会自动关闭。
         *
         */
        /**
         * readLine()依次读取一行，读完的时候返回null
         * 注意细节：它读的时候没有读到换行符
         */
        BufferedReader reader = new BufferedReader(new FileReader("src/static/1.txt"));
        String s;
        while ((s=reader.readLine())!=null)
        System.out.println(s);
    }
}


package IO;

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

public class Test07_OutputStreamWriter {
    public static void main(String[] args) throws Exception{
        //BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/static/6.txt")));
        BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/static/6.txt",true)));
        writer.write("输出字节流转换成字符输出流");
        writer.flush();
        writer.close();
    }
}


package IO;

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

public class Test08_DataOutputStream {
    public static void main(String[] args) throws Exception{
        /**
         * 数据专属的输出流，这个流输出的不是普通文件，
         * 不但能写入数据，而且能写入数据的数据类型
         * 读取的时候怎么加的怎么取，顺序不能错，不然也会出错
         */
        DataOutputStream stream = new DataOutputStream(new FileOutputStream("src/static/7.txt"));

        stream.write((byte) 97);
        stream.write(1);
        stream.writeBytes("你好");


        stream.flush();
        stream.close();

    }
}


package IO;

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

public class Test09_PrintStream {
    public static void main(String[] args) throws Exception {
        /**
         * 标准输出流，不需要关闭
         */
        PrintStream stream = System.out;
        stream.println("nihao");

        stream.println("sss");

        /**
         * 日志框架的实现原理
         */
        PrintStream stream1 = new PrintStream(new FileOutputStream("src/static/8.txt"));
        System.setOut(stream1);
        stream = System.out;
        stream.println("Hello World!");
    }
}


package IO;

import java.io.File;
import java.io.IOException;

public class Test10_File {
    public static void main(String[] args) {
        File file = new File("src/static/9.txt");
        boolean exist;
//        判断文件存不存在
        exist = file.exists();
        //判断是否是一个文件
        exist = file.isFile();


        System.out.println(exist);
//        if (!exist){
//            file.mkdir();
//            try {
//                System.out.println(file.createNewFile());
//                System.out.println("创建了一个文件");
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }

    }
}
北海冥鱼未眠
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java学习（流）
weixin_48079072的博客
03-15 356
流的概念 在Java程序中，对于数据的输入输出操作以流Stream方式进行，JavaSE提供各种各样的类用于使用相同的方法获取不同类型的数据，程序中通过标准的方法输入或者输出数据 流是处理输入/输出的一个洁净的方法，它不需要代码理解键盘和网络的不同。Java中流的实现是基于java.io包定义的类层次结构的 流的分类 从Java不同版本上来说，流可以分为BIO、NIO和AIO三大类。Java中的BIO、NIO和AIO理解为是Java语言对操作系统的各种Il0模型的封装。程序员在使用这些API的时候，不需要关
JAVA流的基本操作
m0_53029821的博客
06-12 1814
1.由值创建流//由值创建//流构造器创建2.数组、列表、文件创建//由数组创建流//由列表创建流//由文件创建。
Java中流的概念
最新发布
hitmengfanchao的博客
03-21 816
本文介绍了Java中流的概念，在Java中，程序所完成的输入输出是以流（Stream）的形式来实现的，流是一组有序的数据序列。按照数据的传输方向，流可分为输入流和输出流。从数据处理的单位划分，流可分为字节流和字符流。
Java IO流基础篇及其图解
2301_78523177的博客
07-09 636
它继承自Reader类，通过将字符数据存储在内部的缓冲区中，减少了对底层Reader的单个字符读取次数，从而提高读取性能。它继承自Writer类，通过将字符数据存储在内部的缓冲区中，减少了对底层Writer的单个字符写入次数，从而提高写入性能。字符缓冲流通过内部的缓冲区，将数据从底层的字符流中读取或写入，减少与底层流的直接交互次数，从而提高读写的效率。用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文。OutputStream:字节输出流的所有类的超类。
Java--流
weixin_74469493的博客
06-11 1792
数据源data source，提供数据的原始媒介。常见的数据源有:数据库、文件、其他程 序、内存、网络连接、lo 设备。数据源分为:源设备、目标设备。源设备:为程序提供数据，一般对应输入流。目标设备:程序数据的目的地，一般对应输出流。
Java IO流学习总结一：输入输出流
weixin_34198881的博客
01-09 3962
Java IO流学习总结一：输入输出流 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/54292148 本文出自【赵彦军的博客】 Java流类图结构： 流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。...
java中流的使用
08-31
本文主要介绍了java中流的使用以及分类。具有一定的参考价值，下面跟着小编一起来看下吧
Java中流的学习
11-22
在学习Java时，流是一个很重要的基础知识。但是，很多人学习了但是对流还是不知道怎么搞的。因为，流的子类很多，有时候记错了。理不清楚他们如何使用。这里个人总结了常用流的使用，从此你就知道，Inputstream,...
Java中流的有关知识点详解
08-26
今天小编就为大家分享一篇关于Java中流的有关知识点详解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Java8中流的性能及流的几个特性
08-28
流（Stream）是Java8为了实现最佳性能而引入的一个全新的概念。接下来通过本文给大家分享Java8中流的性能，需要的朋友参考下吧
在 rtmp 和 rtsp for Android 中流式传输的库 Java
05-30
特征： Android 最低 API 16。 支持camera1和camera2 API 编码器类型缓冲区到缓冲区。 编码器类型表面缓冲。 RTMP/RTSP 认证。 音频噪声抑制器。 音频回声消除。 流式传输时禁用/启用视频和音频。...
JAVA I/0 流学习（一）
流月的博客
09-07 2383
java I/0流属于java基础知识，是每个java学习者必须要掌握的知识点，尤其是在学习网络编程时尤为重要。 在变量、数组和对象中存储的数据是暂时存在的，程序结束后它们就会丢失，为了能够永久地保存程序创建的数据，需要将其保存在磁盘文件中，这样就可以在其他程序中使用它们。JAVA的 I/O技术可以将数据保存到文本文件中、二进制文件甚至是ZIP压缩文件中，以达到永久性保存数据的要求。掌握I/O处...
Java IO流学习总结
小柯基_littlecogi的博客
08-10 2522
1. 输入与输出流 输入流 可以从其中读入一个字节序列的对象 输出流 可以从其中写入一个字节序列的对象 1.1 读写字节 InputStream类有一个抽象方法，用于读入一个直接，并返回读入的直接，当遇到结尾时返回-1 abstract int read() 类似的，OutputStream类定义了一个方法，用于向某个输出位置写出一个字节 abstract ...
Java IO流学习
weixin_34054866的博客
12-04 355
Java IO流学习   Java流操作有关的类或接口： Java流类图结构： 流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。   在IO中涉及的设备文件包括文件、控制台、网络链接等，这其中又根据流的方向可以将两端的设备文件分为数据...
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 7万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
java 流详解_Java中的流详解
weixin_35130561的博客
03-07 1216
一、Java中流的原理流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。设备可以是文件，网络，内存等。四种基本流InputStream，OutputStream，Reader，Writer又分别有更具体的子类，分为文件流，缓冲流，数据流，转换流，Print流，Object流等，都分别有特定的功能或用来操作特定的数据。二、字节流2.1 Inpu...
java基础学习总结——流
草棚
08-12 2866
一、JAVA流式输入/输出原理 　　 　　流是用来读写数据的，java有一个类叫File，它封装的是文件的文件名，只是内存里面的一个对象，真正的文件是在硬盘上的一块空间，在这个文件里面存放着各种各样的数据，我们想读文件里面的数据怎么办呢？是通过一个流的方式来读，咱们要想从程序读数据，对于计算机来说，无论读什么类型的数据都是以010101101010这样的形式读取的。怎么把文件里面的
java中IO流的学习
xiaotai1234的博客
05-27 303
IO 1.io流的概念 2.IO流的分类 按照流的方向 输入流：把数据从 其他设备 上读取到 内存 中的流。（字节输入流/字符输入流） 输出流：把数据从 内存 中写出到 其他设备 上的流。（字节输出流/字符输出流） 按照操作的内容 字节流：计算机中的一切都是字节，可以操作任意类型的文件，一次可以操作一个/多个字节 字符流：只能操作纯文本文件，用记事本打开可以看得懂的文件，一次可以操作一个/多个字节 .txt,.java,.html,.css 是纯文本文件 .doc,.xls 不是纯文本文件 3.字节输出流
测试一下你是否真的了解Java中的流
互扯程序的博客
11-20 335
本文共 9185字，预计阅读时间：15分钟本篇是Java基础中的IO和NIO的讲解，IO和NIO在Java中可以说是必不可少，涉及到硬盘文件读写、网络文件读写等，只要是和文件打交道基本少...
简述java中流的概念
04-29
Java中流的主要分类为输入流和输出流。输入流用于从数据源中读取数据，输出流则用于将数据写到数据源中。另外，根据数据的类型，流又可以分为字节流和字符流，字节流主要用于处理二进制数据，而字符流则主要用于处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北海冥鱼未眠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值