java基础

1、BIO、NIO和AIO之间的区别
答：
    BIO是同步阻塞I/O模式，数据的读取必须阻塞同一个线程内等待其完成
    NIO是同步非阻塞I/O模式，一个线程不断的循环每个输入输出的状态改变，一旦发生改变，就进行下一步操作
    AIO是异步非阻塞I/O模式，不需要一个线程去循环所有IO操作的的状态改变，系统会通知对应的线程来处理
    举个例子：
    同步阻塞的工作就是先到厨房去烧水，一直在水壶旁等到水开为止
    同步非阻塞的工作就是先到厨房开始烧水，离开，隔几分钟就去检查水是否烧开
    异步非阻塞的工作就是先到厨房开始烧水，离开，听到水烧开后的提示音
2、深浅克隆的区别
答：
    深克隆和浅克隆的主要区别在于是否支持引用类型的成员变量的复制
    浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，二引用类型的成员对象并没有复制
    深克隆中，除了对象本身被复制外，对象包含的所有成员变量也被复制
3、什么是序列化，如何实现Java序列化
答：
    序列化是将一个对象转化为二进制的字节数组，保存或转移这些二进制的字节数组达到持久化的目的
    要实现Java序列化，就需要实现Serializable接口

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

package com.zhoukao;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

//编码实现一个任意文件夹的拷贝
public class KaoBei {
	static String source = "data";
	static String target = "out";

	public static void main(String[] args) {
		File file = new File("data");
		copy(file);
	}

	public static void copy(File source) {
		if (source.exists()) {
			if (source.isDirectory()) {
				String ss = source.getAbsolutePath();
				ss = ss.replace(KaoBei.source, KaoBei.target);
				File file = new File(ss);
				if (!file.exists())
					file.mkdirs();
				File[] children = source.listFiles();
				for (File tmp : children)
					copy(tmp);
			} else if (source.isFile()) {
				String ss = source.getAbsolutePath();
				ss = ss.replace(KaoBei.source, KaoBei.target);
				try {
					copyFile(source, new File(ss));
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	private static void copyFile(File source, File target) throws Exception {
		try (InputStream is = new FileInputStream(source); OutputStream os = new FileOutputStream(target)) {
			byte[] arr = new byte[8192];
			int len = 0;
			while ((len = is.read(arr)) > 0) {
				os.write(arr, 0, len);
			}
		}
	}
}

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

 

package com.zhoukao;

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

//统计一个文件calcCharNum.txt中各个字符出现次数：
//A(8),B(16),C(10)...,a(12),b(10),c(3)....，括号内代表字符出现次数，
//要求按照出现次数从小到达排序输出。如果是回车符则按照空格符处理
public class TongJi {
	public static void main(String[] args) throws Exception {
		ArrayList al = new ArrayList();
		try (Reader rr = new FileReader("data/calcCharNum.txt")) {
			while (true) {
				int kk = rr.read();
				if (kk == -1)
					break;
				if (kk == '\r' || kk == '\n' || kk == '\t')
					kk = ' ';
				al.add((char) kk);
			}
			al.sort();
			al.show();
		}
	}
}

package com.zhoukao;

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

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

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

	public char getCh() {
		return ch;
	}

	@Override
	public String toString() {
		return "[ch=" + ch + ",(" + num + ")]";
	}

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

}

package com.zhoukao;

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

	public ArrayList() {
		this(10);
	}

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

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

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

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

	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 cn = arr[k];
					arr[k] = arr[k + 1];
					arr[k + 1] = cn;
				}
			}
		}
	}

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

}