Java集合类中的List类以及常用的子类

目录

ArrayList

LinkedList 

Vector 

---

List接口中常用类:

ArrayList

继承自Collection类，所以继承了其增删改查的特性。

使用前需导入包：

import java.util.*;

例1：迭代器的使用

class  CollectionDemo
{
  public static void main(String[] args)
  {
   //创建一个集合容器。使用Collection接口的子类。ArrayList
    ArrayList al=new ArrayList();
    //添加元素
    al.add("java01");
    al.add("java02");
    al.add("java03");
    //使用迭代器取出集合中的元素
    Iterator it=al.iterator();  //获取迭代器，用于取出集合中的元素
    while(it.hasNext())
    {
      System.out.println(it.next());
    }
    ArrayList al2=new ArrayList();
    al2.add("java03");
    al.retainAll(al2); //去交集，al中只会保留和al2中相同的元素
    System.out.println(al);
    /*
    //方法二迭代：
    for(Iterator it = al.iterator(); it.hasNext() ; )
    {
      System.out.println(it.next());
    }
    */
  }
}

例2：基本方法的使用

class  CollectionDemo
{
  public static void main(String[] args)
  {
    ArrayList al=new ArrayList();
    //添加元素
    al.add("java01");
    al.add("java02");
    al.add("java03");
    al.remove("java01");  //删除指定的元素
    //al.removeAll(al);   //删除所有的元素
    //int num=al.size(); //获取集合的长度
    System.out.println(al.contains("java02"));  //是否包含某元素
    System.out.println(al.isEmpty());   //判断是否为空
    //使用迭代器取出集合中的元素
    Iterator it=al.iterator();  //获取迭代器，用于取出集合中的元素
    while(it.hasNext())
    {
      System.out.println(it.next());
    }
  }
}

例3：去除ArrayList集合中的重复元素

class  CollectionDemo {
  public static void main(String[] args) {
    ArrayList al = new ArrayList();
    //添加元素
    al.add("java01");
    al.add("java02");
    al.add("java03");
    al.add("java02");
    al.add("java03");
    System.out.println(al); //打印原集合
    al=singleElement(al);   //去除重复元素
    System.out.println(al);  //打印新集合元素
  }

  public static ArrayList singleElement(ArrayList al)
  {
    ArrayList newAl = new ArrayList();  //定义一个临时容器
    Iterator it = al.iterator();
    while (it.hasNext())
    {
      Object obj=it.next();  //注意next()返回的是Object类对象
      if(!newAl.contains(obj))   //判断临时容器中是否有取出的元素
        newAl.add(obj);     //添加进临时容器中
    }
    return newAl;
  }
}

例4：

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。

 

class  CollectionDemo {
  public static void main(String[] args) {
    ArrayList al = new ArrayList();
    //添加Person 类对象
    al.add(new Person("Tom",20));
    al.add(new Person("Jack",23));
    al.add(new Person("Mike",22));
    al.add(new Person("Jim",23));
    al.add(new Person("Jack",23));
    System.out.println(al);
    al=singleElement(al);
    //使用迭代器输出集合中的元素
    Iterator it=al.iterator();
    while(it.hasNext())
    {
      Person p=(Person)it.next();
      System.out.println(p.getName()+"..."+p.getAge());
    }
  }

  public static ArrayList singleElement(ArrayList al)
  {
    ArrayList newAl = new ArrayList();  //定义一个临时容器
    Iterator it = al.iterator();
    while (it.hasNext())
    {
      Object obj=it.next();
      if(!newAl.contains(obj))   //判断临时容器中是否有取出的元素，同时调用Person类中复写的equals()方法
        newAl.add(obj);     //添加进临时容器中
    }
    return newAl;
  }
}
class Person
{
  private String name;
  private int age;
  Person(String name,int age)
  {
    this.name=name;
    this.age=age;
  }
  public String getName()
  {
    return name;
  }
  public int getAge()
  {
    return age;
  }
  //复写Object类中的equals方法，进行判断是否为同一个人
  //该方法是在调用singleElement方法中的contains()方法时才调用，用于判断元素是否相同
  public boolean equals(Object obj)
  {
    //判断次对象是否为Person类对象
    if(!(obj instanceof Person))
      return false;
    //向下转型
    Person p=(Person)obj;
    return this.name.equals(p.name) && this.age==p.age;
  }
}

 注意：List集合判断元素是否相同，依据是元素的equals方法。

同时也应注意删除元素的方法：remove方法底层也是依赖于元素的equals方法。

例5：在迭代器中删除元素

class  CollectionDemo {
  public static void main(String[] args) {
    ArrayList al = new ArrayList();
    //添加字符串
    al.add("tom");
    al.add("dd");
    al.add("jack");

    Iterator it=al.iterator();
    //在迭代器中删除元素
    while(it.hasNext())
    {
      Object obj=it.next();
      System.out.println(obj);
      if(obj.equals("dd"))
        it.remove();   //如果存在"dd"则删除该元素
    }
    System.out.println(al);
  }
}

LinkedList 

底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。

LinkedList:特有方法：

addFirst();
addLast();

getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException；

removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException；

在JDK1.6出现了替代方法。

offerFirst();
offerLast()；

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。

pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。

 

 例1：简单应用

class  CollectionDemo {
  public static void main(String[] args) {
    LinkedList link=new LinkedList();
    //对于添加的元素放到最后 可以用addLast也可以用offerLast
    link.addLast("java1");
    link.addLast("java2");
    link.offerLast("java3");
    link.offerLast("java4");

    System.out.println(link.getFirst());   //获取第一个元素，但不删除元素
    System.out.println(link.getLast());   //获取最后一个元素
    System.out.println(link);
    System.out.println(link.removeFirst());  //获取第一个元素，且第一个元素被删除
    System.out.println(link);
    
    while(!link.isEmpty())
    {
      System.out.println(link.pollLast());  //返回最后一个元素，并且删除该元素
    }
  }
}

例2：使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出  如同一个杯子。
队列：先进先出 First in First out  FIFO 如同一个水管。

class  CollectionDemo {
  public static void main(String[] args) {
    //模仿队列的先进先出，如果模仿堆栈则将myAdd方法中的addFirst换成addLast
    DuiLie dl=new DuiLie();
    dl.myAdd("java1");
    dl.myAdd("java2");
    dl.myAdd("java3");
    dl.myAdd("java4");

    while(!dl.isNull())
    {
      System.out.println(dl.myGet());  //返回最后一个元素，并且删除该元素
    }
  }
}
class DuiLie
{
  private LinkedList link;
  DuiLie()
  {
    link = new LinkedList();
  }

  public void myAdd(Object obj)
  {
    link.addFirst(obj);
  }
  public Object myGet()
  {
    return link.removeFirst();
  }
  public boolean isNull()
  {
    return link.isEmpty();
  }

}

Vector 

 Vector：底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。

例1：基本方法

 

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

    Vector vt=new Vector();
    vt.add("java1");
    vt.add("java2");
    Enumeration em=vt.elements();
    while(em.hasMoreElements())
    {
      System.out.println(em.nextElement());
    }

  }
}