• JavaIo流入门篇之字节流基本使用。


    一 基本知识了解(  字节流, 字符流, byte,bit是啥?)

    /*
        java中字节流和字符流之前有接触过,但是一直没有深入的学习和了解。
        今天带着几个问题,简单的使用字节流的基本操作。
    
    1 什么是字节流?
        字节流是由字节组成的,字符流是由字符组成的.Java里字符由两个字节组成.字节流是最基本的
        所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的但实际中很多的数据是文本,
        又提出了字符流的概念,它是按虚拟机的encode来处理,
        也就是要进行字符集的转化。在从字节流转化为字符流时,实际上就是byte[]转化为String时,
        public String(byte bytes[], String charsetName)有一个关键的参数字符集编码,通常我们都省略了,那系统就用操作系统默认的long
    
    总结
        ·字节流按照字节来处理
        ·字符流处理文本
        ·字节输出流OutputStream  数据从程序流到外面(本机电脑等) 在程序中写入文本到本机电脑
        ·字节输入流InputStream   数据从外部流入写的程序(使用程序读取本机的文件内容)
    
    2 什么是字符流?
        Java中的字符流处理的最基本的单元是Unicode码元(大小2字节),它通常用来处理文本数据。所谓Unicode码元,也就是一个Unicode代码单元,
        范围是0x0000~0xFFFF。在以上范围内的每个数字都与一个字符相对应,
        Java中的String类型默认就把字符以Unicode规则编码而后存储在内存中。然而与存储在内存中不同,存储在磁盘上的数据通常有着各种各样的编码方式。
        使用不同的编码方式,相同的字符会有不同的二进制表示。实际上字符流是这样工作的:
    
        输出字符流:把要写入文件的字符序列(实际上是Unicode码元序列)转为指定编码方式下的字节序列,然后再写入到文件中;
        输入字符流:把要读取的字节序列按指定编码方式解码为相应字符序列(实际上是Unicode码元序列从)从而可以存在内存中。
    
    3 什么是字节(byte 简称B)
        是计算机信息技术用于计量存储容量的一种计量单位,也表示一些计算机编程语言中的数据类型和语言字符。
        是计算机中存储数据的一种计量单位。
        是编程语言中的数据类型和语言字符。
        英文1个字节,中文2个字节
    
    4 什么是位(比特 bit)
        电脑的各种存储器的最小的存储单位是比特,也就是位(bit,简称b),它表示一个二进制位。
        比位大的单位是字节(byte,简称B),它等于8个二进制位。
        因为在存储器中含有大量的存储单元,每个存储单元可以存放8个二进制位,所以存储器的容量是以字节为基本单位的。
        电脑有32位和64位。
    
    5 字节(byte)和位(bit)之间的关系?
        ·字节是byte简称B  位是bit简称b。
        ·1B等于8b,一个字节等于八个比特,等于8个二进制位。
        ·bit是电脑存储器中最小的存储单位。他表示一个二进制位。
        ·电脑中存在多个存储单元,一个单元可以存放8个二进制位,就是可以存放一个byte。所以存储器的容量是以字节为基本单位的。
     */

    二  OutPutStream基本使用

    public class OutputDemo {
        public static void main(String[] args)  throws IOException {
            write();
        }
    
        static void write () throws IOException{
            /*
            ·使用file对象,要确保填写的本机路径的位置是正确的。
            ·这里的异常直接交给jvm处理,直接声明出去,基本就是io异常。注意声明异常的范围选择。
            ·File.separator 是系统默认的文件分隔符号,用 File.separator 保证了在任何系统下不会出错。
            */
            File file =  new File("/Users/zhouxufeng/Desktop" + File.separator + "demo.txt");
    
            //通过子类FileOutputStream 实列化父类对象OutputStream,打开流的通道。
            OutputStream outputStream = new FileOutputStream(file);
    
            // 定义一个字符串对象。就是我们要写入的内容
            String str1 = "123";
    
            // 字节流只能处理字节,需要把定义的字符串变为byte。
            byte [] bytes1 = str1.getBytes();
    
            // 实行写入操作。
            outputStream.write(bytes1);
            
            // 流是一种珍贵的资源,使用完毕后要关闭!
            outputStream.close();
        }
    }

    写入成功的结果

    尝试再次写入,追加文本内容,跑一下看看能否追加成功。

    public class OutputDemo {
        public static void main(String[] args)  throws IOException {
            write();
        }
    
        static void write () throws IOException{
            /*
            ·使用file对象,要确保填写的本机路径的位置是正确的。
            ·这里的异常直接交给jvm处理,直接声明出去,基本就是io异常。注意声明异常的范围选择。
            ·File.separator 是系统默认的文件分隔符号,用 File.separator 保证了在任何系统下不会出错。
            */
            File file =  new File("/Users/zhouxufeng/Desktop" + File.separator + "demo.txt");
    
            //通过子类FileOutputStream 实列化父类对象OutputStream,打开流的通道。
            OutputStream outputStream = new FileOutputStream(file);
    
            // 定义一个字符串对象。就是我们要写入的内容
            String str1 = "123";
            String str2 = "666";
    
            // 字节流只能处理字节,需要把定义的字符串变为byte。
            byte [] bytes1 = str1.getBytes();
            byte [] bytes2 = str2.getBytes();
    
            // 实行写入操作。
            outputStream.write(bytes1);
            outputStream.write(bytes2);
    
            // 流是一种珍贵的资源,使用完毕后要关闭!
            outputStream.close();
        }
    }

    查看结果,发现之前写入的文本被后续的写入覆盖了。

     解决方案 在FileOutPutStream 的参数中加入 true标记。

     看源码,发现这里要追加内容,新增一个true的判断即可。

    public class OutputDemo {
        public static void main(String[] args)  throws IOException {
            write();
        }
    
        static void write () throws IOException{
            /*
            ·使用file对象,要确保填写的本机路径的位置是正确的。
            ·这里的异常直接交给jvm处理,直接声明出去,基本就是io异常。注意声明异常的范围选择。
            ·File.separator 是系统默认的文件分隔符号,用 File.separator 保证了在任何系统下不会出错。
            */
            File file =  new File("/Users/zhouxufeng/Desktop" + File.separator + "demo.txt");
            
            //true 表示会在文件末尾追加的内容
            OutputStream outputStream = new FileOutputStream(file,true);
            
            // 定义一个字符串对象。就是我们要写入的内容
            String str1 = "尝试加入新内容";
            String str2 = "龙猫";
    
            // 字节流只能处理字节,需要把定义的字符串变为byte。
            byte [] bytes1 = str1.getBytes();
            byte [] bytes2 = str2.getBytes();
    
            // 实行写入操作。
            outputStream.write(bytes1);
            outputStream.write(bytes2);
    
            // 流是一种珍贵的资源,使用完毕后要关闭!
            outputStream.close();
        }
    }

    查看结果 ,追加内容成功。

    三 InPutStrem的基本public class OutputDemo {

    public static void main(String[] args)  throws IOException {
            read();
        }
    
        static void write () throws IOException{
            /*
            ·使用file对象,要确保填写的本机路径的位置是正确的。
            ·这里的异常直接交给jvm处理,直接声明出去,基本就是io异常。注意声明异常的范围选择。
            ·File.separator 是系统默认的文件分隔符号,用 File.separator 保证了在任何系统下不会出错。
            */
            File file =  new File("/Users/zhouxufeng/Desktop" + File.separator + "demo.txt");
    
            //true 表示会在文件末尾追加的内容
            OutputStream outputStream = new FileOutputStream(file,true);
    
            // 定义一个字符串对象。就是我们要写入的内容
            String str1 = "尝试加入新内容";
            String str2 = "龙猫";
    
            // 字节流只能处理字节,需要把定义的字符串变为byte。
            byte [] bytes1 = str1.getBytes();
            byte [] bytes2 = str2.getBytes();
    
            // 实行写入操作。
            outputStream.write(bytes1);
            outputStream.write(bytes2);
    
            // 流是一种珍贵的资源,使用完毕后要关闭!
            outputStream.close();
        }
    
        static void read () throws  IOException{
            File file =  new File("/Users/zhouxufeng/Desktop" + File.separator + "demo.txt");
    
            // 通过子类实列化父类对象,打开流的通道
            InputStream inputStream = new FileInputStream(file);
    
            // 需要定义一个byte来接收文本中的字符串。
            byte [] bytes =  new byte[1024];
    
            // 读取
            inputStream.read(bytes);
     
    inputStream.close();
    //输出
            System.out.println(new String(bytes));
        }
    }

    可以读取到文本内容,但是后面有很多0。 因为byte定义的1024。数组定义的大,有了很多空格。

    解决方案, 获得read后的返回值。获取byte的长度,在读取数组时,指定读取的范围。

    public class OutputDemo {
        public static void main(String[] args)  throws IOException {
            read();
        }
        
        static void read () throws  IOException{
            File file =  new File("/Users/zhouxufeng/Desktop" + File.separator + "demo.txt");
    
            // 通过子类实列化父类对象,打开流的通道
            InputStream inputStream = new FileInputStream(file);
    
            // 需要定义一个byte来接收文本中的字符串。
            byte [] bytes =  new byte[1024];
    
            // 读取
            int len = inputStream.read(bytes);

    inputStream.close();
            //输出 
        System.out.println(new String(bytes,0,len)); } }

    正常的读取结果。

    在循环中依次读取文本内容

    public class OutputDemo {
        public static void main(String[] args)  throws IOException {
            readFu();
        }
        // 定义一个数组,再循环中一个个的读取文本内容,并存到数组中。
        static void readOne()throws IOException{
            File file = new File("/Users/zhouxufeng/Desktop" + File.separator + "demo.txt");
    
            InputStream inputStream = new FileInputStream(file);
    
            //这个数组的长度,就是文本内容的长度。
            byte [] bytes = new byte[(int)file.length()];
    
            //依次读取,存入数组
            for (int i = 0; i < file.length(); i++) {
                bytes[i] = (byte) inputStream.read();
            }
            inputStream.close();
    
            System.out.println(new String(bytes));
    
        }
    
        // read() 返回-1 表示文件读完。 通过判读是否读到文件末尾的方式来读取文件。
        static void readFu()throws IOException{
            File file = new File("/Users/zhouxufeng/Desktop" + File.separator + "demo.txt");
    
            InputStream inputStream = new FileInputStream(file);
    
            // 首先需要一个容器来装
            byte [] bytes = new byte[1024];
    
            // 用于记录读取的数据
            int len = 0;
    
            // 不定义这个int变量,输出的内容是乱码
            int temp ;
    
            //判读
            while ((temp = inputStream.read())!=-1){
                bytes[len] = (byte) temp;
                len++;
            }
    
            // 文件读到末尾,返回值-1。 未用定义的temp去替代这里的返回值,输出的内容有乱码。
    //        while (inputStream.read()!=-1){
    //            bytes[len] = (byte)inputStream.read();
    //            len++;
    //        }
    
            inputStream.close();
    
            System.out.println(new String(bytes,0,len,"UTF-8"));
    //        System.out.println(new String(bytes,0,len));
        }
    }

    目前简单的介绍了字节流的输入和输出方法,后续的使用慢慢聊。 学习的过程是逐渐的,加油。

  • 相关阅读:
    xtrabackup备份原理
    四“当”
    MySQL BinLog Server 搭建实战
    mysqldump 原理
    MGR测试及搭建
    自动化测试-12.selenium的弹出框处理
    自动化测试-11.selenium的下拉框处理类Select
    自动化测试-10.selenium的iframe与Frame
    自动化测试-9.selenium多窗口句柄的切换
    自动化测试-8.selenium操作元素之键盘和鼠标事件
  • 原文地址:https://www.cnblogs.com/ZXF6/p/15331519.html
Copyright © 2020-2023  润新知