TomyZhang
TomyZhang

JDK源码 -- ArrayList

一、概念

类定义：

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable
  • 继承了AbstractList抽象类，实现了List接口，拥有一组List通用的操作。
  • 实现了RandomAccess接口，可进行随机访问。
  • 实现了Cloneable接口，可进行浅层次拷贝。
  • 实现了Serializable接口，可进行序列化。

特点：

  • 长于随机访问元素。
  • 在List中间插入和删除元素较慢。

二、使用

//TestArrayList
public class TestArrayList {
    private static final String TAG = "TestArrayList";
    private ArrayList list = new ArrayList<>();

    public void testAdd() {
        list.add("a");
        list.add("b");
        list.add("c");
        Log.d(TAG, "zwm, add list: " + list);
    }

    public void testGet() {
        Log.d(TAG, "zwm, get index 2: " + list.get(2));
    }

    public void testAdd2() {
        list.add(0, "ii");
        list.add(1, "jj");
        list.add(2, "kk");
        Log.d(TAG, "zwm, add index list: " + list);
    }

    public void testAddAll() {
        ArrayList temp = new ArrayList<>();
        temp.add("lll");
        temp.add("mmm");
        temp.add("nnn");
        list.addAll(temp);
        Log.d(TAG, "zwm, addAll list: " + list);
    }

    public void testAddAll2() {
        ArrayList temp = new ArrayList<>();
        temp.add("xxxx");
        temp.add("zzzz");
        temp.add("yyyy");
        temp.add("zzzz");
        list.addAll(0, temp);
        Log.d(TAG, "zwm, addAll index list: " + list);
    }

    public void testIndexOf() {
        Log.d(TAG, "zwm, indexOf zzzz: " + list.indexOf("zzzz"));
    }

    public void testLastIndexOf() {
        Log.d(TAG, "zwm, lastIndexOf zzzz: " + list.lastIndexOf("zzzz"));
    }

    public void testClone() {
        ArrayList cloneList = (ArrayList)list.clone();
        Log.d(TAG, "zwm, list.equals(cloneList): " + list.equals(cloneList));
        Log.d(TAG, "zwm, list==cloneList: " + (list==cloneList));
    }

    public void testContains() {
        Log.d(TAG, "zwm, contains zzzz: " + list.contains("zzzz"));
    }

    public void testContainsAll() {
        ArrayList temp = new ArrayList<>();
        temp.add("xxxx");
        temp.add("yyyy");
        temp.add("zzzz");
        Log.d(TAG, "zwm, containsAll: " + list.containsAll(temp));
    }

    public void testSize() {
        Log.d(TAG, "zwm, size: " + list.size());
    }

    public void testClear() {
        list.clear();
        Log.d(TAG, "zwm, clear list: " + list);
    }

    public void testEmpty() {
        Log.d(TAG, "zwm, isEmpty: " + list.isEmpty());
    }

    public void testIterator() {
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Log.d(TAG, "zwm, iterator item: " + iterator.next());
        }
    }

    public void testIterator2() {
        ListIterator iterator = list.listIterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            Log.d(TAG, "zwm, listIterator item: " + item);
            if(TextUtils.equals(item, "b")) {
                Log.d(TAG, "zwm, remove b");
                iterator.remove();
            } else if(TextUtils.equals(item, "c")) {
                Log.d(TAG, "zwm, update c to x");
                iterator.set("x");
            }
        }
        Log.d(TAG, "zwm, listIterator list: " + list);
        Log.d(TAG, "zwm, next index: " + iterator.nextIndex());
        Log.d(TAG, "zwm, previous index: " + iterator.previousIndex());
        while(iterator.hasPrevious()) {
            String item = iterator.previous();
            Log.d(TAG, "zwm, listIterator item: " + item);
        }
    }

    public void testIterator3() {
        ListIterator iterator = list.listIterator(2);
        while (iterator.hasNext()) {
            String item = iterator.next();
            Log.d(TAG, "zwm, listIterator index item: " + item);
        }
    }

    public void testRemove() {
        Log.d(TAG, "zwm, remove a: " + list.remove("a"));
        Log.d(TAG, "zwm, remove list: " + list);
    }

    public void testRemove2() {
        Log.d(TAG, "zwm, remove index 3: " + list.remove(3));
        Log.d(TAG, "zwm, remove index list: " + list);
    }

    public void testRemoveAll() {
        ArrayList temp = new ArrayList<>();
        temp.add("a");
        temp.add("b");
        Log.d(TAG, "zwm, removeAll: " + list.removeAll(temp));
        Log.d(TAG, "zwm, removeAll list: " + list);
    }

    public void testRetainAll() {
        ArrayList temp = new ArrayList<>();
        temp.add("a");
        temp.add("b");
        temp.add("c");
        Log.d(TAG, "zwm, retainAll: " + list.retainAll(temp));
        Log.d(TAG, "zwm, retainAll list: " + list);
    }

    public void testSet() {
        list.set(0, "sss");
        Log.d(TAG, "zwm, set list: " + list);
    }

    public void testSubList() {
        //以下注释语句会抛出异常java.lang.ClassCastException: java.util.ArrayList$SubList cannot be cast to java.util.ArrayList
        //ArrayList subList = (ArrayList)list.subList(1, 2);
         List subList = list.subList(1, 3);
        Log.d(TAG, "zwm, subList: " + subList);
    }

    public void testEnsureCapacity() {
        //在数据量过大的情况下初始化理想的ArryList容量，效率会明显高于自动扩容
        //所以在项目中有些业务处理时候对ArryList的长度有明显的把控时 最好自定义其扩容方法来提高程序的执行效率
        Log.d(TAG, "zwm, ensureCapacity");
        list.ensureCapacity(100);
    }

    public void testTrimToSize() {
        //将ArrayList容量设置为实际大小
        Log.d(TAG, "zwm, trimToSize");
        list.trimToSize();
    }

    public void testToArray() {
        Object[] arrays = list.toArray();
        for(Object item : arrays) {
            Log.d(TAG, "zwm, toArray item: " + item);
        }
    }

    public void testToArray2() {
        String[] param = new String[list.size()];
        String[] result = list.toArray(param);
        for(String item : param) {
            Log.d(TAG, "zwm, toArray T param item: " + item);
        }
        for(String item : result) {
            Log.d(TAG, "zwm, for result T result item: " + item);
        }
    }
}

//测试代码
private void testMethod() {
    Log.d(TAG, "zwm, testMethod");
    TestArrayList testArrayList = new TestArrayList();
    testArrayList.testAdd();
    testArrayList.testAdd2();
    testArrayList.testAddAll();
    testArrayList.testAddAll2();
    testArrayList.testGet();
    testArrayList.testIndexOf();
    testArrayList.testLastIndexOf();
    testArrayList.testClone();
    testArrayList.testContains();
    testArrayList.testContainsAll();
    testArrayList.testSize();
    testArrayList.testClear();
    testArrayList.testEmpty();
    testArrayList.testAdd();
    testArrayList.testIterator();
    testArrayList.testIterator2();
    testArrayList.testAdd();
    testArrayList.testIterator3();
    testArrayList.testEnsureCapacity();
    testArrayList.testRemove();
    testArrayList.testRemove2();
    testArrayList.testRemoveAll();
    testArrayList.testAdd();
    testArrayList.testRetainAll();
    testArrayList.testSet();
    testArrayList.testSubList();
    testArrayList.testTrimToSize();
    testArrayList.testToArray();
    testArrayList.testToArray2();
}

//输出log
2019-08-02 18:31:06.908 zwm, testMethod
2019-08-02 18:31:06.911 zwm, add list: [a, b, c]
2019-08-02 18:31:06.912 zwm, add index list: [ii, jj, kk, a, b, c]
2019-08-02 18:31:06.912 zwm, addAll list: [ii, jj, kk, a, b, c, lll, mmm, nnn]
2019-08-02 18:31:06.913 zwm, addAll index list: [xxxx, zzzz, yyyy, zzzz, ii, jj, kk, a, b, c, lll, mmm, nnn]
2019-08-02 18:31:06.913 zwm, get index 2: yyyy
2019-08-02 18:31:06.913 zwm, indexOf zzzz: 1
2019-08-02 18:31:06.913 zwm, lastIndexOf zzzz: 3
2019-08-02 18:31:06.914 zwm, list.equals(cloneList): true
2019-08-02 18:31:06.914 zwm, list==cloneList: false
2019-08-02 18:31:06.914 zwm, contains zzzz: true
2019-08-02 18:31:06.914 zwm, containsAll: true
2019-08-02 18:31:06.914 zwm, size: 13
2019-08-02 18:31:06.914 zwm, clear list: []
2019-08-02 18:31:06.915 zwm, isEmpty: true
2019-08-02 18:31:06.915 zwm, add list: [a, b, c]
2019-08-02 18:31:06.915 zwm, iterator item: a
2019-08-02 18:31:06.915 zwm, iterator item: b
2019-08-02 18:31:06.915 zwm, iterator item: c
2019-08-02 18:31:06.915 zwm, listIterator item: a
2019-08-02 18:31:06.915 zwm, listIterator item: b
2019-08-02 18:31:06.915 zwm, remove b
2019-08-02 18:31:06.916 zwm, listIterator item: c
2019-08-02 18:31:06.916 zwm, update c to x
2019-08-02 18:31:06.916 zwm, listIterator list: [a, x]
2019-08-02 18:31:06.916 zwm, next index: 2
2019-08-02 18:31:06.916 zwm, previous index: 1
2019-08-02 18:31:06.916 zwm, listIterator item: x
2019-08-02 18:31:06.916 zwm, listIterator item: a
2019-08-02 18:31:06.916 zwm, add list: [a, x, a, b, c]
2019-08-02 18:31:06.917 zwm, listIterator index item: a
2019-08-02 18:31:06.917 zwm, listIterator index item: b
2019-08-02 18:31:06.917 zwm, listIterator index item: c
2019-08-02 18:31:06.917 zwm, ensureCapacity
2019-08-02 18:31:06.917 zwm, remove a: true
2019-08-02 18:31:06.917 zwm, remove list: [x, a, b, c]
2019-08-02 18:31:06.918 zwm, remove index 3: c
2019-08-02 18:31:06.918 zwm, remove index list: [x, a, b]
2019-08-02 18:31:06.918 zwm, removeAll: true
2019-08-02 18:31:06.918 zwm, removeAll list: [x]
2019-08-02 18:31:06.918 zwm, add list: [x, a, b, c]
2019-08-02 18:31:06.919 zwm, retainAll: true
2019-08-02 18:31:06.919 zwm, retainAll list: [a, b, c]
2019-08-02 18:31:06.919 zwm, set list: [sss, b, c]
2019-08-02 18:31:06.919 zwm, subList: [b, c]
2019-08-02 18:31:06.920 zwm, trimToSize
2019-08-02 18:31:06.920 zwm, toArray item: sss
2019-08-02 18:31:06.920 zwm, toArray item: b
2019-08-02 18:31:06.920 zwm, toArray item: c
2019-08-02 18:31:06.920 zwm, toArray T param item: sss
2019-08-02 18:31:06.920 zwm, toArray T param item: b
2019-08-02 18:31:06.920 zwm, toArray T param item: c
2019-08-02 18:31:06.920 zwm, toArray T result item: sss
2019-08-02 18:31:06.920 zwm, toArray T result item: b
2019-08-02 18:31:06.921 zwm, toArray T result item: c

三、原理

重要参数

//默认的数组长度
private static final int DEFAULT_CAPACITY = 10;

//默认的空数组
private static final Object[] EMPTY_ELEMENTDATA = {};

//默认的空数组（与EMPTY_ELEMENTDATA有点区别，在不同的构造函数中用到）
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

//真正用于存放数据的数组
transient Object[] elementData; 

//数组元素个数
private int size;

构造函数

//指定容量大小初始化
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

//无参初始化，DEFAULTCAPACITY_EMPTY_ELEMENTDATA与EMPTY_ELEMENTDATA都是空数组，区别是当第一个元素被插入时，如果使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组，会自动将容量扩容到10
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

//构造一个包含指定Collection的元素的列表，这些元素是按照该Collection的迭代器返回它们的顺序排列的
public ArrayList(Collection c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

public void trimToSize()

//将ArrayList容量设置为实际大小
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size); //拷贝数组elementData，新数组大小为size
    }
}

public void ensureCapacity(int minCapacity)

//在数据量过大的情况下初始化理想的ArryList容量，效率会明显高于自动扩容
//所以在项目中有些业务处理时候对ArryList的长度有明显的把控时 最好自定义其扩容方法来提高程序的执行效率
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        ? 0
        // larger than default for default empty table. It's already
        // supposed to be at default size.
        : DEFAULT_CAPACITY;

    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}

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

    // overflow-conscious code
    if (minCapacity - elementData.length > 0) //如果指定的minCapacity数值比当前数组容量大，则进行扩容
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); //newCapacity赋值为oldCapacity * 1.5
    if (newCapacity - minCapacity < 0) //如果newCapacity小于指定的minCapacity数值，则newCapacity赋值为minCapacity
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0) //如果newCapacity大于MAX_ARRAY_SIZE
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity); //拷贝数组elementData，新数组大小为newCapacity
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? //如果指定的minCapacity数值大于MAX_ARRAY_SIZE，则扩容至Integer.MAX_VALUE，否则使用MAX_ARRAY_SIZE
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

private void ensureCapacityInternal(int minCapacity)

//在相关操作之前，确保数组有足够的容量
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

public boolean add(E e)

//添加一个元素在数组末尾
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

public void add(int index, E element)

//在索引位置插入元素
public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1, //将index及后面的数据后移一位
                     size - index);
    elementData[index] = element; //插入元素到index位置
    size++; //元素个数加1
}

//判断索引是否越界
private void rangeCheckForAdd(int index) { 
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

public boolean addAll(Collection c)

//插入Collection中的所有元素到末尾
public boolean addAll(Collection c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew); //拷贝数组a的numNew个元素到数组elementData的末尾
    size += numNew; //元素个数加numNew
    return numNew != 0;
}

public boolean addAll(int index, Collection c)

//在索引位置插入Collection中的所有元素
public boolean addAll(int index, Collection c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew, //将index及后面的数据后移numNew位
                         numMoved);

    System.arraycopy(a, 0, elementData, index, numNew); //拷贝数组a的numNew个元素到数组elementData的以index开始的numNew个位置
    size += numNew;
    return numNew != 0;
}

public 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, //将index后面的元素前移一位
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

public boolean remove(Object o)

//删除与对象o相等的元素
public boolean remove(Object o) {
    if (o == null) { //要删除的为空对象
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) { //判断是否等于null
                fastRemove(index);
                return true;
            }
    } else { //要删除的为非空对象
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) { //判断是否相等
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0) 
        System.arraycopy(elementData, index+1, elementData, index, //将index后面的元素前移一位
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

public boolean removeAll(Collection c)

//删除Collection中有的所有元素
public boolean removeAll(Collection c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}

private boolean batchRemove(Collection c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement) //如果不需要删除该元素，则从头开始插入
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

public E set(int index, E element)

//修改索引位置的元素
public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

public E get(int index)

//查询索引位置的元素
public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

public int indexOf(Object o)

//查询第一个与对象o相等的元素的索引位置
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 int lastIndexOf(Object o)

//查询最后一个与对象o相等的元素的索引位置
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

public boolean contains(Object o)

//查询是否包含与对象o相等的元素
public boolean contains(Object o) {
    return indexOf(o) >= 0; //调用indexof方法
}

public void clear()

//清空数组
public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

public int size()

//获取数组元素个数
public int size() {
    return size;
}

public boolean isEmpty()

//判断数组是否有元素
public boolean isEmpty() {
    return size == 0;
}

public Iterator iterator()

//返回迭代器对象
public Iterator iterator() {
    return new Itr();
}

//迭代器类，实现了Iterator接口
private class Itr implements Iterator {
    //获取下一个元素
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    //移除当前元素
    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
    
    //确认是否在别的线程有修改集合
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }   
}

fail-fast机制：
在next和remove操作之前，都会调用checkForComodification函数，如果modCount和本身记录的expectedModCount不一致，就证明集合在别处被修改过，抛出ConcurrentModificationException异常，产生fail-fast事件。

fail-fast机制是java集合（Collection）中的一种错误机制，当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了，那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。一般在多线程环境下，可以考虑使用CopyOnWriteArrayList来避免fail-fast。

public ListIterator listIterator()

//返回迭代器对象
public ListIterator listIterator() {
    return new ListItr(0);
}

//迭代器类，实现了ListIterator接口
private class ListItr extends Itr implements ListIterator

四、主题

数组

你可能感兴趣的:(JDK源码 -- ArrayList)

  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java集合类框架源码分析 之 RoleList源码解析 【6】 yunzhonghefei Java集合类源码分析RoleList源码解析
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
  • java 基础 i0208 java开发语言
    基础数据类型，方法，类，异常处理：Java零基础入门学习（小白也能看懂！）_java零基础自学-CSDN博客List在Java中，List接口是集合框架中非常重要的一个接口，它提供了存储和操作有序集合的方法。List是一个接口，因此不能直接实例化，但可以通过其实现类（如ArrayList,LinkedList,Vector等）来使用。List接口的主要实现类ArrayList:动态数组实现，适用于
  • java读取csv文件 c++代码诗人 java与netwindowspython开发语言
    importjava.io.BufferedReader;importjava.io.FileInputStream;importjava.io.IOException;importjava.io.InputStreamReader;importjava.util.ArrayList;importjava.util.List;importjava.util.regex.Matcher;import
  • 根据ArrayList＜Object＞中对象的多个属性值进行模糊匹配，并找到所有匹配的对象 胡子洲 java基础java
    在Java中，如果你想要根据ArrayList中对象的多个属性值进行模糊匹配，并找到所有匹配的对象，你可以通过遍历列表并使用条件语句来检查每个对象的属性。这里，我们假设你的对象类（比如MyClass）有多个属性，并且你想要根据这些属性的组合来查找匹配的对象。以下是一个示例，展示了如何根据MyClass对象的两个属性（比如name和description）进行模糊匹配：importjava.util
  • Java基础day08ArrayList和继承 没有信仰的小白
    ArrayList类对象数组数组长度是固定，无动态扩容java.util.ArrayList集合类，更方便image无参构造函数image基本格式,Jdk7之后右侧尖括号可以留空，但是必须保留ArrayListlist=newArrayList<>();成员方法添加元素publicbooleanadd(Ee)获取元素publicEget(intindex)集合中的元素publicintsize()
  • 数组的随机组合的两种算法 草莓味的¥猪 算法自动化测试算法
    算法1：importjava.util.*;publicclassTest{/*****利用递归进行排列组合算法打印出所有可能的组合*@return*/publicstaticList>show(Stringc[]){List>result=null;for(inti=0;iresultList=newArrayList>();for(intz=0;zlist1=newArrayList<>();
  • Java基础：什么是多态 试着奔跑的菜鸟 javajava开发语言
    什么是多态多态是面向对象的三大特性之一（另外两个是封装和继承），指的是同一个方法能执行不同的行为，在代码上的体现是：声明为父类的对象，可以被不同的实现类赋值，其中实现类必须继承或者实现父类接口，然后程序在运行时会执行实现类的方法。//如ArrayList和LinkedList都实现了List接口classArrayListimplementsList{}classLinkedListimpleme
  • List集合特点，遍历方式，ArrayList（去重原理，增长因子论，LinkedList) 2401_86367086 面试辅导大厂内推listwindows数据结构
    for(inti=0;i();Dld=newDl(list);d.push(“a”);d.push(“b”);d.push(“c”);/**队列的特点先进先出一次只能取一个堆栈的特点反向输出*/System.out.println(d.pop());System.out.println(d.pop());System.out.println(d.pop());}}//队列classDl{Linke
  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector Colourful． Java集合java集合
    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
  • java 对象存储_在Java中将大量对象存储到磁盘的最佳方法 凯文哥爱分享 java对象存储
    顺便说一句,您不需要列表包装器即可将许多项目写入文件,但是您的项目因此需要可序列化.publicclassSObject{privateStringvalue;privateintoccurences;privateStringkey;}来写Listlist=newArrayList<>();ObjectOutputStreamoos=newObjectOutputStream(newFileOu
  • 鸿蒙应用开发-做一个随机转盘 阿康2024 鸿蒙应用开发harmonyos华为
    使用鸿蒙三方库mpchart可以很方便地做一个滚动转盘，可以做随机选择转盘中的任一项。实现效果如下图所示：实现代码如下：import{ColorTemplate,JArrayList,MPPointF,PieChart,PieChartModel,PieData,PieDataSet,PieEntry}from'@ohos/mpchart';importanimator,{AnimatorOpti
  • 记一下 Stream 流操作 清风ꦿ 开发语言java
    JavaStream流Function.identity（）获取原流中的值创建流Collection.stream()/Collection.parallelStream()：从集合生成流，后者为并行流。Listlist=newArrayListstream=list.stream();//获取一个顺序流StreamparallelStream=list.parallelStream();//获取
  • C# List用法 List介绍 光怪陆离的节日 C#c#list开发语言
    #List泛型集合集合是OOP中的一个重要概念，C#中对集合的全面支持更是该语言的精华之一。为什么要用泛型集合？在C#2.0之前，主要可以通过两种方式实现集合：a.使用ArrayList直接将对象放入ArrayList，操作直观，但由于集合中的项是Object类型，因此每次使用都必须进行繁琐的类型转换。b.使用自定义集合类比较常见的做法是从CollectionBase抽象类继承一个自定义类，通过对
  • 寻找身高相近的小朋友 爱棋笑谦 2024年9月华为OD刷题集算法java华为od面试
    题目描述:小明今年升学到小学一年级，来到新班级后发现其他小朋友们身高参差不齐，然后就想基于各小朋友和自己的身高差对他们进行排序，请帮他实现排序。输入描述:第一行为正整数H和N，0frinedHeights=newArrayList();for(inti=0;i{intdifferent1=Math.abs(h1-mingHeight);intdifferert2=Math.abs(h2-mingH
  • ArrayList删除元素的细则 乐只乐之 技林漫步java
      删除ArrayList数组中某个元素，通常会使用for循环匹配目标元素完成删除操作。publicvoidremove(Listlist,Stringstr){Iteratorit=list.iterator();while(it.hasNext()){if(str.equals(it.next())){it.remove();}}}publicvoidremove(Listlist,Strin
  • List、Set与Map的区别 玖六_
    List：1.可以允许重复的对象。2.可以插入多个null元素。3.是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。4.常用的实现类有ArrayList、LinkedList和Vector。ArrayList最为流行，它提供了使用索引的随意访问，而LinkedList则对于经常需要从List中添加或删除元素的场合更为合适。Set：1.不允许重复对象2.无序容器，你无法保证每个元
  • Java小项目——超市会员管理系统（简洁明了） 超级蛋蛋怪无敌冲！！ java开发语言
    1.解题思路：先运用面向对象的思想抽象出两个类：业务类，会员类运用集合中的ArrayList存储对象中的信息需要有一个循环的菜单来供人选择，菜单中的功能有：1.积分累计2.积分兑换3.查询剩余积分4.修改密码5.开卡6.退出首先要完成开卡功能，不然其他的功能没办法使用退出功能最简单，直接跳出循环就行积分累计功能直接用setScore()方法进行累加；积分兑换使用setScore()方法进行减操作；
  • gee mysql数据库_MySQL weixin_39955142 geemysql数据库
    集合如果你有更好的想法请在评论区留下您的答案，一起交流讨论说说常见的集合有哪些？答：主要分List、Set、Map、Queue四类，其中包含ArrayList、LinkedList、HashSet、TreeSet、HashMapComparable和Comparator接口的区别？答：其两...»smart-rick2021-02-15JAVA基础面向对象有哪些特征？答：继承、封装、多态JDK与J
  • ArrayList 和 Vector 的区别？ PIG_先生 Java面试java
    ArrayList和Vector都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引来取出某个元素，并且其中的数据是允许重复的。ArrayList与Vector的区别主要包括两个方面：1、同步性：Vector是线程安全的，也就是说它的方法之间是线程同步（加了synchroniz
  • ArrayList 和 Vector 的区别是什么？ 复活的夜神月 Java容器面试题java
    ArrayList和Vector都是集合框架中提供的动态数组实现类，它们的主要区别如下：1.线程安全性：Vector是线程安全的，即多线程情况下，Vector可以保证容器的同步性。而ArrayList是非线程安全的，需要在多线程环境下使用时，必须手动实现同步操作。2.初始容量和增长方式：Vector的初始容量缺省为10，当容量不足时，容器容量会以原来容量的2倍自动扩展。而ArrayList的缺省初
  • arraylist和vector区别 馒头配咸菜 笔记java列表
    arraylist有三个构造方法：publicArrayList(intinitialCapacity)//构造一个具有指定初始容量的空列表。publicArrayList()//构造一个初始容量为10的空列表。publicArrayList(Collectionc)//构造一个包含指定collection的元素的列表Vector有四个构造方法：publicVector()//使用指定的初始容量和
  • guava中对Map的扩展数据结构 qq_36608622 guavaspringboot
    Multimap-多值Mapguava中的Multimap提供了将一个键映射到多个值的形式，使用起来无需定义复杂的内层集合，可以像使用普通的Map一样使用它，定义及放入数据如下：Multimapmultimap=ArrayListMultimap.create();multimap.put("day",1);multimap.put("day",2);multimap.put("day",8);m
  • JDBC查询案例 2401_83232029 windowslinuxmicrosoft
    1、封装javabean/实体类Persion{属性方法}让属性不可以直接获取，得到方法（get/set）得到封装的时候针对的是表，所以我们的实体类的所有的属性都要和表中的字段对应回忆（*****）:集合：存储各种数据类型。List常用，存放对象add();集合的对象读结果集存储Listlist=newArrayList();while(resultSet.next()){//System.out
  • java上一页下一页的代码怎么写 Java搬砖组长 java开发语言
    在Java中实现“上一页”和“下一页”功能的代码，通常用于分页的情况，比如从数据库查询数据并分页显示结果。假设你有一个列表，想要通过“上一页”和“下一页”按钮来翻页，可以使用以下代码作为参考。假设我们有一个数据列表，每页显示一定数量的项目，可以用简单的分页逻辑来实现：importjava.util.ArrayList;importjava.util.List;importjava.util.Sca
  • Android NDK开发：用C++手写一个简单的ArrayList itfitness
    目录相关文章AndroidNDK开发：java调用dll动态链接库方法AndroidNDK开发：JNIEnv的原理AndroidNDK开发：C修改Java的属性AndroidNDK开发：C调用Java层方法AndroidNDK开发：C创建Java层的对象AndroidNDK开发：C操作Java层的数组AndroidNDK开发：Native层的变量管理及静态缓存AndroidNDK开发：Native
  • JAVA多维动态数组 天微亮。 java开发语言
    JAVA多维动态数组一维数组数组大小size()增加元素add获取元素get删除元素remove修改元素set输出二维数组三维数组ArrayList类是一个可以动态修改的数组（队列），与普通数组的区别就是它是没有固定大小的限制，提供了相关的添加、删除、修改、遍历等功能。一维数组Listlist=newArrayList();Listlist表示声明一个名为list的变量，其类型是List。List
  • android 6.0後讀取外部SD卡的路徑的方法 冬田里的一把火3 Android应用androidSDCard
    android中獲取內部SD卡存儲路徑是有標準API的如下:StringinternalSDPath=Environment.getExternalStorageDirectory().getAbsolutePath();外部SD卡路徑的獲取方法如下:先遍歷掛載的外部設備publicArrayListgetExternalStorageList(){ArrayListstorageList=new
  • Java面试题 路飞Fly了 java面试开发语言
    Java面试题文章目录1、抽象类和接口的区别2、重载和重写的区别3、==和equals的区别4、讲一讲什么是map、set、list5、HashMap原理6、什么是JSP？它与Servlet有什么区别7、synchronized关键字8、HashTable与HashMap的区别9、ArrayList和LinkedList的区别10、Session和Cookie的区别11、String、String
  • 华为 笔试 4.24 第二题：这一题只通过了36%why 2301_78234743 java
    日常实习求捞捞本科北理24届，目前已经拿nus研究生offer准备在剩下这几个月做一段软件开发实习，我之前有小公题解|#[NOIP2010]数字统计##includeusingnamespacestd;intm阿里控股爱橙科技啥啥治理中心Java一面50分钟自我介绍。Java集合。所有的集合都说一遍，包括一些细节，比如ArrayList的扩容机制，Lin育碧源计划初级游戏逻辑开发流程+凉经4.9投
  • java观察者模式 3213213333332132 java设计模式游戏观察者模式
    观察者模式——顾名思义，就是一个对象观察另一个对象，当被观察的对象发生变化时，观察者也会跟着变化。 在日常中，我们配java环境变量时，设置一个JAVAHOME变量,这就是被观察者，使用了JAVAHOME变量的对象都是观察者，一旦JAVAHOME的路径改动，其他的也会跟着改动。 这样的例子很多，我想用小时候玩的老鹰捉小鸡游戏来简单的描绘观察者模式。 老鹰会变成观察者，母鸡和小鸡是
  • TFS RESTful API 模拟上传测试 ronin47
           TFS RESTful API 模拟上传测试。 　　 细节参看这里：https://github.com/alibaba/nginx-tfs/blob/master/TFS_RESTful_API.markdown 模拟POST上传一个图片： curl --data-binary @/opt/tfs.png http
  • PHP常用设计模式单例, 工厂, 观察者, 责任链, 装饰, 策略,适配,桥接模式 dcj3sjt126com 设计模式PHP
    // 多态, 在JAVA中是这样用的, 其实在PHP当中可以自然消除, 因为参数是动态的, 你传什么过来都可以, 不限制类型, 直接调用类的方法 abstract class Tiger { public abstract function climb(); } class XTiger extends Tiger { public function climb()
  • hibernate 171815164 Hibernate
    main,save Configuration conf =new Configuration().configure(); SessionFactory sf=conf.buildSessionFactory(); Session sess=sf.openSession(); Transaction tx=sess.beginTransaction(); News a=new
  • Ant实例分析 g21121 ant
            下面是一个Ant构建文件的实例，通过这个实例我们可以很清楚的理顺构建一个项目的顺序及依赖关系，从而编写出更加合理的构建文件。           下面是build.xml的代码： <?xml version="1
  • [简单]工作记录_接口返回405原因 53873039oycg 工作
             最近调接口时候一直报错，错误信息是:       responseCode:405 responseMsg:Method Not Allowed        接口请求方式Post.
  • 关于java.lang.ClassNotFoundException 和 java.lang.NoClassDefFoundError 的区别 程序员是怎么炼成的
       真正完成类的加载工作是通过调用 defineClass来实现的；  而启动类的加载过程是通过调用 loadClass来实现的；  就是类加载器分为加载和定义   protected Class<?> findClass(String name) throws ClassNotFoundExcept
  • JDBC学习笔记-JDBC详细的操作流程 aijuans jdbc
    所有的JDBC应用程序都具有下面的基本流程：　　1、加载数据库驱动并建立到数据库的连接。　　2、执行SQL语句。　　3、处理结果。　　4、从数据库断开连接释放资源。 下面我们就来仔细看一看每一个步骤： 其实按照上面所说每个阶段都可得单独拿出来写成一个独立的类方法文件。共别的应用来调用。 1、加载数据库驱动并建立到数据库的连接：   Html代码  St
  • rome创建rss antonyup_2006 tomcatcmsxmlstrutsOpera
    引用 1.RSS标准 RSS标准比较混乱，主要有以下3个系列 RSS 0.9x / 2.0 : RSS技术诞生于1999年的网景公司(Netscape)，其发布了一个0.9版本的规范。2001年，RSS技术标准的发展工作被Userland Software公司的戴夫 温那(Dave Winer)所接手。陆续发布了0.9x的系列版本。当W3C小组发布RSS 1.0后，Dave W
  • html表格和表单基础 百合不是茶 html表格表单meta锚点
    第一次用html来写东西,感觉压力山大,每次看见别人发的都是比较牛逼的 再看看自己什么都还不会,   html是一种标记语言,其实很简单都是固定的格式   _----------------------------------------表格和表单 表格是html的重要组成部分,表格用在body里面的 主要用法如下; <table> &
  • ibatis如何传入完整的sql语句 bijian1013 javasqlibatis
            ibatis如何传入完整的sql语句？进一步说，String str ="select * from test_table"，我想把str传入ibatis中执行，是传递整条sql语句。         解决办法： <
  • 精通Oracle10编程SQL(14)开发动态SQL bijian1013 oracle数据库plsql
    /* *开发动态SQL */ --使用EXECUTE IMMEDIATE处理DDL操作 CREATE OR REPLACE PROCEDURE drop_table(table_name varchar2) is sql_statement varchar2(100); begin sql_statement:='DROP TABLE '||table_name;
  • 【Linux命令】Linux工作中常用命令 bit1129 linux命令
    不断的总结工作中常用的Linux命令   1.查看端口被哪个进程占用   通过这个命令可以得到占用8085端口的进程号，然后通过ps -ef|grep 进程号得到进程的详细信息   netstat -anp | grep 8085   察看进程ID对应的进程占用的端口号   netstat -anp | grep 进程ID &
  • 优秀网站和文档收集 白糖_ 网站
    集成 Flex, Spring, Hibernate 构建应用程序   性能测试工具-JMeter   Hmtl5-IOCN网站   Oracle精简版教程网站   鸟哥的linux私房菜   Jetty中文文档   50个jquery必备代码片段   swfobject.js检测flash版本号工具
  • angular.extend boyitech AngularJSangular.extendAngularJS API
    angular.extend 复制src对象中的属性去dst对象中. 支持多个src对象. 如果你不想改变一个对象，你可以把dst设为空对象{}: var object = angular.extend({}, object1, object2). 注意: angular.extend不支持递归复制. 使用方法: angular.extend(dst, src); 参数:
  • java-谷歌面试题-设计方便提取中数的数据结构 bylijinnan java
    网上找了一下这道题的解答，但都是提供思路，没有提供具体实现。其中使用大小堆这个思路看似简单，但实现起来要考虑很多。 以下分别用排序数组和大小堆来实现。 使用大小堆： import java.util.Arrays; public class MedianInHeap { /** * 题目：设计方便提取中数的数据结构 * 设计一个数据结构，其中包含两个函数，1.插
  • ajaxFileUpload 针对 ie jquery 1.7+不能使用问题修复版本 Chen.H ajaxFileUploadie6ie7ie8ie9
    jQuery.extend({ handleError: function( s, xhr, status, e ) { // If a local callback was specified, fire it if ( s.error ) { s.error.call( s.context || s, xhr, status, e ); }
  • [机器人制造原则]机器人的电池和存储器必须可以替换 comsci 制造
           机器人的身体随时随地可能被外来力量所破坏,但是如果机器人的存储器和电池可以更换,那么这个机器人的思维和记忆力就可以保存下来,即使身体受到伤害,在把存储器取下来安装到一个新的身体上之后,原有的性格和能力都可以继续维持.....        另外,如果一
  • Oracle Multitable INSERT 的用法 daizj oracle
    转载Oracle笔记-Multitable INSERT 的用法 http://blog.chinaunix.net/uid-8504518-id-3310531.html 一、Insert基础用法 语法：     Insert Into 表名 (字段1,字段2,字段3...）     Values (值1,
  • 专访黑客历史学家George Dyson datamachine on
    20世纪最具威力的两项发明——核弹和计算机出自同一时代、同一群年青人。可是，与大名鼎鼎的曼哈顿计划（第二次世界大战中美国原子弹研究计划）相 比，计算机的起源显得默默无闻。出身计算机世家的历史学家George Dyson在其新书《图灵大教堂》（Turing’s Cathedral）中讲述了阿兰·图灵、约翰·冯·诺依曼等一帮子天才小子创造计算机及预见计算机未来
  • 小学6年级英语单词背诵第一课 dcj3sjt126com englishword
    always 总是 rice 水稻，米饭 before 在...之前 live 生活，居住   usual 通常的 early 早的 begin 开始 month 月份   year 年 last 最后的 east 东方的 high 高的   far 远的 window 窗户 world 世界 than 比...更  
  • 在线IT教育和在线IT高端教育 dcj3sjt126com 教育
    codecademy  http://www.codecademy.com codeschool  https://www.codeschool.com teamtreehouse  http://teamtreehouse.com lynda http://www.lynda.com/ Coursera https://www.coursera.
  • Struts2 xml校验框架所定义的校验文件 蕃薯耀 Struts2 xml校验Struts2 xml校验框架Struts2校验
      >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年7月11日 15:54:59 星期六 http://fa
  • mac下安装rar和unrar命令 hanqunfeng mac
    1.下载：http://www.rarlab.com/download.htm 选择 RAR 5.21 for Mac OS X 2.解压下载后的文件 tar -zxvf rarosx-5.2.1.tar 3.cd rar sudo install -c -o $USER unrar /bin #输入当前用户登录密码 sudo install -c -o $USER rar
  • 三种将list转换为map的方法 jackyrong list
      在本文中，介绍三种将list转换为map的方法： 1） 传统方法 假设有某个类如下    class Movie { private Integer rank; private String description; public Movie(Integer rank, String des
  • 年轻程序员需要学习的5大经验 lampcy 工作PHP程序员
    在过去的7年半时间里，我带过的软件实习生超过一打，也看到过数以百计的学生和毕业生的档案。我发现很多事情他们都需要学习。或许你会说，我说的不就是某种特定的技术、算法、数学，或者其他特定形式的知识吗？没错，这的确是需要学习的，但却并不是最重要的事情。他们需要学习的最重要的东西是“自我规范”。这些规范就是：尽可能地写出最简洁的代码；如果代码后期会因为改动而变得凌乱不堪就得重构；尽量删除没用的代码，并添加
  • 评“女孩遭野蛮引产致终身不育 60万赔偿款1分未得”医腐深入骨髓 nannan408
    先来看南方网的一则报道： 再正常不过的结婚、生子，对于29岁的郑畅来说，却是一个永远也无法实现的梦想。从2010年到2015年，从24岁到29岁，一张张新旧不一的诊断书记录了她病情的同时，也清晰地记下了她人生的悲哀。 　　粗暴手术让人发寒 　　2010年7月，在酒店做服务员的郑畅发现自己怀孕了，可男朋友却联系不上。在没有和家人商量的情况下，她决定堕胎。 　　12月5日，
  • 使用jQuery为input输入框绑定回车键事件 VS 为a标签绑定click事件 Everyday都不同 jspinput回车键绑定clickenter
    假设如题所示的事件为同一个，必须先把该js函数抽离出来，该函数定义了监听的处理：   function search() { //监听函数略...... }   为input框绑定回车事件，当用户在文本框中输入搜索关键字时，按回车键，即可触发search():   //回车绑定 $(".search").keydown(fun
  • EXT学习记录 tntxia ext
      1. 准备   （1） 官网：http://www.sencha.com/   里面有源代码和API文档下载。   EXT的域名已经从www.extjs.com改成了www.sencha.com ，但extjs这个域名会自动转到sencha上。   （2）帮助文档：   想要查看EXT的官方文档的话，可以去这里h
  • mybatis3的mapper文件报Referenced file contains errors xingguangsixian mybatis
    最近使用mybatis.3.1.0时无意中碰到一个问题： The errors below were detected when validating the file "mybatis-3-mapper.dtd" via the file "account-mapper.xml". In most cases these errors can be d
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他