Java IO流之字节流

 

(1) IO:在设备和设备之间的一种数据传输!
(2) IO流的分类:
    按流的方向分:
           输入流: 读取文件   (e:\\a.txt):从硬盘上文件读取出来后输出这个文件的内容
           输出流: 写文件:将e:\\a.txt 内容读出来--->写到f盘下
    按数据的类型划分:
           字节流
                  字节输入流:InputStream  :读取字节
                  字节输出流:OutputStream :写字节
           字符流 
                  字符输入流:Reader   :读字符
                  字符输出流:Writer   :写字符

[需求]在当项目下输出一个文件,fos.txt文件(文本文件)

分析:

   只要文本文件,优先采用字符流,字符流在字节流之后出现的
   使用字节流进行操作
          无法创建字节输出流对象:OutputSteam :抽象类,不能实例化
          又学习过File类,并且当前是对文件进行操作,子类:FileOutputSteam进行实例化

 

 

开发步骤:
    1)创建字节输出流对象
    2)写数据
    3)关闭资源

public static void main(String[] args) throws Exception {
		//1)创建一个字节输出流对象
		FileOutputStream fos = new FileOutputStream("fos.txt") ; //FileNotFoundException
		
		//2)写数据
		//使用流对象给文件中写入数据
		fos.write("hello".getBytes());
		
		//3)关闭资源
		fos.close(); 
		/**
		 * 如果关闭流对象了,那么就不能对流对象进行操作了
		 */
		//fos.write("java".getBytes());//java.io.IOException: Stream Closed :流已经关闭了
		
	}

 

注:

   1.创建对象做了几件事情?
      1)构造了输出流对象 (系统创建对象)
      2)指向了当前项目下输出fos.txt

   2.关闭资源做了几件事情?  
      1)将文件和流对象不建立关系了 (fos对象不指向fos.txt)
      2)及时释放掉流对象所占用的内存空间

   3. 如果关闭流对象了,那么就不能对流对象进行操作了!

       否则会报异常:java.io.IOException: Stream Closed :流已经关闭了

(3)关于字节输出流写数据的方法
   public void write(int b):一次写一个字节
   public void write(byte[] b) :一次写一个字节数组
   public void write(byte[] b, int off,int len):一次写一部分字节数组

   首先构造一个字节输出流对象
  FileOutputStream fos = new FileOutputStream("fos2.txt") ;

//public void write(int b):一次写一个字节
	    fos.write(97);//a
	    fos.write(126);//a~

 

   注意:最大到126!

 

//public void write(byte[] b) :一次写一个字节数组
		byte[] bys = {97,98,99,100,101} ;
		fos.write(bys);//abcde

 

 //public void write(byte[] b, int off,int len):一次写一部分字节数组
		byte[] bys = {97,98,99,100,101} ;
		fos.write(bys, 0, 2);//ab

 

(4)[需求]输出文本文件,给文本文件中添加一些数据

 

[问题1]写一些数据,这些数据并没有换行,如何实现换行的效果?
    针对不同的操作系统,里面的换行符合不一样的 
           windows: \r\n
           Linux:\n
           mac:\r 
   一些高级记事本针对任意的换行会有换行的效果

[问题2]如何末尾追加数据呢?
   public FileOutputStream(File file, boolean append):指定为true,末尾追加数据

 

public static void main(String[] args) throws Exception {
		
		//1)创建字节文件输出流对象:FileOutputStream
		//FileOutputStream fos = new FileOutputStream("fos3.txt") ;
		FileOutputStream fos = new FileOutputStream("fos3.txt",true) ;
		
		//2)写数据
		for(int x = 0 ; x < 10 ; x ++) {
			fos.write(("hello"+x).getBytes());
			//写入换行符号
			fos.write(("\r\n").getBytes());  
		}
		
		//3)释放资源
		fos.close(); 
	}

 

运行结果:

hello0
hello1
hello2
hello3
hello4
hello5
hello6
hello7
hello8
hello9
(5)IO流中加入异常处理(try...catch...)

   方式1) 分别进行异常处理(非常麻烦)

   方式2) 一起处理 (针对整个资源没有释放,不好)

   方式3) 经常这样使用:try...catch...finally...[模板代码]

FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("fos3.txt");
			fos.write("hello".getBytes());
		} catch (IOException e) {
			e.printStackTrace();
			// 释放资源
			// 对象对象进行非空判断 
		} finally {
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}

		}

 

(6)[需求]去读取当前项目下的fis.txt这个文件内容,将文件的内容输出在控制台上

   InputStream抽象类:字节输入流
   FileInputStream
         构造方法:  public FileInputStream(String name)

开发步骤:
    1)创建字节文件输入流对象
    2)读数据
    3)释放资源

读数据方式:
    public abstract int read():一次读取一个字节
    public int read(byte[] b):一次读取一个字节数组 (读取实际的字节数)

        @Test
	public void demo() throws Exception{
		
		//创建一个字节文件输入流对象
		//方式1:一次读取一个字节
		FileInputStream fis  = new FileInputStream("fis.txt") ;

		//最终版代码:将 赋值,判断写在一块
		int by = 0 ;
		while((by=fis.read())!=-1) {
			System.out.print((char)by);
		}
		
		//释放资源
		fis.close();

	}

public static void main(String[] args) throws Exception {
		
		//创建一个字节文件输入流对象
		//方式2:一次读取一个字节数组
		FileInputStream fis = new FileInputStream("fis2.txt") ;
				
		//最终版代码
		//指定字节数组的长度是:1024或者1024的倍数
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=fis.read(bys))!=-1) { //判断,赋值,循环
			System.out.println(new String(bys, 0, len)); //带上len的用法
		}		
		
	}

 

(7)复制文本文件

[需求1]将当前项目下的a.txt文件的内容读取出来,复制到b.txt文件中

 分析:

    源文件: a.txt  --->  读取文件的内容---->FileInputStream
    目的地文件: b.txt----> 输出文件   --->FileOutputStream

public static void main(String[] args) throws Exception {
		
		//封装目的地文件和源文件
		FileInputStream fis = new FileInputStream("fis.txt") ;
		FileOutputStream fos = new FileOutputStream("b.txt") ;
		
		//进行读写操作
		//一次读取一个字节
		int by = 0 ;
		while((by=fis.read())!=-1) {
			//第一个字节,写个一个字节
			fos.write(by);
		}
		
		//释放资源
		fis.close(); 
		fos.close();
	}

 

[需求2]将当前项目下的高圆圆.jpg读取出来,复制到mm.jpg中

public static void main(String[] args) throws Exception {
		
		//封装源文件和目的地文件
		FileInputStream fis = new FileInputStream("高圆圆.jpg")	 ;
		FileOutputStream fos = new FileOutputStream("mm.jpg") ;
		
		//读写操作
		//一次读取字节数组
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=fis.read(bys))!=-1) {
			//写数据
			fos.write(bys, 0, len);
		}
		
		//释放资源
		fis.close(); 
		fos.close();
		
	}

总结

1.字节输出流的开发步骤

1)创建一个字节输出流对象:OutputStream out = new FileOutputStream(“out.txt”) ;
2)使用流对象给当前文件中写数据
  两种方式:
      写一个字节: write(int b)
      写一个数组: wirte(byte[] bys)
3)释放资源: 关闭流对象

字节输入流的开发步骤

1)创建字节输入流对象:FileInputStream in  = new FileInputStream(“in.txt”) ;
2)读数据
   两种方式:
    (1)一次读一个字节
    int by = 0 ;
    while((by=in.read())!=-1){
          System.out.println((char)by) ;
    }
    (2)一次读取一个字节数组(比第一种方式速度快)public int read(byte[] bys);
    byte[]  bys = new byte[1024] ;
    int len = 0 ;
    while((len=in.read(bys))!=-1){
          System.out.println(new String(bys,0,len)) ;
    }
 
3)释放资源: 关闭流对象

读数据的两种方式(代码一定会写)!

2.读写操作(复制操作(文本文件,音频文件,图片文件…))

复制情况:
		
1)分析源文件	  在哪个盘符下/当前项目下  --使用字节输入流读该文件中的文件
2)分析目的地文件   在哪个盘符下/当前项目下  --使用字节输出流输出这个文件
3)一次读取一个字节(边读边写这个字节)/一次读取一个字节数组(输出流对象.write(bys,0,len);)

3.File file = new File("a.txt");     a.txt这个文件不一定存在！

只是用file对象封装这个文件，一种抽象路径表示形式！

4.如何确定一个文件是使用字节流还是字符流？

打开读不懂，使用字节流；打开读的懂，使用字符流.