Java基础（二十一）

标准输入输出

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

//由于标准输出流是一个字节输出流，所以只能输出字节或者字节数组，
//但是我们读取到的数据是字符串，如果想进行输出还行需要转化成字节数组
//标准输出流转化成字符输出流即可OutputStreamWriter
public class InputDemo_02 {
public static void main(String[] args) throws IOException {
	//创建输入流对象
	BufferedReader br=new BufferedReader(new FileReader("b\\InputDemo.java"));
	//创建输出流对象
	//method1(br);
	//method2(br);
	BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
	String line;
	while((line=br.readLine())!=null) {
		bw.write(line);
		bw.newLine();
	}
	bw.close();
	br.close();
}

private static void method2(BufferedReader br) throws IOException {
	Writer w=new OutputStreamWriter(System.out);//多态，父类型引用子类对象
	String line;
	while((line=br.readLine())!=null) {
		w.write(line);
		w.write("\r\n");
	}
	w.close();
	br.close();
}

private static void method1(BufferedReader br) throws IOException {
	OutputStream os=System.out;
	String line;
	while((line=br.readLine())!=null) {
		os.write(line.getBytes());
		os.write("\r\n".getBytes());
	}
	//释放资源
	os.close();
	br.close();
}
}

读取键盘录入的数据，并输出到项目根目录下的a.txt文件中

mport java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

/*读取键盘录入的数据，并输出到项目根目录下的a.txt文件中
 * 数据源：读取键盘录入的数据  System.in
 * 目的地：项目根目录下的a.txt FileWriter
 * 转换流：需要把字节流输入流转化成字符输入流 InputStreamReader
 * InputStreamReader(InputStream in) */
public class InputDemo_03 {


public static void main(String[] args) throws IOException {
	FileWriter fw=new FileWriter("a.txt");
	InputStream is=System.in;
	//method1(fw, is);
	Reader r=new InputStreamReader(is);
	char[]chs=new char[1024];
	int len;
	while((len=r.read(chs))!=-1) {
		fw.write(chs, 0, len);
		fw.flush();
	}
	r.close();
	fw.close();
}

private static void method1(FileWriter fw, InputStream is) throws IOException {
	int  len;
	byte[]bys=new byte[1024];
	while((len=is.read(bys))!=-1) {
		fw.write(new String(bys,0,len));
		fw.flush();
	}
	is.close();
	fw.close();
}



}

打印流:PrintStream
PrintWriter
注意;只能输出不能输入

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;

/* 打印流:PrintStream
			PrintWriter
			可以自动换行
			不能输出字节，但是可以输出其他任意类型
			通过某些配置，可以实现自动刷新（只有在调用println printf或format才有用）
			也是包赚流
	注意:只能输出不能输入*/
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
	PrintWriter pw=new PrintWriter("b.txt");
	pw.write("hello");
	pw.write("world");
	pw.write("java");
	pw.close();
}
}

打印流的特有功能：
自动换行: println
自动刷新 :创建printWriter对象时启动自动刷新功能，并且使用Println等3个方法
注意：创建FileWriter对象时Boolean参数是是否追加，而创建打印流对象的Boolean类型参数是是否自动刷新

port java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriterDemo_02 {
 public static void main(String[] args) throws IOException {
	 //PrintWriter pw=new PrintWriter("c.txt");
	 PrintWriter pw=new PrintWriter(new FileWriter("d.txt"),true);
	 pw.println("hello");
	 pw.println("world");
	 pw.println("java");
	 
}
}

使用打印流复制文本文件

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

public class PrintWriterDmeo_04 {
public static void main(String[] args) throws IOException {
	BufferedReader br=new BufferedReader(new FileReader("b\\InputDemo.java"));
	PrintWriter pw=new PrintWriter(new FileWriter("d:\\copy2.java"),true);
	String line;
	while((line=br.readLine())!=null) {
		pw.println(line);
	}
	br.close();
	pw.close();
}
}

对象操作流
*对象操作流:可以用于读写任意类型的对象

• ObjectOutputStream

• writeObject

• ObjectOutputStream(OutputStream out)

• ObjectInputStream

• readObject

• ObjectOutputStream(InputStream in)

• 注意;使用对象输出流写出对象，只能使用对象输入流来读取对象

• 只能将支持 java.io.Serializable 接口的对象写入流中*/

`public static void main(String[] args) throws FileNotFoundException, IOException {
	//method1();
	ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e.txt"));
	try {while(true) {
			Object obj=ois.readObject();
			System.out.println(obj);}
	} catch (ClassNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		System.out.println("读完数据");
		e.printStackTrace();
	}
}

private static void method1() throws IOException, FileNotFoundException {
	ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e.txt"));
	Student s=new Student("张三",19);
	Student s1=new Student("李四",20);
	oos.writeObject(s);
	oos.writeObject(s1);
	oos.close();
}
}

解决对象输入流读取对象出现异常的问题

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

//解决对象输入流读取对象出现异常的问题
public class PWDemo {


public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
	//method1();
	//创建对象输入流的对象
	ObjectInputStream ois=new ObjectInputStream(new FileInputStream("d.txt"));
	//读取数据
	Object obj=ois.readObject();
	//向下转型获取子类对象
	ArrayList<Student>list=(ArrayList<Student>) obj;
	for(Student stu:list) {
		System.out.println(stu);
	}
	//释放资源
	ois.close();
}

private static void method1() throws IOException, FileNotFoundException {
	//创建对象输出流对象
	ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("d.txt"));
	//创建学生对象集合
	ArrayList<Student> list=new  ArrayList<Student>();
	//添加数据
	list.add(new Student("wangwu",20));
	list.add(new Student("wangmazi",21));
	//写对象
	oos.writeObject(list);
	oos.close();
}
}

`解决实现序列化接口出现的黄色警告问题

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

public class PWDemo_02 {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
	method1();
	ObjectInputStream ois=new ObjectInputStream(new FileInputStream("a.txt"));
	Object obj=ois.readObject();
	System.out.println(obj);
	ois.close();
	
}
//写对象
private static void method1() throws IOException, FileNotFoundException {
	ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("a.txt"));
	Student s=new Student("前期",25);
	oos.writeObject(s);
	oos.close();
}
}

学生类中添加

private static final long serialVersionUID = 8559854756048717056L;

Properties:表示了一个持久的属性集，属性列表中每个键及其对应值都是一个字符串
构造方法
Properties()

import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class PropertiesDmeo_01 {
public static void main(String[] args) {
	Properties pr=new Properties();
	pr.put("it001","liniao");
	pr.put("it002","wangwu");
	pr.put("it003","mingtian");
	//通过丈夫获取妻子
	Set<Object>keys=pr.keySet();
	for (Object key : keys) {
		Object value=pr.get(key);
		System.out.println(key+"="+value);
		
	}
	System.out.println("---------------");
	//通过结婚证获取丈夫和妻子
	Set<Map.Entry<Object, Object>>entrys=pr.entrySet();
	for (Map.Entry<Object, Object> entry : entrys) {
		Object key=entry.getKey();
		Object value=entry.getValue();
		System.out.println(key+"="+value);
	}
}
}

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;

//Properties和Io流结合
//void list(PrintWriter out)
//void load(Reader reader)
//void store(Writer writer,String comments//描述文本)
public class PropertiesDemo_02 {
public static void main(String[] args) throws IOException {
	//method1();
	//method2();
	Properties pro=new Properties();
	pro.setProperty("it001", "李四");
	pro.setProperty("it002", "王五");
	pro.setProperty("it003", "大牛");
	pro.setProperty("it004", "二毛");
	FileWriter fw=new FileWriter("g.txt");
	pro.store(fw, "helloworld");
}

private static void method2() throws FileNotFoundException, IOException {
	Properties pro=new Properties();
	FileReader fr=new FileReader("f.txt");
	pro.load(fr);
	fr.close();
	System.out.println(pro);
}

private static void method1() throws FileNotFoundException {
	Properties pro=new Properties();
	pro.setProperty("it001", "李四");
	pro.setProperty("it002", "王五");
	pro.setProperty("it003", "大牛");
	pro.setProperty("it004", "二毛");
	PrintWriter pw=new PrintWriter("f.txt");
	pro.list(pw);
	pw.close();
}
}

mport java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

/*编码表：把计算机底层的二进制数据转化成字符
 * ASCII
 * 
 * GB2312---GBK
 * Unicode 所有的字符都占两个字节
 * UTF-8 长度可变的码表
 * 
 * ANSI：本地编码表
 * 乱码：编码保持前后一致即可解决问题*/
public class EncodeDemo {
public static void main(String[] args) throws IOException {
	//method1();
	FileInputStream fis=new FileInputStream("a.txt");
	byte[]bys=new byte[1024];
	int len=fis.read(bys);
	System.out.println(new String(bys,0,len,"UTF-8"));
}

private static void method1() throws UnsupportedEncodingException, FileNotFoundException, IOException {
	String s="高薪就业";
	byte[]bys=s.getBytes("UTF-8");
	FileOutputStream fos=new FileOutputStream("a.txt");
	fos.write(bys);
}
}

*字符流中编码
 * 字符流=字节流+编码*/
public class EncodeDemo_02 {
public static void main(String[] args) throws IOException, FileNotFoundException {
	OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("b.txt"), "UTF-8");
	//OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("b.txt"));
	String s="迎娶白富美";
	osw.write(s);
	osw.close();
}
}