arraylist是链接存储

⑴ LinkedList和ArrayList的区别

一般大家都知道ArrayList和LinkedList的大致区别：
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用(references)。例如我们可以用ArrayList来存储一系列的String或者Integer。那么ArrayList和LinkedList在性能上有什么差别呢？什么时候应该用ArrayList什么时候又该用LinkedList呢？

一．时间复杂度
首先一点关键的是，ArrayList的内部实现是基于基础的对象数组的，因此，它使用get方法访问列表中的任意一个元素时(random access)，它的速度要比LinkedList快。LinkedList中的get方法是按照顺序从列表的一端开始检查，直到另外一端。对LinkedList而言，访问列表中的某个指定元素没有更快的方法了。
假设我们有一个很大的列表，它里面的元素已经排好序了，这个列表可能是ArrayList类型的也可能是LinkedList类型的，现在我们对这个列表来进行二分查找(binary search)，比较列表是ArrayList和LinkedList时的查询速度，看下面的程序：

packagecom.mangocity.test;
importjava.util.LinkedList;
importjava.util.List;
importjava.util.Random;
importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.Collections;
publicclassTestList...{
publicstaticfinalintN=50000;

publicstaticListvalues;

static...{
Integervals[]=newInteger[N];

Randomr=newRandom();

for(inti=0,currval=0;i<N;i++)...{
vals=newInteger(currval);
currval+=r.nextInt(100)+1;
}

values=Arrays.asList(vals);
}

staticlongtimeList(Listlst)...{
longstart=System.currentTimeMillis();
for(inti=0;i<N;i++)...{
intindex=Collections.binarySearch(lst,values.get(i));
if(index!=i)
System.out.println("***错误***");
}
returnSystem.currentTimeMillis()-start;
}
publicstaticvoidmain(Stringargs[])...{
System.out.println("ArrayList消耗时间："+timeList(newArrayList(values)));
System.out.println("LinkedList消耗时间："+timeList(newLinkedList(values)));
}
}

我得到的输出是：ArrayList消耗时间：15
LinkedList消耗时间：2596
这个结果不是固定的，但是基本上ArrayList的时间要明显小于LinkedList的时间。因此在这种情况下不宜用LinkedList。二分查找法使用的随机访问(random access)策略，而LinkedList是不支持快速的随机访问的。对一个LinkedList做随机访问所消耗的时间与这个list的大小是成比例的。而相应的，在ArrayList中进行随机访问所消耗的时间是固定的。
这是否表明ArrayList总是比LinkedList性能要好呢？这并不一定，在某些情况下LinkedList的表现要优于ArrayList，有些算法在LinkedList中实现时效率更高。比方说，利用Collections.reverse方法对列表进行反转时，其性能就要好些。
看这样一个例子，加入我们有一个列表，要对其进行大量的插入和删除操作，在这种情况下LinkedList就是一个较好的选择。请看如下一个极端的例子，我们重复的在一个列表的开端插入一个元素：

packagecom.mangocity.test;

importjava.util.*;
publicclassListDemo{
staticfinalintN=50000;
staticlongtimeList(Listlist){
longstart=System.currentTimeMillis();
Objecto=newObject();
for(inti=0;i<N;i++)
list.add(0,o);
returnSystem.currentTimeMillis()-start;
}
publicstaticvoidmain(String[]args){
System.out.println("ArrayList耗时："+timeList(newArrayList()));
System.out.println("LinkedList耗时："+timeList(newLinkedList()));
}
}

这时我的输出结果是：ArrayList耗时：2463

LinkedList耗时：15
这和前面一个例子的结果截然相反，当一个元素被加到ArrayList的最开端时，所有已经存在的元素都会后移，这就意味着数据移动和复制上的开销。相反的，将一个元素加到LinkedList的最开端只是简单的未这个元素分配一个记录，然后调整两个连接。在LinkedList的开端增加一个元素的开销是固定的，而在ArrayList的开端增加一个元素的开销是与ArrayList的大小成比例的。

二．空间复杂度
在LinkedList中有一个私有的内部类，定义如下：

privatestaticclassEntry{
Objectelement;
Entrynext;
Entryprevious;
}

每个Entry对象reference列表中的一个元素，同时还有在LinkedList中它的上一个元素和下一个元素。一个有1000个元素的LinkedList对象将有1000个链接在一起的Entry对象，每个对象都对应于列表中的一个元素。这样的话，在一个LinkedList结构中将有一个很大的空间开销，因为它要存储这1000个Entity对象的相关信息。
ArrayList使用一个内置的数组来存储元素，这个数组的起始容量是10.当数组需要增长时，新的容量按如下公式获得：新容量=(旧容量*3)/2+1，也就是说每一次容量大概会增长50%。这就意味着，如果你有一个包含大量元素的ArrayList对象，那么最终将有很大的空间会被浪费掉，这个浪费是由ArrayList的工作方式本身造成的。如果没有足够的空间来存放新的元素，数组将不得不被重新进行分配以便能够增加新的元素。对数组进行重新分配，将会导致性能急剧下降。如果我们知道一个ArrayList将会有多少个元素，我们可以通过构造方法来指定容量。我们还可以通过trimToSize方法在ArrayList分配完毕之后去掉浪费掉的空间。

三．总结
ArrayList和LinkedList在性能上各有优缺点，都有各自所适用的地方，总的说来可以描述如下：
1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

3．LinkedList不支持高效的随机元素访问。

4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

⑵ arraylist和linkedlist的区别 vectot

一般大家都知道ArrayList和LinkedList的大致区别：

1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3. 对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。

ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用(references)。

例如我们可以用ArrayList来存储一系列的String或者Integer。

那么ArrayList和LinkedList在性能上有什么差别呢？

什么时候应该用ArrayList什么时候又该用LinkedList呢？

一．时间复杂度
首先一点关键的是，ArrayList的内部实现是基于基础的对象数组的，因此，它使用get方法访问列表中的任意一个元素时(random access)，它的速度要比LinkedList快。

LinkedList中的get方法是按照顺序从列表的一端开始检查，直到另外一端。

对LinkedList而言，访问列表中的某个指定元素没有更快的方法了。

假设我们有一个很大的列表，它里面的元素已经排好序了，这个列表可能是ArrayList类型的也可能是LinkedList类型的，

现在我们对这个列表来进行二分查找(binary search)，比较列表是ArrayList和LinkedList时的查询速度，看下面的程序：

packagecom.mangocity.test;
importjava.util.LinkedList;
importjava.util.List;
importjava.util.Random;
importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.Collections;
publicclassTestList...{
publicstaticfinalintN=50000;

publicstaticListvalues;

static...{
Integervals[]=newInteger[N];

Randomr=newRandom();

for(inti=0,currval=0;i<N;i++)...{
vals=newInteger(currval);
currval+=r.nextInt(100)+1;
}

values=Arrays.asList(vals);
}

staticlongtimeList(Listlst)...{
longstart=System.currentTimeMillis();
for(inti=0;i<N;i++)...{
intindex=Collections.binarySearch(lst,values.get(i));
if(index!=i)
System.out.println("***错误***");
}
returnSystem.currentTimeMillis()-start;
}
publicstaticvoidmain(Stringargs[])...{
System.out.println("ArrayList消耗时间："+timeList(newArrayList(values)));
System.out.println("LinkedList消耗时间："+timeList(newLinkedList(values)));
}
}

我得到的输出是：ArrayList消耗时间：15
LinkedList消耗时间：2596

这个结果不是固定的，但是基本上ArrayList的时间要明显小于LinkedList的时间。

因此在这种情况下不宜用LinkedList。

二分查找法使用的随机访问(random access)策略，而LinkedList是不支持快速的随机访问的。

对一个LinkedList做随机访问所消耗的时间与这个list的大小是成比例的。

而相应的，在ArrayList中进行随机访问所消耗的时间是固定的。

这是否表明ArrayList总是比LinkedList性能要好呢？

这并不一定，在某些情况下LinkedList的表现要优于ArrayList，有些算法在LinkedList中实现时效率更高。比方说，利用Collections.reverse方法对列表进行反转时，其性能就要好些。

看这样一个例子，加入我们有一个列表，要对其进行大量的插入和删除操作，在这种情况下LinkedList就是一个较好的选择。

请看如下一个极端的例子，我们重复的在一个列表的开端插入一个元素：

packagecom.mangocity.test;

importjava.util.*;
publicclassListDemo{
staticfinalintN=50000;
staticlongtimeList(Listlist){
longstart=System.currentTimeMillis();
Objecto=newObject();
for(inti=0;i<N;i++)
list.add(0,o);
returnSystem.currentTimeMillis()-start;
}
publicstaticvoidmain(String[]args){
System.out.println("ArrayList耗时："+timeList(newArrayList()));
System.out.println("LinkedList耗时："+timeList(newLinkedList()));
}
}

这时我的输出结果是：

ArrayList耗时：2463
LinkedList耗时：15

这和前面一个例子的结果截然相反，当一个元素被加到ArrayList的最开端时，所有已经存在的元素都会后移，这就意味着数据移动和复制上的开销。

相反的，将一个元素加到LinkedList的最开端只是简单的未这个元素分配一个记录，然后调整两个连接。

在LinkedList的开端增加一个元素的开销是固定的，而在ArrayList的开端增加一个元素的开销是与ArrayList的大小成比例的。

二．空间复杂度
在LinkedList中有一个私有的内部类，定义如下：

privatestaticclassEntry{
Objectelement;
Entrynext;
Entryprevious;
}

每个Entry对象reference列表中的一个元素，同时还有在LinkedList中它的上一个元素和下一个元素。一个有1000个元素的LinkedList对象将有1000个链接在一起的Entry对象，每个对象都对应于列表中的一个元素。

这样的话，在一个LinkedList结构中将有一个很大的空间开销，因为它要存储这1000个Entity对象的相关信息。

ArrayList使用一个内置的数组来存储元素，这个数组的起始容量是10.当数组需要增长时，新的容量按如下公式获得：新容量=(旧容量*3)/2+1，也就是说每一次容量大概会增长50%。

这就意味着，如果你有一个包含大量元素的ArrayList对象，那么最终将有很大的空间会被浪费掉，这个浪费是由ArrayList的工作方式本身造成的。

如果没有足够的空间来存放新的元素，数组将不得不被重新进行分配以便能够增加新的元素。对数组进行重新分配，将会导致性能急剧下降。

如果我们知道一个ArrayList将会有多少个元素，我们可以通过构造方法来指定容量。我们还可以通过trimToSize方法在ArrayList分配完毕之后去掉浪费掉的空间。

三．总结

ArrayList和LinkedList在性能上各有优缺点，都有各自所适用的地方，总的说来可以描述如下：

1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

3．LinkedList不支持高效的随机元素访问。

4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

⑶ arraylist和linkedlist的区别 遍历速度

就是数组和链表的区别。

使用iterator遍历没有速度区别

根据下标访问时，ArrayList速度快 直接读取到该对象，而LinkedList要从第一个对象一个个的向后寻找直到找到该下标的对象

插入与删除对象时，LinkedList速度快 直接修改链接，而ArrayList里在被操作对象之后的所有对象要向前或后移动。

⑷ arraylist是怎么存储的

把 class player 中的属性添加get和set方法
然后new 一个plater对象
Player player=new Player();
对他的属性调用set方法赋值

然后List list=new ArrayList();
调用 list.add(player) 把你赋值的Player对象放入arraylist中()
取出来的时候用循环遍历 list.get(index) //index是ArrayList的下标

代码就是
Player player=new Player();
List list= new ArrayList();
player.setUsername("张三");
player.setFamilyname("张");
.....
list.add(player);

//从list中取出Player对象
for(int i=0;i<list.size();i++){

Player playerCopy=list.get(i);
//显示封装的对象信息
System.out.println("player的内容"+playerCopy.getUsername());
System.out.println("player的内容"+playerCopy.getFamilyname());
System.out.println("lplayerCopy的内容"+playerCopy.getUsername());
System.out.println("playerCopy的内容"+playerCopy.getFamilyname());
}

⑸ hashmap是以什么方式存储数据 arraylist又是以什么方式存储数据

hashmap 就是表，说通俗点就是一个可以理解为 两列多行 的表格，第一列中存储索引或者起标示作用的对象，第二列存储我们实际要用的对象，当我们需要第二列中某个对象时，就去找这个对象的索引（就是对应它的第一列的对象），arraylist 内部是以数组来储存数据的，它是一个“长度可变”的数组

⑹ ArrayList和LinkedList区别，举例说明下

一般大家都知道ArrayList和LinkedList的大致区别：
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

ArrayList和LinkedList是两个集合 类，用于存储一系列的对象引用(references)。例如我们可以用ArrayList来存储一系列的String或者Integer。那么 ArrayList和LinkedList在性能上有什么差别呢？什么时候应该用ArrayList什么时候又该用LinkedList呢？
一．时间复 杂度
首先一点关键的是，ArrayList的内部实现是基于基础的对象数组的，因此，它使用get方法访问列表中的任意一个元素时 (random access)，它的速度要比LinkedList快。LinkedList中的get方法是按照顺序从列表的一端开始检查，直到另外一端。对 LinkedList而言，访问列表中的某个指定元素没有更快的方法了。
假设我们有一个很大的列表，它里面的元素已经排好序了，这个列表可能是ArrayList类型 的也可能是LinkedList类型的，现在我们对这个列表来进行二分查找(binary search)，比较列表是ArrayList和LinkedList时的查询速度，看下面的程序：Java代码 package com.mangocity.test; import java.util.LinkedList; import java.util.List; import java.util.Random; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; public class TestList ...{ public static final int N=50000; public static List values; static...{ Integer vals[]=new Integer[N]; Random r=new Random(); for(int i=0,currval=0;i<N;i++)...{ vals=new Integer(currval); currval+=r.nextInt(100)+1; } values=Arrays.asList(vals); } static long timeList(List lst)...{ long start=System.currentTimeMillis(); for(int i=0;i<N;i++)...{ int index=Collections.binarySearch(lst, values.get(i)); if(index!=i) System.out.println("***错误***"); } return System.currentTimeMillis()-start; } public static void main(String args[])...{ System.out.println("ArrayList消耗时间："+timeList(new ArrayList(values))); System.out.println("LinkedList消耗时间："+timeList(new LinkedList(values))); } } package com.mangocity.test; import java.util.LinkedList; import java.util.List; import java.util.Random; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; public class TestList ...{ public static final int N=50000; public static List values; static...{ Integer vals[]=new Integer[N]; Random r=new Random(); for(int i=0,currval=0;i<N;i++)...{ vals=new Integer(currval); currval+=r.nextInt(100)+1; } values=Arrays.asList(vals); } static long timeList(List lst)...{ long start=System.currentTimeMillis(); for(int i=0;i<N;i++)...{ int index=Collections.binarySearch(lst, values.get(i)); if(index!=i) System.out.println("***错误***"); } return System.currentTimeMillis()-start; } public static void main(String args[])...{ System.out.println("ArrayList消耗时间："+timeList(new ArrayList(values))); System.out.println("LinkedList消耗时间："+timeList(new LinkedList(values))); } }
我得到的输出 是：ArrayList消耗时间：15
LinkedList消耗时间：2596
这个结果不是固定的，但是基本上ArrayList的 时间要明显小于LinkedList的时间。因此在这种情况下不宜用LinkedList。二分查找法使用的随机访问(random access)策略，而LinkedList是不支持快速的随机访问的。对一个LinkedList做随机访问所消耗的时间与这个list的大小是成比例 的。而相应的，在ArrayList中进行随机访问所消耗的时间是固定的。
这是否表明ArrayList总是比LinkedList性能要好呢？这并不一定，在某些情况 下LinkedList的表现要优于ArrayList，有些算法在LinkedList中实现时效率更高。比方说，利用 Collections.reverse方法对列表进行反转时，其性能就要好些。
看这样一个例子，加入我们有一个列表，要对其进行大量的插入和删除操作，在这种情况下 LinkedList就是一个较好的选择。请看如下一个极端的例子，我们重复的在一个列表的开端插入一个元素：
Java代码 package com.mangocity.test; import java.util.*; public class ListDemo { static final int N=50000; static long timeList(List list){ long start=System.currentTimeMillis(); Object o = new Object(); for(int i=0;i<N;i++) list.add(0, o); return System.currentTimeMillis()-start; } public static void main(String[] args) { System.out.println("ArrayList耗时："+timeList(new ArrayList())); System.out.println("LinkedList耗时："+timeList(new LinkedList())); } } package com.mangocity.test; import java.util.*; public class ListDemo { static final int N=50000; static long timeList(List list){ long start=System.currentTimeMillis(); Object o = new Object(); for(int i=0;i<N;i++) list.add(0, o); return System.currentTimeMillis()-start; } public static void main(String[] args) { System.out.println("ArrayList耗时："+timeList(new ArrayList())); System.out.println("LinkedList耗时："+timeList(new LinkedList())); } } 这时我的输出结果是：ArrayList耗时：2463</SPAN>
LinkedList耗时：15
这和前面一个例子的结果截然相反，当一个元素被加到ArrayList的最开端时，所有已经存在的元素都会后 移，这就意味着数据移动和复制上的开销。相反的，将一个元素加到LinkedList的最开端只是简单的未这个元素分配一个记录，然后调整两个连接。在 LinkedList的开端增加一个元素的开销是固定的，而在ArrayList的开端增加一个元素的开销是与ArrayList的大小成比例的。
二．空间复 杂度
在LinkedList中有一个私有的内部类，定义如下：Java代码 private static class Entry { Object element; Entry next; Entry previous; } private static class Entry { Object element; Entry next; Entry previous; }
每个Entry对象 reference列表中的一个元素，同时还有在LinkedList中它的上一个元素和下一个元素。一个有1000个元素的LinkedList对象将 有1000个链接在一起的Entry对象，每个对象都对应于列表中的一个元素。这样的话，在一个LinkedList结构中将有一个很大的空间开销，因为 它要存储这1000个Entity对象的相关信息。
ArrayList使用一个内置的数组来存储元素，这个数组的起始容量是10.当数组需要增长时，新的容量按 如下公式获得：新容量=(旧容量*3)/2+1，也就是说每一次容量大概会增长50%。这就意味着，如果你有一个包含大量元素的ArrayList对象， 那么最终将有很大的空间会被浪费掉，这个浪费是由ArrayList的工作方式本身造成的。如果没有足够的空间来存放新的元素，数组将不得不被重新进行分 配以便能够增加新的元素。对数组进行重新分配，将会导致性能急剧下降。如果我们知道一个ArrayList将会有多少个元素，我们可以通过构造方法来指定 容量。我们还可以通过trimToSize方法在ArrayList分配完毕之后去掉浪费掉的空间。
三．总结
ArrayList和LinkedList在性能上各 有优缺点，都有各自所适用的地方，总的说来可以描述如下：
1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对 ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是 统一的，分配一个内部Entry对象。
2．在ArrayList的 中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。
3．LinkedList不 支持高效的随机元素访问。
4．ArrayList的空 间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间
可以这样说：当操作是在一列 数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中 间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

⑺ ArrayList、linklist、list的区别

1、ist是一个接口，ArrayList和LinkedList是两个实现类.

2、他们实现的方式不一样，其实LinkedList才是真正的链表（如果不清楚什么是链表，需要了解一下相关数据结构的知识，这不是一两句话能说清楚的）

3、而ArrayList是用数组实现的，它不是真正的链表，在初始化的时候它先对数组设置一个初始容量，当数组空间不够的时候，它会重新构建一个容量更大的数组，然后把先前的元素拷贝进去。

4、ArrayList和LinkedList本质上的区别就是数组和列表这两种数据结构的区别。课参阅相关数据结构的知识。

5、ArrayList：缺点：内存使用量要大一些，添加删除元素效率较低。元素随机访问的效率较高。
LinkedList：相反

(7)arraylist是链接存储扩展阅读

1、ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵活的设置数组的大小等好处。

2、List接口的大小可变数组的实现，位于API文档的java.util.ArrayList<E>。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

3、每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。

4、随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。

5、注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 。

⑻ ArrayList 和LinkdList的区别是什么

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快

⑼ ArrayList和LinkedList内存放的是什么呢

ArrayList类似于数组，是按顺序存储在内存的。
LinkedList类似与链表，是没有顺序的，是通过指针链接了每个元素。
因为LinkedList是无序存储的，所以插入随便一个地方都可以，只要指针指向了就行。
而ArrayList是有序的，插入要遍历到你要插入的位置，所以效率低些。
正因为ArrayList是有序的，所以查询的时候输入索引，就可以很快找到，LinkedList则不然。

⑽ ArrayList和LinkedList的区别

ArrayList和LinkedList

共性：ArrayList与LinkedList都是List接口的实现类，因此都实现了List的所有未实现的方法，只是实现的方式有所不同。

区别：List接口的实现方式不同

ArrayList实现了List接口，以数组的方式来实现的，因此对于快速的随机取得对象的需求，使用ArrayList实现执行效率上会比较好。

LinkedList是采用链表的方式来实现List接口的，因此在进行insert和remove动作时效率要比ArrayList高。适合用来实现Stack(堆栈)与Queue(队列)。

HashTable和HashMap

共性：都实现了Map接口。

区别：

(1)继承的父类不同

Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。

(2)线程安全性不同

Hashtable的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。

(3)提供contains方法

HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey，因为contains方法容易让人引起误解。

Hashtable则保留了contains，containsValue和containsKey三个方法，其中contains和containsValue功能相同。

(4)key和value是否允许null值

Hashtable中，key和value都不允许出现null值。HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。

(5)两个遍历方式的内部实现上不同

HashMap使用了 Iterator；Hashtable使用Iterator，Enumeration两种方式 。

(6)hash值不同

哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

(7)内部实现使用的数组初始化和扩容方式不同

HashTable在不指定容量的情况下的默认容量为11，增加的方式是 old*2+1；而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。