一、字节数组流：
类 ByteArrayInputStream:在构造函数的时候，需要接受数据源，而且数据源是一个字节数组。
包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节
关闭ByteArrayInputStream流无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException
类 ByteArrayOutputStream:在构造函数的时候，不用定义数据目的，因为该对象中内部已经封装了可变长度的字节数组，这就是数据的目的地。
此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。
可使用toByteArray()和toString()获取数据。
关闭ByteArrayOutputStream流无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。
这两个流对象操作的都是数组，并没有使用系统资源，所以，不用进行close()关闭。
用流的思想去操作数组。
在流操作讲解时：
源设备：键盘(System.in)、硬盘(FileStream)、内存(ArrayStream)
目的设备：控制台(System.out)、硬盘(FileStream)、内存(ArrayStream)
//例子1：
import java.io.*; class ByteArrayStreamDemo { public static void main(String[] args) { //数据源 ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEF".getBytes());//getBytes()是将一个字符串转化为一个字节数组 //数据目的 ByteArrayOutputStream bos = new ByteArrayOutputStream(); int by = 0; while((by = bis.read())!=-1) { bos.write(by); } System.out.println(bos.size()); System.out.println(bos.toString()); //bos.writeTo(new FileOutputStream("ByteArray.txt"));//只有此处需要对异常进行处理。 } }
二、字符数组流：CharArrayReader和CharArrayWriter
类 CharArrayReader:在构造函数的时候，需要接受数据源，而且数据源是一个字符数组。
此类实现一个可用作字符输入流的字符缓冲区。读入流会产生IOException
类 CharArrayWriter:在构造函数的时候，不用定义数据目的，因为该对象中内部已经封装了可变长度的字符数组，这就是数据的目的地。
此类实现了一个输出流，其中的数据被写入一个char数组。缓冲区会随着数据的不断写入而自动增长。
可使用toCharArray()和toString()获取数据。
关闭CharArrayWriter流无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。
这两个流对象操作的都是数组，并没有使用系统资源，所以，不用进行close()关闭。
用流的思想去操作数组。
//例子2：
import java.io.*; class CharArrayStreamDemo { public static void main(String[] args)throws IOException { //数据源 CharArrayReader car = new CharArrayReader("世界第一等".toCharArray());//toCharArray()是将一个字符串转化为一个字符数组 //数据目的 CharArrayWriter caw = new CharArrayWriter(); int by = 0; while((by = car.read())!=-1) { caw.write(by); } System.out.println(caw.size()); System.out.println(caw.toString()); //caw.writeTo(new FileOutputStream("CharArray.txt"));//需要对异常进行处理。 } }
三、数据流
DataInputStream: DataInputStream(InputStream in)
DataOutputStream: DataOutputStream(OutputStream out)
可以用于操作基本数据类型的数据的流对象。
//例子3：
import java.io.*; class DataStreamDemo { public static void main(String[] args)throws IOException { //WriteData(); //ReadData(); WriteUTFDemo(); ReadUTFDemo(); } public static void WriteData()throws IOException { DataOutputStream dos = new DataOutputStream(new FileOutputStream("Data.txt")); dos.writeInt(10); dos.writeChar(97); dos.writeDouble(3.1415926); dos.writeBoolean(true); dos.close(); } public static void ReadData()throws IOException { DataInputStream dis = new DataInputStream(new FileInputStream("Data.txt")); System.out.println(dis.readInt()); System.out.println(dis.readChar()); System.out.println(dis.readDouble()); System.out.println(dis.readBoolean()); dis.close(); } public static void WriteUTFDemo()throws IOException { DataOutputStream dos = new DataOutputStream(new FileOutputStream("Data-UTF.txt")); dos.writeUTF("你好"); dos.close(); } public static void ReadUTFDemo()throws IOException { DataInputStream dis = new DataInputStream(new FileInputStream("Data-UTF.txt")); System.out.println(dis.readUTF()); dis.close(); } }
四、管道流：
PipedInputStream
PipedOutputStream
作用：输入输出可以直接进行连接，通过结合线程使用。
//例子4：
import java.io.*; class ReadPiped implements Runnable { private PipedInputStream in; ReadPiped(PipedInputStream in) { this.in = in; } public void run() { try { byte[] buf = new byte[1024]; System.out.println("读取前，没有数据，管道阻塞开始"); int len = in.read(buf); System.out.println("读取数据，管道阻塞结束"); String s = new String(buf,0,len); System.out.println(s); } catch(IOException e) { throw new RuntimeException("管道读取流失败!"); } finally { try { in.close(); } catch(IOException e) { throw new RuntimeException("流关闭失败!"); } } } } class WritePiped implements Runnable { private PipedOutputStream out; WritePiped(PipedOutputStream out) { this.out = out; } public void run() { try { System.out.println("开始写入数据，等待5秒"); Thread.sleep(5000); out.write("guandao lai le".getBytes()); out.close(); } catch(Exception e) { throw new RuntimeException("管道输出流失败!"); } } } class PipedStreamDemo { public static void main(String[] args)throws IOException { PipedInputStream in = new PipedInputStream(); PipedOutputStream out = new PipedOutputStream(); in.connect(out);//使此管道输入流连接到管道输出流 ReadPiped r = new ReadPiped(in); WritePiped w = new WritePiped(out); new Thread(r).start(); new Thread(w).start(); } }
五、打印流：PrintStream
PrintWriter
java.lang.Object
继承者 java.io.OutputStream
继承者 java.io.FilterOutputStream
继承者 java.io.PrintStream
java.lang.Object
继承者 java.io.Writer
继承者 java.io.PrintWriter
--------------------------------------------------------
打印流提供了打印方法，可以将各种类型的数据原样打印出来。
PrintStream:字节打印流
构造函数可以接受的类型：1.file对象。File
2.字符串路径。String
3.字节输出流。OutputStream
//PrintStream(OutputStream out, boolean autoFlush)
如果为 true，则每当写入 byte 数组、调用其中一个 println 方法或写入换行符或字节 ('\n') 时都会刷新
PrintWriter:字符打印流
构造函数可以接受的类型：
1.file对象。File
2.字符串路径。String
3.字节输出流。OutputStream
4.字符数据流。Writer
//PrintWriter(OutputStream out, boolean autoFlush)
autoFlush为true时，则println、printf或format将自动刷新输出缓冲流
//例子5：
import java.io.*; class PrintStreamDemo { public static void main(String[] args)throws IOException { BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); PrintWriter ps = new PrintWriter(System.out,true);//(new BufferedWriter(new FileWriter("F:\\myfile\\print.txt")),true) String line = null; while((line = bufr.readLine())!=null) { if("over".equals(line)) break; ps.println(line.toUpperCase()); //ps.flush(); } ps.close(); bufr.close(); } }
六、Properties
它是hashtable的子类，也就是它具备了Map集合的特点，而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件
那么在加载数据时，需要数据有固定格式：键=值
Object setProperty(String key, String value)
调用 Hashtable 的方法 put。
String getProperty(String key)
用指定的键在此属性列表中搜索属性。
String getProperty(String key, String defaultValue)
用指定的键在属性列表中搜索属性。
Set<String> stringPropertyNames()
返回此属性列表中的键集
void load(InputStream inStream)
从输入流中读取属性列表（键和元素对）。
void load(Reader reader)
按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
void store(OutputStream out, String comments)
以适合使用 load(InputStream) 方法加载到 Properties 表中的格式,并存储到打印流中
void store(Writer writer, String comments)
以适合使用 load(Reader) 方法的格式，并存储到打印流中 。
//例子6：
import java.io.*; import java.util.*; class PropertiesDemo { public static void main(String[] args)throws IOException { //setAndget(); //method_1(); method_2(); } //演示如何将流中的数据添加放到集合中 //想要将key-value.txt数据存到集合进行操作 /* 步骤：1.用一个流和key-value相关联 2.读一行数据，将该行数据用"="进行切割 3.等号左边作为键，右边作为值，存入到Properties集合即可。 */ //方法1(load方法的原理) public static void method_1()throws IOException { Properties p = new Properties(); //FileInputStream fis = new FileInputStream("F:\\myfile\\key-value.txt"); BufferedReader bufr = new BufferedReader(new FileReader("F:\\myfile\\key-value.txt")); String str=null; while((str=bufr.readLine())!=null) { String[] s = str.split("="); System.out.println(s[0]+"...."+s[1]); p.setProperty(s[0],s[1]); } //System.out.println(p); p.list(System.out); bufr.close(); } //方法2(直接调用load方法) public static void method_2()throws IOException { Properties p = new Properties(); p.load(new FileReader("F:\\myfile\\key-value.txt"));//p.load(new FileInputStream("F:\\myfile\\key-value.txt")) p.setProperty("zhaoliu","100");//修改已有的姓名的年龄并保存在文件中 p.store(new FileWriter("F:\\myfile\\key-value.txt"), p.toString()); System.out.println(p); } //设置和获取元素 public static void setAndget() { Properties p = new Properties(); p.setProperty("zhangsan","30"); p.setProperty("lisi","40"); System.out.println(p); String value = p.getProperty("lisi"); System.out.println("value="+value); //p.setProperty("lisi",89+"");//修改lisi年龄 Set<String> name = p.stringPropertyNames(); Iterator<String> it = name.iterator(); while(it.hasNext()) { String key = it.next(); System.out.println("key:"+key+" "+"value"+p.getProperty(key)); } /* for(String key: name) { System.out.println("key:"+key+" "+"value"+p.getProperty(key)); } */ } }
七、随机访问类
类 RandomAccessFile：此类的实例支持对随机访问文件的读取和写入
java.lang.Object
继承者 java.io.RandomAccessFile
RandomAccessFile:RandomAccessFile(File file, String mode)
该类不算是IO体系中的子类，而是直接继承Object。
但是它是IO包中的成员，因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置或者通过seek改变指针的位置。
其实，完成读写的原理是内部封装了字节输入流和输出流。
通过构造函数可以看出，该类只能操作文件。
而且，操作文件还有模式mode：只读r、读写rw、rws、rwd
如果文件只读r，不会创建文件，而是会去读取一个存在的文件，如果该文件不存在，则会出现异常。
如果文件为读写rw，要操作的文件不存在，会自动创建，而且如果存在不会覆盖。
//例子7：
import java.io.*; class RandomAccessFileDemo { public static void main(String[] args)throws IOException { //WriteFile(); //WriteFile2(); ReadFile(); } public static void WriteFile()throws IOException { RandomAccessFile raf = new RandomAccessFile("Random.txt","rw"); raf.write("李四".getBytes()); raf.writeInt(65); raf.write("王武".getBytes()); raf.writeInt(67); raf.close(); } public static void WriteFile2()throws IOException { //改变指针，随机位置写入数据，还可以修改之前位置所写的数据(不会重新覆盖创建的文件) RandomAccessFile raf = new RandomAccessFile("Random.txt","rw"); raf.seek(8*3); raf.write("周七".getBytes()); raf.writeInt(69); raf.seek(8*2); raf.write("赵六".getBytes()); raf.writeInt(68); raf.close(); } public static void ReadFile()throws IOException { RandomAccessFile raf = new RandomAccessFile("Random.txt","r"); PrintStream ps = System.out; System.setOut(ps); byte[] buf = new byte[4]; //ps.println(raf.getFilePointer());//获取当前指针位置 //raf.seek(8*1);//改变当前指针的位置(可以前后移动) //raf.skipBytes(8);//跳过8个字节(只能往后跳) while(raf.read(buf)!=-1) { String name = new String(buf); ps.println("name="+name); int age= raf.readInt(); ps.println("age="+age); } raf.close(); } }
八、序列流
java.lang.Object
继承者 java.io.InputStream
继承者 java.io.SequenceInputStream
类 SequenceInputStream:表示其他输入流的逻辑串联
构造方法：
SequenceInputStream(Enumeration<? extends InputStream> e)
SequenceInputStream(InputStream s1, InputStream s2)
合并文件
//例子8：
import java.io.*; import java.util.*; class SequenceStreamDemo { public static void main(String[] args)throws IOException { Vector<FileInputStream> v = new Vector<FileInputStream>(); v.add(new FileInputStream("F:\\myfile\\1.txt")); v.add(new FileInputStream("F:\\myfile\\2.txt")); v.add(new FileInputStream("F:\\myfile\\3.txt")); Enumeration<FileInputStream> enu = v.elements(); SequenceInputStream sis = new SequenceInputStream(enu);//将多个流整合为一个流对象 BufferedWriter bufw = new BufferedWriter(new FileWriter("F:\\myfile\\123.txt")); int num = 0; while((num=sis.read())!=-1) { bufw.write(num); bufw.flush(); } sis.close(); bufw.close(); } }
九、字符串读写流
类 StringReader：其源为一个字符串的字符流。
StringReader(String s) 创建一个新字符串 reader。
类 StringWriter：一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。关闭 StringWriter 无效。
此类中的方法在关闭该流后仍可被调用，而不会产生任何 IOException。
StringWriter()
使用默认初始字符串缓冲区大小创建一个新字符串 writer。
//例子9：
import java.io.*; class StringReaderWriterDemo { public static void main(String[] args)throws IOException { StringReader sr = new StringReader("Thank you very much"); StringWriter sw = new StringWriter(); //StringWriter s = sw.append('A'); int by = 0; while((by=sr.read())!=-1) { sw.write(by); } System.out.println(sw.toString()); } }
十、对象流
类 ObjectInputStream:
1.ObjectOutputStream()
2.ObjectOutputStream(OutputStream out)
3.void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
java.lang.Object
继承者 java.io.InputStream
继承者 java.io.ObjectInputStream
---------------------------------------------------------------------
类 ObjectOutputStream:
1.ObjectInputStream()
2.ObjectInputStream(InputStream in)
3.Object readObject() 从 ObjectInputStream 读取对象。
java.lang.Object
继承者 java.io.OutputStream
继承者 java.io.ObjectOutputStream
//例子10：
import java.io.*; class ObjectStreamDemo { public static void main(String[] args)throws Exception { //writeObj(); readObj(); } public static void writeObj()throws IOException { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Object.txt")); oos.writeObject(new Person("zhangsan",25)); oos.close(); } public static void readObj()throws Exception { ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Object.txt")); Person p =(Person)ois.readObject(); System.out.println(p); ois.close(); } }
程序猿神奇的手，每时每刻，这双手都在改变着世界的交互方式！
本文转自当天真遇到现实博客园博客，原文链接：http://www.cnblogs.com/XYQ-208910/p/4918714.html如需转载请自行联系原作者