201621123001 《Java程序设计》第8周学习总结

1. 本周学习总结

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

2. 书面作业

1. ArrayList代码分析

1.1 解释ArrayList的contains源代码

Answer:

源代码

public boolean contains(Object o) {
    return indexOf(o) >= 0;
  }
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;
}

• 解释：先判断对象是否为null，是的话，查看列表中是否存在null，存在返回下标。若对象不为null，如果该列表中包含指定元素就返回true。

1.2 解释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;
    return oldValue;
}

• 解释：首先检查删除的位置是否越界，在不越界的前提下，删除该位置的元素，并且在删除位置之后的元素逐一向前移动。将最后空位置置为null。

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

Answer：ArrayList是动态数组，允许所有的列表操作，也允许所有元素，包括null。

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

源代码

public boolean add(E e) {
    ensureCapacityInternal(size + 1);//判断空间是否足够，不够就扩充
    elementData[size++] = e;// 先在尾部添加，然后是数组的长度增一
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        //如果elementData为默认长度的空数组
         {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);  //取最大值（传入参数，默认长度）       }

        ensureExplicitCapacity(minCapacity);
    }
    private void ensureExplicitCapacity(int minCapacity) {
    modCount++;//自增
      if (minCapacity - elementData.length > 0)//容量不够
        grow(minCapacity);
}
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    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;
}

• 由源代码可以知道，如果内存数组容量不够时，数组容量会进行自动扩容。用Arrays.copyOf()方法将原数组元素复制到新数组中去。

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

源代码

private void rangeCheck(int index) {
        if (index >= size)//如果下标越界
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

• 因为检测下标是否超出容量范围这件事并不需要让别人知道是怎么执行的，而是当删除时候自动进行的，别人只要知道是否成功删除就行了。

2. HashSet原理

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

Answer：选择存储位置就是要先判断HashSet内是否已经存在该元素。调用contains方法，如果不存在，再调用add方法。OK,Fine,做完了下面选做原来这一段都是我自己觉得的，下面才是真相

2.2 将元素加入HashSet中的时间复杂度是多少？是O(n)吗？(n为HashSet中已有元素个数)

Answer： 时间复杂度为O（1），因为判断次数n是常量。

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

源代码

public class HashSet<E>
   extends AbstractSet<E>
   implements Set<E>, Cloneable, java.io.Serializable
 {
   static final long serialVersionUID = -5024744406713321676L;  

   private transient HashMap<E,Object> map;  // 使用HashMap来保存HashSet中所有元素。  

   private static final Object PRESENT = new Object();  

   public HashSet() {   // 初始化一个空的HashSet。（实际上初始化的是一个HashMap）
   map = new HashMap<E,Object>();
   }  

   public HashSet(Collection<? extends E> c) {
   map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));
   addAll(c);
   }  

   public HashSet(int initialCapacity, float loadFactor) {  //指定的initialCapacity(初始容量)和loadFactor(加载因子)构造一个HashSet。（实际上构造的是一个HashMap）
   map = new HashMap<E,Object>(initialCapacity, loadFactor);
   }  

   public HashSet(int initialCapacity) {  //以指定的initialCapacity构造一个空的HashSet。
   map = new HashMap<E,Object>(initialCapacity);
   }  

   HashSet(int initialCapacity, float loadFactor, boolean dummy) {
   map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
   }  

   public Iterator<E> iterator() {
   return map.keySet().iterator();  //返回迭代器
   }  

   public int size() {
   return map.size();  //返回元素数量
   }  

   public boolean isEmpty() {    //判断是否为空
   return map.isEmpty();
   }  

   public boolean contains(Object o) {    //判断是否包含指定元素
   return map.containsKey(o);
   }  

   public boolean add(E e) {    //添加指定元素
   return map.put(e, PRESENT)==null;
   }
   //···
}

Answer：由源代码可以看到，HashSet实际上是通过HashMap来保存元素，因此可以说HashMap是实现HashSet的幕后主谋，而在add方法的源代码中可以看到，调用的是HashMap的put方法。查看了put方法的文档，了解到put方法是将值与键形成了一种映射关系，如果已经存在映射关系，那么将新值替换旧值。既然HashSet的实现是HashMap来完成的，那么根据HashMap可以知道HashSet存储元素时也调用了hashCode方法以及equals方法。HashCode是计算出存储位置的，equals就是来比较是否存在了，存在的话，新添加的元素就不会被放入HashMap中，只改变相应的键值，这就满足了Set集的不可重复性。

3. ArrayListIntegerStack

题集jmu-Java-05-集合之ArrayListIntegerStack

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

Answer:比较了两题，发现接口内部的方法名称都相同，但是继承该接口的实现方法的过程不一样，但是实现的功能又都一样，实现的过程就是一个用数组Array实现，一个用列表List实现。

3.2 结合该题简单描述接口的好处，需以3.1为例详细说明，不可泛泛而谈。

Answer：泛泛地说接口的好处就是很灵活，那么具体怎么说呢，按照我的说法就是你看啊，接口的内部只定义了方法的名称，某实现类通过继承该方法，但是又没有明确指出要用什么方式实现，就可以先用自己喜欢的方式来编写实现方法的功能，但如果突然有一天，被强制要求用别的方式实现，那简单啊，直接在实现类中改写实现功能，到时候在main中一句话新建一下就可以，免去了将全部代码改写的麻烦。

4. Stack and Queue

4.1 编写函数判断一个给定字符串是否是回文，一定要使用栈(请利用Java集合中已有的类)，但不能使用java的Stack类（具体原因自己搜索）与数组。请粘贴你的代码，类名为Main你的学号。

• 本题类似jmu-Java-05-集合之ArrayListIntegerStack但是只用到了进出栈，以及判断是否为空

• 我的代码：

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

/**
 * Created by zhangyilin on 2017/11/9.
 */
interface CharacterStack {

    public Character push(Character item);

    public Character pop();

    public boolean empty();

}

class Stack implements CharacterStack {
    private List<Character> list;

    public Stack() {
        list = new ArrayList<Character>();
    }

    @Override
    public Character push(Character item) {
        if (item == null)
            return null;
        list.add(item);
        return item;
    }

    @Override
    public Character pop() {
        if (list.isEmpty())
            return null;
        return list.remove(list.size() - 1);
    }

    @Override
    public boolean empty() {
        if (list.isEmpty())
            return true;
        return false;
    }

}

public class Main201621123001 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Stack stack = new Stack();
        while(sc.hasNext())
        {
            String str = sc.next ();
            char mystr[] = str.toCharArray();
            for (int i = 0; i < str.length(); i++) {

                stack.push(mystr[i]);
            }

            for (int i = 0; i < str.length(); i++) {
                if(mystr[i] != stack.pop()) {
                    System.out.println("No");
                    break;
                }
            }
            if(stack.empty()){
                System.out.println("Yes");
            }
        }
    }
}

运行截图

4.2 题集jmu-Java-05-集合之银行业务队列简单模拟(只粘贴关键代码)。请务必使用Queue接口，并说明你使用了Queue接口的哪一个实现类？

Answer: 我使用的是Queue接口的ArrayDeque实现类。

• 建立A，B两个队列

Queue<Integer> A=new ArrayDeque<Integer>();
Queue<Integer> B=new ArrayDeque<Integer>();

• 将不同编号分别入队

if (num%2!=0)
	A.add(num);
else
	B.add(num);

• 出队方式根据几种不同的可能情况进行判断。

 while (A.size()>=2 && B.size()>=1)
 {//...
 }

 while (A.size()>1)
	// ...
 if (A.size() ==1 )
 {
        if (B.size()==0)
            //...
	else
		//...
 }
 while (B.size()>1)
        //..
 if (B.size() == 1)
        //...

5. 统计文字中的单词数量并按单词的字母顺序排序后输出

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

5.1 实验总结

• 这道题主要就是用到了Set集，用TreeSet的排序功能来按照单词的字母顺序排序。

Set<String>stringSet = new TreeSet<String>();

输出十个时候用一个flag控制foreach输出。

for (String s:stringSet) {
                if (flag<10)
                {
                    //...
                    flag ++;
                }
                else
                    break;

            }

6. 选做：统计文字中的单词数量并按出现次数排序

题集jmu-Java-05-集合之5-3 统计文字中的单词数量并按出现次数排序(不要出现大段代码)

6.1 伪代码

get str
if str.equals("!!!!!") break;
else if contains str -> change value
		else put
compare value
print list 

6.2 实验总结

Answer：因为要统计单词数量（不可重复）又要有键（单词）与值（出现次数）的对应关系，所以就选择了Map，然后要排序嘛，就用到了TreeMap了。说实话这道题真的几近崩溃- -，本来想直接在TreeMap中实现Comparator接口，可是他没有对值排序现成方法，那只能借助一下其他的比较器了，我就参考调用了Collections接口。

• 先将Map转换为List

  List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(treeMap.entrySet());

• 重新进行排序(运用lambda表达式)

Collections.sort(list,((o1, o2) -> o2.getValue().compareTo(o1.getValue())));

7. 选做 面向对象设计大作业-改进

7.1 使用集合类改进大作业或者简述你的面向对象设计大作业中，哪里使用到了集合类。

7.2 进一步完善图形界面(仅需出现改进的后的图形界面截图)

3.码云及PTA

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

3.1. 码云代码提交记录

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

3.2 截图PTA题集完成情况图

需要有两张图（1. 排名图。2.PTA提交列表图）

3.3 统计本周完成的代码量

需要将每周的代码统计情况融合到一张表中。

修改了过时的Long(String)。

周次	总代码量	新增代码量	总文件数	新增文件数
1	374	374	5	5
2	889	515	15	10
3	1417	528	22	7
4	1838	421	27	5
6	2608	770	38	11
7	3270	662	48	10
8	4068	798	52	4
9	4710	642	61	9

选做：4. 使用Java解决实际问题

尝试为代码统计项目 增加图形界面。

3.1 设计图形界面（可用纸画）。

3.2 从该git项目fork一个分支，在该分支上进行你的开发，以后如果开发的好，可以尝试向开发者提出pull request。注意：规划好包名。