做编程的一个常识:不要在循环过程中删除元素本身(至少是我个人的原则)。否则将发生不可预料的问题。
而最近,看到一个以前的同学写的一段代码就是在循环过程中删除元素,我很是纳闷啊。然后后来决定给他改掉。然后引发了另外的惨案。
原来的代码是这样的:
- public List < A > getUserDebitCard(A cond) {
- List < A > list = userService.getCard(cond);
- List < A > result = null;
- if (list ! =null && list.size() > 0) {
- Collections.sort(list, new Comparator < A > () {
- public int compare(A b1, A b2) {
- //按时间排序
- if (Integer.valueOf(b1.getAddTime()) > Integer.valueOf(b2.getAddTime())) {
- return - 1;
- }
- return 1;
- }
- });
- A bean = getA(cond);
- result = new ArrayList < A > ();
- if (bean != null) {
- for (int i = 0; i < list.size(); i++) {
- if (list.get(i).getCardNum().equals(bean.getCardNum())) {
- list.get(i).setAs(1);
- result.add(list.get(i));
- list.remove(i);
- } else {
- list.get(i).setAs(0);
- }
- }
- }
- result.addAll(list);
- }
- return result;
- }
看了如上代码,我很是郁闷,然后给改成如下:
- public List < A > getUserDebitCard(A cond) {
- List < A > list = userService.getCard(cond);
- List < A > result = null;
- if (list != null && list.size() > 0) {
- Collections.sort(list, new Comparator < A > () {
- public int compare(A b1, A b2) {
- //按时间排序
- if (Integer.valueOf(b1.getAddTime()) > Integer.valueOf(b2.getAddTime())) {
- return - 1;
- }
- return 1;
- }
- });
- A bean = getA(cond);
- result = new ArrayList < >();
- if (bean != null) {
- // 将上次的卡放置在第一位
- Integer lastAIndex = 0;
- Integer listSize = list.size();
- if (listSize > 0) {
- for (int i = 0; i < listSize; i++) {
- if (list.get(i).getCardNum().equals(bean.getCardNum())) {
- list.get(i).setAs(1);
- result.add(list.get(i)); //将排在首位的元素先添加好,并记录下index
- lastAIndex = i;
- // list.remove(i); //循环过程中删除元素是危险的
- } else {
- list.get(i).setAs(0);
- }
- }
- list.remove(lastAIndex);
- }
- }
- result.addAll(list); //在循环外删除元素,以为万事大吉,结果悲剧了,这里居然添加了两个元素进来
- }
- return result;
- }
这下出事了,原本只有一个元素的 result, 现在变成了两个了,这是为什么呢?妈蛋,我明明已经 remove 掉了啊。
也想过百度一下,但是木有搞定啊。然后,拿出看家绝招,断点调试,进入 list.remove(Integer) 方法。其源码如下:
- /**
- * Removes the first occurrence of the specified element from this list,
- * if it is present. If the list does not contain the element, it is
- * unchanged. More formally, removes the element with the lowest index
- * <tt>i</tt> such that
- * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>
- * (if such an element exists). Returns <tt>true</tt> if this list
- * contained the specified element (or equivalently, if this list
- * changed as a result of the call).
- *
- * @param o element to be removed from this list, if present
- * @return <tt>true</tt> if this list contained the specified element
- */
- public boolean remove(Object o) {
- if (o == null) {
- for (int index = 0; index < size; index++) if (elementData[index] == null) {
- fastRemove(index);
- return true;
- }
- } else {
- for (int index = 0; index < size; index++) if (o.equals(elementData[index])) {
- fastRemove(index);
- return true;
- }
- }
- return false;
- }
原来,由于我使用 Integer 作为删除元素的条件,这里把 Integer 当作一个元素去比较了,而并不是平时我们以为的自动拆装箱变为 int 了。 而进入这个方法的意思,是要找到和元素内容相等的元素,然后删除它。而我给的是一个索引,自然就不相等了,没有删除也是自然了,因为就会看到重复的元素出来了。
我们再来看一下根据索引删除元素的源码,对比一下:
- /**
- * Removes the element at the specified position in this list.
- * Shifts any subsequent elements to the left (subtracts one from their
- * indices).
- *
- * @param index the index of the element to be removed
- * @return the element that was removed from the list
- * @throws IndexOutOfBoundsException {@inheritDoc}
- */
- 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;
- }
从这里我们可以看到,根据索引删除 ArrayList 元素的原理是,将原来的数组排除要删除的索引,然后复制到新的数组去,然后将最后一个元素置为 null,留给 GC 回收。并把删除的元素返回。
这样,一下就明白了删除 ArrayList 元素到底是咋么一回事了。修复方案就简单了,将 Integer 替换为 int 即可:
- // Integer lastAIndex = 0; //替换成int
- int lastAIndex = 0;
当然了,最后,我还是换成了另一个更稳妥的方案了,用另一个容器接收最终的结果
- public List < A > getUserDebitCard(A cond) {
- List < A > list = userService.getCard(cond);
- List < A > result = null;
- if (list ! =null && list.size() > 0) {
- Collections.sort(list, new Comparator < A > () {
- public int compare(A b1, A b2) {
- //按时间排序
- if (Integer.valueOf(b1.getAddTime()) > Integer.valueOf(b2.getAddTime())) {
- return - 1;
- }
- return 1;
- }
- });
- A bean = getA(cond);
- result = new ArrayList < >();
- if (bean != null) {
- // 将上次的卡放置在第一位
- for (A card1: list) {
- if (card1.getCardNum().equals(bean.getCardNum())) {
- card1.setAs(1);
- result.add(0, card1); //直接插入第一位即可
- // list.remove(i); //循环过程中删除元素是危险的
- } else {
- card1.setAs(0);
- result.add(card1);
- }
- }
- }
- }
- return result;
- }
虽然自动拆装箱很方便,也很实用,但是有时一不小心就会把自己给埋坑里了,当心了。尤其是针对线上问题。
毕竟,代码中的一点点小问题,一到线上就会被无限放大,不可掉以轻心啊!
来源: http://www.cnblogs.com/yougewe/p/7353081.html