列表List
-有序的Collection
-允许重复元素
-{1, 2, 4, {5, 2}, 1, 3}
List主要实现
-ArrayList(非同步的)
-LinkedList(非同步)
-Vector(同步)
ArrayList
-以数组实现的列表,不支持同步
-利用索引位置可以快速定位访问
-不适合指定位置的插入、删除操作
-适合变动不大,主要用于查询的数据
-和Java数组相比,其容量是可动态调整的
-ArrayList在元素填满容器时会自动扩充容器大小的50%
ArrayList只能装对象
创建
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest {
public static void main(String[] a) {
ArrayList<Integer> al = new ArrayList<Integer>(); //<Integer>表示泛型,说明al这个ArrayList里只能存放Integer这个类型的数据
al.add(3);
//自动将普通的int变量3自动装箱为Integer(3)的对象,然后放入al里
al.add(2);
al.add(1);
al.add(4);
al.add(5);
al.add(6);
al.add(new Integer(6));
System.out.print("The third element is ");
System.out.println(al.get(3));//获得第四个元素
al.remove(3); //删除第四个元素,后面元素往前挪动
al.add(3, 9); //将9插入到第4个元素,后面元素往后挪动
输出
The third element is 4
遍历方法
创建ArrayList
ArrayList<Integer> as = new ArrayList<Integer>(100000);//创建了包含100000个数据的ArrayList
for (int i=0; i<100000; i++)
{
as.add(i);
}
traverseByIterator(as); //iteration遍历,如下
traverseByIndex(as); //索引位置遍历,如下
traverseByFor(as); //for-each遍历,如下
}
iteration遍历
public static void traverseByIterator(ArrayList<Integer> al)
{
Iterator<Integer> iter1 = al.iterator();
while(iter1.hasNext())
{
iter1.next();
}
}
索引位置遍历
public static void traverseByIndex(ArrayList<Integer> al)
{
for(int i=0;i<al.size();i++)
{
al.get(i);
}
}
for循环遍历
public static void traverseByFor(ArrayList<Integer> al)
{
for(Integer item : al)
{
; //任意语句
}
}
迭代器的速度最慢,索引方法和for方法速度接近
LinkedList
-以双向链表实现的列表,不支持同步
-可被当作堆栈、队列和双端队列进行操作
-顺序访问高效,随机访问较差,中间插入和删除高效
-适用于经常变化的数据
创建
import java.util.Iterator;
import java.util.LinkedList;
public class LinkedListTest {
public static void main(String[] args) {
LinkedList<Integer> ll = new LinkedList<Integer>();
ll.add(3);
ll.add(2);
ll.add(5);
ll.add(6);
ll.add(6);
System.out.println(ll.size()); //输出5
ll.addFirst(9); //在头部增加9
ll.add(3, 10); //将10插入到第四个元素,四以及后续的元素往后挪动
ll.remove(3); //将第四个元素删除
遍历方法
创建LinkedList
LinkedList<Integer> list = new LinkedList<Integer>();
for (int i=0; i<100000; i++)
{
list.add(i);
}
traverseByIterator(list); //iteration遍历,如下
traverseByIndex(list); //索引位置遍历,如下
traverseByFor(list); //for-each遍历,如下
}
iteration遍历
public static void traverseByIterator(LinkedList<Integer> list)
{
Iterator<Integer> iter1 = list.iterator();
while(iter1.hasNext())
{
iter1.next();
}
}
索引位置遍历
public static void traverseByIndex(LinkedList<Integer> list)
{
for(int i=0;i<list.size();i++)
{
list.get(i);
}
}
for循环遍历
public static void traverseByFor(LinkedList<Integer> list)
{
for(Integer item : list)
{
; //任何语句
}
}
for循环遍历比迭代器快一点点,索引遍历最慢
ArrayList适用于较多查询的静态数据,而LinkedList适用于频繁增删的数据
Vector
-和ArrayList类似,可变数组实现的列表
-Vectora,适合在多线程下使用
-官方文档建议在非同步情况下,优先采用ArrayList
创建
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
public class VectorTest {
public static void main(String[] args) {
Vector<Integer> v = new Vector<Integer>();
v.add(1);
v.add(2);
v.add(3);
v.remove(2);
v.add(1, 5);
System.out.println(v.size());
遍历方法
创建一个Vector
Vector<Integer> v2 = new Vector<Integer>(100000);
for (int i = 0; i < 100000; i++) {
v2.add(i);
}
traverseByIterator(v2);//itertor遍历
traverseByIndex(v2);//索引位置遍历
traverseByFor(v2);//for-each遍历
traverseByEnumeration(v2);//Enumeration遍历
}
iterator遍历
public static void traverseByIterator(Vector<Integer> v) {
Iterator<Integer> iter1 = v.iterator();
while (iter1.hasNext())
{
iter1.next();
}
}
索引位置遍历
public static void traverseByIndex(Vector<Integer> v) {
for (int i = 0; i < v.size(); i++)
{
v.get(i);
}
}
for循环遍历
public static void traverseByFor(Vector<Integer> v) {
for (Integer item : v)
{
; //任意语句
}
}
Enumeration遍历(老方法)
public static void traverseByEnumeration(Vector<Integer> v) {
for (Enumeration<Integer> enu = v.elements();enu.hasMoreElements();){
enu.nextElement();
}
}
for循环最快,其次是位置索引