一角钱技术
一角钱技术

深入ArrayList源码分析（JDK1.8）

深入ArrayList源码分析（JDK1.8）

Java 集合系列源码分析文章：

  • 深入TreeMap源码解析（JDK1.8）
  • 深入LinkedHashMap源码解析（JDK1.8）

ArrayList源码分析（基于JDK8）

数据结构中有两种存储结构，分别是：顺序存储结构、链式存储结构。在 Java 中，对于这四种结构分别进行实现的类有：

  • 顺序存储结构：ArrayList、Stack
  • 链式存储结构：LinkedList、Queue

这里只对 ArrayList 的源码进行分析，ArrayList 是一个数组队列，相当于 动态数组 。与Java 中的数组相比，它的容量能动态增长。

特点

  • 基本的 ArrayList 常用于随机访问元素，但是在 List 中间插入和移除元素较慢；
  • ArrayList 中的操作不是线程安全的。所以建议在单线程中才使用 ArrayList ，而在多线程中可以选择 Vector 或者 CopyOnWriteArrayList ，建议使用 CopyOnWriteArrayList 。

继承关系

上面可以看到，ArrayList 实现来四个接口一个抽象类。它继承类 AbstracList 抽象类，实现了 List 、 RandomAccess （随机访问）、 Cloneable （可克隆）、 Serializable （序列化）四个接口

  • ArrayList 继承于 AbstractList ，实现了 List 。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能；
  • ArrayList 实现了 RandmoAccess 接口，即提供了随机访问功能；
  • ArrayList 实现了 Cloneable 接口，即覆盖了函数 clone() ，能被克隆；
  • ArrayList 实现了 java.io.Serializable 接口，这意味着 ArrayList 支持序列化，能通过序列化去传输。

成员变量

在 ArrayList 的源码中，主要成员变量如下：

public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable{
    ...
    // 默认数组的长度
    private static final int DEFAULT_CAPACITY = 10;
    // 默认的空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 默认的空数组，与上面的区别，在不同的构造函数中用到
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // 真正用于存放数据的数组
    transient Object[] elementData;
    // 数组元素个数
    private int size;
    // 要分配的数组的最大大小，尝试分配更大的阵列可能会导致 OutOfMemoryError
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    ...
}

ArrayList 的底层实现是数组，默认的数组大小是 10。

构造函数

  • ArrayList()：构造一个初始容量为10的空列表
  • ArrayList(Collection c)：构造一个包含指定元素的列表
  • ArrayList( int initialCapcity )：构造一个具有初始容量值得空列表
// 第一种，调用ArrayList(10) 默认初始化一个大小为10的Object数组
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 第二种
public ArrayList(int initialCapacity) {
    // 如果用户初始化大小大于0，则新建一个用户初始化值大小的Objec数组
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 等于0，则赋值为变量EMPTY_ELEMENTDATA，默认的空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 小于0，则抛出异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    }
}
// 第三种：将容器数组化处理并将这个数组值赋给Object数组
public ArrayList(Collection c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        // 当c.toArray 返回的不是 Object 类型的数组时，进行下面的转化
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

增删改查操作

对于增删改查的基本操作，在这里只给出一些比较重要的源代码进行解析。

增加操作

  • add(E e)：添加一个元素到列表的末尾。
  • add( int index, E element ) :在指定的位置添加元素
  • addAll( Collection c )：添加一个集合到元素的末尾.以上返回类型是boolean
  • ensureCapcity（int minCapcity）：确保列表中含有minCapcity的最小容量

ArrayList默认的插入是插在数组的末尾，在不需要扩容时是一个时间复杂度O(1)的操作，需要扩容时复杂度为O(n)，所以如果预先能判断数据量的大小，可以指定初始化数组的大小，避免过多的扩容操作。下面代码看一些第一个增加元素的方法实现：

// 第一步：
public boolean add(E e) {
    // 加入元素前检查数组的容量是否足够
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, 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;
    // 将数组的长度增加原来数组的一半，也就是1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果扩充一半后仍然不够，则 newCapacity = minCapacity；minCapacity实际元素的个数
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 如果扩充后的容量超过最大值变量MAX_ARRAY_SIZE
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    // 将elementData持有的元素复制到新的数组对象，最后将elementData的引用指向新的数组对象
    // 原有的数组对象因为没有了引用，一段时间后将被回收。
    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;
}

ArrayList还支持在指定索引处插入。在指定索引处插入时，需要将指定索引及其之后的元素向后推一个位置，所以是一个复杂度O(n)的操作。源码如下：

// 第一步：
public void add(int index, E element) {
    // 检查index的值是否在0到size之间，可以为size.
    rangeCheckForAdd(index);
    // 看 elementData 的长度是否足够，不够扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 将 elementData 从 index 开始后面的元素往后移一位
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}
// 第二步：
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

// 第三步：
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

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

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

删除操作

  • remove(Object o)：删除列表中第一个出现O的元素
  • remove( int index)：删除列表中指定位置的元素
  • removeAll（Collection c）：删除列表中包含C的所有元素
  • removeIf（Predictcate filter）：删除列表中给定谓词的所有元素
  • removeRange( int from,int to )：删除从from到to的所有元素
  • clear（）：清除所有的元素。返回类型为void

ArrayList 删除元素时，需要将所删元素之后位置的元素都向前推一个位置，复杂度也是O(n)。所以ArrayList不适合需要频繁在指定位置插入元素及删除的应用场景，看代码实现：

public E remove(int index) {
    // 第一步：如果index >= size，则抛出异常
    rangeCheck(index);

    modCount++;
    // 第二步：获取删除元素的值
    E oldValue = elementData(index);
    // 第三步：将 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;
}

再看一个其它的实现：

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                eturn true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

 /*
  * Private remove method that skips bounds checking and does not
  * return the value removed.
  */   
 private void fastRemove(int index) {
    modCount++;
    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
}

更改操作

  • retainAll( Collection c )：仅仅保留列表中和C相同的元素，相当于&运算
  • set（int index,E element）：用element替换index位置上的元素。
  • size()：返回此列表的元素数
  • sort(Comparator c)：按照指定的排序规则排序
  • subList( int from , int to )：返回从from到to之间的列表
  • toArray()：将列表转化为数组
  • trimToSize( )：修改当前实例的容量是列表的当前大小。

set方法

确保set的位置小于当前数组的长度（size）并且大于0，获取指定位置（index）元素，然后放到oldValue存放，将需要设置的元素放到指定的位置（index）上，然后将原来位置上的元素oldValue返回给用户。

// 第一步：
public E set(int index, E element) {
    // 检查index是否大于size，如果是则抛出异常
    rangeCheck(index);

    E oldValue = elementData(index);
    // 覆盖ArrayList中index上的元素
    elementData[index] = element;
    // 返回被覆盖的元素
    return oldValue;
}
// 第二步；
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

subList方法

我们看到代码中是创建了一个ArrayList 类里面的一个内部类SubList对象，传入的值中第一个参数时this参数，其实可以理解为返回当前list的部分视图，真实指向的存放数据内容的地方还是同一个地方，如果修改了sublist返回的内容的话，那么原来的list也会变动。

public List subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, 0, fromIndex, toIndex);
}

谨慎使用 ArrayList 中的 subList 方法

  • ArrayList 的 subList 结果不可强转成 ArrayList，否则会抛出 ClassCastException 异常，即 java.util.RandomAccessSubList cannot be cast to java.util.ArrayList. 说明：subList 返回的是 ArrayList 的内部类 SubList，并不是 ArrayList ，而是 ArrayList 的一个视图，对于 SubList 子列表的所有操作最终会反映到原列表上。
List list = new ArrayList<>();
list.add("1");
list.add("1");
list.add("2");
ArrayList strings =  (ArrayList)list.subList(0, 1);

运行结果：Exception in thread "main" java.lang.ClassCastException: java.util.ArrayList$SubList cannot be cast to java.util.ArrayList  at com.nuih.List.ArrayListTest.main(ArrayListTest.java:29)
  • 在 subList 场景中，高度注意对原集合元素个数的修改，会导致子列表的遍历、增加、 删除均会产 ConcurrentModificationException 异常。
List list = new ArrayList<>();
list.add("1");
list.add("1");
list.add("2");
List subList =  list.subList(0, 1);
// 对原 List 增加一个值
list.add("10");
subList.add("11"); // 这一行会报 java.util.ConcurrentModificationException

trimToSize方法

public void trimToSize() {
    // 修改次数加1
    modCount++;
    // 如果当前元素小于数组容量，则将elementData中空余的空间（包括null值）去除
    // 例如：数组长度为10，其中只有前三个元素有值，其他为空，那么调用该方法后，数组的长度变为3
    if (size < elementData.length) {
        elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

toArray方法

第一个，Object[] toArray()方法。该方法有可能会抛出java.lang.ClassCastException异常，如果直接用向下转型的方法，将整个ArrayList集合转变为指定类型的Array数组，便会抛出该异常，而如果转化为Array数组时不向下转型，而是将每个元素向下转型，则不会抛出该异常，显然对数组中的元素一个个进行向下转型，效率不高，且不太方便。

第二个， T[] toArray(T[] a)方法。该方法可以直接将ArrayList转换得到的Array进行整体向下转型（转型其实是在该方法的源码中实现的），且从该方法的源码中可以看出，参数a的大小不足时，内部会调用Arrays.copyOf方法，该方法内部创建一个新的数组返回，因此对该方法的常用形式如下：

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

public  T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

// 第一种方式（最常用）
Integer[] integer = arrayList.toArray(new Integer[0]);

// 第二种方式（容易理解）
Integer[] integer1 = new Integer[arrayList.size()];
arrayList.toArray(integer1);

// 抛出异常，java不支持向下转型
// Integer[] integer2 = new Integer[arrayList.size()];
// integer2 = arrayList.toArray();

查操作

  • contains（Object o）：如果包含元素o,则返回为true
  • get（int index）:返回指定索引的元素
  • indexOf( Object o )：返回此列表中指定元素的第一次出现的索引，如果列表不包含此元素，返回-1
  • lastindexOf( Object o ):返回此列表中指定元素的最后一次出现的索引，如果列表不包含此元素，返回-1
  • isEmpty（）：如果列表为空，返回true
  • iterator()：返回列表中元素的迭代器
  • listIterator（）：返回列表的列表迭代器（按适当的顺序）
  • listIterator(int index)：从适当的位置返回列表的列表迭代器（按照正确的顺序）

get 方法

返回指定位置上的元素

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

contains方法

调用indexOf方法，遍历数组中的每一个元素作对比，如果找到对于的元素，则返回true，没有找到则返回false。

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;
}

iterator方法

interator方法返回的是一个内部类，由于内部类的创建默认含有外部的this指针，所以这个内部类可以调用到外部类的属性。

public Iterator iterator() {
    return new Itr();
}

一般的话，调用完iterator之后，我们会使用iterator做遍历，这里使用next做遍历的时候有个需要注意的地方，就是调用next的时候，可能会引发ConcurrentModificationException，当修改次数，与期望的修改次数（调用iterator方法时候的修改次数）不一致的时候，会发生该异常，详细我们看一下代码实现：

@SuppressWarnings("unchecked")
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];
}

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

expectedModCount这个值是在用户调用ArrayList的iterator方法时候确定的，但是在这之后用户add，或者remove了ArrayList的元素，那么modCount就会改变，那么这个值就会不相等，将会引发ConcurrentModificationException异常，这个是在多线程使用情况下，比较常见的一个异常。

遍历

ArrayList 遍历的四种方式

  • 第1种，普通for循环随机访问，通过索引值去遍历。
// 随机访问
List list = new ArrayList<>();
int size = list.size();
for (int i = 0; i < size; i++) {
    value = list.get(i);
}
  • 第2种，通过迭代器遍历。即通过Iterator去遍历。
// 迭代器遍历
Iterator iter = list.iterator();
while (iter.hasNext()) {
    value = iter.next();
}
  • 第3种，for-each。
// 增强for循环
for (String s : list) {
    value = s;
}
  • 第4种 forEach + lambda 循环遍历
list.forEach(p -> {
    p.hashCode();
});

性能对比

既然有 4 种遍历，那我们看看哪种遍历效率下面我们通过一个实验来看下这四种循环的耗时吧：测试代码

package com.nuih.List;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;

public class ArrayListTest {
    public static void main(String[] args) {
        // 数据预热
        List testList = createTestList(10);
        testForEach(testList);
        testFor(testList);
        testRandFor(10, testList);
        
        List integers = Arrays.asList(10, 50, 100, 500, 1000, 10000, 50000, 100000, 5000000, 10000000, 30000000);
        for (Integer i : integers) {
            testRand(i);
        }
    }

    private static void testRand(int size) {
        System.out.println("-----------次数:" + size + "------------");
        List list = createTestList(size);
        // 随机访问通过索引值去遍历。
        long time1 = System.nanoTime();
        testRandFor(size, list);
        long time2 = System.nanoTime();
        // 增强 for 循环
        testFor(list);
        long time3 = System.nanoTime();
        // 迭代器遍历
        testIterator(list);
        long time4 = System.nanoTime();
        // forEach + lambda
        testForEach(list);
        long time5 = System.nanoTime();
        System.out.println("随机访问\t\t" + (time2 - time1) / 1000 + " ms");
        System.out.println("增强 for 遍历\t\t" + (time3 - time2) / 1000 + " ms");
        System.out.println("迭代器遍历\t\t" + (time4 - time3) / 1000 + " ms");
        System.out.println("forEach 遍历\t\t" + (time5 - time4) / 1000 + " ms");
        System.out.println();
    }

    private static void testRandFor(int size, List list) {
        for (int i = 0; i < size; i++) {
            list.get(i).hashCode();
        }
    }

    private static void testFor(List list) {
        for (String s : list) {
            s.hashCode();
        }
    }

    private static void testIterator(List list) {
        Iterator iter = list.iterator();
        while (iter.hasNext()) {
            iter.next().hashCode();
        }
    }

    private static void testForEach(List list) {
        list.forEach(p -> {
            p.hashCode();
        });
    }

    public static List createTestList(int size) {
        List list = new ArrayList<>(size);
        for (int i = 0; i < size; i++) {
            list.add(UUID.randomUUID().toString());
        }
        return list;
    }
}

测试结果：

结论：如果数据量比较少的话貌似四种循环耗时都差不多，但是随着数据量的增长会发现 foreach 的效率是最好的。但是从上面我们会发现一个奇怪的现象，第一次循环的时候forEach 遍历的时间是最长的尽管数据量非常少也会这样。但是后面的耗时就正常了。如果放开测试里面的预热代码，每次跑出来的耗时也是正常的。

-----------次数:10------------
随机访问        15 ms
增强 for 遍历       8 ms
迭代器遍历       6 ms
forEach 遍历      65728 ms

-----------次数:50------------
随机访问        16 ms
增强 for 遍历       21 ms
迭代器遍历       13 ms
forEach 遍历      10 ms

-----------次数:100------------
随机访问        7 ms
增强 for 遍历       23 ms
迭代器遍历       34 ms
forEach 遍历      19 ms

-----------次数:500------------
随机访问        64 ms
增强 for 遍历       47 ms
迭代器遍历       39 ms
forEach 遍历      105 ms

-----------次数:1000------------
随机访问        129 ms
增强 for 遍历       99 ms
迭代器遍历       81 ms
forEach 遍历      58 ms

-----------次数:10000------------
随机访问        1748 ms
增强 for 遍历       1921 ms
迭代器遍历       1270 ms
forEach 遍历      2212 ms

-----------次数:50000------------
随机访问        4013 ms
增强 for 遍历       2739 ms
迭代器遍历       3628 ms
forEach 遍历      2368 ms

-----------次数:100000------------
随机访问        9874 ms
增强 for 遍历       4500 ms
迭代器遍历       5159 ms
forEach 遍历      6232 ms

-----------次数:5000000------------
随机访问        215933 ms
增强 for 遍历       27000 ms
迭代器遍历       26586 ms
forEach 遍历      22105 ms

-----------次数:10000000------------
随机访问        379588 ms
增强 for 遍历       57104 ms
迭代器遍历       42973 ms
forEach 遍历      40539 ms

-----------次数:30000000------------
随机访问        1090531 ms
增强 for 遍历       195013 ms
迭代器遍历       185519 ms
forEach 遍历      151925 ms

ArrayList 删除数据

虽然有四种遍历方式，但是能够正确删除数据的方式只有两种

  • 第 1 种通过迭代器进行删除。这种方式的话，也是《阿里代码规约》所推荐的。
Iterator iter = list.iterator();        
while (iter.hasNext()) {
    iter.next().hashCode();
    iter.remove();
}
  • 第 2 种倒序循环删除
for(int i = list.size()-1;i>=0;i--) {
    list.remove(i);
}

下面再演示下错误的删除操作

  • 普通 for 循环正序删除，删除过程中元素向左移动，不能删除重复的元素
List list = new ArrayList<>();
list.add("1");
list.add("1");
list.add("2");
for(int i=0;i

结果输出：1

  • 增强 for 循环删除会抛出 java.util.ConcurrentModificationException
List list = new ArrayList<>();
list.add("1");
list.add("1");
list.add("2");
for (String s : list) {
    list.remove(s);
}        
System.out.println(String.join(",",list));

ArrayList ConcurrentModificationException

ConcurrentModificationException 出现在使用 ForEach遍历，迭代器遍历的同时，进行删除，增加出现的异常。平常使用的ArrayList, HashMap都有可能抛出这种异常，粗心的话，很容易犯这种错误，导致线上事故！

下面总结下ArrayList的一些使用场景，来讨论是否会抛出ConcurrentModificationException

For..i 遍历

这个遍历的意思，是指 for(int i = 0 ; i 这种使用下标进行遍历的方式。
这种情形下，增加都不会有 ConcurrentModificationException。但是也可能导致另外的一些问题，比如下面这段代码，会死循环

List list = new Arraylist<>();
list.add(1);
list.add(2);
list.add(3);
for(int i = 0;i

遍历删除的情况下，不会有ConcurrentModificationException，但是要注意代码，防止数组越界异常。下面这种形式的代码会抛出数组越界异常。

List list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
int length = list.size();
for(int i = 0;i

ForEach 遍历

ForEach 遍历就是 For(Object o : List) 这种遍历方式，众所周知，ForEach循环只是JAVA的一个语法糖，在字节码层面上，等同于迭代器循环遍历。在这种情形下，增加元素一定会抛出ConcurrentModificationException，
而删除元素在大多数情况下，会抛出ConcurrentModificationException（小知识，当且仅当删除小标为 size()-2，也就是倒数第二个元素的时候，不会抛出异常）。
这种情况下，会有异常抛出

List list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
for (Integer i : list) {
    if(i == 1){
        list.remove(i);
    }
}

可以修改上面的判断语句， i == 1 修改为 i == 2 则不会抛出异常。

subList

在 subList 场景中，高度注意对原集合元素个数的修改，会导致子列表的遍历、增加、 删除均会产 ConcurrentModificationException 异常。

List list = new ArrayList<>();
list.add("1");
list.add("1");
list.add("2");
List subList =  list.subList(0, 1);
// 对原 List 增加一个值
list.add("10");
subList.add("11"); // 这一行会报 java.util.ConcurrentModificationException

如何避免ConcurrentModificationException

  1. 需要遍历新增时，最好new一个和老List相同的临时List，遍历老的List，然后在临时List上进行元素的增加
  2. 需要进行删除时，使用迭代器删除(iterator.remove())，而不是直接调用 list.remove()
    3.小心，谨慎

总结

ArrayList底层采用数组实现，是一个用于持有元素的有序、元素可重复的容器。适用于需要查找指定索引处元素的场景。当需要频繁插入、删除元素，或者查找指定元素时，其复杂度为O(n)。

  • 初始化 List 的时候尽量指定它的容量大小。(尽量减少扩容次数)
  • 当使用无参数构造函数创建ArrayList对象时，ArrayList对象中的数组初始长度为0（是一个空数组）。
  • ArrayList的扩容策略是每次都增加当前数组长度的一半（非固定分配）。
  • ArrayList的扩容方式是直接创建一个新的数组，并将数据拷贝到新数组中。

你可能感兴趣的:(深入ArrayList源码分析（JDK1.8）)

  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • 从鸡肉高汤到记忆的魔法再到有效提示的艺术 步子哥 人工智能
    还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
  • 自我意识 徐立华
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 4招写出高价值文章 zhiliner
    文章写得泛泛是因为思考得不够深，思考得越深文章会越有价值。拿到一个主题一定要去深入挖掘事件背后的东西，比如人物困境以及趋势性的东西。写作过程中有几个深度思考的方法一、解剖，让旧素材焕发新意作为一个写作者，我们能够做的最大贡献，就是给出自己看世界的角度。解剖其实就是把这个话题相关的信息都列出来，详细的列出来，看清楚它的内部。我们看到一个老话题或者一段旧素材的时候，不要只看这个素材或者话题本身，一定要
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • 做好总书记心中的新青年 漂洋过海来看岐岐
    习近平总书记在党的二十大报告中强调：“广大青年要坚定不移听党话、跟党走，怀抱梦想又脚踏实地，敢想敢为又善作善成，立志做有理想、敢担当、能吃苦、肯奋斗的新时代好青年。”青年的本领要从基层一线的服务中来，主动跟群众交友，促膝长谈交心，深入基层，为民排忧解难。俗话说，事业都是拼搏出来的，但事业取得成功的前提是要有过硬的本领、足够精湛的技艺，只要肯学习，坚持学以致用，努力求得真知、锤炼本领，就一定会有所收
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • 计算机木马详细编写思路 小熊同学哦 php开发语言木马木马思路
    导语：计算机木马（ComputerTrojan）是一种恶意软件，通过欺骗用户从而获取系统控制权限，给黑客打开系统后门的一种手段。虽然木马的存在给用户和系统带来严重的安全风险，但是了解它的工作原理与编写思路，对于我们提高防范意识、构建更健壮的网络安全体系具有重要意义。本篇博客将深入剖析计算机木马的详细编写思路，以及如何复杂化挑战，以期提高读者对计算机木马的认识和对抗能力。计算机木马的基本原理计算机木
  • Python入门之Lesson2:Python基础语法 小熊同学哦 Python入门课程python开发语言算法数据结构青少年编程
    目录前言一.介绍1.变量和数据类型2.常见运算符3.输入输出4.条件语句5.循环结构二.练习三.总结前言欢迎来到《Python入门》系列博客的第二课。在上一课中，我们了解了Python的安装及运行环境的配置。在这一课中，我们将深入学习Python的基础语法，这是编写Python代码的根基。通过本节内容的学习，你将掌握变量、数据类型、运算符、输入输出、条件语句等Python编程的基础知识。一.介绍1
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南c++数据结构stl
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 绝招曝光！3小时高效利用ChatGPT写出精彩论文 kkai人工智能 chatgpt人工智能ai学习媒体
    在这份指南中，我将深入解析如何利用ChatGPT4.0的高级功能，指导整个学术研究和写作过程。从初步探索研究主题，到撰写结构严谨的学术论文，我将一步步展示如何在每个环节中有效运用ChatGPT。如果您还未使用PLUS版本，可以参考相关教程。**初步探索与主题的确定**起初，我处于庞大的知识领域中，寻找一个可深入研究的领域。ChatGPT如同灯塔，通过深入分析最新研究趋势和领域热点，帮助我在广阔的学
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南C++修炼全景指南c++list链表stl
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
  • 如何利用大数据与AI技术革新相亲交友体验 h17711347205 回归算法安全系统架构交友小程序
    在数字化时代，大数据和人工智能（AI）技术正逐渐革新相亲交友体验，为寻找爱情的过程带来前所未有的变革（编辑h17711347205）。通过精准分析和智能匹配，这些技术能够极大地提高相亲交友系统的效率和用户体验。大数据的力量大数据技术能够收集和分析用户的行为模式、偏好和互动数据，为相亲交友系统提供丰富的信息资源。通过分析用户的搜索历史、浏览记录和点击行为，系统能够深入了解用户的兴趣和需求，从而提供更
  • 字节二面 Redstone Monstrosity 前端面试
    1.假设你是正在面试前端开发工程师的候选人，面试官让你详细说出你上一段实习过程的收获和感悟。在上一段实习过程中，我获得了宝贵的实践经验和深刻的行业洞察，以下是我的主要收获和感悟：一、专业技能提升框架应用熟练度：通过实际项目，我深入掌握了React、Vue等前端框架的使用，不仅提升了编码效率，还学会了如何根据项目需求选择合适的框架。问题解决能力：在实习期间，我遇到了许多预料之外的技术难题。通过查阅文
  • 129/365 给宝贝的第23封信：《道德经》第四章：道冲 珍珠能量站
    亲爱的宝贝：今天周六，我在外学习，听几位创业讲师讲授创业的相关知识，一天共4个老师讲解了7个小时。之前线上培训了40个小时，听了这么多，我还是觉得只是窥见皮毛。可见任何一个领域，都可以深入下去，有无穷无尽的细节值得研究。但是任何一件事，也可以用一句话总结。比如“道可道，非常道”创业，我理解的核心是：创立一个业务，通过调配资源，满足用户的需要。至于创立什么样的业务？调配哪些资源？满足用户什么需要？如
  • 程序员架构师主要是做什么_程序员架构师：职责、技能与挑战 绿色小猪
    免费备考资料（2024年11月软考）：历年试题+视频课合集+电子讲义点击领取>>>免费刷题：2024年11月软考备考刷题点此进入>>>程序员架构师的角色定位在软件开发领域，程序员架构师是一个至关重要的角色。他们不仅需要深入理解业务需求，还要将其转化为技术上的解决方案。程序员架构师是项目中的技术领航者，负责制定和维护软件系统的整体架构，确保系统的可扩展性、可维护性和性能。他们的工作涉及从概念化到实现
  • 【ShuQiHere】 进制与补码的世界：从符号-大小表示法到二补码 ShuQiHere 二进制计算机组成原理
    【ShuQiHere】在计算机系统中，表示正数是相对简单的，只需使用其对应的二进制形式即可。然而，如何有效地表示负数一直是计算机科学中的一个关键问题。为了解决这个问题，科学家们提出了多种表示方法，包括符号-大小表示法（Sign-MagnitudeRepresentation）、一补码（One’sComplement）和二补码（Two’sComplement）。在本文中，我们将深入探讨这些表示方法的
  • 广东麻将开发 红匣子实力推荐
    在中国，麻将作为一种深受人们喜爱的传统娱乐活动，已经有着数百年的历史。随着互联网和移动设备的普及，麻将游戏也从实体桌面转移到了数字平台，其中广东麻将因其独特的地方特色和玩法而备受青睐。本文将介绍广东麻将的开发过程，包括其设计理念、技术实现以及用户体验优化等方面。一、设计理念：广东麻将开发的核心理念是保留传统麻将的精髓，同时融入现代科技元素，使游戏既具有亲切感又不失趣味性。开发者通常会深入研究广东地
  • 《HTML 与 CSS—— 响应式设计》 陈在天box htmlcss前端
    一、引言在当今数字化时代，人们使用各种不同的设备访问互联网，包括智能手机、平板电脑、笔记本电脑和台式机等。为了确保网站在不同设备上都能提供良好的用户体验，响应式设计成为了网页开发的关键。HTML和CSS作为网页开发的基础技术，在实现响应式设计方面发挥着重要作用。本文将深入探讨HTML与CSS中的响应式设计原理、方法和最佳实践。二、响应式设计的概念与重要性（一）概念响应式设计是一种网页设计方法，旨在
  • JVM源码分析之堆外内存完全解读 HeapDump性能社区
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
  • 打造专业投票评选平台：创建大型活动的完整指南 口碑信息传播者
    在数字化时代，打造专业的投票评选平台成为举办大型活动的不可或缺的一环。本指南将深入探讨如何创建一个高效、安全、用户友好的投票平台，旨在帮助您成功举办大型投票评选活动。从平台的设计和功能规划到活动的推广和安全性保障，每个步骤都将得到详细解析。第一部分：构建投票平台的基础在创建投票平台之前，首先需要明确平台的基础构建要素：1.**投票平台的定义和关键功能：**确定您的平台将提供的服务和功能，包括投票方
  • 阿里巴巴商品搜索API返回值实战解析 weixin_43841111 apijava前端javascript
    在解析阿里巴巴中国站商品搜索API返回值并进行实战时，可以从以下几个方面入手：一、了解API返回值的结构基本信息返回值通常包含商品的标题、价格、库存、图片链接等基本信息。这些信息对于了解商品的概况非常重要。例如，商品标题可以让你快速了解商品的名称和特点，价格信息可以帮助你进行价格比较和成本核算。详细描述可能包括商品的详细描述、规格参数、使用方法等。这些信息对于深入了解商品的特性和功能非常有帮助。比
  • h5小游戏定制开发 红匣子实力推荐
    随着科技的不断发展，移动互联网已经成为人们生活中不可或缺的一部分。在这个背景下，H5小游戏应运而生，为人们带来了丰富的娱乐体验。H5小游戏定制开发作为一种新兴的游戏开发方式，正逐渐受到市场的关注和青睐。那么，什么是H5小游戏定制开发呢？它又具有哪些特点和优势呢？让我们一起来深入了解一下。首先，我们来了解一下H5小游戏的基本概念。H5小游戏是一种基于HTML5技术的游戏，可以在移动端、PC端等多平台
  • Nginx：高性能的Web服务器与反向代理 张某布响丸辣 nginx前端服务器javaSpringBoot
    在当今的互联网世界中，Web服务器的选择对于网站的性能、稳定性和安全性至关重要。Nginx（发音为“engineX”）凭借其卓越的性能、丰富的功能集和灵活的配置选项，成为了众多网站和应用程序的首选Web服务器和反向代理。本文将深入探讨Nginx的特点、应用场景、基本配置以及它如何助力你的Web项目。Nginx简介Nginx是一个开源的、高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/
  • knob UI插件使用 换个号韩国红果果 JavaScriptjsonpknob
    图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
  • Android+Jquery Mobile学习系列(5)-SQLite数据库 白糖_ JQuery Mobile
    目录导航   SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。   因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。   我也是第一次接触S
  • impala-2.1.2-CDH5.3.2 dayutianfei impala
    最近在整理impala编译的东西，简单记录几个要点： 根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
  • 求二进制数中1的个数 周凡杨 java算法二进制
    解法一： 对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。   public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
  • spring中hibernate及事务配置 g21121 Hibernate
    hibernate的sessionFactory配置： <!-- hibernate sessionFactory配置 --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
  • log4j.properties 使用 510888780 log4j
    log4j.properties 使用 一.参数意义说明 输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误 主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息 配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
  • Spring mvc-jfreeChart柱图（2） 布衣凌宇 jfreechart
    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。 第一步：导包 第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
  • maven 之 cobertura 简单使用 antlove maventestunitcoberturareport
    1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
  • 程序的执行顺序 百合不是茶 JAVA执行顺序
          刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧   代码如下;     经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
  • 设置session失效的几种方法 bijian1013 web.xmlsession失效监听器
    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
  • java jvm常用命令工具 bijian1013 javajvm
    一.概述         程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具:       &nbs
  • 【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
  • mysql 操作遇到safe update mode问题 bitray update
        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全.     在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
  • nginx_perl试用 ronin47 nginx_perl试用
    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
  • java-63-在字符串中删除特定的字符 bylijinnan java
    public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
  • EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
    本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器     类可以通过
  • [宇宙时代]四边形理论与光速飞行 comsci
       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？    一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口    那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
  • ubuntu server下python脚本迁移数据 cywhoyi pythonKettlepymysqlcx_Oracleubuntu server
    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql， 但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
  • Ajax正确但是请求不到值解决方案 dashuaifu Ajaxasync
    Ajax正确但是请求不到值解决方案   解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！   例如：   $.ajax({     &
  • windows安装配置php+memcached dcj3sjt126com PHPInstallmemcache
    Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
  • iOS开发学习路径的一些建议 dcj3sjt126com ios
    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759   下面是我回复的内容：   结合自己情况聊下iOS学习建议，
  • Javascript闭包概念 fanfanlovey JavaScript闭包
    1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述 要理解闭包，首先需要理解变量作用域问题 内部函数可以饮用外面全局变量 var n=999; 　　functio
  • yum安装mysql5.6 haisheng mysql
    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm   2、yum install mysql   3、yum install mysql-server   4、vi /etc/my.cnf   添加character_set_server=utf8
  • po/bo/vo/dao/pojo的详介 IT_zhlp80 javaBOVODAOPOJOpo
        JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
  • java设计模式 kerryg java设计模式
    设计模式的分类：    一、 设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
  • [1]CXF3.1整合Spring开发webservice——helloworld篇 木头.java springwebserviceCXF
    Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写）） 你的健康 无疑地，软件开发者是世界上最久坐不动的职业之一。 每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
  • linux打开最大文件数量1,048,576 tianzhihehe clinux
    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
  • java语言中PO、VO、DAO、BO、POJO几种对象的解释 衞酆夼 javaVOBOPOJOpo
    PO:persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象 封装业务逻辑的java对象