ArrayList 源码分析 jdk1.8

刺骨的言语ヽ痛彻心扉 2021-10-24 02:24 416阅读 0赞

> ArrayList 源码基本操作是对数组的操作

## ** 1、成员变量** ##

/**
         * Default initial capacity.
         */
        private static final int DEFAULT_CAPACITY = 10;
    
        /**
         * Shared empty array instance used for empty instances.
         */
        private static final Object[] EMPTY_ELEMENTDATA = {};
    
        /**
         * Shared empty array instance used for default sized empty instances. We
         * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
         * first element is added.
         */
        private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    
        /**
         * The array buffer into which the elements of the ArrayList are stored.
         * The capacity of the ArrayList is the length of this array buffer. Any
         * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
         * will be expanded to DEFAULT_CAPACITY when the first element is added.
         */
        transient Object[] elementData; // non-private to simplify nested class access
    
        /**
         * The size of the ArrayList (the number of elements it contains).
         *
         * @serial
         */
        private int size;

首先是一个常量DEFAULT\_CAPACITY，根据注释表示默认的长度为10。然后是一个EMPTY\_ELEMENTDATA的常量object数组，只是空有其表没有内容。然后是一个object数组elementData。

这个就是最重要的成员了，通过注释我们可以看到这表示这个数组用来存储我们的数据。也就是说，我们代码中的add的数据都会放在这个数组里面。那么由此我们可知，ArrayList内部是由数组实现。再看最后一个变量，int类型的size。

第一眼还以为是elementData数组的长度。仔细看注释，才发现它表示的是elementData数组里面包含的数据长度。

## **2、构造函数** ##

介绍完了成员变量，我们来看看构造方法：

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);
            }
        }
    
        
        public ArrayList() {
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        }
    
      
        public ArrayList(Collection<? extends E> 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;
            }
        }

我们看到主要有三个构造方法。

（1）第一个构造方法需要传入一个int类型的变量。表示我们实例化一个ArrayList的时候想让ArrayList的初始化长度为多少。然后如果该变量大于0，那么new一个长度为传入值的对象数组。如果传入为0，那么等于EMPTY\_ELEMENTDATA。这个变量我们上面讲过，就是实例化一个对象数组，内容为空。如果小于0，那么抛出异常。

（2）第二个构造方法是无参构造方法，直接等于DEFAULTCAPACITY\_EMPTY\_ELEMENTDATA。没有其他的好说的。

（3）第三个则我们另外一种常见的使用方法，比如处理化AList的时候想把BList的值传给AList。

list<Alist> list = new ArrayList<>(BList);

我们看看构造函数做了什么。我们看到首先调用了c.toArray()方法将我们传入的集合元素变成一个数组来赋值给elementData数组。

然后判断elementData数组里面是否有数据元素，如果有，那么再判断elementData数组类型是否为Object，不是的话，转为Object类型。如果没有元素，那么直接赋值为EMPTY\_ELEMENTDATA。

至此三个构造方法就已经分析完了，基本上没有什么难度。

## 3、常见方法 ##

接下来我们来分析一些ArrayList的常见方法。

**（1）size()**

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05BNnRMTDBjSGUxSkpMU2ZXRHlwRzhuMUNBRXhCY1A5SXdBakx6aWF6bG5ydktsSlpvZHRDZWdRLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

很简单，就是将elementData数组中元素个数返回。

**（2）****isEmpty()**

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05sMlV0VlMxc2NTWUcwM0xXZHZ6T2h0NmJzOXBib3BKTHFYV2ZoV3B3bXZkUjBJYWxPZHFZVWcvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ][]

也很简单，就是判断sizes是否等于0，即elementData数组中是否有元素。

**（3）****add()**

我们先来看add(E e) 方法：

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU050bWJzZW1kVVdrQzNSSzA1Q3licE5rTVJzbFlQeVdpYW1vWUloSzc5RDBtTVJLbnp0b1Axam9nLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

可以看到add()方法还是比较简短的，接下面我们一步一步的分析,第一行是调用了一个方法，第二行是常见的数组赋值，将下标为size处的数组元素赋值为e，然后size自加1。如果有意识的话，会想到，咦？这么做的话，不怕数组越界？？那么我们去第一行代码的方法里看看：

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05nRW1pY1RUeEdVWmtxc3drV1V6V1U5N1ZjbWtQaWFUOFNaVnhaWFhlaWFOV0duckV5WjZpYnplQjNRLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

首先第一个方法中先判断elementData是否是没有元素的数组(但并不是elemetData为null)。如果是，那么取我们传入的值(也就是size + 1)和默认的数组长度(长度为10)中的最大值。然后调用了ensureExplicitCapacity()方法。我们继续看这个方法：

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05vTmlhNENONUFmbDFlVGVEN1VoMzVIYk80aE1pYlFjdzJQNUVVaWJsdXp3RFJ5NW1FVGFpYkJHWldnLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

首先是一个int类型的成员变量modCount自加，这个变量是ArrayList的父类AbstractList的一个成员，用来表示List的修改次数。接下来有一个判断，用传入的值减去当前elementData的长度，如果大于0，调用grow()方法(我个人理解为扩展的意思)，这里其实也能猜出大概意思。如果我们所需的最小数组长度已经比当前数组长度大了，那么就需要我们扩展数组了。我们接着看grow()方法:

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU041RllzTVF3aWNSRmg3T1VpYnNRTFVaTURkWWxnNHZieFFEMGI1dDR6VDRLSWxyMlhWMzZ6TExUQS82NDA_d3hfZm10PXBuZyZ0cD13ZWJwJnd4ZnJvbT01Jnd4X2xhenk9MSZ3eF9jbz0x][]

我们接着看代码，首先保存当前数组长度到oldCapacity，然后定义一个newCapacity，新长度为旧长度的3/2,也就是增加一半的容量。然后用新长度减去所需最小长度，如果小于0，意味着新长度比所需长度还要小，那么就直接将新长度改为所需最小长度。

然后新长度如果超过了允许的数组最大长度，调用hugeCapacity()方法进行调整。最后处理完毕后，调用Arrays.copyOf()方法赋值给elementData。至此就把elementData数组扩展完毕。然后回到add方法中直接赋值 elementData\[size++\] = e即可。

我们来看第二个add()方法:

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05iMnJ2QnNPeGExRWVaRXA0YVhqUkhNbE1BanNZeHZBRks3YkFXemdINENQV2lidG5OdzlNVUJBLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

上面的方法也是我们常用的，将指定的下标处元素赋值为我们设定的值。最开始我用这个方法的时候一直很担心假设我把指定位置设置了值，那原来的值会不会被覆盖呢？

我们看一下实现代码解惑一下，也很简单。首先检查index索引是否比elementData中拥有元素的数量大或者小于0。有问题则抛出异常。负责又调用ensureCapacityInternal()方法来确认数组长度是否足够。然后调用System.arraycopy()方法，我们来看看：

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05LbHlMTXVuM0pxN29Bc1JQRnFoeWhUUjdEdThGSmpHb04yUHU3cndBZ3hMQmRRRDZHRVBVYWcvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ][]

可以看到是个native方法，我们就不跟源码了，看看参数含义就明白了。src就是源数组，srcPos就是表明从源数组的下标多少开始复制，dest和destPos就是对应的目的数组，复制源数组的数据到从目的数组的下标开始存放，length就是打算复制多少个源数组的值。

说了半天有点绕口，看看上面的调用例子，我们用具体例子来讲解。首先源数组是elementData，假设有6个元素(即size为6，但是elementData的长度大于6)，index假设为3，length为size - index为3。而dest也为elementData，destPos为index + 1 等于4。

所以整体就是从index(3)下标处即elementData\[3\]处开始往后拿3个值，复制到elementDatadestPos开始往后3个值。

其实解释了半天就是将我们要插入的位置开始的元素全部往后移了一个位置。然后把值插入到指定的位置。（我真聪明）所以之前的担心就多余啦。我们插入到指定位置，指定位置的旧值会往后移，并不会被覆盖。

**（4）****clear**

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05NS0M2WTJhS1lhZWpEdE80V05pYkVLSThyM3FDaWI1U1hpY3I3ZjdBaWNzS0hMTGhPNER1WWlhbUM3QS82NDA_d3hfZm10PXBuZyZ0cD13ZWJwJnd4ZnJvbT01Jnd4X2xhenk9MSZ3eF9jbz0x][]

clear()方法也很简单，首先modCount自加，表示我们对list进行了操作。然后for循环置空即可，最后设置size等于0。

**（5）****remove()**

remove()也有两个方法，我们来看第一个：

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05kcTBObFZVSWRkaWFtbHViZGEySE1hZEhSMjJRd3MzazliUVpOcWpqQnZaMzJKU2pRbnJRazJRLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

根据传入参数我们也能猜到意思，就是移除指定下标的元素。

首先还是检查index是否有效。然后modCount++,表示我们对list又进行一次操作。然后将指定下标的元素取出。然后计算出我们需要移动多少个元素，指的是从删除位置往后的元素，不包括删除位置的元素。如果个数大于0，那么调用 System.arraycopy()方法将删除位置后的一个元素开始到最后的元素往前移动一个位置。

然后将size立马自减，然后将最后一个位置置为null(因为元素往前移动一位，那么最后一个元素往前移后，原来的最后一个位置值还存在没有被覆盖)。

最后返回旧的删除位置的元素值。

接下来我们来看第二个remove()方法：

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05GdmRBUnpqRU1mcjNGbkxsZXpaWW4waFlsRjQxdkprN2lhdlZ3OW5vVFc1SGtRalZldVJCWFVnLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

很明显看参数也猜得出是直接移除掉我们某个元素。首先判断我们传入的object是否为空，如果为空，那么就for循环找到第一个数组中值为null的元素，调用fastRemove()方法，我们去看看：

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05lTWNpY1I2M0ZpYVRvUlpha0ozbWdhVnFsV3dpYVZXQkNTWnl4V1ZpY0Rzb1NsRzdKT0VBM1d2eEFnLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

从注释看出，其实这就是第一个remove()方法的简化版，取消了越界检查，并且设置返回类型为void，不再返回删除的旧值。这里就不再分析。

接着上面说，如果remove()中如果传入的对象不为null，那么就是for循环找到这个值然后移除即可。整个函数返回类型为boolean，true表示有这个对象删除成功。没有表示数组里没有这个对象，没有进行删除操作。

**（6）****contains()**

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05aaWJWNHdhVEtLd1ZudGdHUk1Bd2ljTlBYaldlaHdiVXNuZkVsaWMxTUxxS1JCcnZ3dGlhR1NDUXZBLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE][]

contains()也是我们经常使用的方法，用来查询当前ArrayList是否包含某个对象。我们看调用了一个indexOf()方法然后把返回值和0进行比较(乍一看还是很奇怪的，返回布尔值不好吗)，我们来看看indexOf()方法：

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05oU1pKcmIyYW56WGVhWHc4dEtCQ1dZZXhPYjBHdjlXR3h3cXYyM29nUk1MWUVxZUZhUk9qc1EvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ][]

我们来看看代码，首先是对传入对象的判空。如果对象为空，还是一样的，for循环来查找elementData中第一个为null的元素，然后返回下标。如果传入对象不为空，那么一样for循环查找第一个匹配元素，然后返回第一个匹配元素的下标。如果都找不到，那么就返回-1。

看完这个方法，就明白了为啥不用返回值布尔类型了，原来是返回下标来和0进行判断是否包含。但是我们可以看到其实contains()方法并没有返回元素下标。

所以本人第一次看完代码觉得这是多此一举。后来突然想到indexOf()方法是一个public方法，也是我们经常使用的方法。可能就在这里java编写者进行方法重用就不必再重复写新方法来判断。

顺带着我们就把indexOf()方法介绍，方法就是返回第一个匹配传入对象的元素下标。如果数组中没有匹配元素那么返回-1。

**（7）****get()**

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05tcTJhaWFwU0hSU2dtVHFIaWFZOHppYVNqQ0FMZEZ4aWEzcTBWWUNKTkVwakIwY2JianpMSjFGOWlhZy82NDA_d3hfZm10PXBuZyZ0cD13ZWJwJnd4ZnJvbT01Jnd4X2xhenk9MSZ3eF9jbz0x][]

这个方法可以说是最最常用的方法了，但是其实我们看到非常简单，就是进行一个下标的越界判断，然后返回elementData\[index\]元素。

**set()**

![aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU044TlZ2RWljMUtOdG14aDRPSGwwU3NXNjcyZEZMMFhIOTBiemFMQWhmM1JjaWJmdUJZZ3l1aWFLYlEvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ][]

set方法也是，其实set(int index, E element)和add(int index, E element)方法很相似。只是set是将指定位置的值直接覆盖掉，而add()则是将指定位置开始的元素往后全部后移一位，旧值不会被覆盖掉。set()方法没有什么可以多分析的代码。

# **总结** #

*  首先ArrayList内部是由数组来实现的。而且在存放数据的数组长度不够时，会进行扩容，即增加数组长度。在Java 8中是默认扩展为原来的1.5倍。
 *  既然是数组，那么优点就是查找某个元素很快。可以通过下标查找元素，查找效率高。但是由此也看出缺点，每次删除元素，都会进行大量的数组元素移动，复制新的数组等等。增加元素的话如果长度不够，还要进行扩容。因此删除效率低。如果我们在实际开发中能够清楚知道我们的数据量，建议创建ArrayList的时候指定长度，这样无需频繁增加数据时不断进行扩容。

> 元素存储

// 用指定的元素替代此列表中指定位置上的元素，并返回以前位于该位置上的元素。  
    21 public E set(int index, E element) {  
    22    RangeCheck(index);  
    23  
    24    E oldValue = (E) elementData[index];  
    25    elementData[index] = element;  
    26    return oldValue;  
    27 }    
    28 // 将指定的元素添加到此列表的尾部。  
    29 public boolean add(E e) {  
    30    ensureCapacity(size + 1);   
    31    elementData[size++] = e;  
    32    return true;  
    33 }    
    34 // 将指定的元素插入此列表中的指定位置。  
    35 // 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引加1）。  
    36 public void add(int index, E element) {  
    37    if (index > size || index < 0)  
    38        throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);  
    39    // 如果数组长度不足，将进行扩容。  
    40    ensureCapacity(size+1);  // Increments modCount!!  
    41    // 将 elementData中从Index位置开始、长度为size-index的元素，  
    42    // 拷贝到从下标为index+1位置开始的新的elementData数组中。  
    43    // 即将当前位于该位置的元素以及所有后续元素右移一个位置。  
    44    System.arraycopy(elementData, index, elementData, index + 1, size - index);  
    45    elementData[index] = element;  
    46    size++;  
    47 }    
    48 // 按照指定collection的迭代器所返回的元素顺序，将该collection中的所有元素添加到此列表的尾部。  
    49 public boolean addAll(Collection<? extends E> c) {  
    50    Object[] a = c.toArray();  
    51    int numNew = a.length;  
    52    ensureCapacity(size + numNew);  // Increments modCount  
    53    System.arraycopy(a, 0, elementData, size, numNew);  
    54    size += numNew;  
    55    return numNew != 0;  
    56 }    
    57 // 从指定的位置开始，将指定collection中的所有元素插入到此列表中。  
    58 public boolean addAll(int index, Collection<? extends E> c) {  
    59    if (index > size || index < 0)  
    60        throw new IndexOutOfBoundsException(  
    61            "Index: " + index + ", Size: " + size);  
    62  
    63    Object[] a = c.toArray();  
    64    int numNew = a.length;  
    65    ensureCapacity(size + numNew);  // Increments modCount  
    66  
    67    int numMoved = size - index;  
    68    if (numMoved > 0)  
    69        System.arraycopy(elementData, index, elementData, index + numNew, numMoved);  
    70  
    71    System.arraycopy(a, 0, elementData, index, numNew);  
    72    size += numNew;  
    73    return numNew != 0;  
       }

> 元素读

// 返回此列表中指定位置上的元素。  
     public E get(int index) {  
        RangeCheck(index);  
      
        return (E) elementData[index];  
      }

> 元素删除ArrayList提供了根据下标或者指定对象两种方式的删除功能。如下： romove(int index):

// 移除此列表中指定位置上的元素。  
     2  public E remove(int index) {  
     3     RangeCheck(index);  
     4   
     5     modCount++;  
     6     E oldValue = (E) elementData[index];  
     7   
     8     int numMoved = size - index - 1;  
     9     if (numMoved > 0)  
    10         System.arraycopy(elementData, index+1, elementData, index, numMoved);  
    11     elementData[--size] = null; // Let gc do its work  
    12   
    13     return oldValue;  
    14  }

[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05BNnRMTDBjSGUxSkpMU2ZXRHlwRzhuMUNBRXhCY1A5SXdBakx6aWF6bG5ydktsSlpvZHRDZWdRLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/1659674973db4998a1c1af11afdaa284.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05sMlV0VlMxc2NTWUcwM0xXZHZ6T2h0NmJzOXBib3BKTHFYV2ZoV3B3bXZkUjBJYWxPZHFZVWcvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ]: /images/20211023/92119c16c8584f85b93b2a3695540e71.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU050bWJzZW1kVVdrQzNSSzA1Q3licE5rTVJzbFlQeVdpYW1vWUloSzc5RDBtTVJLbnp0b1Axam9nLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/7dc6015a040248d4b4165513a03c6a23.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05nRW1pY1RUeEdVWmtxc3drV1V6V1U5N1ZjbWtQaWFUOFNaVnhaWFhlaWFOV0duckV5WjZpYnplQjNRLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/23a625ed328842fe8260e4f39329952a.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05vTmlhNENONUFmbDFlVGVEN1VoMzVIYk80aE1pYlFjdzJQNUVVaWJsdXp3RFJ5NW1FVGFpYkJHWldnLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/180b9bbdd39044c4a9d9622d8c73eb1a.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU041RllzTVF3aWNSRmg3T1VpYnNRTFVaTURkWWxnNHZieFFEMGI1dDR6VDRLSWxyMlhWMzZ6TExUQS82NDA_d3hfZm10PXBuZyZ0cD13ZWJwJnd4ZnJvbT01Jnd4X2xhenk9MSZ3eF9jbz0x]: /images/20211023/3c7446810c594e14870af5a05d883f2c.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05iMnJ2QnNPeGExRWVaRXA0YVhqUkhNbE1BanNZeHZBRks3YkFXemdINENQV2lidG5OdzlNVUJBLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/55759e21ce3a4b8c89948423f72ab635.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05LbHlMTXVuM0pxN29Bc1JQRnFoeWhUUjdEdThGSmpHb04yUHU3cndBZ3hMQmRRRDZHRVBVYWcvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ]: /images/20211023/70607adb2a374b69806c39ed0fce1e00.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05NS0M2WTJhS1lhZWpEdE80V05pYkVLSThyM3FDaWI1U1hpY3I3ZjdBaWNzS0hMTGhPNER1WWlhbUM3QS82NDA_d3hfZm10PXBuZyZ0cD13ZWJwJnd4ZnJvbT01Jnd4X2xhenk9MSZ3eF9jbz0x]: /images/20211023/54b48a46527e4bd9b809822ce7ffcc29.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05kcTBObFZVSWRkaWFtbHViZGEySE1hZEhSMjJRd3MzazliUVpOcWpqQnZaMzJKU2pRbnJRazJRLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/c8f2d14cc2b9438086acaf1c16b85177.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05GdmRBUnpqRU1mcjNGbkxsZXpaWW4waFlsRjQxdkprN2lhdlZ3OW5vVFc1SGtRalZldVJCWFVnLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/199f920253064f668144f5dd003554a7.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05lTWNpY1I2M0ZpYVRvUlpha0ozbWdhVnFsV3dpYVZXQkNTWnl4V1ZpY0Rzb1NsRzdKT0VBM1d2eEFnLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/076c5aa127cb45cda77907508bd130a5.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05aaWJWNHdhVEtLd1ZudGdHUk1Bd2ljTlBYaldlaHdiVXNuZkVsaWMxTUxxS1JCcnZ3dGlhR1NDUXZBLzY0MD93eF9mbXQ9cG5nJnRwPXdlYnAmd3hmcm9tPTUmd3hfbGF6eT0xJnd4X2NvPTE]: /images/20211023/a7027a83cae7483691c81fc3acf29eff.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05oU1pKcmIyYW56WGVhWHc4dEtCQ1dZZXhPYjBHdjlXR3h3cXYyM29nUk1MWUVxZUZhUk9qc1EvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ]: /images/20211023/3994b06657d94abc89ac7dc86d8a5146.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU05tcTJhaWFwU0hSU2dtVHFIaWFZOHppYVNqQ0FMZEZ4aWEzcTBWWUNKTkVwakIwY2JianpMSjFGOWlhZy82NDA_d3hfZm10PXBuZyZ0cD13ZWJwJnd4ZnJvbT01Jnd4X2xhenk9MSZ3eF9jbz0x]: /images/20211023/52bb72b1735e45cea722145b9697089a.png
[aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VdFdkRGd5bkxkYUhvNnkwaGtXb0REMk84S1NjZWljU044TlZ2RWljMUtOdG14aDRPSGwwU3NXNjcyZEZMMFhIOTBiemFMQWhmM1JjaWJmdUJZZ3l1aWFLYlEvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ]: /images/20211023/fb15f680b7be496aaef8345f14185858.png