在Java中,通过java.io包提供的类来表示流,基本的输入输出流为InputStream和OutputStream。从这两个基本的输入输出流派生出面向特定处理的流,如缓冲区读写流、文件读写流等。

1  InputStream类

InputStream是抽象类,代表字节输入流的所有类的超类。这个类本身不能使用,只能通过继承它的具体类完成某些操作。它的常用方法如下:

public int available() throws IOException                             返回流中可用的字节数。

public void close() throws IOException                               关闭流并释放与流相关的系统资源。用户使用完输入流时,调用这个方法。

public void mark(int readlimit) throws IOException               输入流中标志当前位置。

public boolean markSupported() throws IOException          测试流是否支持标志和复位。

public abstract int read() throws IOException                     读取输入流中的下一个字节。

public int read(byte[] b) throws IOException                      从输入流中读取字节并存储到缓冲区数组b中,返回读取的字节数,遇到文件结尾返回-1。

public int read(byte[] b, int off, int len) throws IOException 从输入流中读取len个字节并写入b中,位置从off开始。返回写的字节数。

public void reset() throws IOException                               重定位到上次输入流中调用的位置。

public long skip(long n) throws IOException                        跳过输入流中n个字节,返回跳过的字节数,遇到文件结尾返回-1。

2  OutputStream类

OutputSteam是抽象类,代表输出字节流的所有类的超类。

public void close() throws IOException                                         关闭输出流,释放与流相关的系统资源。

public void flush() throws IOException                                         清洗输出流,使得所有缓冲区的输出字节全部写到输出设备中。

public void write(byte[] b) throws IOException                             从特定字节数组b将b数组长度个字节写入输出流。

public void write(byte[] b, int off, int len) throws IOException        从特定字节数组b将从off开始的len个字节写入输出流。

public abstract void write(int b) throws IOException                      向输出流写一个特定字节。

3  系统输入输出对象

Java定义了两个流对象System.in和System.out,允许用户在自己的程序中直接使用。System.in对象允许用户从键盘读取数据,System.out对象可以产生屏幕输出。

例:使用流对象System.in和System.out,接收用户从键盘上输入的数据并将数据输出到屏幕上。

  1. package inputOutput;
  2. import java.io.*;
  3.  
  4. public class SystemIO {
  5. public static void main(String[] args)
  6. {
  7. int bytes = 0;
  8. byte buf[] = new byte[255];
  9. System.out.println("\n请输入任意文本:");
  10. try
  11. {
  12. //接收输入字符串
  13. bytes = System.in.read(buf,0,255);
  14.  
  15. System.out.println("这是你输入的文本行:");
  16. String inStr = new String(buf,0,bytes);
  17. //输出字符串
  18. System.out.println(inStr);
  19. }
  20. catch(IOException e)
  21. {
  22. System.out.println(e.getMessage());
  23. }
  24. }
  25. }

4  FileInputStream类

FileInputStream(文件输入流)类是用来得到文件的输入字节流。大部分方法继承于InputStream类。它的构造方法如下:

FileInputStream(File file)                                                           通过打开一个到实际文件的链接,创建一个文件输入流,参数file是一个文件对象。

FileInputStream(String name)                                                   通过打开一个到实际文件的链接,创建文件输入流,参数name为文件的实际路径。

例:使用FileInputStream对象打开源程序文件

  1. package inputOutput;
  2.  
  3. import java.io.*;
  4. public class UseFileInputStream
  5. {
  6. public static void main(String[] args)
  7. {
  8. byte buf[] = new byte[2056];
  9. try
  10. {
  11. //构造文件输入流
  12. FileInputStream fileIn = new FileInputStream("UseFileInputStream.java");
  13. //存入缓冲buf
  14. int bytes = fileIn.read(buf,0,2056);
  15. String inStr = new String(buf,0,bytes);
  16. //输出文件内容
  17. System.out.println(inStr);
  18. }
  19. catch(IOException e){
  20. System.out.println(e.getMessage());
  21. }
  22. }
  23. };

注:此时需要用System.getProperty("user.dir");打印出来看看是在哪个文件夹。需将UseFileInputStream放到此文件夹下。

5  FileOutputStream类

FileOutputStream(文件输出流)类是将数据写入File或 FileDescriptor对象的输出流。它的方法大都是从OutStream继承来的,其构造方法如下:

FileOutputStream(File file)                                                         创建输出流写到特定的file对象。

FileOutputStream(File file, boolean append)                                以追加的方式写入file对象。

FileOutputStream(FileDescriptor fdObj)                                      创建输出文件流到fdObj对象,代表一个到实际文件的链接。

FileOutputStream(String name)                                                创建输出流,写到指定的name文件。

FileOutputStream(String name, boolean append)                        是否以追加的方式写到指定的name文件。

例:使用FileOutputStream对象,打开一个文件,写入一行文本,然后追加一行从键盘接收的字符串

  1. package inputOutput;
  2. import java.io.*;
  3.  
  4. public class UseFileOutputStream {
  5.  
  6. public static void main(String[] args) {
  7. // TODO 自动生成的方法存根
  8. byte buf[] = new byte[255];
  9. byte bufIn[] = new byte[255];
  10. try
  11. {
  12. String str = "你好,这是已有的文本";
  13. buf = str.getBytes();
  14. //创建文件输出流对象
  15. FileOutputStream fileOut = new FileOutputStream("Hello.txt");
  16. //写入文件
  17. fileOut.write(buf,0,buf.length);
  18. //fileOut.flush();
  19. //fileOut.close();
  20. System.out.println("\n请输入一行文本:");
  21. //从键盘接收文本
  22. int bytes = System.in.read(bufIn,0,255);
  23. //追加文本
  24. //fileOut = new FileOutputStream("Hello.txt",true);
  25. fileOut.write(bufIn,0,bytes);
  26. fileOut.flush();
  27. fileOut.close();
  28. }
  29. catch(IOException e)
  30. {
  31. System.out.println(e.getMessage());
  32. }
  33. }
  34. }

6  File类

用户接口和操作系统使用依赖于系统的路径字符串来命名文件和目录。File类就表示这些文件和目录路径,它代表一个抽象的依赖于系统的层次路径视图。File类允许用户向系统查询该文件的所有信息,也可以使用类来创建新的目录或者删除和重命名文件。当用户需要获得有关文件的信息时,就需要创建一个File类,而当File类用于文件读写时,通常与FileInputStream流相结合。

  1. package inputOutput;
  2.  
  3. import java.io.*;
  4.  
  5. public class UseFile {
  6.  
  7. public static void main(String[] args) {
  8. // TODO 自动生成的方法存根
  9. try
  10. {
  11. File f = new File("temp.txt");
  12. System.out.println("创建临时文件");
  13. FileOutputStream fout = new FileOutputStream(f);
  14. PrintStream p = new PrintStream(fout);
  15. p.println("将这句话放入临时文件");
  16. System.out.println("写临时文件");
  17. f.deleteOnExit();
  18. System.out.println("删除临时文件");
  19. }
  20. catch(IOException e)
  21. {
  22. System.out.println(e.getMessage());
  23. }
  24. }
  25. }

7  RandomAccessFile类

RandomAccessFile(随机访问文件)类的实例支持对随机访问文件的读/写。随机访问文件就像存储在文件系统中的巨大的字节数组,通过游标或者索引(叫做文件指示器)指向这个暗含的数组,输入操作从指示器处读取字节,然后前进指针。如果随机访问文件以可读/写模式创建,那么还支持输出操作,输出操作写到暗含数组的尾端,使得数组得以扩展。

例:随机访问文件,将文件内容输出,并写入两个字符“O”、“K”。若文件内容直接输出到屏幕上,的乱码问题,添加一个parseChinese方法后,得以修正。

  1. package inputOutput;
  2. import java.io.*;
  3.  
  4. public class UseRandom {
  5.  
  6. public static void main(String[] args) {
  7. // TODO 自动生成的方法存根
  8. try
  9. {
  10. //构建随机访问文件对象
  11. RandomAccessFile f = new RandomAccessFile("Hello1.txt","rw");
  12. //得到文件指针和长度
  13. long flag = 0;
  14. long len = f.length();
  15. //字符处理后输出
  16. while(flag <len)
  17. {
  18. String s = f.readLine();
  19. System.out.println(parseChinese(s));
  20. flag = f.getFilePointer();
  21. }
  22. //末尾写入字符
  23. f.writeChar('O');
  24. f.writeChar('K');
  25. f.writeUTF("美女,你好!");
  26. }
  27. catch(IOException e)
  28. {
  29. System.out.println(e.getMessage());
  30. }
  31. }
  32. //解决中文转换问题
  33. public static String parseChinese(String inStr)
  34. {
  35. String s = null;
  36. byte temp[];
  37. if (inStr == null)
  38. {
  39. return new String("");
  40. }
  41. try
  42. {
  43. temp=inStr.getBytes("iso-8859-1");
  44. s = new String(temp);
  45. }
  46. catch(UnsupportedEncodingException e)
  47. {
  48. System.out.println (e.toString());
  49. }
  50. return s;
  51. }
  52. }

8  对象流

8.1  ObjectInputStream类

ObjectInputStream(对象输入流)可读取使用对象输出流写入的原始数据和类型,与文件输入输出流一起可以实现对象的持久性存储。它的构造函数和一个读对象的方法如下:

public ObjectInputStream(InputStream in) throws IOException                    从特定的输入流中读取并创建一个对象输入流。

Public Object readObject()                                                                        从对象输入流中读取对象。

8.2  ObjectOutputStream类

ObjectOutputStream(对象输出流)可将Java的原始数据类型和图形写入输出流,对象可以使用对象输入流读取,使用文件可以实现对象的持久存储。它的构造函数和一个写对象方法如下:

public ObjectOutputStream(OutputStream out) throws IOException            创建一个对象输出流,可以写入特定的输出流。

void writeObject(Object obj)                                                                    将对象obj写入对象输出流。

例:将日期对象和向量对象写入文件,然后从文件中读出并输出到屏幕上。要求向量对象含有三个值“语文”、“数学”和“物理”。

  1. package inputOutput;
  2. import java.io.*;
  3. import java.text.SimpleDateFormat;
  4. import java.util.*;
  5.  
  6. public class UseStream {
  7.  
  8. public static void main(String[] args) {
  9. // TODO 自动生成的方法存根
  10. //构建Vector对象
  11. Vector<String> v = new Vector<String>();
  12. v.add("语文");
  13. v.add("数学");
  14. v.add("物理");
  15. try
  16. {
  17. //文件处理对象
  18. File f = new File("temp.txt");
  19. FileOutputStream fOut = new FileOutputStream(f);
  20. ObjectOutputStream objOut = new ObjectOutputStream(fOut);
  21. //写入日期对象
  22.  
  23. objOut.writeObject(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
  24. //写入Vector对象
  25. objOut.writeObject(v);
  26. objOut.close();
  27. //构建readObj的实例
  28. readObj rObj = new readObj();
  29. //调用方法输出
  30. rObj.readO();
  31. }catch(IOException e)
  32. {
  33. System.out.println(e.getMessage());
  34. }
  35. }
  36. };
  37. //自定义类,实现读取对象并输出
  38. class readObj extends Object
  39. {
  40. public void readO()
  41. {
  42. try
  43. {
  44. //文件处理对象
  45. File f = new File("temp.txt");
  46. FileInputStream fIn = new FileInputStream(f);
  47. @SuppressWarnings("resource")
  48. ObjectInputStream objIn = new ObjectInputStream(fIn);
  49. //读取对象输出
  50. Object ob1 = objIn.readObject();
  51. System.out.println(ob1);
  52. Object ob2 = objIn.readObject();
  53. System.out.println(ob2);
  54. }catch(IOException e){
  55. System.out.println(e.getMessage());
  56. }catch(ClassNotFoundException e){
  57. System.out.println(e.getMessage());
  58. }
  59. }
  60. }

Java—输入输出技术的更多相关文章

  1. Java输入输出技术

    输入输出分类     输入流,相对计算机来说是输入的,例如鼠标键盘操作,设备给计算机的信息     输出流,相对计算机来说是输出的,例如屏幕显示,计算机给设备的信息.   具体分类     基本流,I ...

  2. Java输入输出处理技术2

    7.从键盘输入 从键盘输入一行字符,并显示到屏幕上. package io; import java.io.*; public class ReadAndWrite { public static v ...

  3. Java数据库连接技术——JDBC

    大家好,今天我们学习了Java如何连接数据库.之前学过.net语言的数据库操作,感觉就是一通百通,大同小异. JDBC是Java数据库连接技术的简称,提供连接各种常用数据库的能力. JDBC API ...

  4. java 深入技术八(内省)

    1. javabean的软件设计思想 2.内省:封装了java反射,提供直接操作属性的Setter和getter方法的方法 3.核心API:BeanInfo java 的描述信息,Introspect ...

  5. (转)java缓存技术,记录

    http://blog.csdn.net/madun/article/details/8569860 最近再ITEYE上看到关于讨论JAVA缓存技术的帖子比较多,自己不懂,所以上网大概搜了下,找到一篇 ...

  6. paip.java 架构师之路以及java高级技术

    paip.java 架构师之路以及java高级技术 1.    Annotation 设计模式... 概念满天飞.ORM,IOC,AOP. Validator lambda4j memcache. 对 ...

  7. 深入分析Java Web技术内幕(修订版)

    阿里巴巴集团技术丛书 深入分析Java Web技术内幕(修订版)(阿里巴巴集团技术丛书.技术大牛范禹.玉伯.毕玄联合力荐!大型互联网公司开发应用实践!) 许令波 著   ISBN 978-7-121- ...

  8. Java序列化技术与Protobuff

    http://www.cnblogs.com/fangfan/p/4094175.html http://www.cnblogs.com/fangfan/p/4094175.html 前言: Java ...

  9. Java加密技术(一)——BASE64与单向加密算法MD5&SHA&MAC

    Java加密技术(一)——BASE64与单向加密算法MD5&SHA&MAC 博客分类: Java/Security Javabase64macmd5sha     加密解密,曾经是我一 ...

随机推荐

  1. LeetCode:461. Hamming Distance

    package BitManipulation; //Question 461. Hamming Distance /* The Hamming distance between two intege ...

  2. Spring配置文件详解

      转自: http://book.51cto.com/art/201004/193743.htm 此处详细的为我们讲解了spring2.5的实现原理,感觉非常有用 spring配置文件是用于指导Sp ...

  3. iOS设计规范整理|汇总

    来源 UI中国

  4. [译]使用JMH进行微基准测试:不要猜,要测试!

    英文原文:Micro Benchmarking with JMH: Measure, don't guess!翻译地址:使用JMH进行微基准测试:不要猜,要测试!原文作者:Antonio翻译作者:Ho ...

  5. [转]解决IIS下UTF-8文件报错乱码的问题

    找了两天才找到解决办法…….晕晕晕...用第二种方法解决了. 网上找到的方法都没有写这一条 If objASPError.ASPDescription > "" Then 后 ...

  6. ECNAScript6简介

    ECMAScript6.0(以下简称ES6)是JavaScript语言的下一代标砖,已经在2015年6月正式发布了,它的目标,是使得JavaScript语言可以用来编写负责的大型应用程序 ,成为企业级 ...

  7. 浏览器中的Javascript的简单对话框

    简单对话框是指对话框不去做设计,而直接使用默认的,如alert.confirm.prompt: <html> <head> <meta http-equiv=" ...

  8. JAVA 1.3 (原生数据类型 Primitive Data Type)续

    1. 原生数据类型一共有4类8种 >> 整数类型 int表示一个int代表32位 2^32(-2147483648 - 2147483647) >> 字符类型 byte 表示一 ...

  9. About 滚存

    滚存这个神奇的东西就比如DP现在这个状态是上一个状态转移过来的,但也只与上一个状态有关,所以就可以把原本的f[10000,10000]开成f[2,10000],就不会炸内存了.

  10. 【转】linux下安装ssh服务器端及ssh的安全配置

    一.在服务器上安装ssh的服务器端. $ sudo apt-get install openssh-server 2. 启动ssh-server. $ /etc/init.d/sshrestart 3 ...