皮皮网
皮皮网
emmc源码

【抢房软件源码】【asp建站系统源码】【音乐解析网站源码】arraylist源码重写

时间:2024-12-24 00:14:09 分类:综合 编辑:xnote 源码
1.Lists.newArrayList和正常的码重 new ArrayList有什么区别?
2.阿里java开发手册为什么不建议使用arraylist的sublist方法
3.ArrayList详解及扩容源码分析
4.HashMap和Hashtable的区别
5.如何自己实现一个简单的ArrayList
6.Hadoop 的 Lists.newArrayList和正常的 new ArrayList()有什么区别?

arraylist源码重写

Lists.newArrayList和正常的 new ArrayList有什么区别?

       List是一个接口,而ArrayList 是码重一个类。

       1、码重ArrayList 继承并实现了List。码重List list = new ArrayList();这句创建了一个ArrayList的码重对象后把上溯到了List。此时它是码重抢房软件源码一个List对象了,有些ArrayList有但是码重List没有的属性和方法,它就不能再用了。码重而ArrayList list=new ArrayList;创建一对象则保留了ArrayList的码重所有属性。

       2、码重为什么一般都使用 List list = new ArrayList ,码重而不用 ArrayList alist = new ArrayList呢。问题就在于List有多个实现类,码重如 LinkedList或者Vector等等,码重现在你用的码重是ArrayList,也许哪一天你需要换成其它的码重asp建站系统源码实现类呢。

       3、这时你只要改变这一行就行了:List list = new LinkedList; 其它使用了list地方的代码根本不需要改动。假设你开始用 ArrayList alist = new ArrayList,这下你有的改了,特别是如果你使用了 ArrayList特有的方法和属性。 ,如果没有特别需求的话,最好使用List list = new LinkedList,便于程序代码的重构,这就是面向接口编程的好处。

       4、ava的多态,List只是定义了一堆接口,而对于这些接口,有各种各样的实现,比如ArrayList,音乐解析网站源码LinkedList等等,不同的实现,会有自己不同的特性以及追加自己特有的方法。当你仅仅使用List的通用接口方法时,定义成List(也就是面向接口编程)是非常好的习惯。

阿里java开发手册为什么不建议使用arraylist的sublist方法

       使用ArrayList的SubList方法存在潜在风险与不便之处,原因主要体现在以下几个方面。

       举例而言,从ArrayList和内部类SubList的声明出发,两者皆继承自同一个父类AbstractList。在Java源码中,这种设计表明两者在逻辑上存在紧密关联。

       深入分析,SubList对象实质上是影视解析网站源码一个代理对象,它关联于原始ArrayList实例。这意味着任何对SubList的修改操作,最终都会反馈到原始ArrayList中。这种特性虽在某些场景下带来了便利,但同时也带来了风险。

       首先,SubList与原始列表的这种关联性可能导致不必要的资源消耗与性能问题。由于修改操作会反映到原始列表上,每次对子列表的修改都需要同步到原始列表中,这无疑增加了系统的处理负担。

       其次,由于SubList作为代理对象,其操作可能会引发未预料的异常。例如,element ui 源码下载当尝试对已经迭代结束的子列表进行修改时,可能会导致运行时异常,影响程序的稳定性。

       综上所述,考虑到SubList方法在实际应用中的潜在风险与不便,推荐使用更安全且灵活的替代方案。例如,可以创建一个新的ArrayList实例,通过调用原始列表的subList方法并传入指定的开始与结束索引来生成。这种操作不仅避免了与原始列表的关联性,还能提供更可控的列表操作环境。

ArrayList详解及扩容源码分析

       在集合框架中,ArrayList作为普通类实现List接口,如下图所示。

       它实现了RandomAccess接口,表明支持随机访问;Cloneable接口,表明可以实现克隆;Serializable接口,表明支持序列化。

       与其他类不同,如Vector,ArrayList在单线程环境下的线程安全性较差,但适用于多线程环境下的Vector或CopyOnWriteArrayList。

       ArrayList底层基于连续的空间实现,为动态可扩展的顺序表。

       一、构造方法解析

       使用ArrayList(Collection c)构造方法时,传入类型必须为E或其子类。

       二、扩容分析

       不带参数的构造方法初始容量为,此时底层数组为空,即`DEFAULT_CAPACITY_EMPTY_ELEMENTDATA`长度为0。

       元素添加时,默认插入数组末尾,调用`ensureCapacityInternal(size + 1)`增加容量。

       若当前容量无法满足增加需求,计算新的容量以达到所需规模,确保添加元素成功并避免频繁扩容。

       三、常用方法

       通过List.subList(int fromIndex, int toIndex)方法获取子列表,修改原列表元素亦会改变此子列表。

       四、遍历方式

       ArrayList提供for循环、foreach循环、迭代器三种遍历方法。

       五、缺陷与替代方案

       ArrayList基于数组实现,插入或删除元素导致频繁元素移动,时间复杂度高。在需要任意位置频繁操作的场景下,性能不佳。

       因此,在Java集合中引入了更适合频繁插入和删除操作的LinkedList类。

       版权声明:本文内容基于阿里云实名注册用户的贡献,遵循相关协议规定,包括用户服务协议和知识产权保护指引。发现抄袭内容,可通过侵权投诉表单举报,确保社区内容健康、合规。

HashMap和Hashtable的区别

       HashMap和Hashtable的比较是Java面试中的常见问题,用来考验程序员是否能够正确使用集合类以及是否可以随机应变使用多种思路解决问题。HashMap的工作原理、ArrayList与Vector的比较以及这个问题是有关Java 集合框架的最经典的问题。Hashtable是个过时的集合类,存在于Java API中很久了。在Java 4中被重写了,实现了Map接口,所以自此以后也成了Java集合框架中的一部分。Hashtable和HashMap在Java面试中相当容易被问到,甚至成为了集合框架面试题中最常被考的问题,所以在参加任何Java面试之前,都不要忘了准备这一题。

        这篇文章中,我们不仅将会看到HashMap和Hashtable的区别,还将看到它们之间的相似之处。

        HashMap和Hashtable都实现了Map接口,但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有:线程安全性,同步(synchronization),以及速度。

        由于Hashtable是线程安全的也是synchronized,所以在单线程环境下它比HashMap要慢。如果你不需要同步,只需要单一线程,那么使用HashMap性能要好过Hashtable。

        HashMap不能保证随着时间的推移Map中的元素次序是不变的。

        fail-fast机制在遍历一个集合时,当集合结构被修改,会抛出Concurrent Modification Exception。

        fail-fast会在以下两种情况下抛出ConcurrentModificationException

        集合被创建后,在遍历它的过程中修改了结构。

        注意 remove()方法会让expectModcount和modcount 相等,所以是不会抛出这个异常。

        当一个线程在遍历这个集合,而另一个线程对这个集合的结构进行了修改。

        迭代器在遍历过程中是直接访问内部数据的,因此内部的数据在遍历的过程中无法被修改。为了保证不被修改,迭代器内部维护了一个标记 “mode” ,当集合结构改变(添加删除或者修改),标记"mode"会被修改,而迭代器每次的hasNext()和next()方法都会检查该"mode"是否被改变,当检测到被修改时,抛出Concurrent Modification Exception。

        下面看看ArrayList迭代器部分的源码。

        可以看到它的标记“mode”为 expectedModeCount。

        fail-safe任何对集合结构的修改都会在一个复制的集合上进行修改,因此不会抛出ConcurrentModificationException。

        fail-safe机制有两个问题

        HashMap可以通过下面的语句进行同步:

        Map m = Collections.synchronizeMap(hashMap);

        Hashtable和HashMap有几个主要的不同:线程安全以及速度。仅在你需要完全的线程安全的时候使用Hashtable,而如果你使用Java 5或以上的话,请使用ConcurrentHashMap吧。

如何自己实现一个简单的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),不在则返回失败。

Hadoop 的 Lists.newArrayList和正常的 new ArrayList()有什么区别?

       这个方法在google工具类中也有,源码内容如下

public static <E> ArrayList<E> newArrayList() {

           return new ArrayList();

       }

       内容是差不多的,唯一的好处就是可以少写泛型的部分。

       这个方法有着丰富的重载:

Lists.newArrayList(E... elements)

       Lists.newArrayList(Iterable<? extends E> elements)

       Lists.newArrayList(Iterator<? extends E> elements)

       还有很多前缀扩展方法:

List<T> exactly = Lists.newArrayListWithCapacity();

       List<T> approx = Lists.newArrayListWithExpectedSize();

       使得函数名变得更有可读性,一眼就看出方法的作用。

       但是查看源码发现官方的注解里头是这么写的:

       Creates a mutable, empty ArrayList instance (for Java 6 and earlier).

       创建一个可变的空ArrayList(适用于java 6及之前的版本)

       Note for Java 7 and later: this method is now unnecessary and should

       be treated as deprecated. Instead, use the ArrayList constructor

       directly, taking advantage of the new "diamond" syntax.

       针对java 7及之后版本,本方法已不再有必要,应视之为过时的方法。取而代之你可以直接使用ArrayList的构造器,充分利用钻石运算符<>(可自动推断类型)。

Java ArrayList的使用

       import java.util.*;

       class Student {  // 定义学生类

        String name;

        Student(String name) {  // 构造方法

        this.name = name;

        }

        // 重写equals方法,保证只要名字相等,则认为是同一个人.

        public boolean equals(Object obj) {

        if (name == null || obj == null) {

        return false;

        }

        if (obj instanceof Student) {

        Student sd = (Student) obj;

        return name.equals(sd.name);

        }

        return false;

        }

       }

       public class t2 {

        public static void main(String[] args) {

        Scanner reader = new Scanner(System.in);

        Student[] stu = new Student[4];// 定义

        ArrayList<Student> stus = new ArrayList<Student>();// ArrayList泛型,每个元素是1个学生。

        System.out.println("输入4个学生姓名:");

        // 初始化4个学生,并将他们添加进ArrayList

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

        stu[i] = new Student(reader.nextLine());

        stus.add(stu[i]);

        }

        System.out.println("列表中还有" + stus.size() + "个学生:");

        for (int i = 0; i < stus.size(); i++) {  // 遍历输出所有元素中学生的姓名

        System.out.println("第" + i + "个学生: " + stus.get(i).name);

        }

        // 键盘输入一个学生姓名,判断该学生是否在列表中,如存在,则输出其在列表中的下标,然后将它从列表中移除。

        System.out.println("输入要查找的人的姓名:");

        Student s = new Student(reader.nextLine());

        if (stus.contains(s)) {

        System.out.println("找到" + s.name + ",下标为" + stus.indexOf(s));// 输出下标

        stus.remove(s); // 从列表中移除该学生

        System.out.println("删除" + s.name + "后,还有" + stus.size() + "个学生:");

        for (int i = 0; i < stus.size(); i++) {  // 遍历输出所有元素中学生的姓名

        System.out.println("第" + i + "个学生: " + stus.get(i).name);

        }

        } else

        System.out.println("列表中找不到" + s.name); // 如不存在则输出找不到。

        }

       }

       效果

输入4个学生姓名:

       天涯

       明月

       秋水

       清泉

       列表中还有4个学生:

       第0个学生: 天涯

       第1个学生: 明月

       第2个学生: 秋水

       第3个学生: 清泉

       输入要查找的人的姓名:

       天涯

       找到天涯,下标为0

       删除天涯后,还有3个学生:

       第0个学生: 明月

       第1个学生: 秋水

       第2个学生: 清泉

本文地址:http://04.net.cn/html/72b350196426.html

copyright © 2016 powered by 皮皮网   sitemap