Java中的集合（上）
一、集合类
- 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就要对对象进行存储，集合就是存储对象最常用的一种方式。
- 集合特点：
- 用于存储对象的容器。
- 集合的长度是可变的。
- 集合中不可以存储基本数据类型值。
- 集合容器因为内部的数据结构不同，有多种具体容器。不断的向上抽取，就形成了集合框架。
二、集合类的构成：
1. 集合框架的构成及分类
Java集合类主要由两个接口（Collection和Map）派生出来：
Collection
List（子接口）：有序（存入和取出的顺序一致），可以重复，有索引
Vector(实现类):
- 底层数据结构：数组
- 线程：同步
操作数据：增删，查询都很慢
Enumeration elements()
返回此向量的组件的枚举。
IO流中SequenceInputStream中用到e.g.
Vector v = new Vector;
Enumeration en =v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
ArrayList(实现类)： 替代了Vector
- 底层数据结构：数组
- 线程：不同步
- 操作数据：增删稍慢、改查很快
- LinkedList(实现类):
- 底层数据结构：链表
- 线程：不同步
- 操作数据：增删除很快，改查很慢
Set（子接口） ：无序(存入和取出的顺序不一定一致)，不能重复
- HashSet(实现类)：底层数据结构是哈希表，不同步
- LinkedHashSet：具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现
- TreeSet(实现类)：底层数据结构是二叉树，不同步，可以对Set集合中的元素进行排序
- HashSet(实现类)：底层数据结构是哈希表，不同步
Map：存储键值对，一次添加一对，而且要保证键的唯一性
- Hashtable实现类)：
- 底层数据结构：哈希表，不可以存入null键null值
- 线程：同步
- 操作数据：jdk1.0.效率低
- HashMap实现类)：
- 底层数据结构：哈希表，允许使用 null值和null键
- 线程：不同步
- 操作数据：将hashtable替代，jdk1.2.效率高
- TreeMap实现类)：
- 底层数据结构：二叉树
- 线程：不同步
- 操作数据：用于给map集合中的键进行排序
- Hashtable实现类)：
2. Collection接口:
Collection的常见方法：
- 添加：
- boolean add(Object obj);
- boolean addAll(Collection coll);
- 删除：
- boolean remove(Object obj);
- boolean removeAll(Collection coll);
- void clear( );
- 判断：
- boolean contains(Object obj);
- boolean containsAll(Collection coll);
- boolean isEmpty();判断集合中是否有元素。
- 获取：
- int size( );
- Iterator iterator( );
- 其他：
- boolean retainAll(Collection coll); 取交集
- Object toArray( ); 将集合转成数组
3. Iterator接口
概述：
- 对所有的Collection容器进行元素取出的公共接口，称为迭代器
- Collection中有iterator方法，所以每一个子类集合对象都具备迭代器
- 它替代了Vector类中的Enumeration(枚举)。迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
方法：
- boolean hasNext()：若被迭代的集合元素还没有被遍历，返回true.
- Object next():返回集合的下一个元素.
void remove():删除集合上一次next()方法返回的元素。(若集合中有多个相同的元素，都可以删掉)
取出集合的元素代码示例：
方式一： Iterator it=al.iterator();//获取迭代器，用于取出集合中的元素。 while(it.hasNext()) { System.out.println(it.next()); } //方式二：for循环结束，Iterator变量内存释放，更高效 for (Iterator it=al.iterator();it.hasNext() ; ) { System.out.println(it.next()); }
子接口：
- ListIterator：专门输出List中的元素
- 方法：
- boolean hasNext()
- E next() 返回列表中的下一个元素。
- int nextIndex()
- void add(E e) 将指定的元素插入列表（可选操作）
- void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。
- void remove()从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
- boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
- E previous()返回列表中的前一个元素。
- 方法：
三，List
Collection的子接口，有序（存入和取出的顺序一致），元素都有索引（角标），允许重复元素
1. 特有的常见方法。
特点：都可以操作角标。
- 添加
- void add(index,element);
- void addAll(index,collection);
- 删除
- Object remove(index);
- boolean remove(Object o) 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
- 修改
- Object set(index,element);
获取：
- Object get(index);
- int indexOf(object);
- int lastIndexOf(object)：
List subList(from,to);
list特有的取出元素的方式之一
for(int x = 0; x < list.size(); x++){
System.out.println( “get:” + list.get(x));
}
List集合特有的迭代器：ListIterator(列表迭代器)
- 在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常；
- 所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出和删除的操作；
- 如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator.该接口只能通过List集合的listIterator方法获取 。
2. ArrayList
基本方法：增删改查，与List中的方法基本一致
3. LinkedList
基本方法：
- void addFirst(); 1.6以后版本为offerFirst( )
- void addLast(); 1.6以后版本为offerLast( )
- E getFirst();获取但不移除，如果链表为空，抛出NoSuchElementException。
1.6以后版本为：peekFirst(); 获取但不移除，如果链表为空，返回null - E getLast(); 1.6以后版本为：peekLast( );
- E removeFirst(); 获取并移除，如果链表为空，抛出NoSuchElementException。
1.6以后版本为：pollFirst( );获取并移除，如果链表为空，返回null - E removeLast(); 1.6以后版本为： pollLast( );
四，Set
Collection的子接口,元素不可以重复，是无序的，Set接口中的方法和Collection一致
1. HashSet：
概述：
- 内部数据结构是哈希表，是不同步的。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，haseCode和equals来完成的。
如果元素的HashCode值相同，才会判断equals是否为true;
如果元素的HashCode值不同，不会调用equals。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。//HashSet集合中添加重复元素时，返回false System.out.println(hs.add("java01")); System.out.println(hs.add("java01"));//未存储进去为false
代码示例：
import java.util.HashSet;
import java.util.Iterator;
/*
* 往HashSet集合中存入自定义对象姓名和年龄相同为同一个人，重复元素。
*/
class HashSetDemo {
public static void main(String[] args) {
System.out.println("以下为集合中元素存储的比较过程：");
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));
hs.add(new Person("a3", 14));
System.out.println("去掉重复元素后的结果：");
Iterator it = hs.iterator();
while (it.hasNext()) {
Person p = it.next();
System.out.println(p.getName() + "..." + p.getAge());
}
}
}
class Person {
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
// 复写hashCode方法，集合底层内部调用
public int hashCode() {
System.out.println(this.name + "...hashCode");
return name.hashCode() + age * 3;// *3保证hash值的唯一性
}
// 复写equals方法
public boolean equals(Object obj) {
if (!(obj instanceof 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;// 此处equals为Object的方法.
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
运行结果：
LinkedHashSet
- 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现，该类为HashSet的子类，可以将无序变有序。
2. TreeSet
特点：
- 可以对Set集合中的元素进行排序（字母的自然顺序），底层数据结构是二叉树
- 判断元素唯一性的方式：就是根据保证元素唯一性的依据比较方法（实现Comparable接口中根据覆盖的compareTo方法返回值，实现Comparator接口中根据覆盖的compare方法）的返回结果是否是0，是0，就是相同元素，不存。
排序：
排序：
第一种方式：让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。这种方式也称为元素的自然顺序，或者叫做默认顺序。
- Comparable接口：位于java.lang包中，只有一个方法compareTo
- int compareTo(T o)：比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
- Comparable接口：位于java.lang包中，只有一个方法compareTo
代码示例：
import java.util.Iterator;
import java.util.TreeSet;
/**
* 需求： 往TreeSet集合中存储自定义对象学生。 年龄和姓名均相同时，视为同一个人，
* 并按照学生的年龄进行排序, 当年龄相同时，按照名字的自然顺序排序
*/
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Student("C", 19));
ts.add(new Student("D", 17));
ts.add(new Student("C", 19));
ts.add(new Student("A", 20));
ts.add(new Student("E", 17));
Iterator it = ts.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName() + "..." + s.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(Student s) { // 内部底层调用
// 存与取的方式相同,将不能除去重复的对象元素
//return 1;
// 存与取的方式刚好相反，将不能除去重复的对象元素
// return -1;
// 按自然顺序取出
System.out.println(this.name + ":compareto:" + s.name);
if (this.age > s.age) {
return 1;
// 判断次要条件：当年龄相同时，比较姓名是否相同
} else if (this.age == s.age) {
return this.name.compareTo(s.name);// 字符串自有的比较方法。
} else
return -1;
/*简化书写
int temp = this.age - s.age;
return temp == 0? this.name.compareTo(s.name) : temp;*/
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
} 运行结果：
- 第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的，就让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。 注意：如果自定义类实现了Comparable接口，并且TreeSet的构造函数中也传入了比较器，那么将以比较器的比较规则为准
代码示例：
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
/*
* 需求：按姓名排序，不修改compareTo方法
*/
class TreeSetDemo2 {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new MyCompare());// 将比较器对象作为参数传递给TreeSet集合的构造函数
ts.add(new Student("A", 20));
ts.add(new Student("C", 19));
ts.add(new Student("E", 17));
ts.add(new Student("D", 17));
ts.add(new Student("A", 18));
ts.add(new Student("C", 19));
Iterator it = ts.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName() + "..." + s.getAge());
}
}
}
class Student implements Comparable<Student> { // 该接口强制让学生具备比较性。
private String name;
private int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public int compareTo(Student s){ // 内部底层调用
// 按自然顺序取出
System.out.println(this.name + ":compareto:" + s.name);
int temp = this.age - s.age;
return temp == 0? this.name.compareTo(s.name) : temp;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
// 定义一个类，实现Comparator接口
class MyCompare implements Comparator<Student> {
//覆盖compare方法
public int compare(Student s1, Student s2) {
int num = s1.getName().compareTo(s2.getName());
if (num == 0) {
/*//第一种方法
if(s1.getAge()>s2.getAge())
return 1;
if(s1.getAge()==s2.getAge())
return 0;
return -1;
*/
/*//第二种方法
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));*/
// 第三种方法
return s1.getAge() - s2.getAge();
}
return num;
}
} 运行结果：