【Java基础概述-10】IO流、字节流、字符流、缓冲流、转换流、序列化、打印流、Properties属性集对象

已于 2024-03-14 11:19:37 修改
阅读量1k 收藏 16
点赞数 26
分类专栏： Java 文章标签： java 开发语言
于 2024-03-14 11:19:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/airycloud/article/details/136689238
版权

目录

1、IO流概述

2、字节流的使用

2.1、FileInputStream字节输入流

 2.1.1、读取方式一

2.1.2、读取方式二

2.1.3、字节流读取数据如何避免中文乱码

2.2、OutputStream字节输出流

2.3、案例：复制粘贴小案例

3、字符流 

3.1、FileReader字符输入流

 3.1.1、读取方式一（性能较差，不建议使用）

3.1.2、读取方式二（用数组来存）

3.2、FileWriter字符输出流

4、缓冲流

4.1、字节缓冲流

4.1.1、字节缓冲输入流BufferedInputStream

4.1.2、字节缓冲输出流BufferedOutputStream

5.转换流

5.1、转换输入流

5.2、转换输出流

6、对象序列化技术

7、打印流printStream/PrintWriter

1、IO流概述

        I/O:Input/Output

        输入输出流

        Input：输入流

        Output: 输出流。

        引入：

        File类只能操作文件对象本身，不能读写文件对象的内容。

        读写数据内容，应该使用IO流。

        IO流是一个水流模型；IO理解成水管，把数据理解为水流。

        

        按流的方向分为：输入流/输出流。

        （1）输出流：以内存为基准，把内存中的数据写出到磁盘文件或者网络介质中的流称为输出流。

        （2）输入流：以内存为基准，把磁盘文件中的数据或者网络中的数据读入到内存中去的流称为输入流。

        输入流的作用：读取数据到内存。

        

        按照流的内容分为：字节流/字符流。

        字节流：流中的数据的最小单位是一个一个的字节，这个流就是字节流。

        字符流：流中的数据的最小单位是一个一个的字符，这个流就是字符流。

2、字节流的使用

        IO流的体系：

字节流字符流
字节输入流字节输出流字符输入流字符输出流
InputStreamOutputStreamReaderWriter抽象类
FileInputStreamFileOutputStreamFileReaderFileWriter实现类

       

2.1、FileInputStream字节输入流

        作用：以内存为基准，把磁盘文件的数据按照字节的形式读入到内存当中。

        简单来说，就是按照字节方式读取文件数据到内存。

        构造器：

        public FileinputStream(File Path):创建一个字节输入流管道与源文件对象联通。

        public FileinputStream(String PathName):创建一个字节输入流管道与源文件路径对接。

        方法：

        public int read(): 每次读取一个字节返回！！，读取完毕返回-1

 2.1.1、读取方式一

        一个一个字节读，英文和数字没有问题，

        但是中文有问题，可能会出现乱码，

        性能较差，禁止使用一个一个读的方案。        

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        //1.创建文件对象定位test.txt;
        File file = new File("Day09Demo/src/test.txt");
        //2.创建一个字节输入流管道与源文件接通
        InputStream is =new FileInputStream(file);
        //3.读取一个字节。
        int read = is.read();//读取一滴水，一个字节。
        System.out.println((char)read);//97，加char:a
        int code1 = is.read();//读取一滴水，一个字节。
        System.out.println((char)code1);
        int code2 = is.read();//读取一滴水,一个字节。
        System.out.println((char)code2);


        //4.使用while读取字节数
        //定义一个整数变量存储字节。
        int ch = 0;
        while ((ch = is.read())!=-1){
            System.out.println((char) ch);//中文乱码，一个一个读，强行拆开了。
        }
    }
}

        

2.1.2、读取方式二

        public int read(byte[] buffer):从字节输入流中读取字节到字节数组里面中

        返回读取的字节数量，没有字节可读就返回-1;

        

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws Exception {
        //创建一个文件对象。
//        File file = new File("Day09Demo/test.txt");
        //创建一个字节输入流管道与源文件对象接通。
//        FileInputStream fileInputStream = new FileInputStream(file);

        //3.简化写法：创建一个字节输入流管道与源文件接通
        FileInputStream fileInputStream1 = new FileInputStream("Day09Demo/src/test.txt");


        //4.定义一个字节数组读取数组.
        byte[] buffer =new byte[3];
        int len = fileInputStream1.read(buffer);//一次读3字节.
        System.out.println("读取字节数"+len);
        String res = new String(buffer);
        System.out.println(res );


        int len1 = fileInputStream1.read(buffer);//一次读3字节.
        System.out.println("读取字节数"+len1);
        String res1 = new String(buffer);
        System.out.println(res1 );

        fileInputStream1 = new FileInputStream("Day09Demo/src/test1.txt");
//        int len2 = fileInputStream1.read(buffer);//一次读3字节.
//        System.out.println("读取字节数"+len2);
//        String res2 = new String(buffer);
//        System.out.println(res2 );//还是会乱码,例如"12我",一次读三个就乱码了




        //终极读法
//        byte[] bytes =new byte[3];
//        while ((len=fileInputStream1.read(bytes))!=-1){
//            String s = new String(bytes);
//            System.out.println(s);
//            /*
//            *  abc
//               xyz
//               iyz
//            *
//            * */
//        }

        //解决方法
       byte[] bytes =new byte[3];
        while ((len=fileInputStream1.read(bytes))!=-1){
            //读取多少倒出多少
            String s = new String(bytes,0,len);
            System.out.println(s);
            /*
            *  abc
               xyz
               i
            *
            * */
        }
    }
}

           小结：使用字节数组读取内容，效率可以，但是使用字节数组读取文本内容输出，也无法避免中文乱码问题。        

2.1.3、字节流读取数据如何避免中文乱码

       解决办法：

        a.使用字符流。

        b.一桶水全部装满，定义一个字节输出和文件大小一样大的桶（其实这并不能完美解决，有文件大小限制，只适合读写小文件）

        这里引入一个新的方法

        readAllBytes(),可以一次性读完全部文件，返回一个byte[]数组

        

public class FileInputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        File file = new File("Day09Demo/src/test3.txt");
        //b方法:
        FileInputStream fileInputStream = new FileInputStream(file);
//        byte[] buffer = new byte[(int)file.length()];
//        fileInputStream.read(buffer);
//        String s = new String(buffer);
//        System.out.println(s);


        //sun公司其实也考虑到了这个问题.所有:
        byte[] bytes = fileInputStream.readAllBytes();
        String s = new String(bytes);
        System.out.println(s);

    }
}

小结：定义一个字节大小和文件大小一样的桶，可以解决中文乱码问题，但是局限性太大，如文件太大，底层会报错内容溢出。

        字节流并不适合读取文本文件输出，读取文件建议使用字符流

        

2.2、OutputStream字节输出流

        FileoutputStream文件字节输出流：、

        作用：以内存为基准，把内存中的数据，按照字节的形式写到磁盘文件中去。

        简单来说，把内存的数据写出到磁盘中的文件中去。

        构造器：

        public FileOutputStream(File file):创建一个字节输出流管道通向目标文件对象。

        public FileOutputStream(String File):创建一个字节输出流管道通向目标文件路径。

        public FileOutputStream(FIle file,boolean append):创建一个追加数据的字节输出。

        public FileOutputStream(String file,boolean append):创建一个追加数据的字节输出。

        方法：

        public void write(int a):写一个字节出去。

        public void write(byte[] buffer):写一个字节输出出去。

        public void write(byte[] buffer,int pos,int len):写一个字节数组的一部分出去    。

        

public class OutputStreamDemo04 {
    public static void main(String[] args) throws IOException {
         //1.创建一个文件对象定位目标文件。
//        File file = new File("Day09Demo/src/test4.txt");
        //2.创建一个字节输出流管道与目标文件对象接通。
//        OutputStream os = new FileOutputStream(file);
        //3.简化写法：
        FileOutputStream os = new FileOutputStream("Day09Demo/src/test4.txt",true);//默认是覆盖管道。
        //4.写数据出去。
        //a.写一个字节出去（写一滴水出去）
        os.write(97);//写一个a
        os.write('b');//写一个b
//        os.write('张');//有问题，写不进去[ooo],只写出去了[o]
        os.write("\r\n".getBytes());
        //写一个字节数组出去
        byte[] bytes = new byte[]{65,66,67,68};//写个ABCD
        os.write(bytes);
        os.write("\r\n".getBytes());
        byte[] bytes1 ="我爱Java,Java很厉害".getBytes();
        os.write(bytes1);
        os.write("\r\n".getBytes());//换行
        os.write(bytes1,0,10);
        os.flush();//立即刷新数据到文件中去，刷新后管道还可用
        os.close();//关闭管道资源，关闭包含了刷新，关闭后管道不能使用了。

    }
}

    小结：

        可以写一个字符，也可以写一个字节数组，也可以写一个字节数组的一部分出去。

        管道用完需要关闭，数据生效需要刷新，关闭包括刷新，刷新后流还可以继续使用，关闭流无法继续使用。

        字节输出流管道默认是覆盖数据管代，启动管道与写数据前都会清空数据。

2.3、案例：复制粘贴小案例

public class CopyDemo01 {
    public static void main(String[] args) {
        try(
                FileInputStream fileInputStream = new FileInputStream("C:\\Users\\javac\\Pictures\\前端所用杂图\\5848e4a37f5e4fb39f4c4384a9c27523.jpg");
                FileOutputStream fileOutputStream = new FileOutputStream("Day09Demo/src/3.png");
                ){
            /*
            * 先读取文件,在直接写入就完成了
            * */
            byte[] bytes = new byte[1024];
            int len=0;
            while((len=fileInputStream.read(bytes))!=-1) {
                fileOutputStream.write(bytes, 0, len);
            }
            System.out.println("完成了");
            fileInputStream.close();
            fileOutputStream.close();
        }catch (Exception e){
           e.printStackTrace();
        }

    }
}

3、字符流 

        字符流一个一个字符的读取文本内容输出，可以解决中文读取输出乱码问题，

        字符流很适合操作文本内容，一个一个读新性能比较差

3.1、FileReader字符输入流

        FileReader:文件字符输入流。

        作用：以内存为基准，把磁盘文件的数据读入到内存当中，简单来说，读取文本文件内容到内存中去

        构造器：

        public FileReader(File file):创建一个字符输入流与源文件对象接通。

        public FIleReader(StringfilePath):创建一个字符输入流与源文件路径接通。

        方法：

        public int read():读取一个字符的编号返回！，读取完毕返回-1

        public int  read(char[] buffer):读取一个字符数组，读取多少个字符就返回多少个字符数量。

        

 3.1.1、读取方式一（性能较差，不建议使用）
public class FileReaderDemo01 {
    public static void main(String[] args) throws IOException {
        //创建一个文件对象通向源文件
        File file = new File("Day10Demo/src/test.txt");
        Reader fileReader = new FileReader(file);
        int c;
        while ((c=fileReader.read())!=-1){
            System.out.print((char) c);
        }
    }
}
3.1.2、读取方式二（用数组来存）
public class FileReaderDemo02 {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("Day10Demo/src/test.txt");
        int len;
        char[] chars =new char[1024];
        while ((len=fileReader.read(chars))!=-1){
            System.out.print(new String(chars,0,len));
        }

    }
}

        

3.2、FileWriter字符输出流

        作用：以内存为基准，把内存中的数组按照字节的形式写出到磁盘文件中去。

        构造器：

        public FileWriter(File file):创建一个字符输出流管道通向目标文件对象。

        public FileWriter(String filePath):创建一个字符输出流管道通向目标文件路径。

        public FIleWriter(File file,boolean append):创建一个追加数据的字符输出流管道通向文件。

        public FileWriter(String filePath,boolean append):创建一个追加数据的字符输出流通向文件目录。

        方法：

        public void write(int         c):写一个字符出去。

        public void write(String c):写一个字符串出去。

        public void write(char[] buffer):写一个字符数组出去。

        public void write(String c,int pos,int len):写字符串出去一部分。

public class FileWriterDemo03 {
    public static void main(String[] args) throws Exception {
        //创建一个字符输出流管道通向目标文件
        FileWriter fileWriter = new FileWriter("Day10Demo/src/test1.txt",true);//true为追加
        //2.写一个字符出去
        fileWriter.write(97);
        fileWriter.write('a');
        fileWriter.write('我');
        //3.写一个字符串
        fileWriter.write("Java是优美的语言");
        //4.写一个字符数组出去。
        fileWriter.write("我爱中国".toCharArray());


        fileWriter.write("这是不是很棒",4,2);
        fileWriter.write("\n");
//        fileWriter.flush();
        fileWriter.close();
    }
}

4、缓冲流

缓冲流可以提高文件的读写速度，提高读写性能。

字节流字符流
字节输入流字节输出流字符输入流字符输出流
InputStreamOutputStreamReaderWriter抽象类
FileInputStreamFileOutputStreamFileReaderFileWriter实现类
BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWrite缓冲流实现类

        

4.1、字节缓冲流

       

4.1.1、字节缓冲输入流BufferedInputStream

        作用:可以把低级的字节输入流包装成一个高级的缓冲字节输入流管道，从而提升读取文件的效率。

        构造器：public BufferedInputStream(InputStream in)

        原理：缓冲字节输入流管道包装了 低级的字节输入流之后，就自带一个缓冲池，缓冲池是一块区域，一次可以直接提取8kb的数据到内存，以后程序直接在内存的缓冲池里面读取数据，性能很快！！！！

        

public class BufferedInputStreamDemo01 {
    public static void main(String[] args) throws Exception{
        FileInputStream fileInputStream = new FileInputStream("Day10Demo/src/test1.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        byte[] bytes =new byte[1024];
        int len;
        while ((len=bufferedInputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
    }
}

4.1.2、字节缓冲输出流BufferedOutputStream

        作用：可以把低级的字节输出流包装成一个高级的缓冲输出流，提高写的性能。

        构造器：public BufferedoutputStream(OutputStream os)

        原理： 缓冲字节流自带了8kb的缓冲池，数据直接写入到缓冲池中去了，性能提高了！！

public class BufferedOutputStreamDemo02 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fileOutputStream = new FileOutputStream("Day10Demo/src/test2.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fileOutputStream);
        //把一个低级的字节输出流包装成一个高级的缓冲字节输出流
        bos.write('1');
        bos.write('a');
        bos.write('b');
        bos.write('c');
        bos.write("java".getBytes());

        int len;
        byte[] buffer = new byte[]{95,96,97};
        bos.write(buffer);
        bos.close();

    }
}

       

注意：字符流不同编码读取会产生乱码问题 

        代码编码        文件编码        中文情况

        UTF-8                UTF-8                不乱码

        GBK                    GBK                 不乱码

        UTF-8                 GBK                乱码

例如：（这里0代表一个字节）

“我爱java” =>0000000000（UTF-8）=>(GBK解析)00000000

这样解析，中文自然出问题，反之也是。

识别的时候中文因为在各编码所占字节数不同，所以导致了解析乱码问题，所以转换流就出现了

5.转换流

5.1、转换输入流

        作用：可以把原始的字节流按照当前默认的代码编码转换成字符流，

                    可以把原始的字节流按照指定的编码转换成字符流。

字节流字符流
字节输入流字节输出流字符输入流字符输出流
InputStreamOutputStreamReaderWriter抽象类
FileInputStreamFileOutputStreamFileReaderFileWriter实现类
BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWrite缓冲流实现类
无无InputStreamReaderOutputStreamWriter转换流实现类

        构造器：

        public InputStreamReader(InputStream is):可以使用当前代码默认的编码转换成字符流。

        public InputStreamReader(InputStream is,String chatset):可以指定编码把字节转换成字符流。

        

public class InputStreamReaderDemo01 {
    public static void main(String[] args) throws Exception {


        FileInputStream fileInputStream = new FileInputStream("Day10Demo/src/gbk2.txt");
        byte[] bytes =new byte[2];
        int len;
        while((len=fileInputStream.read(bytes))!=-1){
            System.out.print(new String(bytes,0,len,"GBK"));
            /*
            * 注意，这样的解决办法并不好，因为我们的字符串并不是只有中文，还有数字、标点符号等等
            * */
        }

        /*
        * 优质的办法
        * */
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"GBK");
        char[] ch = new char[1024];
        int len1;
        while ((len1=inputStreamReader.read(ch))!=-1){
            System.out.println(new String(ch,0,len));
        }
    }
}

        小结：

        可以解决字节流读取不同编码乱码问题。

        字符输入流可以把字节流按照默认编码转换成字符流。

        字符输入流可以解决不同编码乱码问题。

5.2、转换输出流

        作用：可以指定编码把字节输出流转换成字符输出流。

        构造器：       

        public OutputStreamWriter(OutputStream os):用当前默认的编码UTF-8把字节输出流转换数据写入

        public OutputStreamWriter(OutputStream os,String charset):按照指定的编码格式写入进去。

        小结：

        字符输出转换流可以指定编码把字节输出流转换成字符输出流。

        从而实现指定写出去的字符编码！！

public class OutputStreamWriterDemo02 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fileOutputStream = new FileOutputStream("E:\\Document\\Java\\JavaPlus\\Day10Demo\\src\\GBK.txt");
        OutputStreamWriter gbk = new OutputStreamWriter(fileOutputStream, "GBK");
        gbk.write("我爱Java");
        gbk.close();
    }
}

6、对象序列化技术

        作用：把Java对象数组直接存储到文件中去，需要的时候又把Java对象数据文件恢复到Java对象中去。

字节流字符流
字节输入流字节输出流字符输入流字符输出流
InputStreamOutputStreamReaderWriter抽象类
FileInputStreamFileOutputStreamFileReaderFileWriter实现类
BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWrite缓冲流实现类
无无InputStreamReaderOutputStreamWriter转换流实现类
ObjectInputStreamObjectOutputStream对象序列化

        对象序列化：ObjectOutputStream 

       作用：把内存中的Java对象数据保存到文件中去。

        构造器：public ObjectOutputStream(OutputStream out)

        序列化方法：public final void writerObject(Object obj)

        对象反序列化：        ObjectOutputStream

        注意：如果要序列化对象，那么对象必须实现序列化接口：implements serializable

        存起来不是给我看的，是一种特殊的由JVM设置的格式

        序列化版本号        

        加入序列号版本：private static final long serialVersionUID =2L;

        必须序列化使用版本号和反序列号的版本号一致才能进行正常序列化，否则报错。

        

package _07序列化;

import java.io.Serializable;

public class User implements Serializable {
    private String loginName;
    private transient String userName;//排除这个序列化
    private String passWord;

    public User(String loginName, String userName, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                '}';
    }

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

        序列化

public class SerializeDemo01 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fileOutputStream = new FileOutputStream("Day10Demo/src/obj.dat");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

        //创建一个对象
        User user = new User("cloud","12234","xxx");
        objectOutputStream.writeObject(user);
        objectOutputStream.close();
    }
}

        反序列化：

        

public class SerializeDemo02 {
    public static void main(String[] args) throws Exception {
        //1.定义一个低级的字节输入流通向目标文件。
        FileInputStream fileInputStream = new FileInputStream("Day10Demo/src/obj.dat");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        //2.开始反序列化
        Object o = objectInputStream.readObject();
        User user =(User) o;//大范围转小范围强转换。
        System.out.println(user);
        System.out.println("反序列化完成！！！");
    }
}

7、打印流printStream/PrintWriter

        printStream以字节输出流为底层

        printWriter以字符输出流为底层

        打印流的作用：

        1.可以方便快速把数据输出到磁盘中去。

        2.可以实现打印啥，就是啥出去，不会出现乱码问题处理。

        打印流的构造器：

        public PrintStream(OutputStream os)

        public PrintStream(String filePath)

public class PrintStreamDemo01 {
    public static void main(String[] args) throws Exception {
        //打印流（字节输出流为底层）,注意，这里因为需要printStream的新特性，是不能用多态写法的
        PrintStream printStream = new PrintStream("Day10Demo/src/text3.txt");
        printStream.println("asccaacacac");
        printStream.print("可以打印任何东西到文件中");
        printStream.println("烫烫烫烫烫");//注意：加ln换行
        printStream.close();

        //打印流(以字符输出流为底层Writer)
        PrintWriter printWriter = new PrintWriter("Day10Demo/src/text4.txt");
        printWriter.println("测试测试");
        printWriter.println("烫烫烫烫");
        printWriter.close();
    }
}

        扩展：System.setOut()可以改变输出的方向：

        Public static void setOut(PrintStream out)

public class PrintStreamDemo02 {
    public static void main(String[] args) throws Exception{
        PrintStream printStream = new PrintStream("Day10Demo/src/log.txt");
        System.setOut(printStream);
        System.out.println("输出转变到了log文件了");
    }

}

       

8、Properties属性集对象

        Properties属性集对象其实就是一个Map集合，也就是一个键值对集合，但是我们一般不会当作集合来使用，因为已经由Map了。

        Properties代表的是一个属性文件，可以把键值对的数据存储到一个文件中去，

        属性文件：后缀是.properties结尾的文件，里面的内存都是key=value。

        在一些大型框架中经常使用，属性文件都是很重要的系统配置文件。

        

        Properties的方法：

        -- properties Obejct  setProperty(String key,String value):设置一对属性

        -- properties String getProperty(String key):根据属性名获取属性值

        -- public Set<String> stringPropertyNames():所有键的名称的集合。

        -- public void store(OutputStream out,String comments):保存数据到属性文件中去。

        -- public void store(Writer fw,String comments):保存数据到属性文件中去。comments是备注，不是内容

        --public synchronized void load(InputStream instream):加载属性文件到集合对象中去。

        --public synchronized void load(ReaderStream rs ):加载属性文件到集合对象中去。

 写入文件案例：

    public class PropertiesDemo01 {
    public static void main(String[] args) {
        //1.创建一个属性集对象，Properties的对象。
        Properties properties = new Properties();
//        properties.put("admin","123456"); 不建议使用Map集合
        properties.setProperty("admin","123456");
        properties.setProperty("admin","121212");//键值不不能重复覆盖了。
        properties.setProperty("kuku","12345");
        System.out.println(properties);
        //2.把属性集对象的数据存入到属性文件中去（重点）
        try (
                FileOutputStream fileOutputStream = new FileOutputStream("Day10Demo/src/users.properties");
                ){
            /*
            * 参数一：保存文件的输出管道
            * 参数二：保存心得，对保存的数据注释
            * */
            properties.store(fileOutputStream,"I an very happy");
        }catch (IOException e){
            e.printStackTrace();
        }

    }
}

读出文件案例：

public class PropertiesDemo02 {
    public static void main(String[] args) {
        //1.创建一个属性集合对象，
        Properties properties = new Properties();
        try(
                FileInputStream fileInputStream = new FileInputStream("Day10Demo/src/users.properties");
                ){
            properties.load(fileInputStream);
            System.out.println(properties.get("admin"));
            System.out.println(properties);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

        

努力奋斗的张同学
关注
  • 26
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
字节流、字符流
09-09 674
day09【字节流、字符流】 主要内容 IO流 字节流 字符流 异常处理 Properties 教学目标 能够说出IO流的分类和功能 能够使用字节输出流写出数据到文件 能够使用字节输入流读取数据到程序 能够理解读取数据read(byte[])方法的原理 能够...
JavaIO实例_字节流_字符流_缓冲流_转换流IODemo
12-16
JavaIO实例,包括：字节流、字符流、缓冲流、转换流
JAVA 字符流与字节流
02-01
JAVA 字符流与字节流
Java基础（11）字节流和字符流
最新发布
qq_43012298的博客
05-03 313
字节流和字符流是Java I/O库的基石，理解它们的区别和使用场景对于开发高效、健壮的I/O相关应用程序非常重要。通过上述示例和解析，希望能够帮助你更深入地理解Java中的字节流和字符流。
File类与IO流知识总结（二）：字节流、字符流、IO异常处理和 属性集
洺润Star的博客
11-19 393
一:IO概述 1.1 什么是IO 生活中，我们肯定经历过这样的场景。当你编辑一个文本文件，忘记了 ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。 我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为 输入input 和 输出output ，即流向内存是输...
Java 字节流，字符流
03-31 865
部分转自：http://leonmau.iteye.com/blog/1182712 另外还有一篇文章解释的也比较清楚：http://blog.csdn.net/cynhafa/article/details/6882061  Java 中提供了专用于输入输出功能的包Java.io, 其中包括： InputStream,OutputStream,Reader,Writer l    
Java字节流和字符流
yihanzhi的博客
12-04 286
在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都有输入和输出操作。字节流中输出数据主要用OutputStream完成，输入主要用InputStream；字符流中输出主要用Writer类完成，输入主要用Reader类完成。 字节流和字符流： 字节流：InputStream、OutputStream； 子类：FileInputStream、 FileOutputStream、B...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
Java IO流常用字节字符流原理解析
08-19
它可以读取文件的字节序列，并将其转换为Java中的byte数组。 * BufferedInputStream：BufferedInputStream是带缓存的字节输入流，用于提高读取速度。它内部有一个缓存区，用于存储读取的字节数据，然后将其返回给...
day21_缓冲流、转换流、序列化流、Commons IO.pdf
11-02
总的来说，缓冲流、转换流和序列化流是Java IO编程中的重要组成部分，它们提供了更高的效率和灵活性，帮助开发者更好地处理数据的读写和对象的持久化。了解并熟练运用这些流，对于提升Java应用的性能至关重要。在...
Java IO字符流缓冲区实现原理解析
08-19
Java IO字符流缓冲区实现原理解析 Java IO字符流缓冲区实现原理解析是Java编程语言中的一种重要机制，该机制旨在提高IO操作的效率和性能。缓冲区是Java IO字符流中的一种机制，它可以将数据暂存起来，以便提高读写...
java 字节流和字符流
m0_55680183的博客
05-26 278
java定义了两种类型的输入/输出流：字节流和字符流。 字节流（byte stream）用以处理字节数据的输入、输出； 字符流（character stream）为字符数据的输入和输出提供方便。 字节流有两个重要的抽象类：InputStream和OutputStream，即字节输入流 和字节输出流。 FileInputStream俗称文件输入流，是字节输入流InputStream类的一个子类 //引入相关的类 import java.io.IOException; import java.io.InputS
java中字节流和字符流
handsome1_的博客
09-20 335
一、①什么是字节流？ 字节流--传输过程中，传输数据的最基本单位是字节的流。 FileInputStream (read(byte[] buffer)) FileOutputStream (write(byte[] buffer,0,len) ②什么是字符流？ 字符流--传输过程中，传输数据的最基本单位是字符的流。 FileReader (read(char[] cbuf)) ...
java之字节流，字符流，转换流
qq_38808348的博客
01-31 1037
1.使用字节的输入流和输出流来进行复制 字节流不但可以写文本还可以写图片，音频 public static void main(String[] args){ FileInputStream f = new FileInputStream("/Users/lanou/Desktop/test/11.png"); FileInputStream f2 = new FileInput
Java IO流之转换流
weixin_30535565的博客
05-01 154
一、转换流 1.在IO包中，实际上就是分为字节流和字符流，但是除了这两个流之外，还存在了一组字节流-字符流的转换流 2.转换流用于在字节流和字符流之间转换 3.转换流本身是字符流 二、两种转换流 OutputStreamWriter 1）OutputStreamWriter是Writer的子类，将输出的字符流变为字节流，即：将一个字符流的输出对象变为字节流的输出...
java中的字节流与字符流
weixin_46659330的博客
07-29 1774
2.9.2 IO流 流：数据从源点传输到汇点的“管道” I=Input O=Output 流的分类：字节流10个+字符流 按照方向分：输入流 输出流 按照单位分：字节流 字符流 按照功能分：节点流 过滤流（包装流、处理流） 类： InputStream:所有字节输入流统一的父类，抽象类 int read() int read(byte[] data) int read(byte[] data,int offset,int len) OutputStream:所有字节输出流统一的父类
java基础：java字节流、字符流。
qq_42777490的博客
05-13 1896
java字节流、InputStream、OutputStream、FileInputStream、FileReader、BufferedReader 、FileOutputStream、FileWriter 、BufferedWriter 、字节流复制文件、字节缓冲流复制文件、BufferedInputStream、BufferedOutputStream、字符流复制文件、InputStreamReader 、OutputStreamWriter
JAVA基础——字节流&字符流
weixin_64310048的博客
06-20 229
方法名说明void write(int b)将指定的字节写入此文件输出流 一次写一个字节数据void write(byte[] b)将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据void write(byte[] b, int off, int len)将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据方法说明FileInputStream(File file)通过打开与实际文件的连接来创建一个 FileInputStrea
java I/O流-字节流和字符流
java小记转一转（基础）
02-01 834
字节流和字符流操作的方式基本相同，区别在于操作的数据单元不同，字节流操作的数据单元是字节，字符流操作的数据单元是字符。  输入流操作的抽象基类：InputStream（输入字节流的抽象基类）/Reader(输入字符流的抽象基类)  操作字节流InputStream的3个方法： int read()-从输入流中读取单个字节，返回读取到的字节数据（直接转换为int类型）。int read(b
练习-java输入输出之字节缓冲io流之字节缓存流的高性能
03-16
字节缓存流是一种高性能的输入输出流，它可以将字节数据缓存到内存中，从而提高读写效率。在Java中，我们可以使用字节缓存流来进行文件的读写操作，这样可以大大提高程序的运行效率。与普通的字节流相比，字节缓存流具有更高的性能和更好的效率，因此在实际开发中应该尽可能地使用字节缓存流来进行文件的读写操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

努力奋斗的张同学

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

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

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

打赏作者

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

抵扣说明：

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

余额充值