对象用于封装特有数据,对象多了需要存储;如果对象的个数不确定,就使用集合容器进行存储。
1. 用于存储对象的容器。
2. 集合的长度是可变的。
3. 集合中不可以存储基本数据类型值。
集合容器因为内部的数据结构不同,有多种具体容器。不断的向上抽取,就形成了集合框架。
数组虽然也可以存储对象,但长度是固定的;集合长度是可变的。
数组中可以存储基本数据类型,集合只能存储对象。
` |--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快,但是增删稍慢,线程不同步。
|--LinkeList:底层使用的链表数据结构。特点:增删湿度很快,查询稍慢。
|--Vector:底层是数组数据结构。编程同步。被ArrayList替代了。
|--set:元素是无序的,不可以重复。
|--HashSet:底层数据结构是哈希表。
|--TreeSet : 底层是二叉树结构,可以对set集合中的元素进行排序,线程不同步;
如果元素的HashCode值不同,才会判断equals是否为true。
如果元素的hashCode值相同,不会调用equals。
注意,对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法。
boolean addAll(Collection coll);
2、删除:
boolean remove(Object obj);
boolean removeAll(Collection coll);
void clear();
3、判断:
boolean contains(Object obj);
boolean containsAll(Collection coll);
boolean isEmpty();判断集合中是否有元素。
4、获取:
int size();
Iterator iterator();
迭代器是取出集合中元素的一种方式,因为Collection中有iterator方法,所以每个子类集合对象都具备迭代器;
获取迭代器的方式:
Collection对象可以通过调用自身的iterator方法,返回一个迭代器,例:
Collection< Object o> al=new ArrayList< Object o>();
Iterator it=al.iterator();
迭代器的常用方法:
返回值类型 | 方法 | 功能描述 |
boolean | hasNext() | 如果仍有元素可以迭代返回true; |
E | next() | 返回迭代器的下一个元素; |
void | remove() | 从迭代器指向的集合中移除迭代器返回的最后一个元素; |
import java.util.*;
public class CollectionDemo{
public static void main(String[] args){
Collection coll = new ArrayList();
show(coll);
System.out.println( "---------------------------------" );
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
show(c1,c2);
}
public static void show(Collection coll){
//1、添加元素,add
coll.add( "abc1");
coll.add( "abc2");
coll.add( "abc3");
System.out.println( "coll:" + coll);
//2、删除元素,remove
coll.remove( "abc2");//会改变集合的长度
System.out.println( "coll:" + coll);
//清空集合
//coll.clear();
System.out.println(coll.contains( "abc1"));
}
public static void show(Collection c1,Collection c2){
//给c1添加元素
c1.add( "abc1");
c1.add( "abc2");
c1.add( "abc3");
c1.add( "abc4");
//给c2添加元素
c2.add( "abc2");
c2.add( "abc6");
c2.add( "abc7");
System.out.println( "c1:" + c1);
System.out.println( "c2:" + c2);
//演示addAll
//将c2中的元素添加到c1中
c1.addAll(c2);
//演示removeAll
//从c1集合中删除与c2集合相同的元素
boolean b = c1.removeAll(c2);
System.out.println( "removeAll:" + b);
//演示containsAll
boolean b1 = c1.containsAll(c2);
System.out.println( "containsAll:" + b1);
//演示retainAll
//取交集,保留和指定的集合相同的元素
boolean b2 = c1.retainAll(c2);
System.out.println( "c1、c2交集:" + c1);
}
}
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();
List集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificationException异常。
所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。
该接口只能通过List集合的ListIterator方法获取。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo{
public static void main(String[] args){
List list = new ArrayList();
show(list);
}
public static void show(List list){
list.add( "abc1");
list.add( "abc2");
list.add( "abc3");
list.add( "abc4");
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println( "next:" + it.next());
}
//list 特有的取出元素的方式之一
for(int x = 0; x < list.size(); x++){
System.out.println( "get:" + list.get(x));
}
}
}
ArrayList
概述:底层数据结构使用的是数组,查询速度快,增删慢;线程不安全。
创建一个ArrayList集合对象:
ArrayList al=new ArrayList();
al.add(“java01”);//向集合中添加元素;
Iterator it=al.iterator();//返回一个迭代器;
ArrayList集合是Collection集合框架下的子类,即可使用其自身的特有方法也可使用父类接口中的共性方法;
ArrayList集合可使用特殊迭代器ListIterator,可在迭代的过程中对集合元素进行。
示例:import java.util.*;
class ListDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void method(){
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合是:"+al);
//在指定位置添加元素。
al.add(1,"java09");
//通过角标获取元素。
sop("get(1):"+al.get(1));
sop(al);
//获取所有元素。
for(int x=0; x<al.size(); x++){
System.out.println("al("+x+")="+al.get(x));
}
Iterator it = al.iterator();
while(it.hasNext()){
sop("next:"+it.next());
}
//通过indexOf获取对象的位置。
sop("index="+al.indexOf("java02"));
List sub = al.subList(1,3);
sop("sub="+sub);
}
public static void main(String[] args) {
//演示列表迭代器。
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop(al);
ListIterator li = al.listIterator();
//sop("hasPrevious():"+li.hasPrevious());
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("java02"))
//li.add("java009");
li.set("java006");
}
while(li.hasPrevious()){
sop("pre::"+li.previous());
}
//sop("hasNext():"+li.hasNext());
//sop("hasPrevious():"+li.hasPrevious());
sop(al);
}
}
Vector
概述:底层是数组数据结构,线程同步,被ArrayList替代了。因为效率低(JDK1.2版本)。
枚举(Enumeration)是Vector特有的取出方式,类似于Collection的迭代器,其实和迭代器是一样的,被Iterator取代;
示例:
import java.util.*;
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
概述:底层是链表数据结构,增删快,查询慢;
特有方法:
addFirst();
addLast();
getFirst();
getLast();
获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
remove()方法;
remove();移除首位;
remove(int index);移除指定位置元素
remove(Object obj);//移除指定元素
removeLast();
获取元素,但是元素被删除。如果集合中没有元素,会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素,但是元素被删除,如果集合中没有元素,会返回null
pollFirst();
pollLast();
获取元素,但是元素被删除,如果集合中没有元素,会返回null。
class LinkdeListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
sop(link.getFirst());
sop(link.getLast());
sop(link.removeFirst());
sop(link);
sop("size="+link.size());
while(!link.isEmpty())
{
sop(link.removeLast());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
注:List集合判断元素是否相同,依据的是元素的equals方法;