Java:IO流之字节流InputStream、OutputStream详解-阿里云开发者社区

开发者社区> 吞吞吐吐的> 正文

Java:IO流之字节流InputStream、OutputStream详解

简介:
+关注继续查看
字节流:
(抽象基类)InputStream类(读):
(抽象基类)OutputStream类(写):
 
InputStream:
构造方法摘要
InputStream() 
            
 方法摘要 
int available() 
 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)的估计字节数。 
void close() 
 关闭此输入流并释放与该流关联的所有系统资源。 
void mark(int readlimit) 
 在此输入流中标记当前的位置。 
boolean markSupported() 
 测试此输入流是否支持 mark 和 reset 方法。 
abstract  int read() 
 从输入流中读取数据的下一个字节。 
int read(byte[] b) 
 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。 
int read(byte[] b, int off, int len) 
 将输入流中最多 len 个数据字节读入 byte 数组。 
void reset() 
 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。 
long skip(long n) 
 跳过和丢弃此输入流中数据的 n 个字节。
//例子1:
复制代码
import java.io.*;
class FileInputStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        //读取该文件中的数据
        FileInputStream fis = new FileInputStream("f:\\myfile\\fos.txt");
        int b = 0;
        while((b = fis.read())!=-1)
        {
            System.out.print((char)b);
        }
        
        //此处不适用于刷新,而是用于关闭资源
        fis.close();
    }
}
复制代码
OutputStream:  
构造方法摘要 
OutputStream() 
 
方法摘要 
void close() 
 关闭此输出流并释放与此流有关的所有系统资源。 
void flush() 
 刷新此输出流并强制写出所有缓冲的输出字节。 
void write(byte[] b) 
 将 b.length 个字节从指定的 byte 数组写入此输出流。 
void write(byte[] b, int off, int len) 
 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。 
abstract  void write(int b) 
 将指定的字节写入此输出流。  
 
//例子2:需求:想要操作图片数据,这时就要用到字节流。
复制代码
import java.io.*;
class FileOutputStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        //创建字节流文件并写入数据
        FileOutputStream fos = new FileOutputStream("f:\\myfile\\fos.txt");
        String str = "abcde";
        byte b[] = str.getBytes();
        fos.write(b);
        
        //此处不适用于刷新,而是用于关闭资源
        fos.close();
    }
}
复制代码
使用字节流读取文件中的数据有三种方式:
方法一:一个一个字节的读取;
方法二:先指定长度的数组,再将数据读读入数组,最后从数组中读出数据内容;
方法三:通过available()方法可以获取文件中数据的总个数,以此个数设置为数组长度刚刚好,剩下步骤与方法二相等。
//例子3:
复制代码
import java.io.*;
class FileStream
{
    public static void main(String[] args)throws IOException
    {
     //WriteFile();
     ReadFile1();
     ReadFile2();
     ReadFile3();
    }
    public static void WriteFile()throws IOException
    {
        //创建字节流文件并写入数据
        FileOutputStream fos = new FileOutputStream("f:\\myfile\\fs.txt");
        String str = "xyzabcd123";
        byte b[] = str.getBytes();
        fos.write(b);
        
        //此处不适用于刷新,而是用于关闭资源
        fos.close();
    }
    
    //方法一:一个一个字节的读取
    public static void ReadFile1()throws IOException
    {
        //读取该文件中的数据
        FileInputStream fis = new FileInputStream("f:\\myfile\\fs.txt");
        int b = 0;
        while((b = fis.read())!=-1)
        {
            System.out.println((char)b);
        }
        
        //此处不适用于刷新,而是用于关闭资源
        fis.close();        
    }
    
    //方法二:先指定长度的数组,再将数据读读入数组,最后从数组中读出数据内容。
    public static void ReadFile2()throws IOException
    {
        //读取该文件中的数据
        FileInputStream fis = new FileInputStream("f:\\myfile\\fs.txt");
        byte[] buf = new byte[1024];
        int num = 0;
        while((num = fis.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,num));
        }
 
        //此处不适用于刷新,而是用于关闭资源
        fis.close();     
    }

   //方法三:通过available()方法可以获取文件中数据的总个数,以此个数设置为数组长度刚刚好,剩下步骤与方法二相同。
    public static void ReadFile3()throws IOException
    {
        //读取该文件中的数据
        FileInputStream fis = new FileInputStream("f:\\myfile\\fs.txt");
        byte[] buf = new byte[fis.available()];
        fis.read(buf);
        System.out.println(new String(buf));
        //此处不适用于刷新,而是用于关闭资源
        fis.close();     
    }   
}
复制代码
复制和读取二进制文件,必须使用字节流,下面进行具体的应用实例举例:
//复制图片:
思路:
 1、用字节读取流对象和图片关联;
 2、用字节写入流对象创建一个图片文件,用于存储获取到的数据;
 3、通过循环读写,完成数据的存储;
 4、关闭资源。
复制代码
import java.io.*;
class CopyPicture
{
    public static void main(String[] args)
    {
      FileOutputStream fos = null;
      FileInputStream fis = null;
      try
      {
          fos = new FileOutputStream("F:\\myfile\\2.jpg");
          fis = new FileInputStream("F:\\myfile\\1.jpg");
          byte[] buf = new byte[1024];
          int len = 0;
          while((len = fis.read(buf))!=-1)
          {
               fos.write(buf,0,len);
          }
      }
      catch(IOException e)
      {
          throw new RuntimeException("文件复制失败!");
      }
      finally
      {
          try
          {
              if(fis!=null)
                 fis.close();
          }
          catch(IOException e)
          {
              throw new RuntimeException("读取流关闭异常!");
          }
          try
          {
              if(fos!=null)
                 fos.close();
          }
          catch(IOException e)
          {
              throw new RuntimeException("写入流关闭异常!");
          }          
      }
    }
}
复制代码
//复制MP3:
复制一个音频。(通过Buffered缓冲空间)
BufferedInputStream 
BufferedOutputStream 
思路:
 1、用字节读取流对象和音频关联;
 2、用字节写入流对象创建一个音频文件,用于存储获取到的数据;
 3、通过循环读写,完成数据的存储;
 4、关闭资源。
复制代码
import java.io.*;
class CopyMp3
{
    public static void main(String[] args)
    {
      long start = System.currentTimeMillis();
      copy();
      long end = System.currentTimeMillis();
      System.out.println((end-start)+"毫秒");
    }
    
    //通过字节流缓冲区完成复制
    public static void copy()
    {
      BufferedInputStream bufis = null;
      BufferedOutputStream bufos = null;
      try
      {
          bufis = new BufferedInputStream(new FileInputStream("F:\\myfile\\b01.mp3"));
          bufos = new BufferedOutputStream(new FileOutputStream("F:\\myfile\\b02.mp3"));
          int by = 0;
          while((by = bufis.read())!=-1)
          {
               bufos.write(by);
          }
      }
      catch(IOException e)
      {
          throw new RuntimeException("文件复制失败!");
      }
      finally
      {
          try
          {
              if(bufis!=null)
                 bufis.close();
          }
          catch(IOException e)
          {
              throw new RuntimeException("读取流关闭异常!");
          }
          try
          {
              if(bufos!=null)
                 bufos.close();
          }
          catch(IOException e)
          {
              throw new RuntimeException("写入流关闭异常!");
          }          
      }        
    }
}
复制代码
//复制视频avi:
复制一个视频。(通过自定义的数组缓冲空间)
思路:
 1、用字节读取流对象和视频关联;
 2、用字节写入流对象创建一个视频文件,用于存储获取到的数据;
 3、通过循环读写,完成数据的存储;
 4、关闭资源。
复制代码
import java.io.*;
class CopyAvi
{
    public static void main(String[] args)
    {
      FileOutputStream fos = null;
      FileInputStream fis = null;
      try
      {
          fos = new FileOutputStream("F:\\myfile\\a02.avi");
          fis = new FileInputStream("F:\\myfile\\a01.avi");
          byte[] buf = new byte[4096];
          int len = 0;
          while((len = fis.read(buf))!=-1)
          {
               fos.write(buf,0,len);
          }
      }
      catch(IOException e)
      {
          throw new RuntimeException("文件复制失败!");
      }
      finally
      {
          try
          {
              if(fis!=null)
                 fis.close();
          }
          catch(IOException e)
          {
              throw new RuntimeException("读取流关闭异常!");
          }
          try
          {
              if(fos!=null)
                 fos.close();
          }
          catch(IOException e)
          {
              throw new RuntimeException("写入流关闭异常!");
          }          
      }
    }
}
复制代码
 
最后再提一下,使用api中的字节流是很好的,当然,用户也可以自定义一个字节流缓冲区。下面就给一个具体的实例:
//演示mp3的复制,自定义一个字节流缓冲区
复制代码
import java.io.*;
class MyBufferedStream
{
    private InputStream in;
    private byte[] buf = new byte[1024];
    private int pos = 0,count = 0;
    MyBufferedStream(InputStream in)
    {
        this.in = in;
    }
    //一次读一个字节,从缓冲区(字节数组)获取
    public int myread() throws IOException
    {
        //通过in对象来读取硬盘上的字节数据,存放在字节数组中。
        if(count==0)
        {
          count  = in.read(buf);
          if(count<0)
              return -1;
          pos=0;
          byte b = buf[pos];
          count--;
          pos++;
          return b&255;//byte字节提升为整型int型             
        } 
        else if(count>0)
        {
          byte b = buf[pos];
          count--;
          pos++;
          return b&0xff;//byte字节提升为整型int型+-++++            
        }
        return -1;
    }
    public void myclose()throws IOException
    {
        in.close();
    }
}
class MyBufferedStreamDemo
{
    public static void main(String[] args)throws IOException
    {
      long start = System.currentTimeMillis();
      copymp3();
      long end = System.currentTimeMillis();
      System.out.println((end-start)+"毫秒");
    }
    public static void copymp3()throws IOException
    {
      MyBufferedStream mys  = new MyBufferedStream(new FileInputStream("F:\\myfile\\b01.mp3"));
      BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("F:\\myfile\\b03.mp3"));
      int num = 0;
      //System.out.println("第一个字节是:"+mys.myread());
      while((mys.myread())!=-1)//要区别开-1是数据读完时的-1,还是读取的字节数据内容为-1,所以要用&操作.
      {
          bufos.write(num);
      }
      mys.myclose();
      bufos.close();        
    }
}
复制代码
提升
byte:-1    ------->    int:-1
11111111               11111111-11111111-11111111-111111111
11111111---->提升了一个int类型,那不还是-1吗?是-1的原因是是因为在8个1前面补的1导致的。
那么,我只要在8个1的前面补充0,即可以保持原字节数不变,又可以避免-1的出现。
  11111111-11111111-11111111-11111111
& 00000000-00000000-00000000-11111111
------------------------------------
  00000000-00000000-00000000-11111111
 
程序猿神奇的手,每时每刻,这双手都在改变着世界的交互方式!
本文转自当天真遇到现实博客园博客,原文链接:http://www.cnblogs.com/XYQ-208910/p/4917818.html如需转载请自行联系原作者

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
将std::string当字节流使
string是C++标准定义的字符串类,它不但支持文本,而且支持二进制字节流。给一个string变量赋值有多种方法: 1) 拷贝构造函数 2) 等号赋值函数 3) append成员函数 4) push_back成员函...
795 0
阿里云服务器端口号设置
阿里云服务器初级使用者可能面临的问题之一. 使用tomcat或者其他服务器软件设置端口号后,比如 一些不是默认的, mysql的 3306, mssql的1433,有时候打不开网页, 原因是没有在ecs安全组去设置这个端口号. 解决: 点击ecs下网络和安全下的安全组 在弹出的安全组中,如果没有就新建安全组,然后点击配置规则 最后如上图点击添加...或快速创建.   have fun!  将编程看作是一门艺术,而不单单是个技术。
3966 0
Core Java - 流(Stream) - 字节流和字符流(一)
0. 概述: Java中基于流的I/O构建在4个抽象类之上, 其中2个是字节流,另外2个是字符流。 字节流: InputStream / OutputStream 当操作字节或其它二进制对象时,应当使用字节流。
747 0
java-IO-字节流与和字符流
字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢? 实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件,如图12-6所示。
933 0
[Java IO]02_字节流
概要 字节流有两个核心抽象类:InputStream 和 OutputStream。所有的字节流类都继承自这两个抽象类。 InputStream 负责输入,OutputStream 负责输出。
741 0
阿里云ECS云服务器初始化设置教程方法
阿里云ECS云服务器初始化是指将云服务器系统恢复到最初状态的过程,阿里云的服务器初始化是通过更换系统盘来实现的,是免费的,阿里云百科网分享服务器初始化教程: 服务器初始化教程方法 本文的服务器初始化是指将ECS云服务器系统恢复到最初状态,服务器中的数据也会被清空,所以初始化之前一定要先备份好。
10744 0
4083
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载