java学习（14）_java 文件创建bytearrayoutputstream-CSDN博客

本文链接：https://blog.csdn.net/ag_nevergiveup/article/details/72082627

java学习（14）

这篇接着来写一些Io流

1.LineNumberReader：之前写过的IO流的可以读写文件，而LineNumberReader类不仅能够读文件，还能来获取行号以及设置行号

1）public int getLineNumber():获取行号

2）public void setLineNumber(int lineNumber):设置起始行号

3）String readLine()：读取一行

代码示例：

public static void main(String[] args) throws IOException {
		//创建LineNumberReader对象
		LineNumberReader lnr = new LineNumberReader(new FileReader("lnr.txt"));
		
		//设置行号
		lnr.setLineNumber(12);
		
		//一次一行读文件
		String line;
		while((line = lnr.readLine())!=null){
			System.out.println(lnr.getLineNumber()+":"+line);
		}
	
		//关流
		lnr.close();
	}

结果：

分析：这里设置了行号，就会从下一行开始读取数据。

2.操作基本数据类型的流：可以操作基本类型的流对象。之前对于文件的读写基本都是String类型的，这两个流可以进行基本数据类型的读写，但是读写顺序必须一致，否则数据读出来是有问题的！

1）DataInputStream:读数据

2）DataOutputStream:写数据

代码示例：

private static void read() throws IOException {
		//DataInputStream
		DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));
		//读数据
		System.out.println(dis.readByte());
		System.out.println(dis.readShort());
		System.out.println(dis.readInt());
		System.out.println(dis.readLong());
		System.out.println(dis.readChar());
		System.out.println(dis.readFloat());
		System.out.println(dis.readDouble());
		System.out.println(dis.readBoolean());
		//关流
		dis.close();
	}

	private static void write() throws IOException {
		//DataOutputStream
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
		//写数据
		dos.writeByte(12);
		dos.writeShort(120);
		dos.writeInt(1200);
		dos.writeLong(120000L);
		dos.writeChar(65);
		dos.writeFloat(12.34F);
		dos.writeDouble(23.45);
		dos.writeBoolean(true);
		//关流
		dos.flush();
	}

分析：这里给出了一个简单的读写方法，利用了 DataInputStream和DataOutputStream，关键就在于读写的顺序必须一致！

3. 内存操作流：解决临时数据存储的问题。这里是将数据写到流中保存在内存，并且可以进行读取

1）操作字节数组

ByteArrayInputStream

ByteArrayOutputStream

byte[] toByteArray() 将之前写入内存的流转换成字节数组

2）操作字符数组

CharArrayReader

CharArrayWrite

3）操作字符串

StringReader

StringWriter

代码示例：关于字节数组的操作

public static void main(String[] args) throws IOException {
		//创建ByteArrayOutputStream对象，进行写数据
		ByteArrayOutputStream baos = new ByteArrayOutputStream();

		//写入数据
		baos.write("abcdef".getBytes());

		//转化字节数组
		byte[] buf = baos.toByteArray();
		
		//利用构造方法转化ByteArrayInputStream对象，进行读取
		ByteArrayInputStream bais = new ByteArrayInputStream(buf);
		
		int by;
		while((by = bais.read())!=-1){
			System.out.print((char)by);
		}
		
		//关流
		bais.close();
		baos.close();
	}

4.打印流：分为字节打印流和字符打印流：

字节打印流PrintStream

字符打印流PrintWriter

打印流的特点：

A:只能操作目的地，不能操作数据源

B:可以操作任意类型的数据

C:如果启动了自动刷新，能够自动刷新

D:可以操作文件的流

可以直接操作文件的流：看流对象的构造方法同时有File和String类型的参数，就可以直接操作文件

代码示例：

public static void main(String[] args) throws IOException {
		//封装数据源和目的地
		BufferedReader br = new BufferedReader(new FileReader("test.java"));
		PrintWriter pw = new PrintWriter(new FileOutputStream("pw.java"), true);
		
		//调用PrintWriter的方法写数据
		//如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作
		String line;
		while((line = br.readLine())!=null){
			pw.println(line);
		}
		
		//关流
		br.close();
		pw.checkError();
	}

分析：打印流可以打开自动刷新功能，对于打印流的两个构造方法PrintWriter(OutputStream out, boolean autoFlush)

PrintWriter(Writer out, boolean autoFlush)

把autoFlush这个参数改为true，在调用println，printf和format方法的时候，会进行自动刷新。

pw.println(line)

相当于做了三件事：1）写数据 2）换行 3）刷新

就是BufferedWriter（bw为BufferedWriter类的一个对象）的三条语句：1)bw.write()2)bw.newLine()3)bw.flush()

5.标准输入输出流
System类下成员变量：

标准输入流：

public static final InputStream in

在Scanner对象进行键盘数据录入的时候，会调用System.in，就是把键盘录入数据

封装成了一个标准输入流。

标准输出流：

public static final PrintStream out

经常使用的输出，就是间接使用打印流PrintStream的out方法进行输出。

6.合并流：SequenceInputStream类可以将多个输入流串流在一起，合并为一个输入流，因此，该流也被称为合并流。

它的构造方法有两个输入流参数：SequenceInputStream(InputStream s1, InputStream s2)

将s1和s2合并成一个输入流，先读取s1后读取s2。可以把两个文件复制到一个文件中。

代码示例：

public class SequenceInputStreamTest {

	public static void main(String[] args) throws IOException {
		//SequenceInputStream
		//封装数据源
		SequenceInputStream sis = new SequenceInputStream(new FileInputStream("LineNumerStream.java"), new FileInputStream("PrintWriterTest.java"));
		//封装目的地
		FileOutputStream fos = new FileOutputStream("copy.java");
		
		//一次读写一个字节数组
		byte[] bys = new byte[1024];
		int len;
		while((len = sis.read(bys))!=-1){
			fos.write(bys);
		}
		
		//关流
		sis.close();
		fos.close();
	}

7. 对象的序列化和反序列化：可以把对象写到文件中和从文件中把对象读出来

序列化流：把对象按照流一样的方式写到文件或者在网络中传输。

反序列化流：把文件或者网络中的流对象数据还原对象。

ObjectOutputStream：序列化流

writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

在这里创建一个学生类，用来创建对象写入文件：

public static void main(String[] args) throws IOException {
		//ObjectOutputStream：序列化流
		//writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
		
		//创建ObjectOutputStream对象
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
		
		//创建学生对象
		Student s = new Student("lisi", 12);
		
		//writeObject(Object obj) 将指定的对象写入 ObjectOutputStream
		oos.writeObject(s);
		
		//关流
		oos.close();
	}

ObjectInputStream：反序列化流

Object readObject() 从 ObjectInputStream 读取对象。

public static void main(String[] args) throws IOException, ClassNotFoundException {
		 //ObjectInputStream：反序列化流
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
		
		 //Object readObject() 从 ObjectInputStream 读取对象
		Object object = ois.readObject();
		
		System.out.println(object);
		
		//关流
		ois.close();
	}

运行如下：

注意：如果一个类不是实现Serializable接口无法把实例化，会报异常

java.io.NotSerializableException，

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无

法使其任何状态序列化或反序列化。

8. Properties：实现类map接口，本质上是一个map集合，利用map的方法，可以对Properties进行操作，添加元素或是遍历：

public static void main(String[] args) {
		//创建Properties对象
		Properties prop = new Properties();
		
		//添加元素
		prop.put("001", "erha");
		prop.put("002", "jinmao");
		prop.put("003", "chaiquan");
		
		//获取键的集合
		Set<Object> keys = prop.keySet();
		//遍历键的集合，通过键找值
		for (Object key : keys) {
			System.out.println(key+":"+prop.get(key));
		}
	}

8.1 Properties:Properties 类表示了一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。

特点：Properties 可保存在流中或从流中加载。也就是说，他可以实现从集合到文件的读写操作。

8.2 Properties的特有功能：可以实现map方法一样的效果：

A:添加元素：public Object setProperty(String key,String value)

B:获取元素：

public String getProperty(String key)

public Set<String> stringPropertyNames()

public static void main(String[] args) {
		//创建Properties对象
		Properties prop = new Properties();
		
		//添加元素
		prop.setProperty("001", "erha");
		prop.setProperty("002", "jinmao");
		prop.setProperty("003", "chaiquan");
		
		//获取键的集合
		Set<String> keys = prop.stringPropertyNames();
		for (String key : keys) {
			System.out.println(key+" "+prop.getProperty(key));
		}
		
	}

8.3 可以和IO流进行结合使用：

把文件中的数据加载到集合中。注意：文件中的数据必须是键值对象形式的（例如：a=97）。

public void load(InputStream inStream)

public void load(Reader reader)

public static void main(String[] args) throws IOException {
		//创建Properties集合
		Properties prop = new Properties();
		//public void load(Reader reader)
		prop.load(new FileReader("prop2.txt"));
		//获取键的集合
		Set<String> keys = prop.stringPropertyNames();
		for (String key : keys) {
			System.out.println(key+" "+prop.getProperty(key));
		}
	}

prop2.txt：

运行如下：

把集合中的数据存储到文本文件中，并且是按照键值对形式存储的。

public void store(OutputStream out,String comments)

public void store(Writer writer,String comments)

public static void main(String[] args) throws IOException {
		//创建Properties对象
		Properties prop = new Properties();
		
		//添加元素
		prop.setProperty("001", "abc");
		prop.setProperty("002", "xyz");
		prop.setProperty("003", "qwer");
		
		//写数据
		prop.store(new FileWriter("prop3.txt"), null);

	}

文件prop3.txt: