arraylist方法,Java中ArrayList的构造方法说明

arraylist方法,Java中ArrayList的构造方法说明详细介绍

本文目录一览： ArrayList用法

ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵活的设置数组的大小等好处。
List 接口的大小可变数组的实现，位于API文档的java.util.ArrayList

。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。

简单讲几个常用的用法，其它的用法最好还是查阅api

1。ArrayList实现List接口，

可以这样实例化：List list=new ArrayList();

2。list.add(obj);可以在list的最后插入一个实例，obj可以是任意类型的实例；

3。list.get(index);可以获得list中下标为index的元素，例如list.get(0);就是获得第一个，这样也可以遍历list，list.size()返回list的大小；

4。也可以用迭代器遍历：list.iterator();获得迭代器；

存的时候

ArrayList al = new ArrayList();

User user = new User();

user.setname("张三");

user.setage(21);

user.setsex("男");

User user1 = new User();

user1.setname("李四");

user1.setage(31);

user1.setsex("男");

al.add(user);

al.add(user1);

取出来的时候可以用一个迭代器Iterator拿出来,OK,到此结束

List list = Collections.synchronizedList(new ArrayList(...));

补充个同步的

ArrayList用法：

ArrayList是接口List的实现类，所以推荐以List接口来使用。

1、创建ArrayList的List接口

例：

List books = new ArrayList();

Java支持泛形后，创建的同时可以指定元素的类型。

例：

Class Book {

......

}

List

books = new ArrayList

();

为避免容器自动扩容的次数而影响性能，可以指定创建时的元素大小。

例：

// 创建可容纳100个Book对象的ArrayList，超过100个将自动扩容

List

books = new ArrayList

(100);

2、添加元素

添加在末尾

例：

Book book1 = new Book();

Book book2 = new Book();

Book book3 = new Book();

books.add(book1);

books.add(book2);

books.add(book3);

添加在指定索引处

例：

// 虽然加book1后直接加book3了，但book2是被加在索引1的地方

// 所以效果同上，是book1、book2、book3的顺序

books.add(book1);

books.add(book3);

books.add(1, book2);

3、 获取ArrayList中元素的个数

例：

int count = books.size();

4、读取元素

利用普通的for循环：

例：

for (int i = 0; i < books.size(); i++ {

Book newBook = books.get(i);

// 不带泛形的注意要转型

Book book = (Book) books.get(i);

System.out.println(book.getName());

}

利用for循环的新特性：

例：

for (Book book : books) {

// 用book就能访问了

System.out.println(book.getName());

}

利用枚举：

例：

Iterator

iter = books.iterator();

while (iter.hasNext()) {

Book book = iter.next();

System.out.println(book.getName());

}

5、移除元素

移除指定索引处的元素

例：

books.remove(0); // 移除book1

books.remove(1); // 移除book2

books.remove(2); // 移除book3

移除指定对象的所在元素

例：

Book delBook = books.get(1);

books.remove(delBook); // 移除book2

移除所有元素

例：

books.clear();

6、判断ArrayList是否为空（没有元素）

原方法：

if (books.isEmpty()) {

}

直接判断大小：

if (books.size() == 0) {

}

7、判断ArrayList中是否已经存在了某对象

例：

// 判断是否已经存在book2对象

if (books.contains(book2)) { // 已经存在

}

8、根据对象反查询它的索引位置

从前住后查询，反回第一个符合条件的位置

例：

list.indexOf(book2); // 查询book2对象的索引位置

从后住前查询，反回第一个符合条件的位置

例：

list.lastIndexOf(book2); // 查询book2对象的索引位置

以上这些掌握后，基本就没问题了。

java中Arraylist是干什么的？怎么用？

1.ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：动态的增加和减少元素，实现了ICollection和IList接口，灵活的设置数组的大小。
2.如何用ArrayList
最简单的例子：
ArrayList List = new ArrayList()；
for( int i=0;i<10;i++ ) //给数组增加10个Int元素
List.Add(i);
//..程序做一些处理
List.RemoveAt(5);//将第6个元素移除
for( int i=0;i<3;i++ ) //再增加3个元素
List.Add(i+20);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组
这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法。
扩展资料
ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵活的设置数组的大小等好处。
List 接口的大小可变数组的实现，位于API文档的java.util.ArrayList

。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

参考资料

百度百科-Arraylist

1、什么是ArrayList

ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：

动态的增加和减少元素

实现了ICollection和IList接口

灵活的设置数组的大小

2、如何使用ArrayList

最简单的例子：

ArrayList List = new ArrayList();

for( int i=0;i<10;i++ ) //给数组增加10个Int元素

List.Add(i);

//..程序做一些处理

List.RemoveAt(5);//将第6个元素移除

for( int i=0;i<3;i++ ) //再增加3个元素

List.Add(i+20);

Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组

这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法

3、ArrayList重要的方法和属性

1）构造器

ArrayList提供了三个构造器：

public ArrayList();

默认的构造器，将会以默认（16）的大小来初始化内部的数组

public ArrayList(ICollection);

用一个ICollection对象来构造，并将该集合的元素添加到ArrayList

public ArrayList(int);

用指定的大小来初始化内部的数组

2）IsSynchronized属性和ArrayList.Synchronized方法

IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。

如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：

ArrayList list = new ArrayList();

//...

lock( list.SyncRoot ) //当ArrayList为非线程包装的时候，SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，这里还是使用SyncRoot来保持源代码的规范性

{

list.Add( “Add a Item” );

}

如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用了lock关键字来保证线程同步。

3）Count属性和Capacity属性

Count属性是目前ArrayList包含的元素的数量，这个属性是只读的。

Capacity属性是目前ArrayList能够包含的最大数量，可以手动的设置这个属性，但是当设置为小于Count值的时候会引发一个异常。

4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange

这几个方法比较类似

Add方法用于添加一个元素到当前列表的末尾

AddRange方法用于添加一批元素到当前列表的末尾

Remove方法用于删除一个元素，通过元素本身的引用来删除

RemoveAt方法用于删除一个元素，通过索引值来删除

RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除

Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动

InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动

另外，还有几个类似的方法：

Clear方法用于清除现有所有的元素

Contains方法用来查找某个对象在不在列表之中

其他的我就不一一累赘了，大家可以查看MSDN，上面讲的更仔细

5）TrimSize方法

这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。

6）ToArray方法

这个方法把ArrayList的元素Copy到一个新的数组中。

4、ArrayList与数组转换

例1：

ArrayList List = new ArrayList();

List.Add(1);

List.Add(2);

List.Add(3);

Int32[] values = (Int32[])List.ToArray(typeof(Int32));

例2：

ArrayList List = new ArrayList();

List.Add(1);

List.Add(2);

List.Add(3);

Int32[] values = new Int32[List.Count];

List.CopyTo(values);

上面介绍了两种从ArrayList转换到数组的方法

例3：

ArrayList List = new ArrayList();

List.Add( “string” );

List.Add( 1 );

//往数组中添加不同类型的元素

object[] values = List.ToArray(typeof(object)); //正确

string[] values = (string[])List.ToArray(typeof(string)); //错误

和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。

5、ArrayList最佳使用建议

这一节我们来讨论ArrayList与数组的差别，以及ArrayList的效率问题

1）ArrayList是Array的复杂版本

ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。

2）内部的Object类型的影响

对于一般的引用类型来说，这部分的影响不是很大，但是对于值类型来说，往ArrayList里面添加和修改元素，都会引起装箱和拆箱的操作，频繁的操作可能会影响一部分效率。

但是恰恰对于大多数人，多数的应用都是使用值类型的数组。

消除这个影响是没有办法的，除非你不用它，否则就要承担一部分的效率损失，不过这部分的损失不会很大。

3）数组扩容

这是对ArrayList效率影响比较大的一个因素。

每当执行Add、AddRange、Insert、InsertRange等添加元素的方法，都会检查内部数组的容量是否不够了，如果是，它就会以当前容量的两倍来重新构建一个数组，将旧元素Copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。

例1：比如，一个可能有200个元素的数据动态添加到一个以默认16个元素大小创建的ArrayList中，将会经过：

16*2*2*2*2 = 256

四次的扩容才会满足最终的要求，那么如果一开始就以：

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 al=new ArrayList();

al.Add("How");

al.Add("are");

al.Add("you!");

al.Add(100);

al.Add(200);

al.Add(300);

al.Add(1.2);

al.Add(22.8);

.........

//第一种遍历 ArrayList 对象的方法

foreach(object o in al)

{

Console.Write(o.ToString()+" ");

}

//第二种遍历 ArrayList 对象的方法

IEnumerator ie=al.GetEnumerator();

while(ie.MoveNext())

{

Console.Write(ie.Curret.ToString()+" ");

}

//第三种遍历 ArrayList 对象的方法

我忘记了,好象是 利用 ArrayList对象的一个属性,它返回一此对象中的元素个数.

然后在利用索引

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

Console.Write(al[i].ToString()+" ");

}

1、什么是ArrayList

ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：

动态的增加和减少元素

实现了ICollection和IList接口

灵活的设置数组的大小

2、如何使用ArrayList

最简单的例子：

ArrayList List = new ArrayList();

for( int i=0;i<10;i++ ) //给数组增加10个Int元素

List.Add(i);

//..程序做一些处理

List.RemoveAt(5);//将第6个元素移除

for( int i=0;i<3;i++ ) //再增加3个元素

List.Add(i+20);

Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组

这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法

3、ArrayList重要的方法和属性

1）构造器

ArrayList提供了三个构造器：

public ArrayList();

默认的构造器，将会以默认（16）的大小来初始化内部的数组

public ArrayList(ICollection);

用一个ICollection对象来构造，并将该集合的元素添加到ArrayList

public ArrayList(int);

用指定的大小来初始化内部的数组

2）IsSynchronized属性和ArrayList.Synchronized方法

IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。

如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：

ArrayList list = new ArrayList();

//...

lock( list.SyncRoot ) //当ArrayList为非线程包装的时候，SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，这里还是使用SyncRoot来保持源代码的规范性

{

list.Add( “Add a Item” );

}

如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用了lock关键字来保证线程同步。

3）Count属性和Capacity属性

Count属性是目前ArrayList包含的元素的数量，这个属性是只读的。

Capacity属性是目前ArrayList能够包含的最大数量，可以手动的设置这个属性，但是当设置为小于Count值的时候会引发一个异常。

4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange

这几个方法比较类似

Add方法用于添加一个元素到当前列表的末尾

AddRange方法用于添加一批元素到当前列表的末尾

Remove方法用于删除一个元素，通过元素本身的引用来删除

RemoveAt方法用于删除一个元素，通过索引值来删除

RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除

Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动

InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动

另外，还有几个类似的方法：

Clear方法用于清除现有所有的元素

Contains方法用来查找某个对象在不在列表之中

其他的我就不一一累赘了，大家可以查看MSDN，上面讲的更仔细

5）TrimSize方法

这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。

6）ToArray方法

这个方法把ArrayList的元素Copy到一个新的数组中。

4、ArrayList与数组转换

例1：

ArrayList List = new ArrayList();

List.Add(1);

List.Add(2);

List.Add(3);

Int32[] values = (Int32[])List.ToArray(typeof(Int32));

例2：

ArrayList List = new ArrayList();

List.Add(1);

List.Add(2);

List.Add(3);

Int32[] values = new Int32[List.Count];

List.CopyTo(values);

上面介绍了两种从ArrayList转换到数组的方法

例3：

ArrayList List = new ArrayList();

List.Add( “string” );

List.Add( 1 );

//往数组中添加不同类型的元素

object[] values = List.ToArray(typeof(object)); //正确

string[] values = (string[])List.ToArray(typeof(string)); //错误

和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。

5、ArrayList最佳使用建议

这一节我们来讨论ArrayList与数组的差别，以及ArrayList的效率问题

1）ArrayList是Array的复杂版本

ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。

2）内部的Object类型的影响

对于一般的引用类型来说，这部分的影响不是很大，但是对于值类型来说，往ArrayList里面添加和修改元素，都会引起装箱和拆箱的操作，频繁的操作可能会影响一部分效率。

但是恰恰对于大多数人，多数的应用都是使用值类型的数组。

消除这个影响是没有办法的，除非你不用它，否则就要承担一部分的效率损失，不过这部分的损失不会很大。

3）数组扩容

这是对ArrayList效率影响比较大的一个因素。

每当执行Add、AddRange、Insert、InsertRange等添加元素的方法，都会检查内部数组的容量是否不够了，如果是，它就会以当前容量的两倍来重新构建一个数组，将旧元素Copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。

例1：比如，一个可能有200个元素的数据动态添加到一个以默认16个元素大小创建的ArrayList中，将会经过：

16*2*2*2*2 = 256

四次的扩容才会满足最终的要求，那么如果一开始就以：

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 al=new ArrayList();

al.Add("How");

al.Add("are");

al.Add("you!");

al.Add(100);

al.Add(200);

al.Add(300);

al.Add(1.2);

al.Add(22.8);

.........

//第一种遍历 ArrayList 对象的方法

foreach(object o in al)

{

Console.Write(o.ToString()+" ");

}

//第二种遍历 ArrayList 对象的方法

IEnumerator ie=al.GetEnumerator();

while(ie.MoveNext())

{

Console.Write(ie.Curret.ToString()+" ");

}

//第三种遍历 ArrayList 对象的方法

我忘记了,好象是 利用 ArrayList对象的一个属性,它返回一此对象中的元素个数.

然后在利用索引

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

Console.Write(al[i].ToString()+" ");

}

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。） size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。 每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单 在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问： List list = Collections.synchronizedList(new ArrayList(...)); 此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。 注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。

编辑本段常用的方法

boolean add(E e) 将指定的元素添加到此列表的尾部。 void add(int index, E element) 将指定的元素插入此列表中的指定位置。 boolean addAll(Collection
c) 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。 boolean addAll(int index, Collection
c) 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。

1、ArrayList就是动态数组可以把它当做是Array的复杂版本，它提供了如下一些好处： 动态的增加和减少元素 ；实现了ICollection和IList接口 ；灵活的设置数组的大小。

2、使用ArrayList 的例子：ArrayList List = new ArrayList(); for( int i=0;i <10;i++ ) //给数组增加10个Int元素 List.Add(i); //..程序做一些处理 List.RemoveAt(5);//将第6个元素移除 for( int i=0;i <3;i++ ) //再增加3个元素 List.Add(i+20); Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组3、ArrayList 的重要方法和属性：1）构造器 ArrayList提供了三个构造器：

public ArrayList();默认的构造器，将会以默认（16）的大小来初始化内部的数组

public ArrayList(ICollection);用一个ICollection对象来构造，并将该集合的元素添加到ArrayList

public ArrayList(int);用指定的大小来初始化内部的数组

2）常用方法

add方法用于添加一个元素到当前列表的末尾 ;

addRange方法用于添加一批元素到当前列表的末尾 ;

remove方法用于删除一个元素，通过元素本身的引用来删除 ;

removeAt方法用于删除一个元素，通过索引值来删除 ;

removeRange用于删除一批元素，通过指定开始的索引和删除的数量来删除 ;

insert用于添加一个元素到指定位置，列表后面的元素依次往后移动 ;

insertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动;

另外，还有几个类似的方法：

clear方法用于清除现有所有的元素;

contains方法用来查找某个对象在不在列表之中;

3）TrimSize方法

这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。

4）ToArray方法

这个方法把ArrayList的元素Copy到一个新的数组中。

java中的ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本。

它提供了如下一些好处：动态的增加和减少元素实现了ICollection和IList接口灵活的设置数组的大小 。

ArrayList 的用法：

ArrayList List = new ArrayList(); for( int i=0;i<10;i++ ) //

给数组增加10个Int元素 List.Add(i); //..

程序做一些处理 List.RemoveAt(5);//

将第6个元素移除 for( int i=0;i<3;i++ ) //

再增加3个元素 List.Add(i+20); Int32[] values = (Int32[])List.ToArray(typeof(Int32));//

返回ArrayList包含的数组 。

扩展资料：

Arraylist的定义：

List 接口的大小可变数组的实现，位于API文档的java.util.ArrayList

。

实现了所有可选列表操作，并允许包括 null 在内的所有元素。

除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。

add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。

其他所有操作都以线性时间运行（大体上讲）。

与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。

它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。

并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单

在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。

（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）

这一般通过对自然封装该列表的对象进行同步操作来完成。

如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

List list = Collections.synchronizedList(new ArrayList(...));

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的。

在创建迭代器之后，除非通过迭代器自身的 remove 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。

因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证。

因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。

因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。

参考资料：百度百科 ------ arraylist

</count;i++)
</count;i++)

arraylist添加元素的方法

* 添加元素
* public boolean add(E e)将指定的元素添加到此列表的尾部。
* public void add(int index,
E element)将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。
*
*/public class ArrayListDemo {
public static void main(String[] args) {
//创建集合对象
ArrayList

array=new ArrayList

();

//public boolean add(E e)将指定的元素添加到此列表的尾部

array.add("hello");

array.add("world");

array.add("money");

// public void add(int index,E element)将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。

array.add(1,"app");

System.out.println("array:"+array);

}

}

ArrayList中的toArray方法

1. toArray();

List test = new ArrayList<>();

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

test?.add(i);

}

Integer[] res = (Integer[]) test?.toArray();

因为返回的是Object类型数组，所以此处会报错 [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer。

若想转为Integer数组，则可以用以下方式：

Object[] testArrays = test.toArray();

Integer[] res =new Integer[test.length];

for (int i =0; i < test.length; i++) {

res[i] = (Integer) test[i];

}

此时就不如使用ArrayList中的toArray(T[]? a)方法（后面总结）。

?toArray()方法源码：

public Object[] toArray() {

return Arrays.copyOf(elementData, size);

}

2. toArray(T[]? a);

1）

Integer[] integers =new Integer[5];

Integer[] res = test?.toArray(integers);

因为此时传入的数组长度小于 ArrayList 的长度，所以将会直接返回复制 ArrayList元素的 一个Integer类型数组，不对传入的integers数组操作。

2）

Integer[] integers =new Integer[10];

Integer[] res = test?.toArray(integers);

当数组长度大于等于 ArrayList 的长度时，会将ArrayList的中元素值复制到integers数组中，最终返回的是先前传入的integers数组。

T[]toArray(T[] a)的源码如下：

public T[] toArray(T[] a) {

if (a.length < size)

// Make a new array of a's runtime type, but my contents:

? ? ? ? return (T[]) Arrays.copyOf(elementData, size, a.getClass());

? ? System.arraycopy(elementData, 0, a, 0, size);

? ? if (a.length >size)

a[size] =null;

? ? return a;

}

java arraylist用法

ArrayList al = new ArrayList();
al.set(1,Object); //在第一个，第二个间插入,Object为你要加的内容
al.remove(1); //在第一个与第三个之间把第二个删了（第三个代替第二个的位置，arraylist的长度减少一）
al.removeRange(1,2);//在第一个与第三个之间把第二个删了（第三个代替第二个的位置,arraylist的长度减少1 1,2可以换成你想要的任何数据 比如:1,3就是把第二个和第三个删除 ,arraylist的长度减少2
上面的说的差不多了 我补充几点
1.注意长度 如果你在创建集合时就初始化长度 那么该集合的长度就是这样（如果元素数超过长度 那么长度就跟元素数一样） 简单的说 就是即使集合里什么都没有 长度也是你初始化的长度
2.注意长度 集合可以随时更改长度 如果你的集合里已经有了元素 假设为五个 而你这时将长度更改为三 那么 就会丢失元素
-----------构造方法摘要
ArrayList()
构造一个初始容量为 10 的空列表。
ArrayList(Collection
c)
构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
ArrayList(int initialCapacity)
构造一个具有指定初始容量的空列表。
-----------set()不是构造方法
set(int index, E element)
用指定的元素替代此列表中指定位置上的元素。
--顺便问下如果第二个删了，第三个会不会代替第二个的位置，arraylist的长度会不会减少？
-----------会的
removeRange(int fromIndex, int toIndex)
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
示例代码如下：
import java.util.ArrayList;
public class Temp {
public static void main(String[] args){
ArrayList al = new ArrayList(11);
for(int i=0;i<10;i++){
al.add("string"+(i+1));
}
printList(al);
System.out.println("//insert one element");
//1为你指定的位置
al.add(1,"stringinsert");
printList(al);
System.out.println("//remove one element");
al.remove(1);
printList(al);
}
public static void printList(ArrayList al){//输出ArrayList的方法
System.out.print("current list:|");
for(int i=0;i
<al.size();i++){
System.out.print(al.get(i)+" ");

}

System.out.println("|");

}

}
</al.size();i++){

java ArrayList的用法

public class Person { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Person() { super(); // TODO Auto-generated constructor stub } public Person(String name, int age) { super(); this.name = name; this.age = age; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } }package www.liliang.com;import java.util.ArrayList;import java.util.Iterator;public class ArraylistDemo { public static void main(String[] args) { // 创建ArrayList集合对象 ArrayList arrayList = new ArrayList(); // 添加person类型的对象 Person person1 = new Person("liliang", 29); Person person2 = new Person("lisi", 31); arrayList.add(person1); arrayList.add(person2); arrayList.add(new Person("lijian", 28)); // 取出元素 for (Iterator iterator = arrayList.iterator(); iterator.hasNext();) { // Object object = (Object) iterator.next();这里要注意，取出的都是object类型 Person person = (Person) iterator.next();// 这里需要向下转型为person类，不能是object. System.out.println(person.getName() + "" + person.getAge()); } }}
-----------构造方法摘要 ArrayList() 构造一个初始容量为 10 的空列表。 ArrayList(Collection
c) 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。 ArrayList(int initialCapacity) 构造一个具有指定初始容量的空列表。 -----------set()不是构造方法set(int index, E element) 用指定的元素替代此列表中指定位置上的元素。--顺便问下如果第二个删了，第三个会不会代替第二个的位置，arraylist的长度会不会减少？-----------会的removeRange(int fromIndex, int toIndex) 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。示例代码如下：
import java.util.ArrayList;public class Temp { public static void main(String[] args){ ArrayList al = new ArrayList(11); for(int i=0;i<10;i++){ al.add("string"+(i+1)); } printList(al); System.out.println("//insert one element"); //1为你指定的位置 al.add(1,"stringinsert"); printList(al); System.out.println("//remove one element"); al.remove(1); printList(al); } public static void printList(ArrayList al){//输出ArrayList的方法 System.out.print("current list:|"); for(int i=0;i
<al.size();i++){ system.out.print(al.get(i)+" "); } system.out.println("|"); }}
1.添加元素 add(E e) 将指定的元素添加到此列表的尾部

2.遍历这个ArrayList 两种方法：

1. ArrayList arrayList=new ArrayList();

Iterator it=arrayList.iterator();

while(it.hasNext()){

it.next();

// .........

}

2. for(int i=0;i
<arraylist.size();i++){
arrayList.get(i);

// .........

}

3.移除元素 remove(int index)移除此列表中指定位置上的元素。

4.Hashmap是一个Map接口的具体实现，可以支持键值的映射

ArrayList是一个List接口的具体实现，只是一个链表

针对你的4个问题进行回答（我也是初学，仅供参考）

1.ArrayList 继承于 List //主要作用于添加，删除，修改（个人理解）,所以第一个，肯定OK。。

2.List中还有一个叫LinkedList的，如果我们要访问的话，就用ArrayList，因为数据大的话，用ArrayList访问起来，速度较快。

3.正如我前面所说List中还有一个叫LinkedList，它就是用来移除或增加元素的，很明显，它增删速度要快些，

4.HaspMap继承与Map ...

我的总结是：ArrayList 读快改慢， LinkedList 读慢改快

HashMap，呵呵，自己看看吧。

import java.util.ArrayList;

import java.util.Iterator;

public class Demo {

public static void main(String[] args){

ArrayList list = new ArrayList();

list.add("a");

list.add("b");

list.add("c");

System.out.println("list中添加了a,b,c三个元素");

Iterator it = list.iterator();

System.out.print("遍历list得到的结果：");

while(it.hasNext()){

System.out.print(it.next() + ",");

}

System.out.println();

list.clear();

System.out.println("已经移除了list中的所有元素");

}

}

ArrayList类：

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

Map接口：

请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

在Java中ArrayList用什么方法添加数据？

List list = new ArrayList();
list.add();
add方法的参数是Object。所以只要是java中的对象你都可以添加。
/**
*
*/
/**
* @author qingsongwang
*
*/
import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo
{
public static void main( String[] args )
{

ArrayList arrayList = new ArrayList();

arrayList.add( new Integer( 1 ) );
arrayList.add( new Integer( 2 ) );
arrayList.add( new Integer( 3 ) );
arrayList.add( new Integer( 4 ) );
arrayList.add( new Integer( 5 ) );
arrayList.add( new Integer( 6 ) );
arrayList.add( new Integer( 7 ) );
arrayList.add( new Integer( 8 ) );
arrayList.add( new Integer( 9 ) );
arrayList.add( new Integer( 10 ) );

for( int i=0; i
<arraylist.size(); i++ )
{

System.out.println( i + " = " + arrayList.get( i ) +"\t" );

}

arrayList.remove( 5 );

arrayList.set( 5, new Integer( 28 ) );

arrayList.add(new Integer(11));

for( Iterator i=arrayList.iterator(); i.hasNext(); )

{

Integer integer = ( Integer )i.next();

System.out.println( integer +"\t");

}

}

}

ArrayList list = new ArrayList();

list.add(obj);

//obj 就是要存储的对象。

//取得时候用 list.get（xx）；

//XX就是你要取的对象名或是排列位置。出来要记得强转。

Java中ArrayList的构造方法说明

java泛型你知道不？用两行简单的代码给你解释一下吧！
ArrayList

list = new ArrayList

();

list.add("hello");

String str = list.get(0);//这里不需要强制类型转换了

这个list里面保存的全数据全都是String类的对象，同时，在取出数据的时候，无需强制类型转换。

另外说明一下，泛弄是JDK1.5以后才有的属性。

在import java.util.ArrayList; 之后，然后 ArrayList

名字 = new ArrayList

;（两种类型必须一致）

例： ArrayList

list = new ArrayList

();

然后可以添加元素 list.add(0,数字); //记住，index 从0开始

Java中ArrayList的构造方法

public ArrayList(Collection
c)

API的意思是“构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

参数： c 其元素将放置在此列表中的 collection ”

比如：

ArrayList

list = new ArrayList

();

list.add("hello");

String str = list.get(0);//这里不需要强制类型转换了

这个list里面保存的全数据全都是String类的对象，同时，在取出数据的时候，无需强制类型转换。

java arraylist用法

这样应该差不多了.
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Test {
public static void main(String[] args) {
List list = new ArrayList();
for(int i=0; i<5; i++) {
list.add("key"+i);
list.add("value"+i);
}
Map map = new HashMap();
if(list.size()%2==1) {
throw new IllegalArgumentException("错误：list长度为奇数。");
}
for(int i=0; i
<list.size(); i+="2)" {
map.put(list.get(i), list.get(i+1));

}

System.out.println(map);

}

}

for(int i = 0; i < ArrayList.size(); i += 2) {

map.add(ArrayList.get(i), ArrayList.get(i + 1));

}

具体方法我忘了,这是大概,应该可以看明白吧.

Map本来就是键值对的..

"建后的Map用奇数项作为键,偶数项作为值，如{a,1,b,2}"这句话没有意义.而且这种东西创建不出来..Map中每一值必须对应一键..

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

public class TestMain {

public static void main(String[] args){

List list1 = new ArrayList();

list1.add("a");

list1.add("1");

list1.add("b");

list1.add("2");

list1.add("c");

list1.add("3");

list1.add("d");

//list1.add("4");

Map map1 = genMap(list1);

Iterator it = map1.keySet().iterator();

while(it.hasNext()){

String key = it.next().toString();

String value = map1.get(key).toString();

System.out.println("key :" + key + " ; value = " + value);

}

}

public static Map genMap(List list1){

if(list1.size() % 2 == 1){

throw new IllegalArgumentException("错误：list长度为奇数。");

}

Map map1 = new HashMap();

for(int i=0;i
<list1.size();){
map1.put(list1.get(i), list1.get(i+1));

i += 2;

}

return map1;

}

}

注：

代码中注释掉的这一句：

//list1.add("4");

注释掉，则list1的元素个数为单数，

打开，则list1的元素个数为双数。

请分别测试。
</list1.size();){