java中的流可以从不同的角度进行分类

按流的方向:输入流、输出流(注意这里的输入(read)、输出是相对于程序而言的(writer),个人认为从读、写角度理解更为直观)

按处理数据单位:字节流、字符流(字节流为继承自InputStream和OutputStream的流,以字节(8位)为单位读写;字符流为继承自Reader和Writer的流,以字符(16位)为单位读写)

按实现功能:节点流、处理流(节点流直接与数据源相连读写;处理流在节点流的基础上,再套接一层以完成特定的读写功能)

  

Java IO流详尽解析

java IO流学习总结

一、File

1、File

  1. public class FileTest {
  2.  
  3. public static void main(String[] args) {
  4.  
  5. String ps1 = File.pathSeparator;//与系统有关的路径分隔符(':'),为了方便,它被表示为一个字符串
  6. char ps2 = File.pathSeparatorChar;//与系统有关的路径分隔符(':' 58)
  7. String ps3 = File.separator ;//与系统有关的默认名称分隔符('/'),为了方便,它被表示为一个字符串
  8. char ps4 = File.separatorChar ;//与系统有关的默认名称分隔符('/' 47)
  9.  
  10. File file = new File("/home/sunjf/a.txt");//通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例
  11. File f = new File("/home/sunjf");
  12. File f1 = new File(f, "a.txt");//根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例
  13. File f2 = new File("/home/sunjf", "c.txt");//根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例
  14.  
  15. System.out.println("测试此抽象路径名表示的文件或目录是否存在 : " + file.exists());
  16. System.out.println("测试应用程序是否可以读取此抽象路径名表示的文件 : " + file.canRead());
  17. System.out.println("测试应用程序是否可以修改此抽象路径名表示的文件 : " + file.canWrite());
  18.  
  19. System.out.println("返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回 null : " + file.getParent());
  20. System.out.println("返回由此抽象路径名表示的文件或目录的名称 : " + file.getName());
  21. System.out.println("将此抽象路径名转换为一个路径名字符串 : " + file.getPath());
  22.  
  23. System.out.println("测试此抽象路径名表示的文件是否是一个目录 : " + file.isDirectory());
  24. System.out.println("测试此抽象路径名表示的文件是否是一个标准文件 : " + file.isFile());
  25. System.out.println("测试此抽象路径名指定的文件是否是一个隐藏文件 : " + file.isHidden());
  26. System.out.println("测试此抽象路径名是否为绝对路径名 : " + file.isAbsolute());
  27.  
  28. System.out.println("返回此抽象路径名表示的文件最后一次被修改的时间 : " + file.lastModified());
  29. System.out.println("返回由此抽象路径名表示的文件的长度 : " + file.length());
  30.  
  31. String[] pathStr = f.list();//返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录
  32. for(String s : pathStr) System.out.println("返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录 " + s);
  33. File[] fileArr = f.listFiles();
  34. for(File index : fileArr) System.out.println("返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录 " + index);
  35.  
  36. file.delete();//删除此抽象路径名表示的文件或目录
  37.  
  38. file.mkdir();//创建此抽象路径名指定的目录
  39. //file.mkdirs();//创建此抽象路径名指定的目录,包括所有必需但不存在的父目录
  40.  
  41. //if (file.exists()) file.delete();
  42. /*try {
  43. file.createNewFile();//当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件
  44. } catch (IOException e) {
  45. e.printStackTrace();
  46. }*/
  47. }
  48.  
  49. }

JAVA的I/O介绍

二、字节流:OutputStream和InputStream

1、字节文件流:FileOutStream和FileInputStream

  1. public class Test {
  2. public static void main(String[] args) {
  3. File file = new File("D:/a.txt");
  4. try {
  5.  
  6. } catch (IOException e) {
  7. e.printStackTrace();
  8. }
  9.  
  10. try {
  11. FileOutputStream fos = new FileOutputStream(file);// 创建一个向指定 File 对象表示的文件中写入数据的文件输出流,会覆盖之前的数据
  12. //FileOutputStream fos = new FileOutputStream("D:/a.txt");
  13. //FileOutputStream fos = new FileOutputStream(file, true);//不会覆盖之前数据
  14. //FileOutputStream fos1 = new FileOutputStream("D:/a.txt", true);
  15. //FileOutputStream fos = new FileOutputStream(fos1.getFD());//创建一个向指定文件描述符处写入数据的输出文件流,该文件描述符表示一个到文件系统中的某个实际文件的现有连接
  16. System.out.println("返回与此流有关的文件描述符 : " + fos.getFD().getClass());
  17. System.out.println("返回与此文件输出流有关的唯一 FileChannel 对象 : " + fos.getChannel().getClass());
  18. char[] c = {'H', 'e', 'l', 'l', 'o', ' ', 'I', '/', 'O', '!', '\n'};
  19. for (char ch : c) fos.write(ch);//将指定字节写入此文件输出流
  20. byte[] b = {'H', 'e', 'l', 'l', 'o', ' ', 'I', '/', 'O', '!', '\n'};
  21. fos.write(b);//将 b.length 个字节从指定 byte 数组写入此文件输出流中
  22. fos.write(b, 6, 5);//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流
  23.  
  24. FileInputStream fis = new FileInputStream(file);
  25. int index = 0;
  26. while ((index = fis.read()) != -1) {//数据读出
  27. System.out.print((char) index);
  28. }
  29. fos.close();//关闭写入流
  30. fis.close();//关闭读出流
  31.  
  32. } catch (FileNotFoundException e) {
  33. e.printStackTrace();
  34. } catch (IOException e) {
  35. e.printStackTrace();
  36. }
  37. }
  38. }

2、字节缓存流:BufferOutputStream和BufferInputStream

  继承自FilterOutputStream和FilterInputStream,实现了带缓冲的过滤流,它提供了缓冲机制,可以提高该I/O流的读取效率,在初始化时,除了要指定所连接的I/O流之外,还可以指定缓冲区的大小。在读写的同时对数据缓存,这样避免每次读写数据都要进行实际的物理读写操作,在用BufferdOutputStream输出时,数据先输入缓冲区,当缓冲区满的时再写入连接的输出流,可以调用flush()来清空缓冲区。

  1. public class BufferStreamTest {
  2.  
  3. public static void main(String[] args) {
  4. File file = new File("D:/a.txt");
  5. try {
  6. file.createNewFile();
  7. } catch (IOException e) {
  8. e.printStackTrace();
  9. }
  10. try {
  11. OutputStream fos = new FileOutputStream(file, true);
  12. BufferedOutputStream bos = new BufferedOutputStream(fos);//实例化需要通过OutputStream指定所连接的I/0流
  13. byte[] b = {'H', 'e', 'l', 'l', 'o', ' ', 'I', '/', 'O', '!', '\n'};
  14. bos.write(b);
  15. bos.write(b);
  16. bos.write(b);
  17. bos.flush();//必须flush,write只是将数据写入缓存
  18.  
  19. InputStream fis = new FileInputStream(file);
  20. BufferedInputStream bis = new BufferedInputStream(fis);
  21. int i = 0;
  22. while ((i = bis.read()) != -1) System.out.print((char)i);
  23. } catch (FileNotFoundException e) {
  24. e.printStackTrace();
  25. } catch (IOException e) {
  26. e.printStackTrace();
  27. }
  28. }
  29.  
  30. }

3、字节数据流:DataOutputStream和DataInputStream

  数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后,应用程序可以使用数据输入流将数据读入。需要注意的是输出流的写方法与输入流的读方法必须对应。

  1. public class DateStreamTest {
  2.  
  3. public static void main(String[] args) {
  4. File file = new File("/home/sunjf/a.txt");
  5. try {
  6. if (!file.exists()) {
  7. file.createNewFile();
  8. }
  9. } catch (IOException e) {
  10. e.printStackTrace();
  11. }
  12.  
  13. try {
  14. OutputStream fos = new FileOutputStream(file);
  15. DataOutputStream dos = new DataOutputStream(fos);
  16. String str = "java流学习!";
  17. //dos.writeUTF(str);//以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流
  18. dos.writeLong(123l);//将一个 long 值以 8-byte 值形式写入基础输出流中,先写入高字节
  19. dos.flush();
  20. dos.close();
  21. fos.close();
  22.  
  23. InputStream fis = new FileInputStream(file);
  24. DataInputStream dis = new DataInputStream(fis);
  25. //System.out.println(dis.readUTF());
  26. System.out.println(dis.readLong());//读取八个输入字节并返回一个 long 值
  27. dis.close();
  28. fis.close();
  29. } catch (FileNotFoundException e) {
  30. e.printStackTrace();
  31. } catch (IOException e) {
  32. e.printStackTrace();
  33. }
  34. }
  35.  
  36. }

4、字节对象流:ObjectOutputStream和ObjectInputStream

  被读写的对象必须实现Serializable接口,及必须序列化。

  1. public class ObjectStreamTest {
  2.  
  3. public static void main(String[] args) {
  4. File file = new File("/home/sunjf/User.txt");
  5. try {
  6. if (!file.exists()) {
  7. file.createNewFile();
  8. }
  9. } catch (IOException e) {
  10. e.printStackTrace();
  11. }
  12.  
  13. try {
  14. OutputStream fos = new FileOutputStream(file);
  15. ObjectOutputStream oos = new ObjectOutputStream(fos);
  16. User u = new User();
  17. u.setUserName("java");
  18. u.setAge(20);
  19. oos.writeObject(u);
  20. oos.close();
  21.  
  22. InputStream fis = new FileInputStream(file);
  23. ObjectInputStream ois = new ObjectInputStream(fis);
  24. System.out.println(ois.readObject().toString());
  25. } catch (FileNotFoundException e) {
  26. e.printStackTrace();
  27. } catch (IOException e) {
  28. e.printStackTrace();
  29. } catch (ClassNotFoundException e) {
  30. e.printStackTrace();
  31. }
  32. }
  33.  
  34. }
  35.  
  36. class User implements Serializable {
  37. private String userName;
  38. private int age;
  39.  
  40. public String getUserName() {
  41. return userName;
  42. }
  43.  
  44. public void setUserName(String userName) {
  45. this.userName = userName;
  46. }
  47.  
  48. public int getAge() {
  49. return age;
  50. }
  51.  
  52. public void setAge(int age) {
  53. this.age = age;
  54. }
  55.  
  56. @Override
  57. public String toString() {
  58. return userName + " | " + age;
  59. }
  60. }

三、字符流:Writer和Reader

1、文件字符流:FileWriter和FileReader

  使用字符流可以写入、读取汉字,如果用上面的字节流写入、读取得到的会是乱码。

  1. public class WriterAndReaderTest {
  2. public static void main(String[] args) {
  3. File file = new File("/home/sunjf/a.txt");
  4. try {
  5. if (!file.exists()) {
  6. file.createNewFile();
  7. }
  8.  
  9. char[] c = {'你', '好', ',', '流', '!'};
  10. FileWriter fw = new FileWriter(file);
  11. //fw.write(c);//写入单个字符
  12. //fw.write(c, 0, c.length);//将字符写入数组的某一部分
  13. String str = "你好,流!";
  14. fw.write(str, 0, str.length());//写入一部分字符串
  15. fw.flush();//刷新该流的缓冲
  16.  
  17. FileReader fr = new FileReader(file);
  18. int index = 0;
  19. System.out.println("判断此流是否已经准备好用于读取 : " + fr.ready());
  20. while ((index = fr.read()) != -1) {
  21. System.out.print((char) index);//读取单个字符
  22. //fr.skip('!');//跳过某些字符
  23. }
  24. fw.close();//关闭此流,但要先刷新它
  25. fr.close();//关闭该流并释放与之关联的所有资源
  26. } catch (IOException e) {
  27. e.printStackTrace();
  28. }
  29. }

2、缓存字符流:BufferWriter和BufferReader

  除了多了缓存功能外,还可以按行读写数据。

  1. public class BufferLineTest {
  2.  
  3. public static void main(String[] args) {
  4. File file = new File("D:/a.txt");
  5. try {
  6. if (!file.exists()) {
  7. file.createNewFile();
  8. }
  9. } catch (IOException e) {
  10. e.printStackTrace();
  11. }
  12.  
  13. try {
  14. Writer fw = new FileWriter(file, true);
  15. BufferedWriter bw = new BufferedWriter(fw);//需要通过Writer指定连接的I/O流
  16. String str = "你好,流!";
  17. bw.write(str);
  18. bw.newLine();//写入一个行分隔符
  19. bw.write(str);
  20. bw.newLine();
  21. bw.write(str);
  22. bw.newLine();
  23. bw.flush();
  24.  
  25. Reader fr = new FileReader(file);
  26. BufferedReader br = new BufferedReader(fr);
  27. String s = "";
  28. while ((s = br.readLine()) != null) System.out.println(s);//读取一个文本行
  29. } catch (IOException e) {
  30. e.printStackTrace();
  31. }
  32.  
  33. }
  34.  
  35. }

四、总结

java:IO流学习小结

1、读取纯文本用Reader和Writer

2、按行读写用BufferWriter和BufferReader

3、数据流的读写方法必须对应

4、对象流的读写对象必须实现Serializable接口

5、处理流必须通过OutputStream和InputStream指定所链接的I/O流

java从基础知识(九)I/O的更多相关文章

  1. Java 多线程——基础知识

    java 多线程 目录: Java 多线程——基础知识 Java 多线程 —— synchronized关键字 java 多线程——一个定时调度的例子 java 多线程——quartz 定时调度的例子 ...

  2. java必备基础知识(一)

    学习的一点建议: 每一门语言的学习都要从基础知识开始,学习是一个过程,"万丈高楼平地起",没有一个好的地基,想必再豪华的高楼大厦终究有一天会倒塌.因此,我们学习知识也要打牢根基,厚 ...

  3. 什么才是java的基础知识?

    近日里,很多人邀请我回答各种j2ee开发的初级问题,我无一都强调java初学者要先扎实自己的基础知识,那什么才是java的基础知识?又怎么样才算掌握了java的基础知识呢?这个问题还真值得仔细思考. ...

  4. java部分基础知识整理----百度脑图版

    近期发现,通过百度脑图可以很好的归纳总结和整理知识点,本着学习和复习的目的,梳理了一下java部分的知识点,不定期更新,若有不恰之处,请指正,谢谢! 脑图链接如下:java部分基础知识整理----百度 ...

  5. Java 多线程基础(九)join() 方法

    Java 多线程基础(九)join 方法 一.join() 方法介绍 join() 定义 Thread 类中的,作用是:把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程.如:线 ...

  6. JAVA相关基础知识

    JAVA相关基础知识 1.面向对象的特征有哪些方面 1.抽象: 抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面.抽象并不打算了解全部问题,而只是选择其中的一部分, ...

  7. JAVA多线程基础知识(一)

    一. 基础知识 要了解多线程首先要知道一些必要的概念,如进程,线程等等.开发多线程的程序有利于充分的利用系统资源(CPU资源),使你的程序执行的更快,响应更及时. 1. 进程,一般是指程序或者任务的执 ...

  8. Java SE 基础知识(一)

    一.基础知识 1. Java SE : Java Standard Edition Java ME : Java Micro Edition Java EE : Java Enterprise Edi ...

  9. JAVA学习基础知识总结(原创)

    (未经博主允许,禁止转载!) 一.基础知识:1.JVM.JRE和JDK的区别: JVM(Java Virtual Machine):java虚拟机,用于保证java的跨平台的特性. java语言是跨平 ...

  10. java正则表达式基础知识(转)

    1基础 2.1 简单字符类 构造 描述 [abc] a,b或c [^abc] 除a,b或c外的字符 [a-zA-Z] a至z 或 A至Z [a-d[m-p]] a至d 或 m至p [a-z&& ...

随机推荐

  1. 用grunt搭建web前端开发环境

    1.前言 本文章旨在讲解grunt入门,以及讲解grunt最常用的几个插件的使用. 2.安装node.js Grunt和所有grunt插件都是基于nodejs来运行的,如果你的电脑上没有nodejs, ...

  2. hibernate延迟加载

    http://blog.csdn.net/xc635960736/article/details/7049863 http://www.cnblogs.com/xiaoluo501395377/p/3 ...

  3. [LeetCode] Permutation Sequence 序列排序

    The set [1,2,3,…,n] contains a total of n! unique permutations. By listing and labeling all of the p ...

  4. Android开发之带你轻松集成友盟统计

    友盟统计是什么呢?为什么要集成他呢? 当我们需要获取自己写的软件的装机量和用户使用信息时,这时我们可以集成友盟统计. 首先到友盟统计中注册账号什么的就不废话了,直接看创建项目: 在个人中心中的管理里面 ...

  5. jQuery 模态对话框示例

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  6. linux 常见命令

    redhat 1.获取apt软件列表 sudo apt-cache search all 2.添加用户并创建目录 sudo useradd -m username -s /sbin/bash 3.vs ...

  7. c++多重继承

    可以在子类中通过基类名访问函数 // oj4.cpp : Defines the entry point for the console application.// #include "s ...

  8. PRINCE2风险模块

    我们前几个节学习了PRINCE2七大主题的商业论证.组织.质量和计划,今天我们开展对于风险模块的讲解. 风险:目的是识别.评估和控制不确定性,从而提高项目的成功率.PRINCE2对风险登记册进行了详细 ...

  9. 利用powerDesigner16.5连接oracle数据库并自动生成表结构图

  10. Error Domain=NSURLErrorDomain Code=-999 “The operation couldn’t be completed.

    转:http://www.wangzhengdong.com/blog/error-domainnsurlerrordomain-code-999-the-operation-couldnt-be-c ...