【代币预售源码】【网页查找源码地址】【c#源码+ping】arraylist源码

2024-12-26 03:45:51 来源:易语言邮件源码 分类:知识

1.奇怪,为什么 ArrayList 初始化容量大小为 10?HashMap 的初始化容量为 16?
2.arraylist为什么线程不安全
3.ArrayList 从源码角度剖析底层原理
4.如何自己实现一个简单的ArrayList

arraylist源码

奇怪,为什么 ArrayList 初始化容量大小为 10?HashMap 的初始化容量为 16?

       看ArrayList源码时,无意中发现其初始化容量大小为,这与我们熟知的ArrayList和HashMap底层基于数组的特性大相径庭,为何ArrayList不采用如HashMap所用的代币预售源码作为初始容量,而是选择?

       探讨HashMap的初始化容量,以Java 8源码为例,HashMap的默认初始化容量为,当数据填充至容量的%时,会进行2倍扩容。若用户自定义容量,需保证为2的网页查找源码地址n次方数值,否则,HashMap会自动调整,增加额外步骤。而关于HashMap计算Key值坐标的哈希算法,其效果依赖于数组的大小,确保容量为2的n次方能实现更高效的位操作,减少哈希碰撞。

       通常,选择作为默认值,不仅减少哈希碰撞,也提升了效率,这是c#源码+pingHashMap采用2的n次方,且默认值为的原因。而ArrayList的初始化容量为何设定为?答案其实颇为“直觉”,是一个平衡内存使用与性能损失的“感觉”值。在不考虑算法优化的前提下,ArrayList的容量应是任何正值,而选择作为默认值,可能是出于性能与空间损失之间的最佳平衡考量。这使得ArrayList在创建时无需消耗过多内存,同时保持较低的性能开销。

       通过对比不同集合类的初始化容量,如ArrayList与Vector的,HashSet与HashMap的仿百万站源码,以及独树一帜的HashTable的,我们能更好地理解不同设计决策背后的考量。在实际编程中,选择合适的数据结构不仅取决于其初始容量,更应综合考虑应用需求、性能预期以及资源限制。

arraylist为什么线程不安全

       é¦–先说一下什么是线程不安全:线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。线程不安全就是不提供数据访问保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据。 如图,List接口下面有两个实现,一个是ArrayList,另外一个是vector。 从源码的角度来看,因为Vector的方法前加了,synchronized 关键字,也就是同步的意思,sun公司希望Vector是线程安全的,而希望arraylist是高效的,缺点就是另外的优点。 说下原理(百度的,很好理解): 一个 ArrayList ,在添加一个元素的时候,它可能会有两步来完成:

       1. 在 Items[Size] 的位置存放此元素;

       2. 增大 Size 的值。

       åœ¨å•çº¿ç¨‹è¿è¡Œçš„情况下,如果 Size = 0,添加一个元素后,此元素在位置 0,而且 Size=1;

       è€Œå¦‚果是在多线程情况下,比如有两个线程,线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停,线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素,因为此时 Size 仍然等于 0 (注意哦,我们假设的是添加一个元素是要两个步骤哦,而线程A仅仅完成了步骤1),所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行,都增加 Size 的值。

       é‚£å¥½ï¼ŒçŽ°åœ¨æˆ‘们来看看 ArrayList 的情况,元素实际上只有一个,存放在位置 0,而 Size 却等于 2。这就是“线程不安全”了。

       ç¤ºä¾‹ç¨‹åºï¼š

       package test;

       import java.util.ArrayList;

       import java.util.List;

       public class ArrayListInThread implements Runnable {

       List<String> list1 = new ArrayList<String>();// not thread safe

       // List<String> list1 = Collections.synchronizedList(new ArrayList<String>());// thread safe

       public void run() {

       try {

       Thread.sleep((int)(Math.random() * 2));

       }

       catch (InterruptedException e) {

       e.printStackTrace();

       }

       list1.add(Thread.currentThread().getName());

       }

       public static void main(String[] args) throws InterruptedException {

       ThreadGroup group = new ThreadGroup("mygroup");

       ArrayListInThread t = new ArrayListInThread();

       for (int i = 0; i < ; i++) {

       Thread th = new Thread(group, t, String.valueOf(i));

       th.start();

       }

       while (group.activeCount() > 0) {

       Thread.sleep();

       }

       System.out.println();

       System.out.println(t.list1.size()); // it should be if thread safe collection is used.

       }

       }

ArrayList 从源码角度剖析底层原理

       本文深入剖析了ArrayList的底层实现,重点关注了add和remove方法的源码,以及如何指定元素位置的add操作。

       在add默认添加元素中,我们通过ensureCapacityInternal方法确保数组不会越界,且实现自动扩容。84的源码反码此方法通过minCapacity参数记录在执行完当前add操作后的数组元素数量,从而决定是否扩容。对于数组扩容,核心逻辑为新数组长度等于旧数组长度加旧数组长度的一半,每次扩容1.5倍。然而,当调用addAll方法传入大量元素时,若数组容量不足以容纳所有元素,newCapacity会小于minCapacity。这时,会直接将minCapacity赋值给newCapacity以避免扩容不足。对于极端情况,如传入Integer.MAX_VALUE个元素,会触发hugeCapacity函数处理,确保容量不超过Integer.MAX_VALUE并抛出OOM异常。

       在add指定位置添加元素的操作中,方法首先检查传入的数组下标是否合法,接着通过ensureCapacityInternal方法对数组进行扩容,以确保有足够的空间容纳新元素。随后,调用System.arraycopy方法实现元素移动,即将指定位置后的元素向后移动一位,以为空出位置添加新元素。简单而言,System.arraycopy方法实现了元素的移动逻辑,通过传入数组、源起始索引、目标起始索引和元素个数等参数实现元素的高效复制。

       在remove方法中,根据下标移除元素时,会先检查传入的index是否合法,即确保index不超过数组元素个数。完成元素移除后,会更新modCount的值,验证了删除操作对数组状态的影响。在移动元素时,通过System.arraycopy方法将需要移动的元素向后挪动,以释放被移除元素的位置,最后将该位置设置为null并交给GC回收。

       根据值移除元素时,ArrayList允许传入null值,并通过遍历数组寻找匹配的第一个元素进行移除。无论传入的值是否为null,都会调用fastRemove方法,执行与remove方法类似的逻辑,实现元素的删除。

       综上所述,ArrayList底层基于数组实现,支持动态扩容,每次扩容1.5倍。然而,频繁的随机插入和删除操作会带来性能影响,因此,ArrayList更适合读多写少的场景。值得注意的是,ArrayList非线程安全,多线程环境下可能会导致数据不一致或抛出ConcurrentModificationException异常。

       通过理解add、remove以及指定位置添加元素的源码实现,可以更好地理解ArrayList的操作机制。例如,了解remove方法的遍历逻辑,可以帮助直观理解indexOf和lastIndexOf方法的工作原理。

如何自己实现一个简单的ArrayList

       ArrayList是Java集合框架中一个经典的实现类。他比起常用的数组而言,明显的优点在于,可以随意的添加和删除元素而不需考虑数组的大小。

       å®žçŽ°ä¸€ä¸ªç®€å•çš„ArrayList,实现的过程:

       å®žçŽ°çš„ArrayList主要的功能如下:

       é»˜è®¤æž„造器和一个参数的有参构造器

       add方法

       get方法

       indexOf方法

       contains方法

       size方法

       isEmpty方法

       remove方法

       è¿™ä¸ªç®€å•çš„ArrayListç±» 取名为SimpleArrayList,全部的代码查看SimpleArrayList代码

       æž„造器

       æºç ArrayList一共有三个构造器,一个无参构造器,一个参数为int型有参构造器,一个参数为Collection型的有参构造器。参数为Collection型的构造器用来实现将其他继承Collection类的容器类转换成ArrayList。SimpleArrayList类因为还没有手动实现其他的容器类,所以实现的构造方法只有2个。代码如下:

   public SimpleArrayList(){        this(DEFAULT_CAPACITY);

          }    public SimpleArrayList(int size){        if (size < 0){            throw new IllegalArgumentException("默认的大小" + size);

              }else{

                  elementData = new Object[size];

              }

          }

       æ— å‚构造器中的 DEFAULT_CAPACITY是定义的私有变量,默认值是,用来创建一个大小为的数组。有参构造器中,int参数是用来生成一个指定大小的Object数组。将创建好的数组传给elementData。elementData是真正的用来存储元素的数组。

       add方法

       add 方法用来往容器中添加元素,add方法有两个重载方法,一个是add(E e),另一个是add(int index, E e)。add本身很简单,但是要处理动态数组,即数组大小不满足的时候,扩大数组的内存。具体的代码如下:

   public void add(E e){

              isCapacityEnough(size + 1);

              elementData[size++] = e;

          }

       æ–¹æ³•isCapacityEnough就是来判断是否需要扩容,传入的参数就是最小的扩容空间。因为add一个元素,所以最小的扩容空间,即新的长度是所有元素+ 1。这里的size就是真正的元素个数。

  private void isCapacityEnough(int size){        if (size > DEFAULT_CAPACITY){

                  explicitCapacity(size);

              }       if (size < 0){            throw new OutOfMemoryError();

              }

          }

       åˆ¤æ–­æ‰©å®¹çš„方法也很简单,判断需要扩容的空间是不是比默认的空间大。如果需要的空间比默认的空间大,就调用explicitCapacity进行扩容。这里有个size小于0的判断,出现size小于0主要是因为当size超过Integer.MAX_VALUE就会变成负数。

   private final static int MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8;    private void explicitCapacity(int capacity){        int newLength = elementData.length * 2;        if (newLength - capacity < 0){

                  newLength = capacity;

              }        if (newLength > (MAX_ARRAY_LENGTH)){

                  newLength = (capacity > MAX_ARRAY_LENGTH ? Integer.MAX_VALUE : MAX_ARRAY_LENGTH);

              }

              elementData = Arrays.copyOf(elementData, newLength);

          }

       ä¸Šé¢çš„代码是扩容的代码,首先,定义一个数组最大的容量的常量为最大值,这个值按照官方的源码中的解释是要有些VM保留了数组的头部信息在数组中,因此实际存放数据的大小就是整数的最大值 - 8

       ç„¶åŽè®¾å®šä¸€ä¸ªè¦æ‰©å®¹çš„数组的大小,虽然上面说了有一个扩容空间的值 size + 1 ,这个是实际我们最小需要扩容的大小。但为了继续增加元素,而不频繁的扩容,因此一次性的申请多一些的扩容空间。这里newLength 打算申请为 数组长度的2倍,然后去判断这个长度是否满足需要的扩容空间的值。 即有了后续的两段代码

     if (newLength - capacity < 0){            newLength = capacity;

            }      if (newLength > (MAX_ARRAY_LENGTH)){            newLength = (capacity > MAX_ARRAY_LENGTH ? Integer.MAX_VALUE : MAX_ARRAY_LENGTH);

            }

       å¦‚æžœ2倍的长度仍然不满足,则申请到需要的扩容长度。在我们只增加一个元素的情况下,这个判断是永远不会生效的,但是如果有addAll方法,则增加的元素很多,就要导致一次申请2倍的长度是不够的。第二个判断是判断newLength的长度如果超过上面定义的数组最大长度则判断要需要的扩容空间是否大于数组最大长度,如果大于则newLength为 MAX_VALUE ,否则为 MAX_ARRAY_LENGTH。

       æœ€åŽï¼ŒçœŸæ­£å®žçŽ°æ•°ç»„扩容到设定长度的方法就没意思了,调用Arrays.copyOf(elementData, newLength)得到一个扩容后的数组。

       add的另一个重载方法也很简单。

  public void add(int index, E e) {

             //判断是不是越界

              checkRangeForAdd(index);

              //判断需不需要扩容

              isCapacityEnough(size + 1);

              //将index的元素及以后的元素向后移一位

              System.arraycopy(elementData,index,elementData,index + 1,size - index);

              //将index下标的值设为e

              elementData[index] = e;        size++;

          }

          private void checkRangeForAdd(int index){        //这里index = size是被允许的,即支持头,中间,尾部插入

              if (index < 0 || index > size){            throw new IndexOutOfBoundsException("指定的index超过界限");

              }

          }

       è‡³æ­¤ï¼Œä¸€ä¸ªç®€å•çš„add方法就实现完了。

       get方法

       get方法用来得到容器中指定下标的元素。方法实现比较简单,直接返回数组中指定下标的元素即可。

   private void checkRange(int index) {        if (index >= size || index < 0){

                  throw new IndexOutOfBoundsException("指定的index超过界限");

              }

          }    public E get(int index){

              checkRange(index);        return (E)elementData[index];

          }

       indexOf方法

       indexOf方法用来得到指定元素的下标。实现起来比较简单,需要判断传入的元素,代码如下:

   public int indexOf(Object o){        if (o != null) {            for (int i = 0 ; i < size ; i++){                if (elementData[i].equals(o)){                    return i;

                      }

                  }

              }else {            for (int i = 0 ; i < size ; i++){                if (elementData[i] == null) {                    return i;

                      }

                  }

              }        return -1;

          }

       åˆ¤æ–­ä¼ å…¥çš„元素是否为null,如果为null,则依次与null。如果不为空,则用equals依次比较。匹配成功就返回下标,匹配失败就返回-1。

       contains方法

       contains用来判断该容器中是否包含指定的元素。在有了indexOf方法的基础上,contains的实现就很简单了。

    public boolean contains(Object o){        return indexOf(o) >= 0;

           }

       size方法

       size方法用来得到容器类的元素个数,实现很简单,直接返回size的大小即可。

   public int size(){        return size;

          }

       isEmpty方法

       isEmpty方法用来判断容器是否为空,判断size方法的返回值是否为0即可。

   public boolean isEmpty(){        return size() == 0;

          }

       remove方法

       remove方法是用来对容器类的元素进行删除,与add一样,remove方法也有两个重载方法,分别是

       remove(Object o)和remove(int index)

    public E remove(int index) {

              E value = get(index);        int moveSize = size - index - 1;        if (moveSize > 0){

                  System.arraycopy(elementData,index + 1, elementData,index,size - index - 1);

              }

              elementData[--size] = null;        return value;

          }    

          public boolean remove(Object o){        if (contains(o)){

                  remove(indexOf(o));            return true;

              }else {            return false;

              }

          }

       ç¬¬ä¸€ä¸ªremove方法是核心方法,首先得到要删除的下标元素的值,然后判断index后面的要前移的元素的个数,如果个数大于零,则调用库方法,将index后面的元素向前移一位。最后elementData[--size] = null;缩减size大小,并将原最后一位置空。

       ç¬¬äºŒä¸ªremove方法不需要向第一个方法一样,需要告诉使用者要删除的下标对应的元素,只需要判断是否删除成功即可。如果要删除的元素在列表中,则删除成功,如果不在则失败。因此调用contains方法就可以判断是否要删除的元素在列表中。在则调用remove(int index),不在则返回失败。

本文地址:http://581.net.cn/news/33a99098976.html 欢迎转发