黑马程序员_毕向东_Java基础_DAY19_字节流、转换流、小知识点

----------- android培训、java培训、期待与您交流！ ------------

字节流：

基础概念：

字节流的两个抽象基类：

OutputStream

InputSteam

 

OutputStream类：

java.lang.Object

 java.io.OutputStream

 

构造器：

OutputStream()

 

方法：

 voidclose()

         关闭此输出流并释放与此流有关的所有系统资源。

 voidflush()

          刷新此输出流并强制写出所有缓冲的输出字节。

 voidwrite(byte[] b)

         将 b.length 个字节从指定的 byte 数组写入此输出流。

 voidwrite(byte[] b, int off, int len)

         将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

abstract void write(int b)

         将指定的字节写入此输出流。

 

注意：

字节流只能操作int、字节数组，不能操作char[]和String。

 

子类：

FileOutputStream

直接对字节流进行操作，不需要flush，每获取一个字节，就存入到目标当中。

FileOutputStream output = newFileOutputStream("demo.txt");

output.write("abcde".getBytes());//使用getBytes方法将字符串转换为字节数组

 

FileInputStream

具有一个特有方法：

available()，可以返回文件的字节数。

FileInputStream fis = newFileInputStream("源文件.txt");

byte buf = new byte[fis.available()];

 

使用字节流复制图片文件：

import java.io.*;

class  CopyPicture
{
	public static void main(String[] args) 
	{
		BufferedInputStream fis = null;
		BufferedOutputStream fos = null;
		try
		{
			fis = new BufferedInputStream(new FileInputStream("error.jpg"));
			fos = new BufferedOutputStream(new FileOutputStream("error_buffcopy.jpg"));
			int b = 0;
			while((b = fis.read()) != -1){
				fos.write(b);
			}
		}
		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("文件字节输出流关闭错误");
			}
		}
	}
}

 

字节流的缓冲区：

字节流的缓冲区使用的是：

BufferedInputStream / BufferedOutputStream

在使用上与字符流的缓冲区类似。

使用自定义类模拟字节缓冲流：

import java.io.*;
 
class MyBufferedInputStream extendsInputStream{
       privateInputStream is;
       privateint pos = 0;
       privateint count = 0;
       privatebyte[] buff = new byte[1024 * 1024];
 
       publicMyBufferedInputStream(InputStream is){
              this.is= is;
       }
 
       publicint read() throws IOException{
              if(count== 0){           
                     count= is.read(buff);
                     if(count< 0)
                            return-1;
                     pos= 0;
                     count--;
                     returnbuff[pos++] & 255;
              }
              elseif(count > 0){
                     count--;
                     returnbuff[pos++] & 255;
              }
              return-1;
       }
 
       //测试MyBufferedInputStream，拷贝MP3
       publicstatic void main(String[] args){
              MyBufferedInputStreammyin = null;
              BufferedOutputStreambos = null;
              try{
                     myin= new MyBufferedInputStream(new FileInputStream("加州旅馆---老鹰乐队.mp3"));
                     bos= new BufferedOutputStream(new FileOutputStream("加州旅馆---老鹰乐队_copy.mp3"));
                     intby = 0;
                     while((by= myin.read()) != -1){
                            bos.write(by);
                     }
              }
              catch(IOException e){
                     thrownew RuntimeException("mp3文件复制错误");
              }
              finally{
                     if(myin!= null){
                            try{
                                   myin.close();
                            }
                            catch(IOException e){
                                   thrownew RuntimeException("读入流关闭错误");
                            }
                     }
                     if(bos!= null){
                            try{
                                   bos.close();
                            }
                            catch(IOException e){
                                   thrownew RuntimeException("输出流关闭错误");
                            }
                     }
              }
       }
}

 

转换流：

自定义类读取键盘录入：

使用System.in来获取与键盘录入关联的InputStream对象。

通过调用此对象的read方法可以获取从键盘录入的第一个字符。

如果想要一次读取一行，可以自定义一个与BufferedReader类的readLine方法类似的方法。

使用StringBuilder作为临时缓冲，然后利用while(true)来循环读取，读到普通字符时append进缓冲区，当读到\r\n时，判断是否录入的是结束符，如果是，退出循环，如果不是打印缓冲区中的数据，并清空缓冲区。

 

利用转换流来读取键盘录入：

事实上读一行的方法已经存在于BufferedReader方法中了。

因此我们可以简单的使用BufferedReader中的readLine方法即可。

但是，BufferedReader读取的是字符流，但是System.in却是一个字节流。这时就需要利用转换流InputStreamReader来将字节流转换为字符流。

InputStreamReader isr = newInputStreamReader(System.in);
BufferedReader br = newBufferedReader(isr);
while(true){
       Strings = br.readLine();
       if("over".equals(s))
              break;
       System.out.println(s);
}

 

练习：

//将控制台输入的字符串存储到文件中，并改变编码形式
 
import java.io.*;
 
class IOChange
{
       publicstatic void main(String[] args)
       {
              BufferedReaderbr = null;
              BufferedWriterbw = null;
              try
              {
                     br= new BufferedReader(new InputStreamReader(System.in));
                     bw= new BufferedWriter(new OutputStreamWriter(newFileOutputStream("iochange.txt"), "UTF-8"));
                     while(true){
                            Strings = br.readLine();
                            if("over".equals(s))
                                   break;
                            bw.write(s);
                            bw.newLine();
                            bw.flush();
                     }
              }
              catch(IOException e)
              {
                     thrownew RuntimeException("信息录入错误");
              }
              finally{
                     if(br!= null){
                            try
                            {
                                   br.close();
                            }
                            catch(IOException e)
                            {
                                   thrownew RuntimeException("输入流关闭错误");
                            }
                     }
                     if(bw!= null){
                            try
                            {
                                   bw.close();
                            }
                            catch(IOException e)
                            {
                                   thrownew RuntimeException("输出流关闭错误");
                            }
                     }
              }
       }
}

 

流操作的基本规律：

流对象有很多，不知道该用哪一个时怎么办？

 

通过三个明确来完成：

1.明确源和目的

       源：输入流--InputStream / Reader

       目的：输出流 -- OutputStream / Writer

2.操作的数据是否是纯文本。

       纯文本：字符流

       非文本：字节流

 

3.当体系明确后，再明确要使用哪个具体的对象。

   通过设备来区分：

       源设备：内存、硬盘、键盘

       目的设备：内存、硬盘、控制台

 

转换流什么时候使用：

1.     字符和字节之间的桥梁。

2.     涉及到字符编码转换时需要用到转换流。

 

小知识点：

改变标准输入输出设备：

使用System类中的static方法：

static void setIn(InputStream in)

static void setOut(PrintStreamout)

 

异常日志信息：

import java.io.*; 
import java.util.*; 
import java.text.*; 
class ExceptionInfo 
{ 
    public static void main(String[] args) 
    { 
         try 
         { 
               int[] arr = new int[2]; 
               System.out.println(arr[3]); 
         } 
         catch (Exception e) 
         { 
               try 
               { 
                    Date d = new Date(); 
                    SimpleDateFormat sdf = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
                    String s =sdf.format(d); 
                    PrintStream ps = newPrintStream("exception.log"); 
                    ps.println(s); 
                    System.setOut(ps);                    
               } 
               catch (IOException ie) 
               { 
                    throw newRuntimeException("创建日志文件失败"); 
               } 
              e.printStackTrace(System.out); 
         } 
    } 
} 

保留异常日志信息是以后开发中可能经常需要做的事儿，对此可以使用 网上提供的用于java异常信息存储的包--- log4j。