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

1. 本周学习总结

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

2. 书面作业

ArrayList代码分析

1.1 解释ArrayList的contains源代码

public boolean contains(Object o) {
        return indexOf(o) >= 0; 
    }

public int indexOf(Object o) {               //找到元素就返回当前位置,否则返回-1
        if (o == null) {                     //因为对于null没有分配内存空间,且不是对象,不能用equals来比较
            for (int i = 0; i < size; i++)   
                if (elementData[i]==null)    //elementData是数组缓冲区中存储元素的数组
                    return i;                
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

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

 public E remove(int index) {
        rangeCheck(index);                        //检查是否在范围内

        modCount++;                               //初始值为0
        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;
    }

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

答:首先ArrayList存储的要是引用类型数据,在实例化一个动态数组时,人为地指定类型,如下图所示,所以不管用的是什么类型的,ArrayList都能转换

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

add源代码:

public boolean add(E e) {
        ensureCapacityInternal(size + 1);            // 确认下个元素进来是否已经放不下了,如果是就扩充
        elementData[size++] = e;
        return true;
    }

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); // DEFAULT_CAPACITY = 10,默认长度为10
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);                       
    }

private void grow(int minCapacity) {                         //增加容量
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);  //新的=旧的*1.5
        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;                                   //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
    }

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

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

public IndexOutOfBoundsException(String s) {
        super(s);
    }

private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

get的源码:
public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
答:比如在get方法的内部中,就可以用到rangeCheck的方法,不允许其他外面的类访问,所以设为private的类型

HashSet原理

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

add的源代码:

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

将key和value放入map中

 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//如果Key值为空,返回原hash值与原hash值右移16位的值按位异或的结果
    }

那么这个putVals:(这么长,好难的样子...)
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)//table为空或长度为0,说明未创建
            n = (tab = resize()).length;                   //创建
        if ((p = tab[i = (n - 1) & hash]) == null)         //判断下标为i的节点是否存在
            tab[i] = newNode(hash, key, value, null);
        else {                                             //说明这个坑已经被占了,那么久要开始处理冲突了
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

这个putVal处理冲突的好像有点复杂,那还是看看这个链接吧,讲得比较详细请戳此处

2.2 选做:尝试分析HashSet源代码后,重新解释2.1

答:使用hashCode方法的哈希码来确定位置,
构造函数:
 public HashSet() {
        map = new HashMap<>();
    }
其本质上是HashMap

源代码:
public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];          //计算哈希地址
            }
            hash = h;
        }
        return h;
    }

eclipse自动生成的:
public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + x;   //计算地址
		return result;
	}


ArrayListIntegerStack

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

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

答:不同之处在于前者使用了ArrayList的动态数组,不需要判断是否栈满,直接使用ArrayList内部的方法,后者是已经定义了数组的长度,纯粹就是对数组的操作

3.2 简单描述接口的好处.

这题我漏做了...现在补上

简而言之:接口含有实现这个接口的类所拥有共性的属性和方法,在接口里定义方法(不需要具体的实现),在实现类中复写我们想要的实现方式,比较方便

Stack and Queue

4.1 编写函数判断一个给定字符串是否是回文,一定要使用栈,但不能使用java的Stack类(具体原因自己搜索)。请粘贴你的代码,类名为Main你的学号。

public class Main063 {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入字符串:");
		while (scan.hasNext()) {
			ArrayListStack stack = new ArrayListStack();
			
			String s = scan.next();
			String s1="";
			for (int i = 0; i < s.length(); i++) {
				s1 = s.substring(i, i + 1);
				stack.push(s1);
			}
			s1 = "";
			for (int i = 0; i < s.length(); i++) {
				s1 = s1 + stack.peek();
				stack.pop();
			}
			if (s.equals(s1)) {
				System.out.println("是回文");
			}else {
				System.out.println("不是回文");
			}
			System.out.println("请输入字符串:");
		}
		scan.close();
	}

}
大概思路:利用到接口,复写入栈,出栈的方法,取栈顶元素的方法

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

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

答:这题主要用的是用到Queue接口,如上图所示,我们只能用Queue的实现类,比如LinkList来实现,这题我用了三个对,第一个放奇数,第二个放偶数,第三个是放真正的顺序,好像有点多此一举...好像可以利用几个循环就好了

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

5.1 实验总结

分析:这题我用到了比较器(p为实现比较器接口的一个实现类,根据题意在该类中比较大小)

TreeSet<String> set = new TreeSet<String>(new p());
最后打印出前十个就好了

选做:加分考察-统计文字中的单词数量并按出现次数排序

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

  • 6.1 伪代码
s.equals("!!!!!") break

map.containsKey(s)?map.put(s, map.get(s) + 1):map.put(s, 1);

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

for i in range 10  

list.get(i).toString()

  • 6.2 实验总结
这题用到了map映射,用其中containsKey方法来判断是否已经存在当前的映射,将统计累加的数字,还有对应的单词放入map当中,用到Collections的sort方法,以第二个参数对象的方法来比较大小,注意的是map当中的每一个元素都是Map.Entry<String, Integer>类型,如下定义:
ArrayList<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
其中map.entrySet()的源代码:
 @return a set view of the mappings contained in this map
    Set<Map.Entry<K, V>> entrySet();

面向对象设计大作业-改进

7.1 完善图形界面(说明与上次作业相比增加与修改了些什么)

答:因为上周的是只有唯一的账号和密码,功能比较单一,可以增加一个注册的功能,将这些信息保存在集合列表中,比如用映射,在输出商品信息时,我用的是文本框域,这周考虑使用JTable来改进,而且发现每次登陆了账号,购物车就要重新new一个,还是有很多不足的地方

7.2 使用集合类改进大作业

  • 新添加注册的功能:

  • 用JTable列表来显示信息:

  • 购物车的列表:


新增的用map映射来保存信息

Map<String, String> map = new HashMap<String, String>();//账户和密码一一对应
	Map<String,Cart> mapcart = new HashMap<String, Cart>(); //每个账户有独立的购物车,也存在映射
	ArrayList<Goods> list=new ArrayList<Goods>();
	public Shopping() {
		new Login().setVisible(true);
	}

将list当中的商品在列表中显示出来:

public void push(ArrayList<Goods> g){
            	
            	for (int i = 0; i < g.size(); i++) {
            		jTable1.setValueAt(g.get(i).getName(),0,1);
            		jTable1.setValueAt(g.get(i).getPrice(),0,2);
            		jTable1.setValueAt(g.get(i).getNumber(),0,3);
				}
            }

这次相对上次有了挺大改进,但是仍存在bug尚未解决,毕竟能力有限...
参考资料:
JTable参考项目

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

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

3.1. 码云代码提交记录

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

3.2 实验总结已经在上面体现出来了

posted @ 2017-04-08 16:42  Linyq  阅读(266)  评论(2编辑  收藏  举报