_柚子啊
_柚子啊

Android性能优化（一）数据结构优化

前言

性能优化是一个app中不可或缺并需不断重复的工作，一个app的性能体验在很大程度上也决定了是否能留住用户，而对于性能优化这一块，有很多的知识点需要掌握，优化的目的总的来说分为三块，分别是：更快（流畅性）、更稳定（稳定性）、更省（资源节省性）。

下面将结合ArrayList、LinkedList、HashMap、SparseArray的源码来跟大家讲解一下关于数据结构方面的优化，数据结构的优化主要是优化速度以及内存空间的。

ArrayList

概要

相信有大部分人在平时写代码时，只要是需要用到集合的地方都会第一时间敲上List list = new ArrayList<>()，但是也需要注意使用场景，毕竟在某些场景下使用它会耗性能，下面先来分析一下ArrayList的工作原理。

工作原理

ArrayList的底层是使用数组实现的，而这也意味着它也有跟数组类似的缺点，比如它的随机访问效率高，但是增删的效率比较低（尾插除外）。

以下这是尾插add(E e)的代码：

public boolean add(E e) {
    // 扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

可以看到，尾插的话只需要把size加1，并往数组的最后一位添加数据就好了。

下面的是往数组中间的特定位置插入数据add(int index, E element)的代码：

public void add(int index, E element) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

    // 扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

可以看到，其中的添加数据的代码最重要的是System.arraycopy()这一句，它是通过把原本的index这个位置以及后面的所有位置都往后挪一位，然后再在空出来的那个位置插入数据的，这样添加数据效率并不高。

在添加数组的过程中，我们也要注意一下ensureCapacityInternal()这个方法，下面来看一下这个方法的作用：

private static final int DEFAULT_CAPACITY = 10; 

private void ensureCapacityInternal(int minCapacity) {
    // 如果传入的是个空数组则最小容量取默认容量与minCapacity之间的最大值
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // 如果最小需要空间比elementData的内存空间长度要大，则需要扩容
    if (minCapacity - elementData.length > 0)
        // 扩容代码
        grow(minCapacity);
}

在创建ArrayList的时候，若调用的是它的无参构造函数：

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

则首先会创建一个空数组，并在添加数据的时候判断是否为空数组并把最小容量赋值为一个默认的数组长度，即DEFAULT_CAPACITY = 10。然后会判断ArrayList的长度是否足够添加新的数据，如果不够则进行扩容。

下面是扩容的关键方法：

private void grow(int minCapacity) {
    // 获取到ArrayList中elementData数组的内存空间长度
    int oldCapacity = elementData.length;
    // 扩容至原来的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 再判断一下新数组的容量够不够，够了就直接使用这个长度创建新数组，
    // 不够就将数组长度设置为需要的长度
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 若预设值大于默认的最大值检查是否溢出，MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 调用Arrays.copyOf方法将elementData数组指向新的内存空间时newCapacity的连续空间
    // 并将elementData的数据复制到新的内存空间
    elementData = Arrays.copyOf(elementData, newCapacity);
    }

可以看到，当原来的数组长度不够时，会创建一个新的内存空间，并把原本的数据复制到新的内存空间。

分析完了添加数据的代码，下面来看一下删除数据的代码：

public E remove(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        modCount++;
        E oldValue = (E) 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;
    }

删除数据的操作，跟添加数据的方式相似，首先是判断一下是否有数组越界的可能，然后再通过System.arraycopy()把index后面的所有位置都往前挪一位，最后再把最后一位元素设为null。

接下来来看一下get部分的代码，由于根据索引获取数组的某个数组大家都比较熟悉了，这里就不过多解释，只把相关代码贴上来：

public E get(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    return (E) elementData[index];
}

优缺点

优点：物理空间连续并且是顺序存储的，随机访问很快，可动态增加数组大小，并且实现了序列化。
缺点：新增元素慢且耗费资源，删除非尾部的元素慢，非线程安全。

使用场景

当只是简单的展示数据，不需要频繁进行增加或删除的操作时可以使用，比如只需要使用RecyclerView展示数据。

常见面试题

如何遍历ArrayList中的元素？
如果只是需要遍历数组里面的元素的话，最简单并且效率最高的是for循环。

如何遍历并删除ArrayList中的所有元素？
当涉及到删除操作的时候应该使用迭代器Iterator，若使用for循环或者for-each的话容易造成数组越界，原理可参考ArrayList的remove方法，若想使用for循环，可从尾部开始删起。有兴趣的可以自己去了解一下，这里不详细说明。

LinkedList

概述

LinkedList跟ArrayList都实现了List接口，但是不同于ArrayList的是：LinkedList是基于链表实现的，熟悉链表的人都知道，它在物理上不是连续的空间，但在逻辑上是有先后顺序，所以它的增删速度快，但是查询速度慢。

工作原理

下面来分析一下LinkedList的add以及remove原理。

首先来看一下LinkedList的Node节点：

private static class Node {
    E item;
    Node next;
    Node prev;

    Node(Node prev, E element, Node next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

由Node的定义可以看出LinkedList是双向链表。

它可以在头部添加节点也可以在尾部添加节点，以下是添加到尾部的实现：

// 添加到尾部
public void addLast(E e) {
    linkLast(e);
}

void linkLast(E e) {
    // 指向链表尾部
    final Node l = last;
    // 创建一个新节点
    final Node newNode = new Node<>(l, e, null);
    // 将链表尾部指向新节点
    last = newNode;
    // 如果链表为空，那么该节点既是头节点也是尾节点
    if (l == null)
        first = newNode;
    // 链表不为空，那么将该结点作为原链表尾部的后继节点
    else
        l.next = newNode;
    size++;
    modCount++;
}

从上面代码可以看到，linkLast()方法中就是一个链表尾部添加一个双端节点的操作，但是需要注意对链表为空时头节点的处理。添加到头部的操作跟添加到尾部的操作是一样的，这里不多做说明，感兴趣的可以自己去看一下源码。

add(int index, E element)用于在指定位置添加元素，实现如下：

public void add(int index, E element) {
    // 检查索引是否越界
    checkPositionIndex(index);
    // 添加在链表尾部
    if (index == size)
        linkLast(element);
    // 添加在链表中间
    else
        linkBefore(element, node(index));
}

从上面代码可以看到，主要分为3步：
1. 检查index的范围，否则抛出异常
2. 如果插入位置是链表尾部，那么调用linkLast方法
3. 如果插入位置是链表中间，那么调用linkBefore方法

第二步在上面已经分析过了，现在来分析一下第三步，在分析linkBefore()之前，我们先来看一下node(int index)方法的作用：

// 该方法返回指定位置的节点
Node node(int index) {
    // 如果索引位置靠链表前半部分，从头开始遍历
    if (index < (size >> 1)) {
        Node x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {  // 否则，从尾开始遍历
        Node x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

从上面可以看到，node(int index)方法将根据index是靠近头部还是尾部选择不同的遍历方向，这是双向链表的一个好处，可以减少遍历时间。

分析完了node(int index)，现在来看一下linkBefore(E e, Node succ)：

void linkBefore(E e, Node succ) {
    final Node pred = succ.prev;
    final Node newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

从代码中可以看到linkBefore主要分三步：
1. 创建newNode节点，将newNode的后继指针指向succ，前驱指针指向pred
2. 将succ的前驱指针指向newNode
3. 根据pred是否为null，进行不同操作：

- 如果pred为null，说明该节点插入在头节点之前，要重置first头节点
- 如果pred不为null，那么直接将pred的后继指针指向newNode即可

LinkedList由于实现了List和Deque接口，所以有多种添加方法，分别如下：

将数据插入到链表头部

  • void addFirst(E e)
  • boolean offerFirst(E e)

将数据插入到链表尾部

  • void addLast(E e)
  • boolean add(E e):
  • boolean offerLast(E e)

将数据插入到指定索引位置

  • boolean add(int index,E e)

其中，添加到头部以及尾部的方法内部都是通过linkLast以及linkFirst实现的，所以这里不多做说明。

add部分分析完了，接下来分析get(int index)部分

public E get(int index) {
    // 检查index是否越界
    checkElementIndex(index);
    return node(index).item;
}

上面的代码中，node(index)我们在上面已经分析过了，不理解的小伙伴可以拉上去看一看。

接下来我们来看一下remove部分的代码，remove操作分为按照位置删除和按照对象删除，下面我们先来分析一下按照对象删除的代码：

// 删除某个对象
public boolean remove(Object o) {
    // 如果删除对象为null
    if (o == null) {
        for (Node x = first; x != null; x = x.next) {
            // 一旦匹配，调用unlink()方法删除对象
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {   // 如果删除对象不为null
        for (Node x = first; x != null; x = x.next) {
            // 判断x.item是否为要删除的对象
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

// 执行删除操作
E unlink(Node x) {
    final E element = x.item;
    // 得到后继节点
    final Node next = x.next;
    // 得到前驱节点
    final Node prev = x.prev;

    // 删除前驱指针
    if (prev == null) {
        first = next;
    } else {
        prev.next = next; // 将前驱节点的后继节点指向后继节点
        x.prev = null;
    }
    // 删除后继指针
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev; // 将后继节点的前驱节点只想前驱节点
         x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

根据上面的代码，我们可以分为三步：
1. 得到待删除节点的前驱节点和后继节点
2. 删除前驱节点
3. 删除后继节点

我们再来看一下删除某个位置的对象是怎么实现的：

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

分析一下上面代码的两步操作：
1. 检查index是否越界
2. 调用unlink(node(index))进行删除

unlink()以及node(index)这两个方法已经在上面分析过了，通过unlink删除遍历得到的对象，这里不再多说明。

关于删除头节点以及尾节点的方法还有很多，分别如下：

删除头节点位置的对象

  • E removeFirst()
  • E pollFirst()

删除尾节点位置的对象

  • E removeLast()
  • E pollLast()

由于它们的内部实现都是一样的，所以这里不具体分析这些方法。

优缺点

优点：基于双向链表实现，在插入和删除时只需要添加或删除前后对象的引用，效率较快
缺点：在内存中存储空间不连续，只能通过遍历查询，效率相对较低，非线程安全

使用场景

当需要频繁地进行增删操作时，或涉及到排序、需要动态的去修改元素的位置时，可使用LinkedList。

LinkedList总结

在首部插入时，LinkedList更快；在中间和尾部插入，ArrayList更快；所以建议，数据量不大的集合，主要进行插入、删除操作，建议使用LinkedList；数据量大的集合，使用ArrayList，不仅查询速度快，并且插入和删除效率也相对较高。并且当数据量大的时候，ArrayList每次扩容都能得到很大的新空间（比如长度为1000，扩容后为1500），解决了前期频繁扩容的劣势。

常见面试题

ArrayList跟LinkedList的区别？
关于这点在上面的优缺点分析中已经说明了，可从底层实现、效率、优缺点来进行回答。

LinkedList一定比ArrayList的插入和删除操作效率高吗？
以下的分析适用于插入操作和删除操作：
（1）在首部插入数据，LinkedList较快，因为LinkedList遍历插入位置花费时间很小，而ArrayList需要将原数组所有元素进行一次System.arraycopy；
（2）插入位置越往中间，LinkedList效率越低，因为它遍历获取插入位置是从两头往中间搜，index越往中间遍历越久，因此ArrayList的插入效率可能会比LinkedList高；
（3）插入位置越往后，ArrayList效率越高，因为数组需要复制后移的数据少了，那么System.arraycopy就快了。

HashMap

概述

HashMap是基于哈希表(散列表)，实现Map接口的双列集合，数据结构是“链表散列”，也就是数组跟链表的混合结构。

工作原理

HashMap是近年来较为常见的面试点，我们先来分析一下它的工作原理，后面再解答一些相关的面试点。
我们首先来看一下HashMap的底层结构

transient Entry[] table;

static class Entry implements Map.Entry {
    final K key;
    V value;
    Entry next;
    final int hash;
    ……
}

可以看出，Entry就是数组中的元素，每个 Map.Entry 其实就是一个key-value键值对，它持有一个指向下一个元素的引用，这就构成了链表。

下面来看一下put(key, value)存储的原理：

public V put(K key, V value) {
    // HashMap允许存放null键和null值。
    // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。
    if (key == null)
        return putForNullKey(value);
    // 根据key的keyCode重新计算hash值。
    int hash = hash(key.hashCode());
    // 搜索指定hash值在对应table中的索引。
    int i = indexFor(hash, table.length);
    // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。
    for (Entry e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            // 如果发现已有该键值，则存储新的值，并返回原始值
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    // 如果i索引处的Entry为null，表明此处还没有Entry。
    modCount++;
    // 将key、value添加到i索引处。
    addEntry(hash, key, value, i);
    return null;
}

在这里我们要注意看hash(key.hashCode())方法，这个方法是通过我们传入的key，然后得到key的hashCode并调用hash(int h)去重新计算一次散列值。注：在JDK1.8时这个方法的计算方式已改变。

static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

然后把计算得到的hash值通过indexFor(hash, table.length)去对数组的长度进行取模运算，得到的值即为这个元素在数组中的下标值。如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。

static int indexFor(int h, int length) {  
    return h & (length-1);
}

由于HashMap的key是唯一的，所以根据上面put方法的源码可以看出，当程序试图将一个key-value键值对放入HashMap中时，程序首先根据该key的hashCode()返回值决定该Entry的存储位置：如果两个Entry的hash值相同，那它们的存储位置相同。如果这两个Entry的key通过equals比较返回true，新添加Entry的value将覆盖集合中原有Entry的value，但key不会覆盖。如果这两个Entry的key通过equals比较返回false，新添加的Entry将与集合中原有的Entry形成Entry链，而且新添加的Entry位于Entry链的头部。

分析完了HashMap的put原理，下面来分析一下get(Object key)原理：

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    int hash = hash(key.hashCode());
    for (Entry e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
            return e.value;
    }
    return null;
}

在HashMap中get一个元素时，首先也是通过hash(key.hashCode())去得到该元素位于数组的哪个位置，然后通过遍历该位置下的链表，通过key的equals方法在对应位置的链表中找到需要的元素并返回。

当HashMap中的元素越来越多时，造成hash碰撞的几率也会越来越大，这样会导致在查询某个元素时遍历链表的时间比较长，效率比较低，所以这时候HashMap的数组会进行扩容。那么hashmap什么时候进行扩容呢？

static final float DEFAULT_LOAD_FACTOR = 0.75f; // 负载因子
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 数组默认容量

我们先来了解一个概念：负载因子(loadFactor)，也就是HashMap能够承受住自身负载（大小或容量）的因子，loadFactor的默认值为0.75，在默认情况下，HashMap的数组容量是16，当HashMap中元素个数超过16 * 0.75=12的时候，就把数组的大小扩展为2 * 16=32，即扩大一倍。然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知 HashMap 中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

HashMap总结

HashMap在底层将key-value当成一个整体进行处理，这个整体就是一个Entry对象。HashMap底层采用一个 Entry[]数组来保存所有的key-value，当需要存储一个Entry对象时，会根据 hash 算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。

常见面试题

当两个键的hashcode相同，如何获取它们的值？
通过hashcode可以获取到它们位于数组中的具体位置，然后通过遍历链表，对每个key进行hash计算，并对key进行equals比较后，返回对应的value值。

当两个对象的hashcode相同会怎么样？
两个对象的hashcode相同，说明它们位于数组的同一位置上，然后HashMap会遍历链表中的每个元素，通过key的equals方法来判断是否为同一个key，如果是同一个key，则新的value会覆盖旧的value，并且返回旧的value。如果不是同一个key，则存储在该位置上的链表的链头。

如果HashMap的大小超过了负载因子的容量，会怎么样？
负载因子为0.75，当超过负载因子的容量后，会对数组进行扩容，即创建一个是原来HashMap数组大小的两倍的新数组，并重新计算原本的元素在新数组中的位置。

HashMap的扩容会造成什么问题？
在多线程的情况下，可能产生条件竞争。当重新调整HashMap大小的时候，确实存在条件竞争，如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的数组位置的时候，HashMap并不会将元素放在LinkedList的尾部，而是放在头部，这是为了避免尾部遍历。所以在多个线程同时扩容的情况下就可能导致产生一个存在闭环的单链表，从而导致死循环。（在JDK8中不会导致死循环问题）

Java8中对HashMap的改进
（1）对key求hash值的方法改变了，变为：

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

（2）引入了红黑树，这一点在hash不均匀并且元素个数很多的情况时，对hashmap的性能提升非常大。在JDK7中HashMap采用的是位桶+链表的方式，而JDK8中采用的是位桶+链表/红黑树的方式，当某个位桶的链表的长度超过8的时候，这个链表就将转换成红黑树。
因为引入了树，所以其他操作也更复杂了，比如put方法以前只要通过hash计算下标位置，判断该位置有没有元素，如果有就往下遍历，如果存在相同的key就替换value，如果不存在就添加。但是到了8以后，就要判断是链表还是树，如果是链表，插入后还要判断要不要转化成树。
不过这些操作都是常量级别的，复杂度还是O(1)的，但是对整体性能提升非常大。

（3）还有一项比较大的改变就是扩容机制。JDK8以前的扩容机制如下所示：

void addEntry(int hash, K key, V value, int bucketIndex) {
    //1、判断当前个数是否大于等于阈值
    //2、当前存放是否发生哈希碰撞
    //如果上面两个条件否发生，那么就扩容
    if ((size >= threshold) && (null != table[bucketIndex])) {
        //扩容，并且把原来数组中的元素重新放到新数组中
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    createEntry(hash, key, value, bucketIndex);
}

由上面的代码可以看出，在JDK8以前，Hashmap的扩容需要满足两个条件，一是当前数据存储的数量（即size）大小必须大于等于阈值；二是当前加入的数据是否发生了hash冲突。

而在JDK8的时候，扩容只需要满足一个条件：当前存放新值（注意不是替换已有元素位置时）的时候已有元素的个数大于阈值（若已有元素等于阈值，下一个存放后必然触发扩容机制）

为什么String、Integer这样的Wrapper类适合作为键
因为在Wrapper类中已经重写了equals()和hashCode()方法，它们是被final修饰的，为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。

SparseArray

SparseArray的功能类似于HashMap，其内部是由两个数组实现的，不同于HashMap的是，SparseArray的key只能是int类型，而HashMap的key是Object类型的。

private int[] mKeys;
private Object[] mValues;

由上面的代码可以看出，SparseArray分别用了数组 int[] 和 object[] 来存储key以及value。

下面我们先来看一下它的构造函数：

public SparseArray() {
    this(10);
}

public SparseArray(int initialCapacity) {
    if (initialCapacity == 0) {
        mKeys = EmptyArray.INT;
        mValues = EmptyArray.OBJECT;
    } else {
        mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);
        mKeys = new int[mValues.length];
    }
    mSize = 0;
}

由构造函数中我们可以看到，当SparseArray使用无参数构造函数进行初始化的时候，默认的数组大小是10。我们也可以使用有参构造函数来对SparseArray进行初始化来设置它的数组大小。

下面我们来分析一下它的put(int key, E value)方法：

public void put(int key, E value) {
    // 对key进行二分查找
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
    // 如果返回的i是正数，则说明这个key已经存在，直接覆盖value即可
    if (i >= 0) {
        mValues[i] = value;
    } else {
        // 若返回的i是负数，说明 key不存在.
        // 先对返回的i取反，得到应该插入的位置i
        i = ~i;
        // 如果i没有越界，且对应位置是已删除的标记，则复用这个空间
        if (i < mSize && mValues[i] == DELETED) {
            mKeys[i] = key;
            mValues[i] = value;
            return;
        }
        // 如果需要GC，且需要扩容
        if (mGarbage && mSize >= mKeys.length) {
            // 先触发GC
            gc(); 
            // gc后，下标i可能发生变化，所以再次用二分查找找到应该插入的位置i
            i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
        }
        // 插入key（可能需要扩容）
        mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
        // 插入value（可能需要扩容）
        mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
        mSize++;
    }
}

这个方法的注释我在上面已经写得很详细了，在一开始我们就对key进行了二分查找，若查找到该key已经存在，则覆盖它的value，若没有查找到，则判断是否需要gc或者扩容，然后再进行插入操作。这也说明SparseArray与HashMap都是要求key是唯一的。

在上面的put()方法中调用了很多外部的方法以及内部的方法，首先来看一下ContainerHelpers#binarySearch()二分查找的代码：

static int binarySearch(int[] array, int size, int value) {
    int lo = 0;
    int hi = size - 1;

    while (lo <= hi) {
        final int mid = (lo + hi) >>> 1;
        final int midVal = array[mid];

        if (midVal < value) {
            lo = mid + 1;
        } else if (midVal > value) {
            hi = mid - 1;
        } else {
            return mid;  // value found
        }
    }
    // 若没找到，则lo是value应该插入的位置，是一个正数。对这个正数取反，返回负数
    return ~lo;  
}

那么在插入之前，我们为什么要判断是否需要gc呢？由于之前进行过 delete()、remoeAt()以及 removeReturnOld()中的某一个方法，那就可能要进行gc()操作。当然，这里的gc不是指的内存的gc。

// 垃圾回收函数,压缩数组
private void gc() {
    // 保存GC前的集合大小
    int n = mSize;
    // 既是下标index，又是GC后的集合大小
    int o = 0;
    int[] keys = mKeys;
    Object[] values = mValues;
    // 遍历values集合，以下算法意义为从values数组中，删除所有值为DELETED的元素
    for (int i = 0; i < n; i++) {
        Object val = values[i];
        // 如果当前value没有被标记为已删除
        if (val != DELETED) {
            // 压缩keys、values数组
            if (i != o) {
                keys[o] = keys[i];
                values[o] = val;
                // 并将当前元素置空，防止内存泄漏
                values[i] = null;
            }
            o++;
        }
    }
    // 修改标识位，改为不需要GC
    mGarbage = false;
    // gc后的元素个数变为压缩后的个数o
    mSize = o;
}

由上面的代码不难看出，gc()的作用是把被标记为DELETED的value剔除掉，把没有被标记为DELETED的value在原数组中重新构建为一个新的数组。gc()完之后，下标 i 可能会发生变化，因此需要重新进行二分查找，以得到一个新的下标 i。

最后就是通过 GrowingArrayUtils.insert() 来进行 key 和 value 的插入。这个 insert() 根据数组类型重载了多个，这里只分析 int[] 类型的即可。

public static int[] insert(int[] array, int currentSize, int index, int element) {
    // 确认当前集合长度小于等于 array数组长度
    assert currentSize <= array.length;
    // 不需要扩容
    if (currentSize + 1 <= array.length) {
        // 将array数组内从 index 移到 index + 1，共移了 currentSize - index 个，即从index开始后移一位，那么就留出 index 的位置来插入新的值。
        System.arraycopy(array, index, array, index + 1, currentSize - index);
        // 在index处插入新的值
        array[index] = element;
        return array;
    }
    // 需要扩容，构建新的数组，新的数组大小由growSize() 计算得到
    int[] newArray = new int[growSize(currentSize)];
    // 这里再分 3 段赋值。首先将原数组中 index 之前的数据复制到新数组中
    System.arraycopy(array, 0, newArray, 0, index);
    // 然后在index处插入新的值
    newArray[index] = element;
    // 最后将原数组中 index 及其之后的数据赋值到新数组中
    System.arraycopy(array, index, newArray, index + 1, array.length - index);
    return newArray;
}

这里再看看 growSize() 是如何进行扩容 size 的计算的：

public static int growSize(int currentSize) {
    //如果当前size 小于等于4，则返回8， 否则返回当前size的两倍
    return currentSize <= 4 ? 8 : currentSize * 2;
}

我们已经分析完了put()方法，现在来看一下get()方法：

public E get(int key) {
    return get(key, null);
}

public E get(int key, E valueIfKeyNotFound) {
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
    if (i < 0 || mValues[i] == DELETED) {
        return valueIfKeyNotFound;
    } else {
        return (E) mValues[i];
    }
}

get()方法相当简单，就是通过 key 来返回对应的 value，这里同样运用到了上面说的二分查找，若查找到了，则会通过下标直接从mValues[]中返回。

接下来再来看一下delete()方法：

public void delete(int key) {
    int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
    if (i >= 0) {
        if (mValues[i] != DELETED) {
            mValues[i] = DELETED;
            mGarbage = true; // 把是否需要gc的标志位设为true
        }
    }
}

delete() 也非常简单，通过二分查找算法定位到下标，然后将对应的 value 标记为 DELETE，并且标记需要进行 gc 了。这里需要注意的是被标记为 DELETE 的 value 不会在 gc 中被移除掉，而只会被覆盖掉，从而提高了插入的效率。

SparseArray总结

  • key值不能重复，否则会发生覆盖，并且key是以升序在数组中进行排列的
  • SparseArray的删除操作并不是真的删除，而只是标记为 DELETE，以便下次能够直接复用

常见面试题

HashMap与SparseArray的区别？
（1）HashMap的key值可以是object类型的，而SparseArray的key值只能是int型的；
（2）SparseArray扩容时只需要数组拷贝工作(System.arraycopy)，而HashMap需要重建哈希表并且这个过程十分消耗性能；
（3）SparseArray基于二分查找算法，将 key 以升序的方式排列在一起，从而提高内存的利用率以及访问的效率。相比较 HashMap 而言，这是典型的以时间换空间的策略（在数据量大的情况下）；
（4）在数据量不大的情况下，SparseArray相比于HashMap，既省空间又省时间，申请相同长度的存储结构，SparseArray比HashMap占用的内存更小。

总结

关于性能优化，我们应该从平时最常用的数据结构入手，要善于选择在适合的场景使用合适的数据结构来进行编程，这样可以有效的节省时间跟空间，有利用速度以及内存空间的优化。

你可能感兴趣的:(Android性能优化（一）数据结构优化)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 想家 爆米花机
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • 瑶池防线 谜影梦蝶
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 《策划经理回忆录之二》 路基雅虎
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 分享100个最新免费的高匿HTTP代理IP mcj8089 代理IP代理服务器匿名代理免费代理IP最新代理IP
      推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/     120.198.243.130:80,中国/广东省 58.251.78.71:8088,中国/广东省 183.207.228.22:83,中国/
  • mysql高级特性之数据分区 annan211 java数据结构mongodb分区mysql
    mysql高级特性 1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。 2 分区的原理 分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层 表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
  • JS采用正则表达式简单获取URL地址栏参数 chiangfai js地址栏参数获取
    GetUrlParam:function GetUrlParam(param){ var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)"); var r = window.location.search.substr(1).match(reg); if(r!=null
  • 怎样将数据表拷贝到powerdesigner (本地数据库表) Array_06 powerDesigner
    ================================================== 1、打开PowerDesigner12，在菜单中按照如下方式进行操作 file->Reverse Engineer->DataBase 点击后，弹出 New Physical Data Model 的对话框 2、在General选项卡中 Model name:模板名字，自
  • logbackのhelloworld 飞翔的马甲 日志logback
    一、概述 1.日志是啥？ 当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 当我项目工作时，以为是一堆得.log文件。 这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。 传送门1：日志的作用与方法： http://www.infoq.com/cn/articles/why-and-how-log 上面的作
  • 新浪微博爬虫模拟登陆 随意而生 新浪微博
    转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235     近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。      现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
  • synchronized 香水浓 javathread
        Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
  • maven 简单实用教程 AdyZhang maven
    1. Maven介绍  1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源 见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
  • Android 通过 intent传值获得null aijuans android
    我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下 1 2 3 4 5 6 7 8 9 public void getMap(View view){            Intent i =
  • apache 做代理 报如下错误：The proxy server received an invalid response from an upstream baalwolf response
    网站配置是apache＋tomcat,tomcat没有报错，apache报错是： The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
  • Tomcat6 内存和线程配置 BigBird2012 tomcat6
    1、修改启动时内存参数、并指定JVM时区 （在windows server 2008 下时间少了8个小时） 在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数：  window下， 在catalina.bat最前面 set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
  • Karam与TDD bijian1013 KaramTDD
    一.TDD         测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。         TDD的原则很简单： a.只有当某个
  • [Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States bit1129 zookeeper
    public enum States { CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态 ASSOCIATING, //？？？ CONNECTED, //链接建立，可以与Zookeeper服务器正常通信 CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
  • 【Scala十四】Scala核心八：闭包 bit1129 scala
    Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
  • android发送json并解析返回json ronin47 android
    package com.http.test; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import
  • 一份IT实习生的总结 brotherlamp PHPphp资料php教程php培训php视频
    今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
  • 据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 将重物放到天平左侧，问在两边如何添加砝码 bylijinnan java
    public class ScalesBalance { /** * 题目： * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 （假设N无限大，但一种重量的砝码只有一个） * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡 * * 分析： * 三进制 * 我们约定括号表示里面的数是三进制，例如 47=(1202
  • dom4j最常用最简单的方法 chiangfai dom4j
    要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
  • 简单HBase笔记 chenchao051 hbase
     一、Client-side write buffer 客户端缓存请求 描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。 可以使用getWriteBuffer()方法来取得客户端缓存中的数据。 默认关闭。 二、Scan的Caching 描述： next( )方法请求一行就要使用一次RPC,即使
  • mysqldump导出时出现when doing LOCK TABLES daizj mysqlmysqdump导数据
    　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　 导出表时，会报 mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 解决
  • CSS渲染原理 dcj3sjt126com Web
      从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？          一、浏览器的发展与CSS           
  • 《阿甘正传》台词 dcj3sjt126com
    Part Ⅰ: 《阿甘正传》Forrest Gump经典中英文对白 Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
  • Java处理JSON dyy_gusi json
    Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。 在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 1、读取json然后处理 class ReadJSON { public static void main(String[] args)
  • win7下nginx和php的配置 geeksun nginx
    1.  安装包准备 nginx :  从nginx.org下载nginx-1.8.0.zip php： 从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 RunHiddenConsole: 用于隐藏命令行窗口   2. 配置 # java用8080端口做应用服务器，nginx反向代理到这个端口即可 p
  • 基于2.8版本redis配置文件中文解释 hongtoushizi redis
    转载自： http://wangwei007.blog.51cto.com/68019/1548167        在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server   xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
  • 第五章 常用Lua开发库3-模板渲染 jinnianshilongnian nginxlua
    动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。   如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
  • JZSearch大数据搜索引擎 颠覆者 JavaScript
    系统简介： 大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
  • 10招让你成为杰出的Java程序员 pda158 java编程框架
    如果你是一个热衷于技术的  Java 程序员， 那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。 　　 1. 拥有扎实的基础和深刻理解 OO 原则 　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
  • tomcat之oracle连接池配置 小网客 oracle
    tomcat版本7.0 配置oracle连接池方式： 修改tomcat的server.xml配置文件： <GlobalNamingResources> <Resource name="utermdatasource" auth="Container" type="javax.sql.DataSou
  • Oracle 分页算法汇总 vipbooks oraclesql算法.net
        这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ -- Oracle 分页算法一 select * from ( select page.*,rownum rn from (select * from help) page -- 20 = (currentPag