ArrayList and LinkedList知识补充

Java中数组与LinkedList的相互转换

数组,LinkedList:双向链表

数组转LinkedList:

LinkedList linklist=new LinkedList(Arrays.asList(array));

LinkedList转数组:

//对应 T[] toArray(T[] a)
方法一:String[]  array1= (String[]) linklist.toArray(new String [0]);//(String[])可省略  new String [0]里写几都可以,并不是只是需要赋一个具体的值
		String[]  array1= (String[]) linklist.toArray(new String [1])

方法二:String[] array2= new String[linklist.size()];
       linklist.toArray(array2); 

数组转换链表的是调用了Arrays.asList方法

static List asList(T… a)
返回由指定数组支持的固定大小的列表。

链表转数组有两个方法的原因LinkedList的两种toArray方法:

Object[] toArray()
以正确的顺序(从第一个到最后一个元素)返回一个包含此列表中所有元素的数组。
T[] toArray(T[] a)
以正确的顺序返回一个包含此列表中所有元素的数组(从第一个到最后一个元素); 返回的数组的运行时类型是指定数组的运行时类型。

		String[] planets=new String[]{
     "Mecury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
         LinkedList linklisted=new LinkedList(Arrays.asList(planets));

        linklisted.add(3,"Position");
        System.out.println("linkdelist"+linklisted.toString());

        String[] newPlanets1= (String[]) linklisted.toArray(new String [0]);
        System.out.println("ArrayList1"+Arrays.toString(newPlanets1));

        String[] newPlanets2= new String[linklisted.size()];
        linklisted.toArray(newPlanets2);
        System.out.println("ArrayList2"+Arrays.toString(newPlanets2));


	//linkdelist[Mecury, Venus, Earth, Position, Mars, Jupiter, Saturn, Uranus, Neptune]
	//ArrayList1[Mecury, Venus, Earth, Position, Mars, Jupiter, Saturn, Uranus, Neptune]
A	//ArrayList2[Mecury, Venus, Earth, Position, Mars, Jupiter, Saturn, Uranus, Neptune]


ArrayList和LinkedList的区别、优缺点以及应用场景

ArrayList和LinkedList都是实现了List接口的容器类,用于存储一系列的对象引用,且他们都可以对元素的增删改查进行操作。

区别

  1. ArrayList是实现了基于动态数组的数据结构,LinkedList是基于链表结构。
  2. 对于随机访问的get和set方法,ArrayList要优于LinkedList,因为LinkedList要移动指针。
  3. 对于新增和删除操作add和remove,LinkedList比较占优势,因为ArrayList要移动数据。

具体说明

ArrayList源码

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.
     */

在源码中可看到,ArrayList是实现了基于动态数组的数据结构,而数组是一段连续的内存空间,在内存中我们可以简单表示为下图样式:

ArrayList and LinkedList知识补充_第1张图片
因为数组在存储数据时是按顺序存储的,存储数据的内存也是连续的,所以他的特点就是寻址读取数据比较容易,插入和删除比较困难。简单解释一下为什么,在读取数据时,只需要告诉数组要从哪个位置(索引)取数据就可以了,数组会直接把你想要的位置的数据取出来给你。插入和删除比较困难是因为这些存储数据的内存是连续的,要插入和删除就需要变更整个数组中的数据的位置。举个例子:一个数组中编号0->1->2->3->4这五个内存地址中都存了数组的数据,但现在你需要往4中插入一个数据,那就代表着从4开始,后面的所有内存中的数据都要往后移一个位置,这可是很耗时的。
所以,对于ArrayList,它在集合的末尾删除或添加元素所用的时间是一致的,但是在列表中间的部分添加或删除时所用时间就会大大增加。但是它在根据索引查找元素的时候速度很快。

LinkedList部分说明
LinkedList底层是双向列表

// 双向链表的节点所对应的数据结构。
// 包含3部分:上一节点,下一节点,当前节点值。
     private static class Entry<E> {
     
         // 当前节点所包含的值
         E element;
         // 下一个节点
         Entry<E> next;
         // 上一个节点
         Entry<E> previous;
 
         /**
          * 链表节点的构造函数。
          * 参数说明:
          *   element  —— 节点所包含的数据
          *   next      —— 下一个节点
          *   previous —— 上一个节点
          */
         Entry(E element, Entry<E> next, Entry<E> previous) {
     
             this.element = element;
             this.next = next;
             this.previous = previous;
         }
     }

当需要在首位置插入元素时,first 引用指向需要插入到链表中的节点对象,新的节点对象的next引用指向原先的首节点对象;

所以,对于LinkedList,它在插入、删除集合中任何位置的元素所花费的时间都是一样的,但是它根据索引查询一个元素的时候却比较慢。

缺点

  1. 对ArrayList和LinkedList而言,在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言,主要是在内部数组中增加一项,指向所添加的元素,偶尔可能会导致对数组重新进行分配;而对LinkedList而言,这个开销是统一的,分配一个内部Entry对象。
  2. 在ArrayList集合中添加或者删除一个元素时,当前的列表移动元素后面所有的元素都会被移动。而LinkedList集合中添加或者删除一个元素的开销是固定的。
  3. LinkedList集合不支持高效的随机随机访问(RandomAccess),因为可能产生二次项的行为。
  4. ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间,而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间.

应用场景

ArrayList使用在查询比较多,但是插入和删除比较少的情况,而LinkedList用在查询比较少而插入删除比较多的情况

ArrayList知识补充

Deque接口只能用LinkedList实现即Deque deque=new LinkedList();

 Deque<TreeNode> deque=new ArrayList();
 incompatible types: ArrayList cannot be converted to Deque<TreeNode>

List 中 new ArrayList (20) 与 new ArrayList () 区别

new ArrayList(); 这种是创建默认长度为0的数组;
new ArrayList(20); 这种是创建初始容量长度为20的数组;
上面两种创建方式都可扩充,每次扩容大小为原数组容量的1.5倍 。
注意:new ArrayList() 在装值时(执行add()方法)会对ArrayList的初始容量指定为10

Arrays.asList的使用

Arrays.asList的作用是将数组转化为list,一般是用于在初始化的时候,设置几个值进去,简化代码,省去add的部分

List nums= Arrays.asList(1,2,3);
注意

  • 该方法不适用于基本数据类型(byte,short,int,long,float,double,boolean),可以是integer。
  • 该方法将数组与列表链接起来,当更新其中之一时,另一个自动更新
  • 不支持add和remove方法
    最重要的一点就是,不支持add和remove,如果不需要改变长度可以使用Arrays.asList()。

List是接口,ArrayList是List的实现类。

List list=new ArrayList() 原因

至于为什么是写成List list = new ArrayList()而不是ArrayList arrayList = new ArrayList()原因如下:

  1. 接口有什么好处,这种定义方式就有什么好处,当然你可以用 ArrayList list = new ArrayList(),但是一般不这么用

  2. 设计模式中有对依赖倒置原则。程序要尽量依赖于抽象,不依赖于具体。从Java语法上,这种方式是使用接口引用指向具体实现。
    比如,你若希望用LinkedList的实现来替代ArrayList的话,只需改动一行即可:List list = new LinkedList();,而程序中的其它部分不需要改动,这样比较灵活;这个如果你想把存储结构该为LinkedList的时候,只要把List list = new ArrayList()改为list = new LinkedList()而其他的所有的都不需要改动。这也是一种很好的设计模式.一个接口有多种实现,当你想换一种实现方式时,你需要做的改动很小.

  3. 面向接口编程

  4. 提高程序宽展性,以后修改易维护

具体解释

ArrayList不是继承List接口,是实现了List接口。

你写成ArrayList arrayList = new ArrayList();这样不会有任何问题。和List list = new ArrayList();相比这2个写是有区别的。arrayList是一个ArrayList对象,它可以使用ArrayList的所有方法

List是接口,它是不可以被实例化的(接口是个抽象类),所以必须以它的实现类去实例化它。list对象虽然也是被实例化为ArrayList但是它实际是List对象,list只能使用ArrayList中已经实现了的List接口中的方法,ArrayList中那些自己的、没有在List接口定义的方法是不可以被访问到的。
我们说,用接口去做是有它的好处的,如果你把类型定义成ArrayList(也就是一个具体的实现类)那么你就只能接收这一种类型的数据了,如果你要是定义为List那么你不仅可以接收ArrayList的对象还可以接收LinkedList的对象,这样你的程序就灵活了。

一个例子

Set s = hashset 可以简单的改写成 Set s = LinkedHashset. 最主要的是如果你把它 变成 public Set getSet() 提供给别人的时候,别人的程序不用变. 如果用public HashSet getSet() 的话,你想把它改变成linkedhashset,那么别人的程序得跟着你改写

References

List list=new ArrayList()怎么理解???

ArrayList和LinkedList的区别、优缺点以及应用场景

你可能感兴趣的:(知识点总结)