day19Java-其它IO

博客名称
Java-(中级)

DataIn(out)putStream-数据操作流

java.io.InputStream 继承者 java.io.FilterInputStream 继承者 java.io.DataInputStream
java.io.OutputStream 继承者 java.io.FilterOutputStream 继承者 java.io.DataOutputStream

数据输入流：DataInputStream
  			DataInputStream(InputStream in)
数据输出流：DataOutputStream
  			DataOutputStream(OutputStream out) 

代码演示

public class DataStreamDemo {
	public static void main(String[] args) throws IOException {
		// 写
		// write();
		// 读
		read();
	}

	private static void read() throws IOException {
		// DataInputStream(InputStream in)
		// 创建数据输入流对象
		DataInputStream dis = new DataInputStream(
				new FileInputStream("dos.txt"));

		// 读数据
		byte b = dis.readByte();
		short s = dis.readShort();
		int i = dis.readInt();
		long l = dis.readLong();
		float f = dis.readFloat();
		double d = dis.readDouble();
		char c = dis.readChar();
		boolean bb = dis.readBoolean();

		// 释放资源
		dis.close();

		System.out.println(b);
		System.out.println(s);
		System.out.println(i);
		System.out.println(l);
		System.out.println(f);
		System.out.println(d);
		System.out.println(c);
		System.out.println(bb);
	}

	private static void write() throws IOException {
		// DataOutputStream(OutputStream out)
		// 创建数据输出流对象
		DataOutputStream dos = new DataOutputStream(new FileOutputStream(
				"dos.txt"));

		// 写数据了
		dos.writeByte(10);
		dos.writeShort(100);
		dos.writeInt(1000);
		dos.writeLong(10000);
		dos.writeFloat(12.34F);
		dos.writeDouble(12.56);
		dos.writeChar('a');
		dos.writeBoolean(true);

		// 释放资源
		dos.close();
	}
}

ByteArrayIn(out)putStream、CharArrayReader(Writer)、StringReader(Writer)-内存操作流

java.io.InputStream 继承者 java.io.ByteArrayInputStream
java.io.OutputStream 继承者 java.io.ByteArrayOutputStream

java.io.Reader 继承者 java.io.CharArrayReader
java.io.Writer 继承者 java.io.CharArrayWriter

java.io.Reader 继承者 java.io.StringReader
java.io.Writer 继承者 java.io.StringWriter

内存操作流：用于处理临时存储信息的，程序结束，数据就从内存中消失。
字节数组：
		ByteArrayInputStream
		ByteArrayOutputStream
字符数组：
		CharArrayReader
		CharArrayWriter
字符串：
		StringReader
		StringWriter

代码演示

public class ByteArrayStreamDemo {
	public static void main(String[] args) throws IOException {
		// 写数据
		// ByteArrayOutputStream()
		ByteArrayOutputStream baos = new ByteArrayOutputStream();

		// 写数据
		for (int x = 0; x < 10; x++) {
			baos.write(("hello" + x).getBytes());
		}

		// 释放资源
		// 通过查看源码我们知道这里什么都没做，所以根本需要close()
		// baos.close();

		// public byte[] toByteArray()
		byte[] bys = baos.toByteArray();

		// 读数据
		// ByteArrayInputStream(byte[] buf)
		ByteArrayInputStream bais = new ByteArrayInputStream(bys);

		int by = 0;
		while ((by = bais.read()) != -1) {
			System.out.print((char) by);
		}

		// bais.close();
	}
}

System.in(out)-标准输入(出)流

标准输入流

System.in 标准输入流。是从键盘获取数据的
键盘录入数据：
		A:main方法的args接收参数。
			java HelloWorld hello world java
		B:Scanner(JDK5以后的)
			Scanner sc = new Scanner(System.in);
			String s = sc.nextLine();
			int x = sc.nextInt()
		C:通过字符缓冲流包装标准输入流实现
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

代码演示

public class SystemInDemo {
	public static void main(String[] args) throws IOException {
		// //获取标准输入流
		// InputStream is = System.in;
		// //我要一次获取一行行不行呢?
		// //行。
		// //怎么实现呢?
		// //要想实现，首先你得知道一次读取一行数据的方法是哪个呢?
		// //readLine()
		// //而这个方法在哪个类中呢?
		// //BufferedReader
		// //所以，你这次应该创建BufferedReader的对象，但是底层还是的使用标准输入流
		// // BufferedReader br = new BufferedReader(is);
		// //按照我们的推想，现在应该可以了，但是却报错了
		// //原因是：字符缓冲流只能针对字符流操作，而你现在是字节流，所以不能是用?
		// //那么，我还就想使用了，请大家给我一个解决方案?
		// //把字节流转换为字符流，然后在通过字符缓冲流操作
		// InputStreamReader isr = new InputStreamReader(is);
		// BufferedReader br= new BufferedReader(isr);
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.println("请输入一个字符串：");
		String line = br.readLine();
		System.out.println("你输入的字符串是：" + line);

		System.out.println("请输入一个整数：");
		// int i = Integer.parseInt(br.readLine());
		line = br.readLine();
		int i = Integer.parseInt(line);
		System.out.println("你输入的整数是：" + i);
	}
}

标准输出流

System类中的两个成员变量：
		public static final InputStream in “标准”输入流。
		public static final PrintStream out “标准”输出流。

		InputStream is = System.in;
		PrintStream ps = System.out;

代码演示

public class SystemOutDemo {
	public static void main(String[] args) {
		// 有这里的讲解我们就知道了，这个输出语句其本质是IO流操作，把数据输出到控制台。
		System.out.println("helloworld");

		// 获取标准输出流对象
		PrintStream ps = System.out;
		ps.println("helloworld");
		
		ps.println();
		// ps.print();//这个方法不存在
		
		// System.out.println();
		// System.out.print();
	}
}

转换流的应用

public class SystemOutDemo2 {
	public static void main(String[] args) throws IOException {
		// 获取标准输入流
		// // PrintStream ps = System.out;
		// // OutputStream os = ps;
		// OutputStream os = System.out; // 多态
		// // 我能不能按照刚才使用标准输入流的方式一样把数据输出到控制台呢?
		// OutputStreamWriter osw = new OutputStreamWriter(os);
		// BufferedWriter bw = new BufferedWriter(osw);
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				System.out));

		bw.write("hello");
		bw.newLine();
		// bw.flush();
		bw.write("world");
		bw.newLine();
		// bw.flush();
		bw.write("java");
		bw.newLine();
		bw.flush();
		
		bw.close();
	}
}

RandomAccessFile-随机访问流

java.lang.Object 继承者 java.io.RandomAccessFile

随机访问流：

		RandomAccessFile类不属于流，是Object类的子类。
  		但它融合了InputStream和OutputStream的功能。
  		支持对文件的随机访问读取和写入。

public RandomAccessFile(String name,String mode)：第一个参数是文件路径，第二个参数是操作文件的模式。
  		模式有四种，我们最常用的一种叫"rw",这种方式表示我既可以写数据，也可以读取数据 

代码演示

public class RandomAccessFileDemo {
	public static void main(String[] args) throws IOException {
		// write();
		read();
	}

	private static void read() throws IOException {
		// 创建随机访问流对象
		RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

		int i = raf.readInt();
		System.out.println(i);
		// 该文件指针可以通过 getFilePointer方法读取，并通过 seek 方法设置。
		System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

		char ch = raf.readChar();
		System.out.println(ch);
		System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

		String s = raf.readUTF();
		System.out.println(s);
		System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

		// 我不想重头开始了，我就要读取a，怎么办呢?
		raf.seek(4);
		ch = raf.readChar();
		System.out.println(ch);
	}

	private static void write() throws IOException {
		// 创建随机访问流对象
		RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

		// 怎么玩呢?
		raf.writeInt(100);
		raf.writeChar('a');
		raf.writeUTF("中国");

		raf.close();
	}
}

SequenceInputStream-合并流

java.io.InputStream 继承者 java.io.SequenceInputStream

 以前的操作：
  	a.txt -- b.txt
 	c.txt -- d.txt
  
 现在想要：
  	a.txt+b.txt -- c.txt

代码演示1(双流合并)

public class SequenceInputStreamDemo {
	public static void main(String[] args) throws IOException {
		// SequenceInputStream(InputStream s1, InputStream s2)
		// 需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的内容复制到Copy.java中
		InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
		InputStream s2 = new FileInputStream("DataStreamDemo.java");
		SequenceInputStream sis = new SequenceInputStream(s1, s2);
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("Copy.java"));

		// 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = sis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}

		bos.close();
		sis.close();
	}
}

代码演示2(多流合并)

以前的操作：
  a.txt -- b.txt
  c.txt -- d.txt
  e.txt -- f.txt

现在想要：
  a.txt+b.txt+c.txt -- d.txt

代码演示

public class SequenceInputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		// 需求：把下面的三个文件的内容复制到Copy.java中
		// ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java

		// SequenceInputStream(Enumeration e)
		// 通过简单的回顾我们知道了Enumeration是Vector中的一个方法的返回值类型。
		// Enumeration<E> elements()
		Vector<InputStream> v = new Vector<InputStream>();
		InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
		InputStream s2 = new FileInputStream("CopyFileDemo.java");
		InputStream s3 = new FileInputStream("DataStreamDemo.java");
		v.add(s1);
		v.add(s2);
		v.add(s3);
		Enumeration<InputStream> en = v.elements();
		SequenceInputStream sis = new SequenceInputStream(en);
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("Copy.java"));

		// 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = sis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}

		bos.close();
		sis.close();
	}
}