本文深入解析Java集合框架，包括List、Set的主要类型如ArrayList、LinkedList、HashSet、TreeSet的特性和使用场景，以及如何实现元素的唯一性和排序。
下图是简略的集合框架，主要说明list，set中的集合
list：元素是有序的，元素可以重复，因为该集合体系有索引（凡是可以操作索引的方法都是该体系中特有的方法）
ArrayList：底层的数组数据结构，线程不同步，JDK1.2版本出现
特点：查询速度快，但是增删慢，因为有下标，所以查询速度要快，但是由于下标是有顺序的，如果有很多元素，删除和添加下标为一的元素，那么后面元素的下标都要改变，所以增删速度要慢
LinkedList：底层是链表结构
特点：增删速度很快，查询稍慢，因为是链表结构，一个结点只需要知道前面和后面的元素是谁，当我们要删除或添加一个元素时，只需要变化两个结点即可删除或添加，查询的画，需要一个一个顺着链去查，会很慢
Vector：底层是数组数据结构，线程同步，JDK1.0版本出现
特点：
1.被ArrayList替代了，增删和查询都慢，为什么不用线程同步的呢？因为java中有专门控制线程同步的方法
2.枚举时vector特有的取出方式，枚举和迭代器是一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器取代了
例子一：使用LinkedList模拟一个堆栈或者队列数据结构
import java.util.*;
class Queue
{
private LinkedList link;
Queue()
{
link=new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
//先进先出
return link.removeLast();
//先进后出
return link.removeFirst();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(Stirng[] args)
{
Queue 1=new Queue();
q.myAdd("java01");
q.myAdd("java02");
q.myAdd("java03");
q.myAdd("java04");
while(!q.isNull())
{
System.out.println(q.myGet());
}
}
}
例子二：去除ArrayList集合中的重复元素
class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList a1=new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java01");
a1.add("java02");
a1.add("java01");
a1.add("java01");
al=singleElement(al);
sop(al); //输出：java01,java02,java03
}
public Static ArrayList singleElement(ArrayList a1)
{
//定义一个临时容器
ArrayList newA1=new ArrayList();
Iterator it=al.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(!newA1.contains(obj))
newA1.add(obj);
}
return newA1;
}
}
其中对于迭代器有一种情况，在迭代器循环中next调用一次，就要hasNext判断一次
public static void main(String[] args)
{
ArrayList a1=new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java01");
a1.add("java02");
a1.add("java01");
a1.add("java03");
Iterator it=a1.iterator();
while(it.hasNext())
{
sop(it.next()+"---"+it.next()); //第二个next会取到第一个next的next
}
}
输出结果：
java01---java02
java01---java02
java01---java03
set：元素是无序的(存入和取出的顺序不一定一致) ，元素不可以重复，set集合的功能和Collection是一致的
（注意:虽然Set中元素没有顺序，但是元素在set中的位置是由该元素的HashCode决定的，其具体位置其实是固定的。）
HashSet：底层数据结构是哈希表
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成，
如果元素的hashcode值相同，才会判断equals是否为ture，
如果元素的hashcode值不同，不会调用equals
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法，在往集合中添加元素的时候，一般都要重写hashcode和equals方法
public static void main(String[] atgs)
{
HashSet hs=new HashSet();
hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
hs.add(new Person("a2",12));
Iterator it=hs.iterator();
while(it.hasNext())
{
Person p=(Person)it.next();
sop(p.gerNme()+"::"p.getAge());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
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+"...hashCode");
return 60;
}
//重写
public boolean equals(Object obj)
{
if(!(obj instaceof Person))
return false;
Person p=(Person)obj;
System.out.println(this.name+"...equals..."+p.name);
return this.name.equals(p.name) && this.age==p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
输出结果：
a1...hashCode
a2...hashCode
a2...equals...a1
a3...hashCode
a3...equals...a2
a3...equals...a1
a2...hashCode
a2...equals...a3
a2...equals...a2
a3::13
a2::12
a1::11
TreeSet：底层数据结构是二叉树
1.可以对Set集合中的元素进行排序
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet();
ts.add("cba");
ts.add("aaa");
ts.add("bac");
ts.add("abcd");
Iterator it =new ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
//输出结果：
aaa
abcd
bac
cba
保证元素唯一性的依据：compareTo方法return 0
-
如果指定的数与参数相等返回0。
-
如果指定的数小于参数返回 -1。
-
如果指定的数大于参数返回 1。
//需求:往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts =new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
Iterator it=ts.iterator();
while(it.hasNext())
{
//想要用Student中的方法，需要强制转换为Student
Student stu =(Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable //该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Object obj)
{
if(!(obj instacepf Student))
throw new RuntimeException("不是学生对象")；
Student s =(Student)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
//当主要条件相同时，一定要判断一下次要条件，因为Stiring类实现了Comparable接口，本身就有这个方法（按照字典顺序比较两个字符串）
//return this.name.compareTo(s.name);
return 0；
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
输出结果：
lisi08...19
lisi09...19
lisi007...20
lisi02...22
TreeSet排序的第一种方式(图上)：让元素自身具有比较性，元素需要实现Compareable接口，覆盖CompareTo方法，这种方式也称为元素的自然顺序，或者叫做默认顺序
TreeSet的第二种排序方式，当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性，在集合初始化时，就有了比较方式,定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数
class TreeSetDemo
{
public static void main(String[] args)
{
//构造一个空的TreeSet，它根据指定比较器进行排序
TreeSet ts =new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
Iterator it=ts.iterator();
while(it.hasNext())
{
//想要用Student中的方法，需要强制转换为Student
Student stu =(Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable //该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Object obj)
{
if(!(obj instacepf Student))
throw new RuntimeException("不是学生对象")；
Student s =(Student)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
return 0；
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Stident1 s1=(Student)o1;
Student2 s2=(Student)o2;
int num= s1.getName().compateTo(s2.getName());
//如果相同，比次要条件
if(num==0)
{
//Integer中有compareTo方法
return new Integer(s1.getAge().compareTo(new Integer(s2.getAge())));
}
return num;
}
}
当两种排序都存在时，以比较器为主，定义一个类，实现Comparator接口，覆盖compare方法
TreeSet的第二种排序方式第二个例子：
improt java.util.*;
class TreeSetTest
{
public static void main(Stiring[] args)
{
TreeSet ts=new TreeSet(new StrLenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
Iterator it= ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1=(String)o1;
String s2=(Stirng)o2;
int num =new Interger(s1.length().compareTo(new Integer(s2.length())));
if(num==0)
//因为s1是字符串类，此类中有compareTo方法
return s1.compareTo(s2);
return num;
}
}
输出结果：
z
cc
aaa
cba
abcd
扫一扫
5703
到【灌水乐园】发言
