比尔云BierYun--阿里云最新优惠活动
阿里云优惠码丨阿里云代金券

总结JAVA—-IO流中的字节流

对于IO流中字节流的总结

 

字节流的概念

由于应用程序,经常需要和文件打交道,所以Inputstream专门提供了读写文件的子类:FileInputStream和FileOutputStream类,如果程序对于文件的操作较为简单,就比如说只是顺序的读写文件,那么就可以使用字节流进行操作.并且我们都知道,所有文件的最底层数据类型都是字节,所以说,字节流的应用范围是十分广的,当然,它也有相应的缺点,只能处理简单的数据文本,一旦数据多了,其处理速度慢的弊端也就显现了出来.

子父类关系

通过超级父类InputStream延伸出的很多派系,并且一些派系完美的解决了,字节流速度慢的问题(字节缓冲流)

编码方式

查阅了挺久资料的,发现在编码方式这块,由于我还没有接触计算机原理这门课,所以对于这块的概念十分的模糊,从昨天到今天也查阅了许多资料,但还是无法很系统的整理出一些真正有用的东西,所以对于编码方式这里,我会在以后认真的总结一番。

其与字符流的不同

1.

字节流传输的最基本单位是字节

字符流传输的最基本单位是字符

2.

编码方式不同

3.

字符流在传输方面上,由于计算机的传输本质都是字节,而一个字符由多个字节组成,转成字节之前先要去查表转成字节,所以传输时有时候会使用缓冲区。

字节流传输时不会用到缓冲区,是通过直接访问IO设备的方式来完成传输。

4.

字节流适用于图片,文本,视频等等格式的数据.

字符流适用于文本,并且最好是中文文本,处理速度超快.

字节流的输入\输出流

构造方法(1)

构造方法(2)

构造方法(3)

这三种构造方法都要求在对象创建之前便给出文件名。

对于一个文件进行的输入输出操作的代码

复制代码
import java.io.*;
import java.util.Scanner;
/*
 * 该类用于做一个文件字节流的例子
 */
public class Demo1 {
     public static void main(String[] args) throws IOException{
        File file=function();
        choice(file);
    }
     public static File function() throws IOException{     //该方法用于创建一个文件对象
         File file=new File("C:\\Users\\Lenovo\\Desktop\\Demo.txt");   
         //创建一个文件对象
         if(!file.exists()) {
             file.createNewFile();      //若文件不存在则创建一个文本文件
         }
        return file;
     }
      public static void choice(File file) throws IOException{    //该类用于进行选择输入方式(是覆盖还是从文件末尾写)
          int a = 0;
          System.out.println("a==");
          Scanner sc=new Scanner(System.in);
          a=sc.nextInt();
          switch(a) {
          case 1:function1(file);function3(file);break;     //这是覆盖式写入
          case 2:function2(file);function3(file);break;     //这是从文件末尾写入
          default:System.out.println("无该索引");
          }
          sc.close();
      }
      public  static void function1(File file) throws IOException{
          FileOutputStream  fos=new  FileOutputStream(file);
          System.out.println("请输入您想要写入的信息");
          Scanner sc=new Scanner(System.in);
          String s=sc.nextLine();
          byte[] b=s.getBytes();      //将字符串转换为字节数组
          fos.write(b);
          fos.close();
          sc.close();
      }
      public static void function2(File file) throws IOException{  //该方法是从末尾开始写
          FileOutputStream  fos=new  FileOutputStream(file,true);
          System.out.println("请输入您想要写入的信息");
          Scanner sc=new Scanner(System.in);
          String s=sc.nextLine();
          byte[] b=s.getBytes();      
          fos.write(b);
          fos.close();
          sc.close();
      }
      public static void function3(File file) throws IOException{
          FileInputStream fis=new  FileInputStream(file);
          byte[] b=new byte[(int) file.length()];
            //运用File类关于文件属性的方法,但是返回值是long型数据,需要强转。
          fis.read(b);
          System.out.println(new String(b));
          fis.close();
      }
}
复制代码

第一次键入a=1,输入”啊哈哈”

第二次键入a=1,输入”嘿嘿嘿”   会发现文件中只剩下”嘿嘿嘿”

第三次键入a=1,输入”啊哈哈”

第二次键入a=2,输入”嘿嘿嘿”   会发现文件中是”啊哈哈嘿嘿嘿”

字节缓冲流

BufferedInputStream&BufferedOutputStream

这两种类为IO提供了带缓冲区的操作,一般打开文件进行写入或读取操作时,都会加上缓冲,这样提高了IO的性能。

对于IO的抽象理解

如果我们要将一缸水转到另一缸水中

FileOutputStream&FileInputStream相当于把水一滴一滴的转移

DataOutputStream&DateaInputStream相当于把水一瓢一瓢的转移

BufferedOutputStream&BufferdeInputStream相当于先把水全部放入一缸水中,然后在将这一缸水倒入目标缸中。

所以说带缓冲区的字节缓冲流是很好使的。

我们用字节缓冲流代码实现一下文件的复制

复制代码
import java.io.*;

/*
 * 用字节缓冲流完成对于文件的复制
 */
public class Dmeo2 {
    public static void main(String[] args) throws IOException{
          byte[] b=function();
          function1(b);
    }
    public static byte[] function() throws IOException {
        InputStream is=new FileInputStream("C:\\Users\\Lenovo\\Desktop\\Demo.txt");
        BufferedInputStream bis=new BufferedInputStream(is);    //构造方法参数为InputStream类型
        byte[] b=new byte["C:\\Users\\Lenovo\\Desktop\\Demo.txt".length()];
        bis.read(b);          //将信息转换为字节数组
        bis.close();       
        return b;                //将字节数组返回
    }
    public static void function1(byte[] b) throws IOException {
        OutputStream os=new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\Demo1.txt");
        BufferedOutputStream bos=new BufferedOutputStream(os);
        bos.write(b);
        bos.flush();         //此处一定要记得刷新缓冲区,这样信息才能流入文件
        bos.close();      //若是我们手动关闭的话,系统会帮我们自动刷新缓冲区
        /*所以说fluse()方法与close()方法写一个就行,但这只是理论上的
         * 但是为了程序的可读性还是都写好一点
         */
    }
}
复制代码

这里的Demo文件是我们上个代码也就是字节流中所创建的文件。

字节数组流

字节数组流在功能方面属于字节流,属于直接作用于目标设备的一种流类.经常而言我们都是针对文件的操作,然后带上缓冲的节点流进行处理,但有时候为了提升效率,我们发现频繁的读写文件并不是太好,那么于是出现了字节数组流,即存放在内存中,因此又称之为内存流.(这里是直接copy别人的).其实也就是将我们的目标放在了缓冲区之上,而不再是文件了.

ByteOtputArrayStream(字节数组输出流)

构造方法:

第一个是有初始长度但可以增加,第二个是自己设置长度

这里我感觉我们不可以将其理解为数组,总感觉它和集合真的好像,因为他的属性单位也是以size()方法来查看的,并且他和集合一样长度是可变的。

特殊方法:

这个无效close最先真的搞得我一头雾水,后来才反应过来这里我们操作的对象是缓冲区,缓冲区是无法关闭的,或者说关闭了会出很大的问题,所以这里他应该是无效的,并且作为子类,我们从父类中所拿到的方法并不全是有用的,毕竟子类与父类是不同的两个单独存在的个体。

关于缓冲区属性的一个方法

这两个方法都是write方法,这里的处理方式其实和父类中的write方法基本一致吧,只是目标有所变化。

ByteInputArrayStream\字节输入流

构造方法

这里最关键的是buf的选择,作为输入流我们若是想从缓冲区得到数据的话,buf应该是输入流.toByteArray()方法得到的数组,在我看来输入流就代表着那一块我们正存放数据的缓冲区,这样转换成数组合情合理

完成一个简单读写操作

复制代码
 import java.io.*;
public class Demo3 {
   public static void main(String[] args) throws IOException{
       function();
}
     public static void function() throws IOException{   //该方法用于输出流的存入
         ByteArrayOutputStream  bos=new ByteArrayOutputStream();  //使用默认构造方法
         String s="我是哈哈哈";
         byte[] b=s.getBytes();
         bos.write(b); //这里不要像上文给出的write(byte[] b,int off,int len)因为这样的话我们还要
         //计算一下字节个数,很麻烦,还容易出错,当然也有其它方法知道准确字节数但是代码量会多
         function1(bos.size(),bos);
     }
      public static void function1(int a,ByteArrayOutputStream bos) throws IOException{
          ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
          //如上文所说,以输出流所转化成的数组为参数创建一个对象
          byte[] b=new byte[a];
          bis.read(b);   //把字节存到b数组中
          System.out.println(new String(b));
      }
}
复制代码

字节数据流

DataInputStream和DataOutputStream类创建的对象称为数据输入流和数据输出流.这两个流是很有用的流,他们允许程序按着及其无关的的风格读取JAVA原始数据.也就是说,当读取一个数值时,不必再关心这个数值应该是多少个字节(而且有些数据类型long,double数据类型真的很难转成字节),它们属于处理流,即程序通过一个间接流类去调用节点流类,以达到更加灵活方便地读写各种类型的数据,这个间接流类就是处理流。

构造方法

也就是说他们的参数是节点流。并且这里我们可以很好的利用多态的概念,FileInputStream。。。。等等都可以作为参数

读写方法writexxx,readxxx。

代码完成简单的读取操作

复制代码
import java.io.*;

public class Demo4 {
    static String file="C:\\Users\\Lenovo\\Desktop\\李xx.txt";
   public static void main(String[] args) throws IOException{
        function();
        function1();
}  
   public static void function() throws IOException{  //该方法用于存
       
       DataOutputStream dos=new DataOutputStream(new FileOutputStream(Demo4.file));
       dos.writeInt(1);
       dos.writeInt(2);
       dos.writeInt(3);
       dos.writeInt(4);
       dos.writeUTF("你是真滴6");
       dos.close();
   }
   public static void function1() throws IOException{
       DataInputStream  dis=new DataInputStream(new FileInputStream(file));
       System.out.println(dis.readInt());
       System.out.println(dis.readInt());
       System.out.println(dis.readInt());
       System.out.println(dis.readInt());
       System.out.println(dis.readUTF());
   }
}
复制代码

但是我发现数据流中读取时指针的跳转过于笨拙,也就是说我们必须知道下个数据类型是啥,才能将其准确读取出来,并且前一个读不出来的话,后一个也是无法读取的。

原文地址https://www.cnblogs.com/roseneverdie/p/10650952.html

未经允许不得转载:阿里云代金券 » 总结JAVA—-IO流中的字节流

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

强烈推荐

高性能SSD云服务器ECS抗攻击,高可用云数据库RDS