IO流2

最新推荐文章于 2024-01-27 16:24:57 发布

薪火华扬

最新推荐文章于 2024-01-27 16:24:57 发布

阅读量245

点赞数 1

分类专栏：学习 java语言文章标签：数据 io流

本文链接：https://blog.csdn.net/struts_spring_hibern/article/details/53390057

版权

java语言同时被 2 个专栏收录

38 篇文章 0 订阅

订阅专栏

学习

29 篇文章 0 订阅

订阅专栏

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();
			}
		
	}

}

薪火华扬

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流2

IO 流1、流，在我们程序中，所操作数据，以各种格式，从一个地方传输到另一个地方，这个过程就是数据流。2、I，Input，输入。3、O，output ，输出。4、输入，输出，基于程序是输入还是输出。5、程序---文件（常用），程序---网络，程序----内存。6、java jdk 中给我们提供了很多，操
复制链接

扫一扫

专栏目录