Java的IO流

原文地址：http://blog.csdn.net/lihuapiao/article/details/50731405

一.IO

1.IO概念

·输入流：把能够读取一个字节序列的对象称为输入流（百度百科）

·输出流：把能够写一个字节序列的对象称为输出流（百度百科）

从定义上看可能会让你感到困惑，这里解释一下：输入输出是相对于内存设备而言的，将外设（硬盘，键盘等）中的数据读取到内存设备中叫输入；将内存设备中的数据写入到外设中叫输出，所以有读入，写出的称呼：读入到内存，写出内存。

可以这样比喻：输入流和输出流中间连接着内存，输入流和输出流将读写分离开来进行操作,先从外设读入内存，然后再写出内存转移到其他外设。

·总体结构图（摘自网友）

2.字节流      （用字节流处理字符数据可能会有编码问题，因为字节流是以字节为单位，没有编码，而字符流是以字符为单位传送数据，字符流即以字节流+编码）

·两个顶层父类 （抽象类）及实现类

·InputStream（读入内存）  ：所有字节输入流相关类的父类

··FileInputStream ：obtain input bytes from a file in a file system,for reading streams of raw bytes(原始字节) such as image data..For
writing streams of characters,consider using FileReader

初始化时（构造函数）要和文件关联，读取的对象，要首先判断文件是否存在

——read():read a byte of data from this inputStream.

——read(byte [] b):read up to b.length bytes of data from this inputStream into an array of bytes.

——read(byte [] b,int off,int length)

——close()

[java] view plain copy

  1. import java.io.*;
  2. /**
  3. * Created by 111 on 2016/1/29.
  4. */
  5. public class Demo1 {
  6. public static void main(String [] args){
  7. File file = new File("d:/helloWorld.txt");
  8. InputStream in = null;
  9. try {
  10. if (!file.exists()){                              //文件不存在则创建
  11. file.createNewFile();
  12. }
  13. in = new FileInputStream(file);
  14. byte [] buf = new byte[1024];                 //先写到缓存中，然后再一起写到其他外设中
  15. int length = 0;
  16. while ((length=in.read(buf))!=-1){                //-1 represent the end of the file is reached    ，
  17. //字节一个一个地读入到内存
  18. System.out.println(new String(buf,0,length)); //需要将int转为字节，如果为中文的话输出乱码字符  ，
  19. //此处其实是写出到了外设（控制台）上，System.out返回的是PrintStream对象
  20. }
  21. } catch (IOException e) {
  22. e.printStackTrace();
  23. }finally {
  24. if (in != null){
  25. try {
  26. in.close();
  27. } catch (IOException e) {
  28. e.printStackTrace();
  29. }
  30. }
  31. }
  32. }

··ByteArrayInputStream:包含一个内置的缓冲器存储字节

构造函数要和字节数组相关联:byte [] buff

——read():从输入流中读取下一个字节

——read(byte [] buff,int off,int len):

——close():关闭后并没有影响，类中的方法仍然可以调用而不抛出IO异常

·OutputStream(写出内存)：所有和输出字节流相关类的父类

··FileOutputStream：for writing data to a file or a FileDescriptor,for
writing streams of raw data(原始字节)such as image data.For writing streams
of characters,consider using FileWriter.

初始化时要和文件关联，写出的目的地。没有该文件时会自动创建。

——write(int b):write the specified(指定的) byte to this file output stream.

——write(byte [] b):

——write(byte [] b,int off,int len)

——close()

[java] view plain copy

  1. import java.io.*;
  2. /**
  3. * Created by 111 on 2016/2/25.
  4. */
  5. public class Demo2 {
  6. public static void main(String [] args){
  7. File file = new File("d:/helloWorld3.txt");   //没有<span style="font-family:KaiTi_GB2312;">会自动创建</span>
  8. OutputStream out = null;
  9. try {
  10. out = new FileOutputStream(file);
  11. out.write(69);                    //文件中产生ASC码对应的字符
  12. } catch (IOException e) {
  13. e.printStackTrace();
  14. } finally {
  15. try {
  16. out.close();
  17. } catch (IOException e) {
  18. e.printStackTrace();
  19. }
  20. }
  21. }
  22. }

★ FileInputStream  & FileOutputStream   协同完成文件复制(不会乱码)

[java] view plain copy

  1. import java.io.*;
  2. /**
  3. * Created by 111 on 2016/2/25.
  4. */
  5. public class Demo3 {
  6. /**
  7. * 从一个文件复制到另一个文件
  8. * @param args
  9. */
  10. public static void main(String [] args){
  11. File origin = new File("d:/helloWorld.txt");//原始文件
  12. if (!origin.exists()){
  13. try {
  14. origin.createNewFile();
  15. } catch (IOException e) {
  16. e.printStackTrace();
  17. }
  18. }
  19. File destination = new File("d:/helloWorld4.txt");//目的文件
  20. InputStream in = null;
  21. OutputStream out = null;
  22. try {
  23. in = new FileInputStream(origin);
  24. out = new FileOutputStream(destination);
  25. byte [] buff = new byte[1024];
  26. int len = 0;
  27. while ((len=in.read(buff))!=-1){
  28. out.write(buff,0,len);
  29. }
  30. } catch (IOException e) {
  31. e.printStackTrace();
  32. } finally {
  33. try {
  34. if (in != null){
  35. in.close();
  36. }
  37. if (out != null){
  38. out.close();
  39. }
  40. } catch (IOException e) {
  41. e.printStackTrace();
  42. }
  43. }
  44. }
  45. }

3.字符流

·两个顶层父抽象类及其实现类

·Reader：for reading character streams

··InputStreamReader:从字节流到字符流的桥梁：读取字节流然后按指定的编码方式进行解码（看不懂→能看懂）

构造函数要和输入流InputStream/编码方式Charset相关联:System.in/FileInputStream传入

——read()    :读入一个字符

——read(char [] cbuf,int offset,int length)

——close()

···FileReader:读字符文件的方便类，本质是InputStreamReader在构造时 指定了默认的编码方式，用于读取字符流

构造函数要和文件相关联

★InputStreamReader 接收键盘上输入的数据，写入文件中（中文会乱码）

[java] view plain copy

  1. import java.io.*;
  2. /**
  3. * Created by 111 on 2016/2/25.
  4. */
  5. public class Demo4 {
  6. /**
  7. * 控制台输入，写到文件夹中
  8. * @param args
  9. */
  10. public static void main(String [] args){
  11. File file = new File("d:/helloWorld.txt");//会覆盖之前的数据
  12. OutputStream out = null;
  13. InputStreamReader reader = null;
  14. try {
  15. reader = new InputStreamReader(System.in);
  16. out = new FileOutputStream(file);
  17. int len = 0;
  18. while ((len = reader.read())!= -1){
  19. out.write(len);
  20. }
  21. } catch (IOException e) {
  22. e.printStackTrace();
  23. } finally {
  24. if (out!=null){
  25. try {
  26. out.close();
  27. } catch (IOException e) {
  28. e.printStackTrace();
  29. }
  30. }
  31. if (reader!=null){
  32. try {
  33. reader.close();
  34. } catch (IOException e) {
  35. e.printStackTrace();
  36. }
  37. }
  38. }
  39. }
  40. }

··BufferedReader：从一个字符输入（character-input）流中读取文本（text），并进行缓冲字符,默认缓存8192（8M），行最长80

构造函数要和Reader in/int size 关联：InputStreamReader

——in read（）

——in read(char [] cbuf,int off,int len)

——String readLine()

——close()

★键盘录入，使用缓存

[java] view plain copy

  1. BufferedReader buffr = new BufferedReader(new InputStreamReader(System.in))

·Writer:for writing to character streams （字符流的写操作基本上后面都需要进行flush()操作）

··OutputStreamWriter :从字符流到字节流的桥梁：写出的字符被用指定的编码方式进行编码。

构造函数要和OutputStream out/charset 关联：System.out/FileOutputStream

——write(int c):写一个单独的字符

——write(char [] cbuf,int off,int len)

——write(String str,int off,int len)

——flush():刷新流

——close()

···FileWriter:写字符文件的方便类，实质是：OutputStreamWriter指定了默认的本机编码方式，且可以处理文件

··BufferedWriter:写文本到一个字符输出（character-out）流，并对传入的字符进行缓存

构造函数要和 Writer out/int size 相关联

——write(int c):写一个单独的字符

——write(char [] cbuf,int off,int len)

——write(String str,int off,int len)

——newLine():换行

——flush():刷新流

——close()

★控制台输出，使用缓存

[java] view plain copy

  1. BufferedWriter buffw= new BufferedWriter(new OutputStreamWriter(System.out,"utf-8"));

★键盘输入，控制台输出功能

[java] view plain copy

  1. import java.io.*;
  2. /**
  3. * Created by 111 on 2016/2/26.
  4. */
  5. public class Demo5 {
  6. /**
  7. * 键盘输入，控制台输出
  8. * @param args
  9. */
  10. public static void main(String[]args){
  11. BufferedReader buff = null;
  12. BufferedWriter bufferedWriter = null;
  13. String line = null;
  14. try {
  15. buff = new BufferedReader(new InputStreamReader(System.in,"utf-8"));
  16. bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out,"utf-8"));
  17. <span style="font-family:SimSun;">while</span> ((line=buff.readLine())!=null){
  18. bufferedWriter.write(line);
  19. <span style="font-family:KaiTi_GB2312;">            <span style="font-family:SimSun;"> }</span></span>
  20. bufferedWriter.flush();         //一定要刷新
  21. } catch (IOException e) {
  22. e.printStackTrace();
  23. } finally {
  24. if (buff!=null){
  25. try {
  26. buff.close();
  27. } catch (IOException e) {
  28. e.printStackTrace();
  29. }
  30. }
  31. if (out!=null){
  32. try {
  33. out.close();
  34. } catch (IOException e) {
  35. e.printStackTrace();
  36. }
  37. }
  38. }
  39. }
  40. }

☆面试题：简述一下将文件中的数据输入到另一个文件中的步骤

1.首先创建File对象，并且和需要操作的文件相关联，这时候需要对文件进行判断是否存在，不存在则会报错

2.既然是读取文件并且写到文件，属于纯文本，可以选择FileReader和FileWriter进行读写操作,如果出现乱码可以使用其父类指定编码方式

3.创建FileReader对象用于读取文件中的数据，这里可以使用缓冲流进行处理，提高效率，创建一个BufferedReader对象

BufferedReader buffr = new BufferedReader(new InputStreamReader(new FileReader(file)));

4.创建FileWriter，同上使用缓存

★代码如下

[java] view plain copy

  1. import java.io.*;
  2. /**
  3. * Created by 111 on 2016/2/26.
  4. */
  5. public class Demo6 {
  6. public static void main(String[] args){
  7. File origin = new File("d:/helloWorld.txt");
  8. File destination = new File("d:/helloWorld6.txt");
  9. InputStreamReader in = null;
  10. OutputStreamWriter out = null;
  11. BufferedReader reader = null;
  12. BufferedWriter writer = null;
  13. if (!origin.exists()){
  14. try {
  15. origin.createNewFile();
  16. } catch (IOException e) {
  17. e.printStackTrace();
  18. }
  19. }
  20. try {
  21. reader = new BufferedReader(new InputStreamReader(new FileInputStream(origin),"ISO-8859-1"));
  22. //            reader = new BufferedReader(new FileReader(origin));
  23. writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(destination),"ISO-8859-1"));
  24. String line = null;
  25. while ((line = reader.readLine())!=null){
  26. writer.write(line);
  27. writer.newLine();
  28. }
  29. writer.flush();
  30. } catch (IOException e) {
  31. e.printStackTrace();
  32. } finally {
  33. if (in!=null){
  34. try {
  35. in.close();
  36. } catch (IOException e) {
  37. e.printStackTrace();
  38. }
  39. }
  40. if (out!=null){
  41. try {
  42. out.close();
  43. } catch (IOException e) {
  44. e.printStackTrace();
  45. }
  46. }
  47. if (reader!= null){
  48. try {
  49. reader.close();
  50. } catch (IOException e) {
  51. e.printStackTrace();
  52. }
  53. }
  54. if (writer!=null){
  55. try {
  56. writer.close();
  57. } catch (IOException e) {
  58. e.printStackTrace();
  59. }
  60. }
  61. }
  62. }
  63. }
时间： 2024-10-26 19:32:14

Java的IO流的相关文章

java常用IO流数据流小结

  类名 常用方法 说明 输入流 InputStream int read(); 只能读字节流,虽然返回值是int,但只有低8位起作用. DataInputStream Type readType(); 可以读二进制流,可以读byte,short,int,long,double等二进制流. BufferedReader String readLine(); 可以读文本行. 输出流 OutputStream void write(int); 只能写字节流,虽然形参是int,但只有低8为起作用. D

【Java】IO流简单分辨

转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/5827509.html Java的IO流体系十分庞大,并且体系层次稍复杂,很容易记混或记错.在此,我把平时经常用到的几个流类的简易区分以及体系层次整理出来,方便记忆与辨析.本人对IO了解尚浅,文章如有错漏,恳请前辈指正,感激不尽! 字节流体系: 基类:InputStream/outputStream(抽象类,不能new) 子类: 文件IO字节流:FileInputStream/FileoutputStream

JAVA中IO流总结

本文是在学习中的总结,欢迎转载但请注明出处:http://write.blog.csdn.net/postedit/42119261 我想你对JAVA的IO流有所了解,平时使用的也比较的多,但是对于其具体分类和继承体系可能知道的并不多,可能也很少去看相关的API文档,找出其中的关系和各自的应用情形.本文简单对常用的IO流进行分类整理,并简单举例说明其应用.希望本文对你有所帮助. (A)IO流大致分为两种: (1)字节流:对应抽象类为InputStream(输入流)和 OutputStream(输

【JAVA的 IO流之FileInputStream和FileOutputStream】

java的 IO流即输入输出流,流是一组有顺序的,有起点和终点的字节结合,是对数据传输的总称.即数据在两设备间的传输称为流,流的本质是数据传输. IO流可以分为字节流和字符流.给出相应的IO结构图: 在接下来的一段时间里,将会慢慢介绍各种流的使用,本篇博客先介绍字节流的FileOutputStream和相对应的FileInputStream. 一.FileOutputStream(文件输出流) OutputStream是一个抽象类,抽象类必须通过子类实现.现在要向文件里输出就要用FileOutp

java的IO流，字节流和字符流

java操作文件都是通过流来处理的,(其实其他很多语言也是这样) 第一:java的IO流,分为:输入流 和 输出流(这真是废话,这是从流向的角度来说的) 第二:java的所有IO流,只分为:字节流 和 字符流(其实就是传输的颗粒,传输的基本单位) 总结:凡是处理纯文本的优先考虑字符流:其他的才考虑使用字节流

Java之IO流---字节流

1.1 IO流的引入 IO流在很多语言已有体现,诸如C语言的stdio.h,C++中的iostream.Java中的IO流大抵是用于在控制台.磁盘.内存上进行数据的读写操作,完成数据的传递. 我们可以对它进行如下分类: 按处理的数据类型可分为字节流与字符流 按流的流向可分为输入流(in)与输出流(out) 按流的功能可分为节点流(Node)和过滤流(Filter) 本篇侧重于梳理字节流相关的知识,毕竟作为字符流的前辈,它还是非常重要的.下篇继续梳理字符流. 1.2 IO流的继承体系图 大概描述了

Java笔记-IO流的运用

1.InputStream和System.in(Scanner) InputStream 输出流以字节为单位来获取数据,且需要复杂的判断并创建字节数组作为缓冲 另外字节转换为字符时容易出现中文乱码的情况:Scanner Java扫描器类,可以从输入流中读取指定类型的数据或字符串. 对于字符数据的读取,应该使用Scanner扫描器进行封装,然后获取字符串类型的数据 2. out和err out和err是System类的两个static类成员变量: out:主要是输出调试信息的输出流,以黑色显示 e

java的Io流学习

Java中io流的学习(一)File:https://blog.csdn.net/qq_41061437/article/details/81672859 Java中io流的学习(二)FileInputStream和FileOutputStream:https://blog.csdn.net/qq_41061437/article/details/81742175 Java中io流的学习(三)BuffereInputStream和BuffereOutputStream:https://blog.

Java之IO流用法总结

Java的IO流概述:1.I/O是Input/Output的缩写,I/O技术是非常实用的技术,用于处理设备之间的数据传输.如读/写文件,网络通讯等.2.Java程序中,对于数据的输入/输出操作以“流(stream)” 的方式进行.3.java.io包下提供了各种“流”类和接口,用以获取不同种类的数据,并通过标准的方法输入或输出数据. IO流的分类:1.按操作数据单位不同分为:字节流(8 bit), 字符流(16 bit).2.按数据流的流向不同分为:输入流,输出流.3.按流的角色的不同分为:节点

Java 之IO流及应用

IO流 IO流概述及FileWriter类的使用 FileReader类使用 缓冲流介绍和使用 IO流相关案例 NO.one IO流概述及FileWriter类使用 1.1 IO流概述及分类 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种:输入流,输出流 1.2 FileWriter类使用 A:打开帮助文档 B:点击显示,找到索引,看到输入框 C:你要学习什么内容,你就在框框里面输入什么内容 举例:Random D:看包