java学习笔记（十六）

一、InputStream(字节输入流)和OutputStream（字节输出流）

1.打开一个文本文件

InputStream is=new FileInputStream("gbk.txt");

Reader in=new InputStreamReader(is);

2.打开一个文本文件

Reader in=new InputStreamReader(new FileInputStream("gbk.txt"));

3.打开一个文本文件

Reader in=new FileReader("gbk.txt");

实例：

public static void main(String[] args) throws IOException{
BufferedReader in=new BufferedReader(new FileReader("question.txt"));
String str;
while((str=in.readLine())!=null){				//in.readLine()按行读取文本文件
System.out.println(str);
}
in.close();
}

4.打开输出文件

Writer out=new OutputStreamWriter(new FileOutputStream("filename.txt"));

可简写成：Writer out=new FileWriter("filename.txt");

5.文本文件的输出

PrintWriter out=new PrintWriter(new FileWriter("filename"));

out.println("hello,world!");

实例：

PrintWriter out=new PrintWriter(new FileWriter("question.txt"));//若文本文件不存在，默认自动创建
out.println("1.\"同福客栈\"的老板是谁？");
out.println("\tA.莫小贝");
out.println("\tB.李莫愁");
out.println("\tC.白展堂");
out.println("\tE.佟湘玉");
out.println("D");

6.文本文件的读取：BufferedReader,readLine()

in-------->CPU+RAM----------->out

可由键盘，磁盘，USB设备进行输入；显示屏，磁盘，USB设备进行输出

实例：

public static void main(String[] args)
throws Exception{
//读取question.txt文件为Question的集合
List<Question> question=read("question.txt");
//迭代每个问题，输出每个题
//获取用户的选择，与标准答案比较，如果一致，提示答对了
BufferedReader console=								//早期输入的写法
new BufferedReader(
new InputStreamReader(System.in));
for(Question q:question){
System.out.println(q);							//输出每个题
System.out.print("请选择：");
//阻塞式IO，不敲回车，软件不运行
String str=console.readLine();						//获取用户选择
if(str.charAt(0)==q.getAnswer()){					//将用户的答案与标准答案进行比较
System.out.println("答对了，下一题");
}
}
}
private static List<Question> read(String filename)
throws Exception {
List<Question>list=new ArrayList<Question>();			<span style="white-space:pre">		</span>//声明问题序列
BufferedReader in=
new BufferedReader(
new FileReader(filename));
String str;
while((str=in.readLine())!=null){						//判断是否读完文件，获取题目
Question q=new Question();						//创建一个新的问题对象
String id=str.substring(0, str.indexOf(' '));	//从字符串开头开始，如果到了空格就停下来，空格前的内容就是所要的
q.setId(Integer.parseInt(id));			//将ID从字符串转换成数字
q.setText(str.substring(str.indexOf(' ')+1));	//从空格出现位置的后一位置开始，已知到这一句的结束
q.getOptions().add(in.readLine());		//将选项放到Question的Options中
q.getOptions().add(in.readLine());
q.getOptions().add(in.readLine());
q.getOptions().add(in.readLine());
q.setAnswer(in.readLine().charAt(0));		//将答案放到Question的answer中
list.add(q);					//将这一条添加到list中
}
return list;
}

其中Question类含有如下属性：

private int id;//题号

private String text;//题目

private List<String> options=new ArrayList<String>();//选项

private char answer;

二、对象序列化

int---->4个byte流

long-->8个byte流

String(5个字符)->GBK编码，10个byte流

Object-------------->n个byte流

1.ObjectOutputStream和ObjectInputStream对象序列化流

writeObject(obj)和readObject()

必须实现初始化接口（Serializable）,以后的所有类都要实现这个，这是javaBean的要求

实例：

public static void main(String[] args)throws Exception {
ByteArrayOutputStream out=new ByteArrayOutputStream();	<span style="white-space:pre">		</span>//目标节点流
ObjectOutputStream oos=new ObjectOutputStream(out);		<span style="white-space:pre">	</span>//序列化流
Foo foo=new Foo(1,"ABC",23);						//创建对象
oos.writeObject(foo);							//序列化对象到流中
oos.close();								//完成关闭流（自动清理缓冲区）
byte[] ary=out.toByteArray();						//ByteArrayOutputStream带的方法，初始序列化方法
//foo（对象）->ary(流)
String s=IOUtils.toHexString(ary);
System.out.println(s);							//查看序列化流的内容
//反序列化
ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(ary));
Object o=ois.readObject();
ois.close();
if(o instanceof Foo){
Foo f=(Foo) o;
System.out.println(f.id+","+f.name);
System.out.println(f==foo);					//false,内容一样，但不是一个东西
}
}

其中，IOUtils.toHexString()是将ary转换成十六进制

实现对象的复制实例：

public static void main(String[] args) throws IOException,ClassNotFoundException{
String[] ary={"1","2","3"};
String[] ary2=ary.clone();					//ary和ary2不是同一个对象，但是内容一样
//java中默认对象的复制规则：浅层复制，只复制一层
System.out.println(ary==ary2);
System.out.println(ary[0]==ary2[0]);
ArrayList list=new ArrayList();
list.add("a");
ArrayList l=new ArrayList(list);
System.out.println(list==l);				//flase
System.out.println(list.get(0)==l.get(0));	<span style="white-space:pre">	</span>//true
//可以实现深层复制,使用序列化和反序列化可以变相实现深层复制
ArrayList l2=(ArrayList) IOUtils.unserialize(IOUtils.serialze(list));
System.out.println(list==l2);
System.out.println(list.get(0)==l2.get(0));
}

其中IOUtils.serialze是将对象进行序列化的函数

IOUtils.unserialize是将对象进行反序列化的函数

三、二维数组

1.声明

int[][] ary

2.初始化

静态初始化：

int[][] ary={{2,3},{4,5},{6,7,8}};//第二层的长度可以不同

动态初始化：

int[][] ary=new int[3][2];

int[][] ary=new int[3][];

int[][] ary=new int[][]{{2,3},{4,5},{6,7,8}};

二维数组是数组的数组，数组变量是一个对象数组的引用，每一行是一个一维数组的实例

例子：

public static void main(String[] args) {
int[][] ary={{2,3},{4,5},{6,7}};
int[] sum=new int[ary[0].length];
for(int i=0;i<ary.length;i++){				//迭代行
for(int j=0;j<ary[i].length;j++){
sum[j]+=ary[i][j];
}
}
System.out.println(Arrays.toString(sum));
}