IO流2

原创 于 2016-11-29 10:53:49 发布 · 301 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据 #io流

本文深入讲解Java中的IO流概念及其实现方式，包括字节流、字符流、节点流、处理流等，并通过实例演示了文件读写、复制等常见操作。
IO 流


1、流，在我们程序中，所操作数据，以各种格式，从一个地方传输到另一个地方，这个过程就是
  数据流。


2、I，Input，输入。


3、O，output  ，输出。


4、输入，输出，基于 程序  是输入还是输出。


5、程序---文件（常用）， 程序---网络 ，  程序----内存。


6、java jdk 中给我们提供了很多，操作各种流的类型。


7、基于数据的本身，格式，分为：


  a、字节流 （InputStream，OutputStream）


  b、字符流  (Reader ,Writer)


8、基于流向：


  a、输入流 (InputStream,Reader)


  b、输出流 (OutputStream ,Writer)


9、流操作方式：


  a、节点流（原始流）


  b、处理流(封装流)




10、File ，文件流， 可以代表文件对象，也可以代表文件夹。


   可以创建文件，也可以创建文件夹。


   判断是不是文件，是不是文件夹，是不是隐藏文件。


   可以拿到某个文件夹中的所有文件名，和文件对象。


11、基于字节流，输入流，对指定一个文件进行读取，


   FileInputStream(new File("d://test.txt"))


   FileInputStream("d://test.txt")


   一个字节一个字节的度，read() ,返回一个 int 的字节数据。


   一次性把所有的字节读到一个byte 数组中， read（bs）,byte bs[] = new byte[in.avilable()];
   


12、文件copy


   一边读取，另一边输出。


   FileOutputStream(new File（“.....”），true);


   FileOutputStream("....."，true);


   第二个参数，代表不覆盖原来有的这个文件中数据，而是在文件上追加数据。




   writer（int）； 一次写一个字节。


   writer (byte[]);  一次写一组字节。


   flush();


   colse();  finally 中关闭。 






13、如果你是按照字节流来处理文件，是一个字节一个字节的读取，


   这种情况下，如果有中文，中文会分为两个字节读取，那么在类型转换的时候，就会乱码。


   如果要避免这个情况，我们就得使用字符流读取。


14、使用字符流，输入流，原始流，读取一个指定的文件


15、把Demo.java  这个文件 从D盘中，copy 到test 文件夹中，字符流，原始流。




16、 缓冲字节流，输入和输出，处理流


   BufferedInputStream  BufferedOutputStream  


17、缓冲字符串，输入和输出，处理流


   BufferedReader   BufferedWriter


要求： 针对这几个类型，api 文档看看。




18、BufferedReader 中的两个方法。这两个方法在BufferedInputStream 中也有。


    mark   reset


19、处理流，转换流


    InputStreamReader(in);


    OutputStreamWriter(out);


20、数据流（数据类型流），在读取数据的时候或者输出数据的时候，是按照java 中的数据类型


    而定义的（按照本身数据类型所占字节大小）。


    DataInputStream    DataOutputStream


    利用数据流对内存进行一次操作。


    字节数组流（ByteArrayInputStream，ByteArrayOutputStream）


    数据流读取的时候，（要按照数据类型和读取的顺序）
   


   






   
package com.salmon.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class Demo {

	/**
	 * 使用字符流，输入流，原始流，读取一个指定的文件
	 */
	public static void test1() {
		File file = new File("d://test/test2/test1.txt");
		Reader r = null;
		try {
			r = new FileReader(file);
			// 一个字符，两个字节
			int i = 0;
			while ((i = r.read()) != -1) {
				System.out.print((char) i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				r.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void test2() {
		Reader r = null;
		try {
			//r = new FileReader("d://test/test2/test1.txt");
			r = new  FileReader("d://Demo.java");
			char  cs[] = new  char[1000];
			r.read(cs);
			for (int i = 0; i < cs.length; i++) {
				System.out.print(cs[i]);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e){
			e.printStackTrace();
		} finally{
			try {
				r.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	/**
	 * 字符流  输出流  原始流
	 * @param args
	 */
    public  static  void   test3(){
    	File  file  = new  File("d://demo.java");
    	Writer  out = null;
    	try {
			out = new  FileWriter(file);
			String  msg = "public  class HelloWorld{"
					+ " public static  void  main(String args[]){"
					+ "}"
					+ "}";
			// 
			out.write(msg);
			//
			out.flush();
			
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			try {
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
    	
    }
    /**
     * 使用字符流来对文件进行copy
     * @param args
     * 
     */
    public  static  void  copy(){
    	File  file = new  File("D://Demo.java");
    	File  newFile = new File("D://test/Demo.java");
    	Reader  r = null;
    	Writer  w = null;
    	try {
			r = new  FileReader(file);
			w = new  FileWriter(newFile);
			//
			int i = 0;
			while((i = r.read()) != -1){
				w.write(i);
			}
			w.flush();
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			try {
				w.close();
				r.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
    }
	public static void main(String[] args) {
		//test2();
		copy();
	}

}


package com.salmon.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;

public class Demo2 {

	/**
	 * 字节 缓冲 输入 封装
	 */
	public static void test1() {
		InputStream in = null;
		BufferedInputStream bis = null;
		try {
			File file = new File("d://Demo.java");
			in = new FileInputStream(file);
			bis = new BufferedInputStream(in);
			// 仅仅提供了缓冲区 提高了读取效率
			byte  bs [] = new  byte[bis.available()];
			bis.read(bs);
			// 
			for (int i = 0; i < bs.length; i++) {
				System.out.print((char)bs[i]);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e){
			e.printStackTrace();
		} finally{
			try {
				in.close();
				bis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	/**
	 * 字节流 缓冲  输出流   处理流
	 * @param args
	 */
	public   static  void  test2(){
		BufferedOutputStream bos = null;
		try {
		    bos = new  BufferedOutputStream(
					new  FileOutputStream(
							new File("d://test88.txt")));
			String  msg = "hello";
			bos.write(msg.getBytes());
			bos.flush();
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e){
			e.printStackTrace();
		} finally{
			try {
				bos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
    /**
     * 字符  缓冲 输入流  处理流
     * @param args
     */
	public  static  void   test3(){
		BufferedReader  br = null;
		try {
			  br = new  BufferedReader(
					new  FileReader(
							new  File("d://Demo.java")));
			  // 不光 提供了 缓冲区 还提供了 比较方便的方法
			  String  msg = null;
			  while((msg = br.readLine()) != null){
				  System.out.println(msg);
			  }
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e){
			e.printStackTrace();
		} finally{
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	/**
	 * 字符流  输出流  缓冲  处理流
	 * @param args
	 * @throws IOException 
	 */
	public  static  void  test4() throws IOException{
		  File  file = new File("d://test99.txt");
		  Writer  out = new  FileWriter(file);
		  BufferedWriter  bw = new BufferedWriter(out);
		  String msg = "hello world! 你好";
		  bw.write(msg);
		  bw.newLine();//  换行
		  bw.write("public class Hello{}");
		  bw.flush();
		  bw.close();
		  
	}
	/**
     * 字符  缓冲 输入流  处理流
     * @param args
     */
	public  static  void   test5(){
		BufferedReader  br = null;
		try {
			  br = new  BufferedReader(
					new  FileReader(
							new  File("d://Demo.java")));
			  //  设置一个 标记
			  br.mark(100);
			  //  先读取一行
			String  msg =   br.readLine();
			System.out.println(msg);
			String  msg2 =   br.readLine();
			System.out.println(msg2);
			String  msg3 =   br.readLine();
			System.out.println(msg3);
			// 回到那个标记点 再开始读取
			br.reset();
			// 不光 提供了 缓冲区 还提供了 比较方便的方法
			  String  msg4 = null;
			  while((msg4 = br.readLine()) != null){
				  System.out.println(msg4);
			  }
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e){
			e.printStackTrace();
		} finally{
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		/*try {
			test4();
		} catch (IOException e) {
			e.printStackTrace();
		}*/
		test5();
	}

}


package com.salmon.test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

public class Demo3 {
	
	/**
	 * 转换流  处理流 输入流
	 */
	public  void  test(){
		try {
			// 使用字节流  读取文件
			File  file = new File("d://Demo.java");
			InputStream in = new FileInputStream(file);
			// 把字节流  转换成 字符流
			Reader   isr = new  InputStreamReader(in);
			// 把字符流 封装成 缓冲流
			BufferedReader  br = new  BufferedReader(isr);
			String  msg = "";
			while((msg=br.readLine()) != null){
				System.out.println(msg);
			}
			//  关闭资源  就近原则
			br.close();
			isr.close();
			in.close();
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		  File  file  = new File("D://Demo22.java");
		  try {
			OutputStream out = new FileOutputStream(file);
			// 输出转换
			Writer  w = new  OutputStreamWriter(out);
			// 
			BufferedWriter  bw  = new  BufferedWriter(w);
			// 
			String  msg = "hello world 你好";
			//
			bw.write(msg);
			//
			bw.newLine();
			//
			bw.write("dajiahao");
			//
			bw.flush();
			//
			bw.close();
			w.close();
			out.close();
			
		  } catch (Exception e) {
			e.printStackTrace();
		 }
		
	}

}


package com.salmon.test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Demo4 {
	
	public  void   test(){
	//  在内存中 定义一个  能够存储数据的结构   (在内存中 新建了一个字节类型数组)
			ByteArrayOutputStream   baos  = new   ByteArrayOutputStream();
			//  封装流  数据类型 来操作
			DataOutputStream   out = new  DataOutputStream(baos);
			
			try {
				//  根据类型  和 顺序
				out.writeInt(25);
				out.writeBoolean(false);
				out.writeUTF("hello");//  按照指定编码格式 把这个字符串写入到 内存中
				//  输入流
				ByteArrayInputStream  bais = new  ByteArrayInputStream(baos.toByteArray());
				//
				DataInputStream  in = new  DataInputStream(bais);
				// 根据类型  和 顺序
				System.out.println(in.readInt());
				System.out.println(in.readBoolean());
				System.out.println(in.readUTF());
				//
				in.close();
				bais.close();
				out.close();
				baos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
	}

	public static void main(String[] args) {
		     try {
				OutputStream   w = new  FileOutputStream(
						 new  File("d://test77.txt"));
				DataOutputStream  dos = new  DataOutputStream(w);
				dos.writeInt(34);
				dos.writeDouble(34.5);
				dos.writeBoolean(true);
				dos.flush();
				dos.close();
				w.close();
				//
				InputStream  in = new FileInputStream("d://test77.txt");
				DataInputStream  dis = new  DataInputStream(in);
				System.out.println(dis.readInt());
				System.out.println(dis.readDouble());
				System.out.println(dis.readBoolean());
				dis.close();
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		
	}

}

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值