java.util.*中AbstractList源代码详解

超、凢脫俗 2022-11-28 15:18 118阅读 0赞

### java.util.\*中AbstractList源代码详解 ###

*   *  核心方法
     *  boolean add()
     *  set(int index, E element)
     *  void add(int index, E element)
     *  E remove(int index)
     *  int indexOf(Object o)
     *  int lastIndexOf(Object o)
     *  void clear()
     *  boolean addAll()
     *  Iterator iterator()
     *  ListIterator listIterator()
     *  List subList()
     *  boolean equals(Object o)
     *  int hashCode()

## 核心方法 ##

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
    
    boolean add(E e) 向List末尾位置,添加一个元素[OK]
    E set(int index, E element) 向指定位置,设置元素的值,替换原有位置的值[OK]
    void add(int index, E element) 向指定位置添加元素,原所在位置及后面位置的元素,全部往后移动[OK]
    E remove(int index) 删除某个位置的元素[OK]
    int indexOf(Object o) 从list头部开始检索目标对象的索引位置[OK]
    int lastIndexOf(Object o) 从list尾索目标对象的索引位置[OK]
    void clear() 清空list[OK]
    boolean addAll() 向某个索引位置添加元素集合[OK]
    Iterator<E> iterator() 获取当前list的迭代器对象[OK]
    ListIterator<E> listIterator() 获取当前对象ListIterator对象[OK]
    List<E> subList() 获取子list序列,[from,to)[OK]
    boolean equals(Object o) 比较两个list元素是否相等[OK]
    int hashCode() 计算list的hashCode值[OK]

## boolean add() ##

/** * 向数组中添加一个对象(添加到末尾位置) */
    public boolean add(E e) { 
        add(size(), e);
        return true;
    }
    
    public void add(int index, E element) { 
        throw new UnsupportedOperationException();
    }

## set(int index, E element) ##

/** * 向指定位置,设置元素的值,替换原有位置的值 */
    public E set(int index, E element) { 
        throw new UnsupportedOperationException();
    }

## void add(int index, E element) ##

public void add(int index, E element) { 
        throw new UnsupportedOperationException();
    }

## E remove(int index) ##

/** * 删除某个位置的元素 */
    public E remove(int index) { 
        throw new UnsupportedOperationException();
    }

## int indexOf(Object o) ##

/** * 默认获取0号索引位置的迭代器 */
    public ListIterator<E> listIterator() { 
        return listIterator(0);
    }
    
    public int indexOf(Object o) { 
    	//获取当前对象的ListIterator迭代器对象
        ListIterator<E> it = listIterator();
        //判断o是否为空
        if (o==null) { 
        	//如果it.hasNext()下一个元素存在
            while (it.hasNext())
            	//比较下一个元素,是否为null
                if (it.next()==null)
                	//返回null元素的索引位置
                	//这里it.previosIndex()
                	//因为it迭代器指针已经转移到下一个位置
                    return it.previousIndex();
        } else { 
        	//如果it.hasNext()下一个元素存在
            while (it.hasNext())
            	//比较下一个元素是否等于传入元素o
                if (o.equals(it.next()))
                	//如果匹配上,则返回匹配位置的索引
                    return it.previousIndex();
        }
        //如果没找到,返回-1
        return -1;
    }

## int lastIndexOf(Object o) ##

public int lastIndexOf(Object o) { 
    	//获取list数组末尾位置的迭代器对象
        ListIterator<E> it = listIterator(size());
        if (o==null) { 
        	//判断它的前一个位置是否存在元素
            while (it.hasPrevious())
            	//比较元素是否为空
                if (it.previous()==null)
                	//返回空元素的索引位置
                	//it在执行一次it.previos后,指针已经前移
                	//所以null的真实所以位置应该是it.nextIndex()
                    return it.nextIndex();
        } else { 
            while (it.hasPrevious())
                if (o.equals(it.previous()))
                    return it.nextIndex();
        }
        return -1;
    }

## void clear() ##

/** * 清空list */
    public void clear() { 
        removeRange(0, size());
    }
    
    protected void removeRange(int fromIndex, int toIndex) { 
        ListIterator<E> it = listIterator(fromIndex);
        for (int i=0, n=toIndex-fromIndex; i<n; i++) { 
            it.next();
            //删除所在位置的值
            it.remove();
        }
    }

## boolean addAll() ##

/** * 向某个索引位置添加元素集合 */
    public boolean addAll(int index, Collection<? extends E> c) { 
    	//角标范围检查
        rangeCheckForAdd(index);
        boolean modified = false;
        for (E e : c) { 
        	//添加元素
            add(index++, e);
            modified = true;
        }
        return modified;
    }

## Iterator iterator() ##

/** * 获取当前list的迭代器对象 */
    public Iterator<E> iterator() { 
        return new Itr();
    }
    
    private class Itr implements Iterator<E> { 
        /** * Index of element to be returned by subsequent call to next. */
        int cursor = 0;
    
        /** * Index of element returned by most recent call to next or * previous. Reset to -1 if this element is deleted by a call * to remove. */
        int lastRet = -1;
    
        /** * The modCount value that the iterator believes that the backing * List should have. If this expectation is violated, the iterator * has detected concurrent modification. */
        int expectedModCount = modCount;
    
        public boolean hasNext() { 
            return cursor != size();
        }
    
        public E next() { 
            checkForComodification();
            try { 
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) { 
                checkForComodification();
                throw new NoSuchElementException();
            }
        }
    
        public void remove() { 
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
    
            try { 
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) { 
                throw new ConcurrentModificationException();
            }
        }
    
        final void checkForComodification() { 
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

## ListIterator listIterator() ##

/** * 获取当前对象ListIterator对象 */
    public ListIterator<E> listIterator() { 
        return listIterator(0);
    }
    
    public ListIterator<E> listIterator(final int index) { 
        //角标合法性检查
        rangeCheckForAdd(index);
        return new ListItr(index);
    }
    
    private class ListItr extends Itr implements ListIterator<E> { 
        ListItr(int index) { 
            cursor = index;
        }
    
        public boolean hasPrevious() { 
            return cursor != 0;
        }
    
        public E previous() { 
            checkForComodification();
            try { 
                int i = cursor - 1;
                E previous = get(i);
                lastRet = cursor = i;
                return previous;
            } catch (IndexOutOfBoundsException e) { 
                checkForComodification();
                throw new NoSuchElementException();
            }
        }
    
        public int nextIndex() { 
            return cursor;
        }
    
        public int previousIndex() { 
            return cursor-1;
        }
    
        public void set(E e) { 
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
    
            try { 
                AbstractList.this.set(lastRet, e);
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) { 
                throw new ConcurrentModificationException();
            }
        }
    
        public void add(E e) { 
            checkForComodification();
    
            try { 
                int i = cursor;
                AbstractList.this.add(i, e);
                lastRet = -1;
                cursor = i + 1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) { 
                throw new ConcurrentModificationException();
            }
        }
    }

## List subList() ##

/** * 获取子list对象[fromIndex,toIndex) */
    public List<E> subList(int fromIndex, int toIndex) { 
        return (this instanceof RandomAccess ?
                new RandomAccessSubList<>(this, fromIndex, toIndex) :
                new SubList<>(this, fromIndex, toIndex));
    }

## boolean equals(Object o) ##

/** * 比较两个list元素是否相等 */
    public boolean equals(Object o) { 
    	//判断内存地址是否相当,如果一样,直接返回true
        if (o == this)
            return true;
        //判断对象是否是list,否则返回false 
        if (!(o instanceof List))
            return false;
    	//获取当前对象的ListIterator对象
        ListIterator<E> e1 = listIterator();
        //获取比较对象的ListIterator对象
        ListIterator<?> e2 = ((List<?>) o).listIterator();
        while (e1.hasNext() && e2.hasNext()) { 
            E o1 = e1.next();
            Object o2 = e2.next();
            //比较两个元素是否相等
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        //如果最后两个元素都不存在下一个元素,返回true
        return !(e1.hasNext() || e2.hasNext());
    }

## int hashCode() ##

public int hashCode() { 
        int hashCode = 1;
        for (E e : this)
        	//核心算法 31*hashCode + 元素.hashCode()
            hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
        return hashCode;
    }

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！