IO-03字节流字符流

在程序中所有的数据都是以流的方式进行传输和保存的，程序需要数据的时候要使用输入流读取数据，而程序需要将一些数据保存起来则需要使用输出流来完成。

在JAVA.IO包中操作文件内容的主要有两大类：字节流，字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream,输入主要使用InputStream,在字符流中输出主要使用Writer类完成，输入只要使用Reader类完成。

主要的操作流程如下：

  • 使用FILE类打开一个文件
  • 通过字节流或者字符流的子类，指定输出的位置。
  • 进行读/写操作
  • 关闭输入/输出

字节流输出操作代码：

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. public class lianxi043 {
  8. public static void main(String[] args){
  9. //1.使用File类找到一个文件
  10. File f = new File("F:\\aaa.txt");
  11. //2.通过子类实例化父类
  12. try {
  13. OutputStream out = new FileOutputStream(f);
  14. //3.进行读写操作
  15. String ss =  "hello";
  16. byte[] b = ss.getBytes();
  17. out.write(b);
  18. //关闭输出流
  19. out.close();
  20. } catch (FileNotFoundException e) {
  21. // TODO Auto-generated catch block
  22. e.printStackTrace();
  23. } catch (IOException e) {
  24. // TODO Auto-generated catch block
  25. e.printStackTrace();
  26. }
  27. }
  28. }

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. public class lianxi043 {
  8. public static void main(String[] args){
  9. //1.使用File类找到一个文件
  10. File f = new File("F:\\aaa.txt");
  11. //2.通过子类实例化父类
  12. try {
  13. OutputStream out = new FileOutputStream(f);
  14. //3.进行读写操作
  15. String ss =  "hello1111";
  16. byte[] b = ss.getBytes();
  17. for(int i=0;i<b.length;i++){//采用循环写入，每次只写入1位
  18. out.write(b[i]);
  19. }
  20. //关闭输出流
  21. out.close();
  22. } catch (FileNotFoundException e) {
  23. // TODO Auto-generated catch block
  24. e.printStackTrace();
  25. } catch (IOException e) {
  26. // TODO Auto-generated catch block
  27. e.printStackTrace();
  28. }
  29. }
  30. }

如果不想覆盖之前文件，需要执行追加操作：

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. public class lianxi043 {
  8. public static void main(String[] args){
  9. //1.使用File类找到一个文件
  10. File f = new File("F:\\aaa.txt");
  11. //2.通过子类实例化父类
  12. try {
  13. OutputStream out = new FileOutputStream(f, true);
  14. //3.进行读写操作
  15. String ss =  "hello1111";
  16. byte[] b = ss.getBytes();
  17. for(int i=0;i<b.length;i++){//采用循环写入，每次只写入1位
  18. out.write(b[i]);
  19. }
  20. //关闭输出流
  21. out.close();
  22. } catch (FileNotFoundException e) {
  23. // TODO Auto-generated catch block
  24. e.printStackTrace();
  25. } catch (IOException e) {
  26. // TODO Auto-generated catch block
  27. e.printStackTrace();
  28. }
  29. }
  30. }

如果想在末尾换行需要加入“\r\n”

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. public class lianxi043 {
  8. public static void main(String[] args){
  9. //1.使用File类找到一个文件
  10. File f = new File("F:\\aaa.txt");
  11. //2.通过子类实例化父类
  12. try {
  13. OutputStream out = new FileOutputStream(f, true);
  14. //3.进行读写操作
  15. String ss =  "\r\nhello1111";
  16. byte[] b = ss.getBytes();
  17. for(int i=0;i<b.length;i++){//采用循环写入，每次只写入1位
  18. out.write(b[i]);
  19. }
  20. //关闭输出流
  21. out.close();
  22. } catch (FileNotFoundException e) {
  23. // TODO Auto-generated catch block
  24. e.printStackTrace();
  25. } catch (IOException e) {
  26. // TODO Auto-generated catch block
  27. e.printStackTrace();
  28. }
  29. }
  30. }

字节流输入操作代码：

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. public class lianxi044 {
  8. public static void main(String[] args){
  9. File f = new File("f:\\abc.txt");
  10. try {
  11. InputStream in = new FileInputStream(f);
  12. byte[] b = new byte[(int)f.length()];
  13. in.read(b);
  14. System.out.println(new String(b));
  15. in.close();
  16. } catch (FileNotFoundException e) {
  17. // TODO Auto-generated catch block
  18. e.printStackTrace();
  19. } catch (IOException e) {
  20. // TODO Auto-generated catch block
  21. e.printStackTrace();
  22. }
  23. }
  24. }

一位一位读进来

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. public class lianxi044 {
  8. public static void main(String[] args){
  9. File f = new File("f:\\abc.txt");
  10. try {
  11. InputStream in = new FileInputStream(f);
  12. byte[] b = new byte[(int)f.length()];
  13. for(int i=0;i<b.length;i++){
  14. b[i] =(byte)in.read();
  15. }
  16. System.out.println(new String(b));
  17. in.close();
  18. } catch (FileNotFoundException e) {
  19. // TODO Auto-generated catch block
  20. e.printStackTrace();
  21. } catch (IOException e) {
  22. // TODO Auto-generated catch block
  23. e.printStackTrace();
  24. }
  25. }
  26. }

如果不知道文件的大小则：

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. public class lianxi044 {
  8. public static void main(String[] args){
  9. File f = new File("f:\\abc.txt");
  10. try {
  11. InputStream in = new FileInputStream(f);
  12. byte[] b = new byte[1024];
  13. int len =0;
  14. int tem=0;
  15. while((tem = in.read())!=-1){
  16. b[len] = (byte)tem;
  17. len++;
  18. }
  19. System.out.println(new String(b,0,len));
  20. in.close();
  21. } catch (FileNotFoundException e) {
  22. // TODO Auto-generated catch block
  23. e.printStackTrace();
  24. } catch (IOException e) {
  25. // TODO Auto-generated catch block
  26. e.printStackTrace();
  27. }
  28. }
  29. }

字符流输出：

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  5. import java.io.Writer;
  6. public class lianxi045 {
  7. /**
  8. * @param args
  9. */
  10. public static void main(String[] args) {
  11. File f = new File("f:\\abc.txt");
  12. try {
  13. Writer  w = new FileWriter(f);
  14. String ss = "aaaaaaaaaaaaa";
  15. w.write(ss);
  16. w.close();
  17. } catch (IOException e) {
  18. // TODO Auto-generated catch block
  19. e.printStackTrace();
  20. }
  21. }
  22. }

字符流读取数据：

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.io.Reader;
  6. public class lianxi045 {
  7. /**
  8. * @param args
  9. */
  10. public static void main(String[] args) {
  11. File f = new File("f:\\abc.txt");
  12. try {
  13. Reader r = new FileReader(f);
  14. char[] c = new char[1024];
  15. r.read(c);
  16. System.out.println(new String(c));
  17. } catch (IOException e) {
  18. // TODO Auto-generated catch block
  19. e.printStackTrace();
  20. }
  21. }
  22. }

字节流与字符流的区别：

字节流在操作的时候本身不会用到缓冲区，是与本件本身直接操作的，而字符流在操作的时候是使用到缓冲区的。

在所有的硬盘上保存的文件或者是进行传输的时候是以字节的方式进行的。包括图片也是按字节完成的，而字符只有在内存中才会形成，使用字节的操作是最多的。

复制文件的小程序：

[java] view
plaincopy

  1. package lianxijihe;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.OutputStream;
  9. public class lianxi046 {
  10. public static void main(String[] args){
  11. if(args.length!=2){
  12. System.out.println("输入的格式不对");
  13. System.exit(1);
  14. }
  15. File f1 = new File(args[0]);
  16. File f2 = new File(args[1]);
  17. if(!f1.exists()){
  18. System.out.println("源文件不存在");
  19. System.exit(1);
  20. }
  21. try {
  22. InputStream in = new FileInputStream(f1);
  23. OutputStream out = new FileOutputStream(f2);
  24. int temp =0;
  25. while((temp=in.read())!=-1){
  26. out.write(temp);
  27. }
  28. in.close();
  29. out.close();
  30. } catch (FileNotFoundException e) {
  31. // TODO Auto-generated catch block
  32. e.printStackTrace();
  33. } catch (IOException e) {
  34. // TODO Auto-generated catch block
  35. e.printStackTrace();
  36. }
  37. }
  38. }

IO-03字节流字符流

时间： 2024-11-08 21:01:24

IO-03字节流字符流的相关文章

IO 复习字节流字符流拷贝文件

/* 本地文件 URL 文件拷贝 *//*文本文件拷贝 可以通过 字符流,也可以通过字节流*/ /*二进制文件拷贝 只可以通过字节流*//* 希望这个例子能帮助搞懂 字符流与字节流的区别 */ import java.io.*; //in order to utilize stream object import java.util.*; // in order to utilize ArrayList import java.net.*; class Copy{ public static v

Android笔记：利用InputStream和BufferedReader 进行字节流 字符流处理

通过socket获取字节流处理时最初使用的是BufferedReader和PrintWriter  这种方式在解析字符串时是比较方便的 但是在处理字节时不够方便最终还是回归到InputStream和OutputStream方式 不使用缓存直接使用字节流操作,一次传输的字节数据在300字节以内,目前没有测试差距会有多大. import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException;

io系列之字符流

java中io流系统庞大,知识点众多,作为小白通过五天的视频书籍学习后,总结了io系列的随笔,以便将来复习查看. 本篇为此系列随笔的第一篇:io系列之字符流. IO流 :对数据的传输流向进行操作,java中将这种操作行为本身封装为对象,以供使用. Input and Output java将io流对象都在IO包中.(java.IO.*) 分类: 按照数据种类分: 字节流 和 字符流, 按照数据流向分: 输出流 和 输入流. 字节流抽象类: InputStream OutputStream 字符流

Java 字节流 字符流 转换流

我们知道Java中的流分为字符流和字节流,其中字符流主要针对字符文本进行处理,而字节流处理范围更为广泛,毕竟图片.电影等只要是文件都是以二进制的形式存在的,而不是字符. 字符流: FileReader FileWriter. BufferedReader BufferedWriter 字节流: FileInputStream FileOutputStream BufferedInputStream BufferedOutputStream 我们看一下J2SE文档: BufferedReader(

java IO(三)：字符流

*/ .hljs { display: block; overflow-x: auto; padding: 0.5em; color: #333; background: #f8f8f8; } .hljs-comment, .hljs-template_comment, .diff .hljs-header, .hljs-javadoc { color: #998; font-style: italic; } .hljs-keyword, .css .rule .hljs-keyword, .h

字节流 字符流 - 12

一.IO概述 Java中I/O操作主要是指使用java.io包下的内容,进行输入.输出操作.输入也叫做读取数据,输出也叫做作写出数据. 输入流 :把数据从其他设备上读取到内存中的流. 输出流 :把数据从内存 中写出到其他设备上的流. 字节流 :以字节为单位,读写数据的流. 字符流 :以字符为单位,读写数据的流. 二.字节流 一切皆为字节 OutputStream.FileOutputStream java.io.OutputStream抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到

java io 学习之三 字符流的缓冲区

 /** 字符流的缓冲区 缓冲区的出现,提高了对数据的读写效率 对应的类: BufferedWriter BufferedReader 缓冲区要结合流才可以使用 缓冲区是在流的基础上对流的功能进行增强 软件的优化可以分为:设计优化和性能优化 设计优化:对代码进行重构,让代码实现更强的可扩展性和灵活性,复用性. 提高性能最常用的的手段是:缓冲区  线程池 BufferedWriter 构造方法摘要 BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输

Java——IO类，字符流读数据

body, table{font-family: 微软雅黑} table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;} th{border: 1px solid gray; padding: 4px; background-color: #DDD;} td{border: 1px solid gray; padding: 4px;} tr:nth-child(2n){background-co

Java+字节流+字符流转换

原文地址:http://blog.51cto.com/janephp/2150039