java学习（14）

喜欢ヅ旅行 2022-06-15 19:59 191阅读 0赞

**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();
    	}

结果：

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

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();
    	}

运行如下：

![Center 1][]

> 注意：如果一个类不是实现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.1Properties:Properties 类表示了一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。

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

>   
>

> 8.2Properties的特有功能：可以实现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：
> > 
> > ![Center 2][]  
> > 
> > 
> > 运行如下：
> > 
> > ![Center 3][]  
> >

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

> > > 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:
> > 
> > ![Center 4][]  
> >

[Center]: /images/20220616/d9398391db0847d8879680e9a26efb6d.png
[Center 1]: /images/20220616/db43d9a04cab447e86ea75985253ee39.png
[Center 2]: /images/20220616/a6530c64efbe494e85b4dda7c570fd05.png
[Center 3]: /images/20220616/d4d92349ce1e483e958e44e84fee7efb.png
[Center 4]: /images/20220616/6d30f1b636a943b9975ff14359a062d6.png