day-2-2-3

理论

BIO、NIO和AIO之间的区别

• BIO即同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成，BIO适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。
• NIO即同步非阻塞，一个线程不断的轮询每个输入输出的状态改变，如果有状态发生了改变，则进行下一步的操作，NIO适用于连接数目比较多且连接比较短的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。
• AIO即异步非阻塞I/O模型，无需一个线程去轮询所有IO操作的状态改变，在相应的状态改变后，系统会通知对应的线程来处理，AIO方式适用于连接数目多且连接比较长的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

深浅克隆的区别

浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制。

• 浅克隆中，如果对象的成员变量是值类型，就会克隆一份给克隆对象，如果是引用类型就会克隆他的引用值给克隆对象，也就是说对象的克隆指向的是成员变量的引用地址值。
• 深克隆中，无论是对象的成员变量是值类型还是引用类型都会复制给克隆对象，可以通过序列化来实现。

什么是序列化，如何实现Java序列化

• 序列化就是将对象写到流的过程，解决在对对象流读写操作时所引发的问题，实现的也是深克隆。
• 实现序列化必须实现Serializable接口。

编码

编码实现一个任意文件夹的拷贝

package demo1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy {
	public static void main(String[] args) throws IOException {
		File f1 = new File("src/demo/input");
		String f2s = "src/demo/output";
		copyFile(f1, f2s);
	}

	public static void copyFile(File f1, String f2s) throws IOException {
		if (f1.isDirectory()) {
			File file = new File(f2s + "/" + f1.getName());
			file.mkdirs();
			File[] fs = f1.listFiles();
			if (fs.length == 0) {
				return;
			} else {
				for (File tmp : fs) {
					copyFile(tmp, file.getPath());
				}
			}
		} else {
			FileInputStream fis = new FileInputStream(f1);
			File f3 = new File(f2s + "/" + f1.getName());
			if (!f3.exists()) {
				f3.createNewFile();
			}
			FileOutputStream fos = new FileOutputStream(f3);
			byte[] buffer = new byte[8192];
			int len = 0;
			while ((len = fis.read(buffer)) > -1) {
				fos.write(buffer, 0, len);
			}
			fos.close();
			fis.close();
		}
	}
}

统计一个文件calcCharNum.txt中各个字符出现次数：A(8),B(16),C(10)…,a(12),b(10),c(3)…，括号内代表字符出现次数，要求按照出现次数从小到达排序输出。如果是回车符则按照空格符处理

App

package calcCharNum;

import java.io.FileReader;
import java.io.Reader;

public class App {
	public static void main(String[] args) throws Exception {
		ArrayList list = new ArrayList();
		try (Reader r = new FileReader("E:\\java\\eclipse-workspace\\0803\\src\\calcCharNum\\ArrayList.java")) {
			int k = -1;
			while (true) {
				k = r.read();
				if (k == -1)
					break;
				if (k == '\r' || k == '\n' || k == '\t')
					k = ' ';
				list.add((char) k);
			}
			list.sort();
			list.show();
		}
	}
}

ArrayList

package calcCharNum;

public class ArrayList {
	private CharNum[] arr;
	private int count;

	public ArrayList() {
		this(10);
	}

	public ArrayList(int length) {
		arr = new CharNum[length];
	}

	public void add(char ch) {
		int exists = indexOf(ch);
		if (exists >= 0)
			arr[exists].addNum();
		else {
			arr[count++] = new CharNum(ch);
			if (count >= arr.length)
				resize();
		}
	}

	private void resize() {
		CharNum[] res = new CharNum[arr.length * 3 / 2];
		for (int i = 0; i < count; i++)
			res[i] = arr[i];
		this.arr = res;
	}

	private int indexOf(char ch) {
		int res = -1;
		for (int i = 0; i < count; i++) {
			CharNum cn = arr[i];
			if (cn.getCh() == ch) {
				res = i;
				break;
			}
		}
		return res;
	}

	public void show() {
		for (int i = 0; i < count; i++)
			System.out.print(arr[i] + " ,");
	}

	public void sort() {
		for (int i = 1; i < count; i++) {
			for (int k = 0; k < count - i; k++) {
				if (arr[k].bigger(arr[k + 1])) {
					CharNum tmp = arr[k];
					arr[k] = arr[k + 1];
					arr[k + 1] = tmp;
				}
			}
		}
	}
}

CharNum

package calcCharNum;

public class CharNum {
	private char ch;
	private int num;

	public CharNum(char ch) {
		this.ch = ch;
		this.num = 1;
	}

	@Override
	public String toString() {
		return ch + "(" + num + ")";
	}

	public void addNum() {
		this.num++;
	}

	public char getCh() {
		return ch;
	}

	public boolean bigger(CharNum charNum) {
		boolean res = false;
		if (this.num > charNum.num)
			res = true;
		else if (this.num == charNum.num) {
			res = this.ch > charNum.ch;
		}
		return res;
	}
}