201521123003《Java程序设计》第7周学习总结

1. 本周学习总结

以你喜欢的方式（思维导图或其他）归纳总结集合相关内容。
参考资料:

XMind

---

2. 书面作业

Q1.ArrayList代码分析
1.1 解释ArrayList的contains源代码
下面是contains的源代码：

    public boolean contains(CharSequence s) {
            return indexOf(s.toString()) > -1;
    }
    public int indexOf(Object o) {
        if (o == null) {
           for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    public boolean equals(Object obj) {
        return (this == obj);
    }

ArrayList的contains方法是比较是否包含某元素，调用的是对象的equals方法，其实比较的是引用是否相等。如果对象不为空的话，一一与数组中每一个元素比较，如何找到了，则indexOf(Object o)返回一个>=0的值，最终indexOf(Object o)则返回true，如果没找到，indexOf(Object o)则返回-1，最终indexOf(Object o)返回false。

1.2 解释E remove(int index)源代码
E remove(int index)源代码如下：

    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

E remove(int index)是删除在此数组中指定位置的元素。int numMoved = size - index - 1;为要移动的所删除元素后面的元素个数，如果删除个数大于0，则将index位置后的元素全部往前移动一位，elementData[--size] = null;即数组大小减一，将最后一个位置的引用置为null。rangeCheck(int index)方法则是判断我们所指定的位置是否超出了size的大小，如果超出，则抛出异常。

1.3 结合1.1与1.2，回答ArrayList存储数据时需要考虑元素的类型吗？

不需要，ArrayList的初始数组数据类型是Object类型的，数组内元素可以是任何Object类可接受的数据类型。而Object类是所有类的父类，所以任何类都可以用ArrayList存储的。

1.4 分析add源代码，回答当内部数组容量不够时，怎么办？
以下是add源代码：

    public boolean add(E e) {
    //调用了ensureCapacity(size+1)方法，之后将元素的索引赋给elementData[size]，而后size自增 
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//存储结构修改次数

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量扩大到原容量的1.5倍，右移一位相当于原数值除以2。
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

每当执行add添加元素的方法，都会检查内部数组的容量是否不够了，如果是，它就会以当前容量的1.5倍来重新构建一个数组，容量变化的规则的公式：((旧容量 * 3) / 2) + 1;将旧元素Copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。

1.5 分析private void rangeCheck(int index)源代码，为什么该方法应该声明为private而不声明为public?
private void rangeCheck(int index)源代码如下：

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

rangeCheck(int index)方法是判断我们指定的位置index是否超出size的大小，如果超出，则抛出IndexOutOfBoundsException异常。
用private声明表明了该方法是内部方法，判断是否越界，用户只需要知道结果即可，不必知道具体的方法，所以该方法声明为private而不声明为public。

---

Q2.HashSet原理
2.1 将元素加入HashSet(散列集)中，其存储位置如何确定?需要调用那些方法？

HashSet继承于Set接口，不允许有重复的元素。底层使用HashMap来保存HashSet中所有元素。HashSet类按照哈希算法来存取对象，当向集合中加入一个新对象时，会调用对象的HashCode()方法得到对象的哈希码，然后根据这个码计算出对象在集合中存储的位置。需要调用hashCode()和equals(Object o)方法，为了保证HashSet能正常工作，要求当两个对象用equals比较相等时，hashCode也要相等，否则就会有可能加入两个相同的项。即如果有元素和传入对象的hashcode相等，那么，继续进行equles()判断，如果仍然相等，那么就认为传入元素已经存在，不再添加，结束，否则仍然添加。

2.2 选做：尝试分析HashSet源代码后，重新解释1.1

• 对于HashSet中保存的对象，注意正确重写其equals和hashCode方法，以保证放入的对象的唯一性。
• 而对于ArrayList中的contains()方法，只用到了equals()方法来判断是否存在相同的引用，所以储存对象时，只需重写equals方法。

---

Q3.ArrayListIntegerStack
题集jmu-Java-05-集合之5-1 ArrayListIntegerStack
3.1 比较自己写的ArrayListIntegerStack与自己在题集jmu-Java-04-面向对象2-进阶-多态、接口与内部类中的题目5-3自定义接口ArrayIntegerStack，有什么不同？(不要出现大段代码)

ArrayListIntegerStack是用ArrayList动态数组来实现栈，数组空间是不固定的，在栈满的情况下可以自动扩容；在编写代码时直接复用ArrayList中已有的方法，没有使用top指针。
ArrayIntegerStack是用Integer数组来实现栈，数组空间是固定的，需要注意栈满的情况；利用了top指针，在出栈入栈时相应的移动了top指针。

下面是两个题目的主要差别比较的代码：

//ArrayListIntegerStack
class ArrayListIntegerStack implements IntegerStack {
	private List<Integer> list;
	public ArrayListIntegerStack(int size) {
		list=new ArrayList<Integer>();
	}
}

//ArrayIntegerStack
class ArrayIntegerStack implements IntegerStack {
	private Integer[] arr;
	private int top=0;
	public ArrayIntegerStack(int size){
	arr=new Integer[size];
	}
}

3.2 简单描述接口的好处.

接口定义的对象不考虑具体实现，所有实现都是在实现子类里面完成，在以上两个题目中，我们可以知道，它们的接口都是相同的，只是具体在子类中的实现不同而已，减少了代码量，更加简洁。同时在修改它们的属性时，只需在接口处修改，从而提高了代码的维护性。

---

Q4.Stack and Queue
4.1 编写函数判断一个给定字符串是否是回文，一定要使用栈，但不能使用java的Stack类（具体原因自己搜索）。请粘贴你的代码，类名为Main你的学号。
自己编写一个Stack类，我将实验第一题的代码稍微改动了一下，具体代码如下：

import java.util.ArrayList;
import java.util.List;


interface StringStack {
	public String push(String item);// 如item为null，则不入栈直接返回null。如栈满，也返回null.

	public String pop();// 出栈，如为空，则返回null.

}

class ArrayListStack implements StringStack {
	private List<String> list;

	

	public  ArrayListStack(){
		list=new ArrayList<String>();
	}

	@Override
	public String push(String item) {
		// TODO Auto-generated method stub
		if (item == null)
			return null;
		list.add(item);
		return item;
	}

	@Override
	public String pop() {
		// TODO Auto-generated method stub
		if (list.isEmpty())
			return null;
		return list.remove(list.size() - 1);
	}

	
	@Override
	public String toString() {
		return list.toString();
	}

}
public class Main201521123003 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayListStack stack=new ArrayListStack();
		String str="201521123003";
		char c;
		for(int i=0;i<str.length();i++){
			c=str.charAt(i);
			stack.push(String.valueOf(c));
		}
		int f=1;
		for(int i=0;i<str.length();i++){
			if(!stack.pop().equals(str.charAt(i))){
				f=-1;
				break;
			}
		}
                System.out.println("学号：201521123003");
		if(f==1)
			System.out.println("你的学号是回文");
		else
			System.out.println("你的学号不是回文");
	}

}

运行结果如下：

4.2 题集jmu-Java-05-集合之5-6 银行业务队列简单模拟。(不要出现大段代码)

        for (int i = 1; i <= N; i++) {//根据数值奇偶加入两个链表
		    int e = sc.nextInt();
		    if ( e% 2 == 0) {
		        list2.add(e);
		    } else {
		        list1.add(e);
		    }
	}
        for(int i=0;!list2.isEmpty()||!list1.isEmpty();){//依照题目先输出A窗口2个，再输出B窗口1个，以此类推。
		if(!list1.isEmpty()){
		     if(i==N)
		         System.out.print(list1.poll());
		     else if(list1.size()==2&&i==N-1)
		         System.out.print(list1.poll()+" "+list1.poll());
		     else{
		         if(list1.size()==1){
		             System.out.print(list1.poll()+" ");
		             i++;
		         }
		         else{
		             System.out.print(list1.poll()+" "+list1.poll()+" ");
		             i=i+2;
		         }
		     }   
	      }

		 if(!list2.isEmpty()){
		     if(i==N)System.out.print(list2.poll());
		     else
		         System.out.print(list2.poll()+" ");
		     i++;
		 }
	}

运行结果如下：

---

Q5.统计文字中的单词数量并按单词的字母顺序排序后输出
题集jmu-Java-05-集合之5-2 统计文字中的单词数量并按单词的字母顺序排序后输出 (不要出现大段代码)
5.1 实验总结

• 这道题题目提及了统计文章单词数量，则表明了不能有重复的元素，于是想到了用Set集合。
• 而后题目进一步要求前10个(按字母顺序)单词输出，HashSet不能保证元素的排列顺序，顺序有可能发生变化，所以，选择采用TreeSet。TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。自然排序是使排序元素用CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列，正好符合该题目的要求。

附上主要代码：

public class Main1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set<String> set = new TreeSet<String>();
		Scanner sc = new Scanner(System.in);
		String str = sc.next();
		while (!str.equals("!!!!!")) {
			set.add(str);
			str = sc.next();
		}
        }
}

Q6.选做：加分考察-统计文字中的单词数量并按出现次数排序
题集jmu-Java-05-集合之5-3 统计文字中的单词数量并按出现次数排序(不要出现大段代码)
6.1 伪代码

Map<String,Integer> map =new TreeMap<String,Integer>();
List<Map.Entry<String,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
while (!str.equals("!!!!!")) {
	str = sc.next();
	if (set.contains(str)) {
	    if (map.containsKey(str))
	    map.put(str, map.get(str) + 1);
	    else
		map.put(str, 1);
	}
	set.add(str);
}//将文章映射到map中，同时对每个单词进行计数
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {...});//对单词出现次数进行排序

6.2 实验总结
主要是对单词出现次数进行排序，这就需要将键/值放入Arraylist中，通过Collections.sort()进行排序。

Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {

	@Override
	public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
        if(o2.getValue() - o1.getValue()!=0)
	    return o2.getValue() - o1.getValue();
	return o1.getKey().compareTo(o2.getKey());
        }
});

---

Q7.面向对象设计大作业-改进
7.1 完善图形界面(说明与上次作业相比增加与修改了些什么)
7.2 使用集合类改进大作业
参考资料:
JTable参考项目

主要改动的是进入查看购物车的界面，以及后台用户名改用了Set来进行存储，保证了用户名不会重复。

---

3. 码云上代码提交记录及PTA实验总结

题目集：jmu-Java-05-集合

3.1. 码云代码提交记录

在码云的项目中，依次选择“统计-Commits历史-设置时间段”, 然后搜索并截图

3.2. PTA实验

编程(5-1, 5-2, 5-3(选做), 5-6)
实验总结已经在作业中体现，不用写。