java从入门到弃坑第十四天

1.LineNumberReader：跟踪行号的字符缓冲输入流。

                    构造方法：LineNumberReader(Reader in):用默认输入缓冲区的大小创建行编号Reader。

                                      LineNumberReader(Reader in，int sz):创建行编号reader，给定缓冲区大小。

         成员方法：public int getLineNumber():获取行号

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

                                      String readLine()：读取一行

exp：读取文件，每次读取一行打印并且加上行号，要在根目录下先创建文件在读取

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class ReaderDemo {
	public static void main(String[] args) throws IOException {
		LineNumberReader lnr=new LineNumberReader(new FileReader("1.txt"));
		String s;//用字符串s接取读取的行字符。
		while((s=lnr.readLine())!=null){
			System.out.println(lnr.getLineNumber()+"  "+s);
		}
	}
}

2.操作基本数据类型的流：DataInputStream：向文件中写入数据。

                                           DataOutputStream：从文件中读取数据。

 注：用该io流操作时读取数据顺序必须和写入时的一致，否则数据有问题。顺序不一致，

          报错：Exception in thread "main" java.io.EOFException。

3.内存操作流：解决临时数据储存的问题。

     操作字节数组：用InputStream或OutputStream。

     操作字符数组：用StringReader或StringWriter。将数据写到流中保存在内存，并且读取。

4.打印流：字节打印流：PrintStream，字符打印流：PrintWriter。

      特点：A：只能操作目的地，不能操作数据源。

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

                 C：创建对象时可以启用自动刷新功能，但仅限于println、printf 或 format方法。

                 D：可以操作文件的流：其构造方法中同时有File和String类型的参数。

exp：利用字符打印流复制java文件(BufferedReader+PrintWriter)，启动自动刷新。

import java.io.BufferedReader;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class CopyDemo1 {
	public static void main(String[] args) throws IOException {
		BufferedReader bw=new BufferedReader(new FileReader("1.java"));
		PrintWriter pw=new PrintWriter(new FileWriter("2.java"), true);
		String s;
		while((s=bw.readLine())!=null){
			pw.println(s);
		}
		bw.close();
		pw.close();
	}
}

5.标准输入输出流：public static final InputStream in，public static final PrintStream out，这两个是System下的两个

                                成员变量，System.out是标准输出流，而println是操作字符流，所以在这之中用转换流对其操作

                                即为System.out.println();

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

   构造放法：SequenceInputStream(InputStream s1, InputStream s2)：将两个流合并成一个输入流，先s1，后s2

exp：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
//将1.java和2.java用一个合并输入流读取并复制到3.java中。
public class CopyDemo2 {	
	public static void main(String[] args) throws IOException {
		SequenceInputStream sis=new SequenceInputStream(new FileInputStream("1.java"), new FileInputStream("2.java"));
		FileOutputStream fo=new FileOutputStream("3.java");
		byte b[]=new byte[1024];//一次读取一个字节数组
		int len;//设定读取到的数组长度
		while((len=sis.read(b))!=-1){
			fo.write(b, 0, len);
		}
		sis.close();
		fo.close();
	}
}

7.对象的序列化和反序列化

     ObjectOutputStream：序列化流，把对象按照流一样的方式写到文件或者在网络中传输，writeObject(Object obj)

     ObjectInputStream：反序列化流，把文件或者网络中的流对象数据还原对象，Object readObject()

     注：要让类实现序列化，必须先实现Serializable接口，不然会报错：java.io.NotSerializableException

exp：

import java.io.Serializable;

public class Student implements Serializable {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}

测试类：

import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class TestDemo {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		Student s1=new Student("a", 1);
		Student s2=new Student("b", 2);
		Student s3=new Student("c", 3);
		ObjectOutputStream ops=new ObjectOutputStream(new FileOutputStream("Student.txt"));
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("Student.txt"));
		ops.writeObject(s1);
		ops.writeObject(s2);
		ops.writeObject(s3);
		try {
			while(true){
				System.out.println(ois.readObject().toString());
			}
		} catch (EOFException e) {
			// TODO: handle exception
			//若用一般判断条件，则读完回报该异常，因此再此抓掉异常，遇到异常中断
		}
		ops.close();
		ois.close();
	}
}

8.Properties：该类表示一个持久的属性集，其列表中每个键都对应一个字符串。

            特点：该类就是一个可以保存在流中或从流中加载的map集合。

     成员方法：A：添加元素，public Object setProperty(String key,String value)

                       B：获取元素，public String getProperty(String key)

                                               public Set<String> stringPropertyNames()

exp：把集合中的数据存储到文本文件中，并且是按照键值对形式存储的，然后改变一个键所对应的值。

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class propDemo1 {
	public static void main(String[] args) throws IOException {
		Properties prop =new Properties();
		FileOutputStream fos=new FileOutputStream("1.txt");
		prop.setProperty("a", "1");
		prop.setProperty("b", "2");
		prop.setProperty("c", "3");
		Set<Object> key=prop.keySet();
		for (Object o : key) {
			if(o.equals("b")){
				prop.setProperty("b", "100");
			}
		}
		prop.store(fos, "null");
		fos.close();
	}
}