存储数据用数组,存储对象用集合。集合的长度可变,存储的对象类型可以不同。集合中这些存储对象的东东叫容器,都实现于接口Collection。集合中存储的都是对象的地址。
Collection的子类都有add,remove,contains,clear,iterator方法。
import java.util.*;
class CollectionDemo
{
public static void main(String[] args)
{
//创建一个集合容器,使用子类ArrayList
ArrayList al=new ArrayList();
//添加元素(对象)
al.add("java 01");
al.add("java 02");
al.add("java03");
al.add("java 04");
//打印
getColl("alsize:"+al.size());
getColl("原al:"+al);
//删除
System.out.println("al删除\"java 02\" "+
al.remove("java 02"));
getColl("al:"+al);
//是否包含
System.out.println("al中包含\"java 03\" "+
al.contains("java 03"));
ArrayList alt=new ArrayList();
alt.add("java 02");
alt.add("java 03");
alt.add("java 04");
System.out.println("原alt:"+alt);
//alt保留和al的交集
alt.retainAll(al);
getColl("保留和al的交集后,alt:"+alt);
//alt删除和al的交集
alt.removeAll(al);
getColl("删除和al的交集后,alt:"+alt);
//清空
al.clear();
//是否为空
System.out.println("al.clear()之后al为空"+
al.isEmpty());
ArrayList arr=new ArrayList();
arr.add("ArrayList01");
arr.add("ArrayList02");
arr.add("ArrayList03");
arr.add("ArrayList04");
arr.add("ArrayList05");
//迭代,遍历
for (Iterator ite=arr.iterator();ite.hasNext(); )
{
getColl("元素:"+ite.next());
}
}
public static void getColl(Object obj)
{
System.out.println(obj);
}
}
![](https://img-my.csdn.net/uploads/201211/23/1353646183_6541.jpg)
一. List:
元素有索引,因此可以重复。特有方法:
增: add(int index, Eelement)
addAll(int index, Collection)
删: remove(int index)
改: set(int index, Eelement)
查: get(int index)
subList(int fromIndex, inttoIndex)
listIterator(int index)
代码示例:
import java.util.*;
class ListDemo
{
public static void getColl(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//List的子类ArrayList
ArrayList alt=new ArrayList();
alt.add("ArrayList1");
alt.add("ArrayList2");
alt.add("ArrayList3");
alt.add("ArrayList4");
getColl("原 集 合:"+alt);
//指定索引插入
alt.add(1,"Java list");
getColl("索引1插入,新集合:"+alt);
//指定位置删除
alt.remove(1);
getColl("索引1删除,新集合:"+alt);
//指定索引修改
alt.set(2,"Javaworld");
getColl("索引2修改,新集合:"+alt);
//查询指定索引的元素
getColl("索引2元素是:"+
alt.get(2));
//查询所有元素
for(int x=0; x<alt.size(); x++)
{
getColl("集合alt("+x+"):"+alt.get(x));
}
//迭代查询
for(Iterator ite=alt.iterator(); ite.hasNext(); )
{
getColl("迭代,next:"+ite.next());
}
ListIterator ltr=alt.listIterator();
while(ltr.hasNext())
{
Object obj=ltr.next();
if(obj.equals("ArrayList2"))
{
ltr.set("Vigiles");
ltr.add("Hello");
}
}
getColl("迭代while添加:"+alt);
//迭代修改,仅用于List对象。不能使用集合和迭代器同时操作容器
for(ListIterator lt=alt.listIterator(); lt.hasNext(); )
{
Object obj=lt.next();
if(obj.equals("ArrayList4"))
{
lt.add("Friend");
//lt.set("Vigiles");
}
}
getColl("迭代器for添加:"+alt);
}
}
ListIterator还有个hasPrevious属性,以及previous()方法,可以在迭代正序后倒序访问元素。代码片段:
ListIterator lit=alt.listIterator();
//正序迭代
while(lit.hasNext())
{
getColl("next:"+lit.next());
}
//倒序迭代
while(lit.hasPrevious())
{
getColl("previous:"+lit.previous());
}
List最重要的三个子类
ArrayList:数组结构存储。查询很快;增删稍慢,元素越多越明显。多线程不同步。
LinkedList:链表(链条)数据结构。元素前后关联,有助于按顺序访问元素。增删很快,查询稍慢。
Vector:类似数组的数据结构。多线程同步。基本被ArrayList替代。
二. LinkedList:
链表集合。此实现不是同步的。如果多个线程同时访问一个链接列表,而其中至少一个线程从结构上修改了该列表,则它必须保持外部同步。
import java.util.*;
class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList ll=new LinkedList();
ll.addFirst("LinkedList1");
ll.addFirst("LinkedList2");
ll.addFirst("LinkedList3");
ll.addFirst("LinkedList4");
getColl("\n头部addFirst加入:"+ll);
ll.addLast("LinkedList5");
ll.addLast("LinkedList6");
getColl("尾部addLast加入:"+ll);
getColl("头部offerFirst加入:"+
ll.offerFirst("HelloJava")+"\n新集合:"+ll);
getColl("头部get查询:"+
ll.getFirst()); //如果集合为空,返回NoSuchElementException异常
getColl("尾部get查询:"+
ll.getLast()); //如果集合为空,返回NoSuchElementException异常
getColl("头部peek查询:"+
ll.peekFirst()); //如果集合为空,返回null
getColl("头部remove删除:"+
ll.removeFirst()+ //返回删除的元素。如果集合中没有元素会出现NoSuchElementException异常
"头部删除后集合长度:"+ll.size());
getColl("尾部remove删除:"+
ll.removeLast()+ //返回删除的元素。如果集合中没有元素会出现NoSuchElementException异常
"尾部删除后集合长度:"+ll.size());
getColl("头部poll删除:"+
ll.pollFirst()); //如果集合为空,返回null
}
public static void getColl(Object obj)
{
System.out.println(obj);
}
}
三. Set:
元素无序,不可以重复。线程非同步。Set集合的功能和Collection一致。子类HashSet、TreeSet。HashSet通过hashCode方法和equals方法保证元素的唯一性。如果hashCede值相同才回调用equals方法。ArrayList只依赖equals方法判断元素。
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name, int age)
{
this.name=name;
this.age=age;
}
//底层自动调用
public int hashCode()
{
System.out.println(this.name+"计算hash code");
return name.hashCode()+age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//底层自动调用
public boolean equals(Object obj)
{
if (!(obj instanceof Person))
{
//如果调用的对象不是Person的实例,返回false
return false;
}
//如果调用的是Person的实例
Person p=(Person)obj;
System.out.println(this.name+"..同名比较.."+p.name);
//根据name和age两个方面与之前存储的比较。有一个方面不同即返回false
return this.name.equals(p.name)&&this.age==p.age;
}
}
class HashSetDemo
{
public static void main(String[] args)
{
HashSet hs=new HashSet();
hs.add(newPerson("a1",23));
hs.add(newPerson("a2",23));
hs.add(newPerson("a3",23));
hs.add(newPerson("a4",23));
hs.add(newPerson("a5",23));
hs.add(newPerson("a3",23));
hs.add(newPerson("a4",23));
Iterator it = hs.iterator();
while (it.hasNext())
{
Person p =(Person)it.next();
show(p.getName()+"---"+p.getAge());
}
}
public static void show(Object obj)
{
System.out.println(obj);
}
}
四. TreeSet:
可以自动为元素按ASCII码排序。底层数据结构是二叉树,自动调用compareTo方法比较元素顺序。如果返回0即相同,-1为小保存在前,1为大保存在后。
第一种方式:元素实现Comparable接口,覆盖compareTo方法:
import java.util.*;
class Student implements Comparable //强制让Student具备比较性
{
private String name;
private int age;
Student(String name, int age)
{
this.name=name;
this.age=age;
}
//实现Comparable的类底层默认调用此方法
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
{
throw new RuntimeException("不是Student对象");
}
Student s=(Student)obj;
if (this.age>s.age)
{
return 1;
}
if (this.age==s.age)
{
return this.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet();
ts.add(new Student("张三",12));
ts.add(new Student("李四",34));
ts.add(new Student("王五",34));
ts.add(new Student("赵六",22));
Iterator it=ts.iterator();
while (it.hasNext())
{
Student s =(Student)it.next();
System.out.println(s.getName()+"..."+s.getAge());
}
}
}
第二种方式:当元素不具备比较性,或所具备的比较性不是需要的。此时需要集合具备比较性。此方式为底层首选。
import java.util.*;
class Student
{
private String name;
private int age;
Student(String name, int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class TreeSetDemo
{
public static void main(String[] args)
{
//使用比较器使元素具有比较性
TreeSet ts=new TreeSet(newMyComparator());
ts.add(new Student("张三",12));
ts.add(new Student("李四",34));
ts.add(new Student("王五",34));
ts.add(new Student("赵六",22));
ts.add(new Student("王五",30));
ts.add(new Student("赵六",23));
Iterator it=ts.iterator();
while (it.hasNext())
{
Student s =(Student)it.next();
System.out.println(s.getName()+"..."+s.getAge());
}
}
}
class MyComparator implements Comparator //比较器
{
public int compare(Object o1, Object o2)
{
Student s1=(Student)o1;
Student s2=(Student)o2;
int num=s1.getName().compareTo(s2.getName());
if (num==0)
{
return newInteger(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}