/**
* ！！：以后写流的时候一定要加入缓冲！！
* 对文件或其它目标频繁的读写操作，效率低，性能差。
* 缓冲流：好处是能更高效地读写信息，原理是将数据先缓冲起来，然后一起写入或读取出来。
*
* BufferedInputStream：字节缓冲流（有一个内部缓冲区数组，用于缓冲数据）
*/
public class Main {
public static void main(String[] args) {
input();
output();
}
/**
* 使用字节缓冲流进行读取操作
*/
public static void input(){
try {
InputStream in = new FileInputStream("c:\\fuck\\javaTest1.txt");
BufferedInputStream bis = new BufferedInputStream(in); //根据字节输入流构造一个字节缓冲流
Reader r= new InputStreamReader(bis);
char[] cs = new char[512];
int len = -1;
StringBuilder sb = new StringBuilder();
while((len=r.read(cs))!=-1){
sb.append(new String(cs));
}
r.close();
bis.close();
in.close();
System.out.println(sb);
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
/**
* 使用字节缓冲流进行写入操作
*/
public static void output(){
try {
OutputStream out = new FileOutputStream("c:\\fuck\\javaTest1.txt");
BufferedOutputStream bis = new BufferedOutputStream(out); //根据字节输出流构造一个字节缓冲流
String info = "顶替要夺kasdfas山不在高";
bis.write(info.getBytes());
bis.flush(); //刷新缓冲区（把数据写入文件里）
bis.close(); //关闭了会刷新缓冲区
out.close();
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
public class Main {
public static void main(String[] args) {
// output();
input();
System.out.println("finished.");
}
/**
* 使用字符缓冲流进行读取操作
*/
public static void input(){
try {
Reader r = new FileReader("c:\\fuck\\javaTest1.txt");
BufferedReader br = new BufferedReader(r); //根据字符输入流构造一个字符缓冲流
char[] cs = new char[512];
int len = -1;
StringBuilder sb = new StringBuilder();
while((len=br.read(cs))!=-1){
sb.append(new String(cs));
}
br.close();
r.close();
System.out.println(sb);
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
/**
* 使用字符缓冲流进行写入操作
*/
public static void output(){
try {
Writer w = new FileWriter("c:\\fuck\\javaTest1.txt");
BufferedWriter bw = new BufferedWriter(w); //根据字符输出流构造一个字符缓冲流
bw.write("abcde i love u 丁");
bw.flush();
w.close();
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
/**
* 打印流：主要功能是用于输出
* PrintStream：字节打印流
* PrintWriter：字符打印流
*/
public class Main {
public static void main(String[] args) {
// print();
print2();
System.out.println("finished.");
}
/**
* 使用PrintStream打印流
*/
public static void print(){
try {
OutputStream out = new FileOutputStream("c:\\fuck\\javaTest1.txt");
BufferedOutputStream bos = new BufferedOutputStream(out);
PrintStream ps = new PrintStream(bos); //构造字节打印流
ps.println(3.14f);
ps.println(188);
ps.println(true);
ps.println("it has.");
ps.flush();
bos.close(); //关掉一个就行了，其它也跟着关了
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
/**
* 使用PrintWriter打印流
*/
public static void print2(){
try {
BufferedWriter bw = new BufferedWriter(new FileWriter("c:\\fuck\\javaTest1.txt"));
PrintWriter pw = new PrintWriter(bw);
pw.print("\r\n"); //输出回车换行符
pw.println(105);
pw.println("饥饿营销\"饿\"成笑话");
pw.flush();
pw.close();
bw.close();
} catch (FileNotFoundException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
/**
* 对象流
* 对象序列化：将一个对象转化成二进制的byte流
* 序列化操作：将对象保存在文件上 ObjectOutputStream
* 反序列化操作：将对象从文件中恢复 ObjectInputStream
* 被序列化对象所在的类必须实现java.Serializable接口
* 序列化一组对象可采用：对象数组的形式，因为对象数组可以向Object进行转型操作
* transient关键字：声明一个实例变量，当对象存储时，它的值不需要维持。
* 当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。
* 为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。
* 当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。
*/
public class Main {
public static void main(String[] args) {
// writerObject();
// readerObject();
// writerObject2();
readerObject2();
System.out.println("finished.");
}
//使用ObjectOutputStream把对象写入文件
public static void writerObject(){
try {
OutputStream out = new FileOutputStream("c:\\fuck\\obj.tmp");
ObjectOutputStream oos = new ObjectOutputStream(out); //根据字节输出流构造一个对象流
oos.writeInt(106);
Dog d1 = new Dog("fish7",15);
oos.writeObject(d1);
oos.close();
out.close();
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
//使用ObjectOutputStream把一组对象写入文件（对象数组）
public static void writerObject2(){
try {
OutputStream out = new FileOutputStream("c:\\fuck\\obj.tmp");
ObjectOutputStream oos = new ObjectOutputStream(out); //根据字节输出流构造一个对象流
Dog[] dogs = {new Dog("fish7",15),new Dog("fish8",16),new Dog("fish9",17)};
oos.writeObject(dogs);
oos.close();
out.close();
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
//使用ObjectInputStream读取文件中的对象
public static void readerObject(){
try {
InputStream in = new FileInputStream("c:\\fuck\\obj.tmp");
ObjectInputStream ois = new ObjectInputStream(in); //根据字节输入流构造一个对象流
int num = ois.readInt();
Dog d1 = (Dog)ois.readObject();
ois.close();
in.close();
System.out.println(num);
System.out.println(d1.name+" "+d1.age);
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
}
//使用ObjectInputStream读取文件中的一组对象（对象数组）
public static void readerObject2(){
try {
InputStream in = new FileInputStream("c:\\fuck\\obj.tmp");
ObjectInputStream ois = new ObjectInputStream(in); //根据字节输入流构造一个对象流
Dog[] dogs = (Dog[])ois.readObject();
ois.close();
in.close();
for(Dog i:dogs)
System.out.println(i.name+" "+i.age);
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
}
}
/**
* 类通过实现java.Serializable接口以启用其序列化功能，标记接口，没有任何方法
*/
class Dog implements Serializable{
String name;
transient int age; //使用transient关键字声明的属性，将不会被序列化
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
