Day08——字符串匹配、小结

字符串匹配

通过字符数组模拟了字符串基础操作，字符串匹配用的是暴力匹配，当模式串和主串不匹配时，i++，再重新开始匹配，比较简单。相对老师的代码，我在MyString的第二个构造函数多加了一个判断（因为在测试的时候，我多输入了一个字符，导致字符串的长度大于了预设的最大长度，报错了），程序健壮性好了些。

package day08;

public class MyString {

	/**
	 * The maximal length.
	 */
	public static final int MAX_LENGTH = 10;

	/**
	 * The actual length.
	 */
	int length;

	/**
	 * The data.
	 */
	char[] data;

	/**
	 * Construct an empty char array.
	 */
	public MyString() {
		length = 0;
		data = new char[MAX_LENGTH];
	}// Of the first constructor.

	public MyString(String paraString) {
		data = new char[MAX_LENGTH];
		length = paraString.length();
		length = length > MAX_LENGTH ? MAX_LENGTH : length;

		// Copy data.
		for (int i = 0; i < length && i < MAX_LENGTH; i++) {
			data[i] = paraString.charAt(i);
		} // Of for i
	}// Of the second constructor

	/**
	 * Overrides the method claimed in Object, the superclass of any class.
	 */
	public String toString() {
		String resultString = "";

		for (int i = 0; i < length; i++) {
			resultString += data[i];
		} // Of for i

		return resultString;
	}// Of toString

	/**
	 * Locate the position of substring.
	 * 
	 * @param paraMyString The given substring.
	 * @return The first position. -1 for no matching.
	 */
	public int locate(MyString paraMyString) {
		boolean tempMatch = false;
		for (int i = 0; i < length - paraMyString.length; i++) {
			// Initialize.
			tempMatch = true;
			for (int j = 0; j < paraMyString.length; j++) {
				if (data[i + j] != paraMyString.data[j]) {
					tempMatch = false;
					break;
				} // Of if
			} // Of for j

			if (tempMatch) {
				return i;
			} // Of if
		} // Of for i
		return -1;
	}// Of locate

	/**
	 * Get a substring.
	 * 
	 * @param paraStartPosition The start position in the original string.
	 * @param paraLength        The length of the new string.
	 * @return The first position. -1 for no matching.
	 */
	public MyString subString(int paraStartPosition, int paraLength) {
		if (paraStartPosition + paraLength > length || paraStartPosition < 0) {
			System.out.println("The bound is exceeded.");
			return null;
		}
		MyString resultMyString = new MyString();
		resultMyString.length = paraLength;
		for (int i = 0; i < paraLength; i++) {
			resultMyString.data[i] = data[paraStartPosition + i];
		} // Of for i

		return resultMyString;
	}// Of substring

	/**
	 * The entrance of the program.
	 * 
	 * @param args Not used now.
	 */
	public static void main(String args[]) {
		MyString tempFirstString = new MyString("I like ik.");
		MyString tempSecondString = new MyString("ik");
		int tempPosition = tempFirstString.locate(tempSecondString);
		System.out.println(
				"The position of \"" + tempSecondString + "\" in \"" + tempFirstString + "\" is: " + tempPosition);

		MyString tempThirdString = new MyString("ki");
		tempPosition = tempFirstString.locate(tempThirdString);
		System.out.println(
				"The position of \"" + tempThirdString + "\" in \"" + tempFirstString + "\" is: " + tempPosition);

		tempThirdString = tempFirstString.subString(1, 2);
		System.out.println("The substring is: \"" + tempThirdString + "\"");

		tempThirdString = tempFirstString.subString(5, 5);
		System.out.println("The substring is: \"" + tempThirdString + "\"");

		tempThirdString = tempFirstString.subString(5, 6);
		System.out.println("The substring is: \"" + tempThirdString + "\"");
	}// Of main
}// Of class MyString

运行结果：

小结

1. 面向对象与面向过程相比, 有哪些优势?
   答：面向对象比面向过程的代码复用性更高，面向对象有清晰的代码结构，易维护和拓展。
2. 比较顺序表和链表的异同.
   答：同：逻辑上都是顺序结构；异：顺序表在内存中是必须连续存储的，且长度在声明时就确定了，支持随机访问，但不宜元素的随机插入和删除；链表在内存中可以离散存储，长度不固定，每个元素要记录下一个元素在内存中的地址，只能顺序访问，能动态增加或减少元素。
3. 分析顺序表和链表的优缺点.
   答：顺序表：优点：能随机访问元素；缺点：表长固定，不能修改表长，不适合在表中间添加和删除元素（需要移动其它元素）。链表：优点：可以改变表长，添加和删除都不需要移动其他元素；缺点：只能顺序访问元素，每个元素都要保存下一个元素的地址，浪费了一定的存储空间。
4. 分析调拭程序常见的问题及解决方案.
   答：如果有报错，就直接定位到报错的代码；如果看运行结果与预期结果不符，就打印可能出错的中间结果，由下到上，逐步定位到出错代码。
5. 分析链队列与循环队列的优缺点.
   答：链队列优点：不需要考虑队列最大长度（只要内存满足）；缺点：每个元素要保存下一个元素的地址，浪费内存。循环队列优点：不用保存下一个元素的地址；缺点：有长度限制，为了区分队空和队满要浪费一个元素空间。
6. 第 18 天建立的两个队列, 其区别仅在于基础数据不同, 一个是 int, 一个是 char. 按这种思路, 对于不同的基础数据类型, 都需要重写一个类, 这样合理吗? 你想怎么样?
   答：不合理。在CircleIntQueue的构造函数中设置参数，根据调用者new 一个CircleIntQueue对象时传递的参数来初始化data数据，并把类型保存为实例属性，至于有关类型的方法调用，则通过方法重载实现。