本篇文章给大家谈谈arraylist初始容量和扩容，以及arraylist自动扩容对应的知识点，文章可能有点长，但是希望大家可以阅读完，增长自己的知识，最重要的是希望对各位有所帮助，可以解决了您的问题，不要忘了收藏本站喔。
一、java中arraylist<>是什么写法
java的arraylist_Java中ArrayList类详解
ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：
ArrayList List= new ArrayList();
for( int i=0;i<10;i++)//给数组增加10个Int元素
List.RemoveAt(5);//将第6个元素移除
for( int i=0;i<3;i++)//再增加3个元素
Int32[] values=(Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组
这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法
默认的构造器，将会以默认(16)的大小来初始化内部的数组
public ArrayList(ICollection);
用一个ICollection对象来构造，并将该集合的元素添加到ArrayList
用指定的大小来初始化内部的数组
2)IsSynchronized属性和ArrayList.Synchronized方法
IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。
如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：
ArrayList list= new ArrayList();
lock( list.SyncRoot)//当ArrayList为非线程包装的时候，SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，这里还是使用SyncRoot来保持源代码的规范性
如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用了lock关键字来保证线程同步。
Count属性是目前ArrayList包含的元素的数量，这个属性是只读的。
Capacity属性是目前ArrayList能够包含的最大数量，可以手动的设置这个属性，但是当设置为小于Count值的时候会引发一个异常。
4)Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange
Add方法用于添加一个元素到当前列表的末尾
AddRange方法用于添加一批元素到当前列表的末尾
Remove方法用于删除一个元素，通过元素本身的引用来删除
RemoveAt方法用于删除一个元素，通过索引值来删除
RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除
Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动
InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动
Clear方法用于清除现有所有的元素
Contains方法用来查找某个对象在不在列表之中
其他的我就不一一累赘了，大家可以查看MSDN，上面讲的更仔细
这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。
这个方法把ArrayList的元素Copy到一个新的数组中。
ArrayList List= new ArrayList();
Int32[] values=(Int32[])List.ToArray(typeof(Int32));
ArrayList List= new ArrayList();
Int32[] values= new Int32[List.Count];
上面介绍了两种从ArrayList转换到数组的方法
ArrayList List= new ArrayList();
object[] values= List.ToArray(typeof(object));//正确
string[] values=(string[])List.ToArray(typeof(string));//错误
和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。
ArrayList List= new ArrayList();
Int32[] values=(Int32[])List.ToArray(typeof(Int32));
ArrayList List= new ArrayList();
Int32[] values= new Int32[List.Count];
上面介绍了两种从ArrayList转换到数组的方法
ArrayList List= new ArrayList();
object[] values= List.ToArray(typeof(object));//正确
string[] values=(string[])List.ToArray(typeof(string));//错误
和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。
这一节我们来讨论ArrayList与数组的差别，以及ArrayList的效率问题
ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。
对于一般的引用类型来说，这部分的影响不是很大，但是对于值类型来说，往ArrayList里面添加和修改元素，都会引起装箱和拆箱的操作，频繁的操作可能会影响一部分效率。
但是恰恰对于大多数人，多数的应用都是使用值类型的数组。
消除这个影响是没有办法的，除非你不用它，否则就要承担一部分的效率损失，不过这部分的损失不会很大。
这是对ArrayList效率影响比较大的一个因素。
每当执行Add、AddRange、Insert、InsertRange等添加元素的方法，都会检查内部数组的容量是否不够了，如果是，它就会以当前容量的两倍来重新构建一个数组，将旧元素Copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。
例1：比如，一个可能有200个元素的数据动态添加到一个以默认16个元素大小创建的ArrayList中，将会经过：
四次的扩容才会满足最终的要求，那么如果一开始就以：
ArrayList List= new ArrayList( 210);
的方式创建ArrayList，不仅会减少4次数组创建和Copy的操作，还会减少内存使用。
例2：预计有30个元素而创建了一个ArrayList：
ArrayList List= new ArrayList(30);
在执行过程中，加入了31个元素，那么数组会扩充到60个元素的大小，而这时候不会有新的元素再增加进来，而且有没有调用TrimSize方法，那么就有1次扩容的操作，并且浪费了29个元素大小的空间。如果这时候，用：
ArrayList List= new ArrayList(40);
所以说，正确的预估可能的元素，并且在适当的时候调用TrimSize方法是提高ArrayList使用效率的重要途径。
4)频繁的调用IndexOf、Contains等方法(Sort、BinarySearch等方法经过优化，不在此列)引起的效率损失
首先，我们要明确一点，ArrayList是动态数组，它不包括通过Key或者Value快速访问的算法，所以实际上调用IndexOf、Contains等方法是执行的简单的循环来查找元素，所以频繁的调用此类方法并不比你自己写循环并且稍作优化来的快，如果有这方面的要求，建议使用Hashtable或SortedList等键值对的集合。
这个方法把ArrayList的元素Copy到一个新的数组中。
ArrayList类实现了List接口，由ArrayList类实现的List集合采用数组结构保存对象。数组结构的优点是便于对集合进行快速的随机访问，如果经常需要根据索引位置访问集合中的对象，使用由ArrayList类实现的List集合的效率较好。数组结构的缺点是向指定索引位置插入对象和删除指定索引位置对象的速度较慢，如果经常需要向List集合的指定索引位置插入对象，或者是删除List集合的指定索引位置的对象，使用由ArrayList类实现的List集合的效率则较低，并且插入或删除对象的索引位置越小效率越低，原因是当向指定的索引位置插入对象时，会同时将指定索引位置及之后的所有对象相应的向后移动一位，如图1所示。当删除指定索引位置的对象时，会同时将指定索引位置之后的所有对象相应的向前移动一位，如图2所示。如果在指定的索引位置之后有大量的对象，将严重影响对集合的操作效率。
就是因为用ArrayList类实现的List集合在插入和删除对象时存在这样的缺点，在编写例程06时才没有利用ArrayList类实例化List集合，下面看一个模仿经常需要随机访问集合中对象的例子。
在编写该例子时，用到了Java.lang.Math类的random()方法，通过该方法可以得到一个小于10的double型随机数，将该随机数乘以5后再强制转换成整数，将得到一个0到4的整数，并随机访问由ArrayList类实现的List集合中该索引位置的对象，具体代码如下：
src\com\mwq\TestCollection.Java关键代码：
public static void main(String[] args){
String a="A", b="B", c="C", d="D", e="E";
list.add(a); //索引位置为 0
list.add(b); //索引位置为 1
list.add(c); //索引位置为 2
list.add(d); //索引位置为 3
list.add(e); //索引位置为 4
System.out.println(list.get((int)(Math.random()* 5))); //模拟随机访问集合中的对象
1 packagecode;2 importjava.util.ArrayList;3 importjava.util.Iterator;4 public classSimpleTest{5
7public static voidmain(String []args){8
9 ArrayList list1= newArrayList();10 list1.add("one");11 list1.add("two");12 list1.add("three");13 list1.add("four");14 list1.add("five");15 list1.add(0,"zero");16 System.out.println(""+ list1.size()+"个元素");17 System.out.println("");18
19 ArrayList list2= newArrayList();20 list2.add("Begin");21 list2.addAll(list1);22 list2.add("End");23 System.out.println(""+ list2.size()+"个元素");24 System.out.println("");25
26 ArrayList list3= newArrayList();27 list3.removeAll(list1);28 System.out.println("");29
30 list3.add(0,"same element");31 list3.add(1,"same element");32 System.out.println(""+ list3.size()+"个元素");33 System.out.println("");34 System.out.println("");35 System.out.println("");36
38 System.out.println("");39 Iterator it=list3.iterator();40 while(it.hasNext()){41 String str=(String)it.next();42 System.out.println("");43}44
45 System.out.println("");46 list3.set(0,"another element");47 list3.set(1,"another element");48 System.out.println("");49//Object [] array=(Object[]) list3.toArray(new Object[list3.size()]);
50 Object [] array=list3.toArray();51 for(int i= 0; i< array.length; i++){52 String str=(String)array[i];53 System.out.println("array["+ i+"]="+str);54}55
56 System.out.println("");57 list3.clear();58 System.out.println("");59 System.out.println(""+ list3.size()+"个元素");60
61//System.out.println("hello world!");
二、java中Arraylist是干什么的怎么用
1、java中的ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本。
2、它提供了如下一些好处：动态的增加和减少元素实现了ICollection和IList接口灵活的设置数组的大小。
3、ArrayList List= new ArrayList(); for( int
4、给数组增加10个Int元素 List.Add(i);//..
5、将第6个元素移除 for( int i=0;i<3;i++)//
6、List.Add(i+20); Int32[] values=
7、(Int32[])List.ToArray(typeof(Int32));//
8、List接口的大小可变数组的实现，位于API文档的java.util.ArrayList<E>。
9、实现了所有可选列表操作，并允许包括 null在内的所有元素。
10、除了实现 List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector类，除了此类是不同步的。）
11、size、isEmpty、get、set、iterator和 listIterator操作都以固定时间运行。
12、add操作以分摊的固定时间运行，也就是说，添加 n个元素需要 O(n)时间。
13、其他所有操作都以线性时间运行（大体上讲）。
14、与用于 LinkedList实现的常数因子相比，此实现的常数因子较低。
15、每个 ArrayList实例都有一个容量。该容量是指用来存储列表元素的数组的大小。
16、它总是至少等于列表的大小。随着向 ArrayList中不断添加元素，其容量也自动增长。
17、并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单
18、在添加大量元素前，应用程序可以使用
19、 ensureCapacity操作来增加 ArrayList
20、实例的容量。这可以减少递增式再分配的数量。
21、注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList
22、实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。
23、（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）
24、这一般通过对自然封装该列表的对象进行同步操作来完成。
25、如果不存在这样的对象，则应该使用 Collections.synchronizedList方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：
26、List list= Collections.synchronizedList(new ArrayList(...));
27、此类的 iterator和 listIterator方法返回的迭代器是快速失败的。
28、在创建迭代器之后，除非通过迭代器自身的
29、 remove方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出
30、ConcurrentModificationException。
31、因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。
32、注意，迭代器的快速失败行为无法得到保证。
33、因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出
34、ConcurrentModificationException。
35、因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测
36、参考资料：百度百科------ arraylist
三、ArrayList和LinkedList的区别
ArrayList和LinkedList的大致区别如下:
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
LinkedList链表由一系列表项连接而成。一个表项总是包含3个部分：元素内容，前驱表和后驱表，如图所示：
在下图展示了一个包含3个元素的LinkedList的各个表项间的连接关系。在JDK的实现中，无论LikedList是否为空，链表内部都有一个header表项，它既表示链表的开始，也表示链表的结尾。表项header的后驱表项便是链表中第一个元素，表项header的前驱表项便是链表中最后一个元素。
ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵活的设置数组的大小等好处。
List接口的大小可变数组的实现，位于API文档的java.util.ArrayList<E>。实现了所有可选列表操作，并允许包括 null在内的所有元素。除了实现 List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。
每个 ArrayList实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。
参考资料：百度百科-ArrayList词条
四、arraylist 和 linkedlist 的区别
ArrayList是一个动态数组，也是我们最常用的集合。
它允许任何符合规则的元素插入甚至包括null。
每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。
随着容器中的元素不断增加，容器的大小也会随着增加。
在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作。
所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。
size、isEmpty、get、set、iterator和 listIterator操作都以固定时间运行。
add操作以分摊的固定时间运行，也就是说，添加 n个元素需要 O(n)时间（由于要考虑到扩容，所以这不只是添加元素会带来分摊固定时间开销那样简单）。
同样实现List接口的LinkedList与ArrayList不同，ArrayList是一个动态数组，而LinkedList是一个双向链表。
所以它除了有ArrayList的基本操作方法外还额外提供了get，remove，insert方法在LinkedList的首部或尾部。
由于实现的方式不同，LinkedList不能随机访问，它所有的操作都是要按照双重链表的需要执行。
在列表中索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。
这样做的好处就是可以通过较低的代价在List中进行插入和删除操作。
与ArrayList一样，LinkedList也是非同步的。
如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
= Collections.synchronizedList(new LinkedList(...));
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList.
因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。
arraylist初始容量和扩容和arraylist自动扩容的问题分享结束啦，以上的文章解决了您的问题吗？欢迎您下次再来哦！
