集合类库的整体框架
Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合。
Set集合
java.util.Set集合是Collection集合的子集合，与List集合平级。
该集合中元素没有先后放入次序，且不允许重复。
该集合的主要实现类是：HashSet类 和 TreeSet类以及LinkedHashSet类。
其中HashSet类的底层是采用哈希表进行数据管理的。
其中TreeSet类的底层是采用红黑树进行数据管理的。
其中LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
而由于TreeSet使用红黑树进行管理，打印时需要考虑集合内元素的先后顺序。
常用方法与Collection接口类似：
方法声明 | 功能 |
boolean add(E e) | 向集合中添加对象 |
boolean addAll(Collection<? extends E> c) | 用于将参数指定集合c中的所有元素添加到当前集合中 |
boolean contains(Object o) | 判断是否包含指定对象 |
boolean containsAll(Collection<?> c) | 判断是否包含参数指定的所有对象 |
boolean retainAll(Collection<?> c) | 保留当前集合中存在且参数集合中存在的所有对象 |
boolean remove(Object o) | 从集合中删除对象 |
boolean removeAll(Collection<?> c) | 从集合中删除参数指定的所有对象 |
void clear() | 清空集合 |
int size() | 返回包含对象的个数 |
boolean isEmpty() | 判断是否为空 |
Object[] toArray() | 将集合转换为数组 |
Iterator iterator() | 获取当前集合的迭代器 |
示例：
public class HashSetTest {
public static void main(String[] args) {
//Set集合的实现类有HashSet和TreeSet
Set<String> map=new HashSet<>();
//Set集合没有顺序，且不可重复
map.add("one");
map.add("two");
map.add("three");
System.out.println(map);
boolean b=map.add("one");//已存在one，添加失败
System.out.println(b);
System.out.println(map);
}
}
TreeSet集合
由于TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使用新元素与集合中已有的元素依次比较来确定新元素的合理位置，且打印时遵从从小到大的顺序。
满足以下3个特征的二叉树叫做有序二叉树。
（1）左子树中的任意节点元素都小于根节点元素值；
（2）右子树中的任意节点元素都大于根节点元素值；
（3）左子树和右子树的内部也遵守上述规则；
比较元素大小的规则有两种方式：
（1）使用元素的自然排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口；
（2）使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口；
通过Comparable接口进行比较排序
创建Person类实现Comparable接口并重写compareTo方法，使用TreeSet集合存储Person对象并打印。
Person类：
public class Person implements Comparable<Person>{
private String name;
private int id;
public Person() {
}
public Person(String name, int id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
//重写Comparable接口的compareTo方法
@Override
public int compareTo(Person o) {
int b=this.getName().compareTo(o.getName());
return b!=0?b:this.getId()-o.getId();
}
}此时在compareTo方法中通过先Person对象name的字典序比较先后，若name相同则比较id大小。
Main方法：
public class TreeSetTest {
public static void main(String[] args) {
Set<Person> set1=new TreeSet<>();
set1.add(new Person("liubei",30));
set1.add(new Person("liubei",31));
set1.add(new Person("guanyu",20));
set1.add(new Person("zhangfei",10));
System.out.println(set1);
}
}打印时则对TreeSet内容进行了排序输出
通过传入Comparator接口实现比较
该方式需要在构造TreeSet时传入Comparator接口的引用。在此使用匿名内部类的方法。
在此Person无需再实现Comparable接口
public class Person {
private String name;
private int id;
public Person() {
}
public Person(String name, int id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
}main方法：
public class TreeSetTest {
public static void main(String[] args) {
//使用匿名内部类
Set<Person> set1=new TreeSet<>(new Comparator<Person>(){
@Override
public int compare(Person o1, Person o2) {
int b=o1.getName().compareTo(o2.getName());
return b!=0?b:o1.getId()-o2.getId();
}
});
set1.add(new Person("liubei",30));
set1.add(new Person("liubei",31));
set1.add(new Person("guanyu",20));
set1.add(new Person("zhangfei",10));
System.out.println(set1);
}
}结果与上相同。
此外也可以使用Lambda表达式，如下：
public class TreeSetTest {
public static void main(String[] args) {
//使用Lambda表达式
Comparator<Person> comparator=(Person o1,Person o2)->{
int b=o1.getName().compareTo(o2.getName());
return b!=0?b:o1.getId()-o2.getId();
};
Set<Person> set1=new TreeSet<>(comparator);
set1.add(new Person("liubei",30));
set1.add(new Person("liubei",31));
set1.add(new Person("guanyu",20));
set1.add(new Person("zhangfei",10));
System.out.println(set1);
}
}Map集合
java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，其中类型参数如下：
K - 此映射所维护的键(Key)的类型，相当于目录。
V - 映射值(Value)的类型，相当于内容。
该集合中key是不允许重复的，而且一个key只能对应一个value。
该集合的主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、Properties类。
其中HashMap类的底层是采用哈希表进行数据管理的。
其中TreeMap类的底层是采用红黑树进行数据管理的。
其中LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
其中Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null作为key或者value的数值。
常用方法：
方法声明 | 功能介绍 |
V put(K key, V value) | 将Key-Value对存入Map，若集合中已经包含该Key，则替换该Key所对应的Value，返回值为该Key原来所对应的Value，若没有则返回null |
V get(Object key) | 返回与参数Key所对应的Value对象，如果不存在则返回null |
boolean containsKey(Object key) | 判断集合中是否包含指定的Key |
boolean containsValue(Object value) | 判断集合中是否包含指定的Value |
V remove(Object key) | 根据参数指定的key进行删除 |
Set keySet() | 返回此映射中包含的键的Set视图 |
Collection values() | 返回此映射中包含的值的Set视图 |
Set<Map.Entry<K,V>> entrySet() | 返回此映射中包含的映射的Set视图 |
简单使用：
public class MapTest {
public static void main(String[] args) {
Map<Integer,String> map=new HashMap<>();
String str=map.put(1,"son");//放入son并获取原来的值
System.out.println(str);
str=map.put(2,"father");//放入father并获取原来的值
System.out.println(str);
System.out.println(map);
str=map.put(1,"grandfather");
System.out.println(str);
System.out.println(map);
}
}
Collections类
java.util.Collections类主要提供了对集合操作或者返回集合的静态方法。
常用方法：
常用方法 | 功能 |
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) | 根据元素的自然顺序返回给定集合的最大元素 |
static T max(Collection<? extends T> coll, Comparator<? super T> comp) | 根据指定比较器引发的顺序返回给定集合的最大元素 |
static <T extends Object & Comparable<?super T>> T min(Collection<? extends T> coll) | 根据元素的自然顺序返回给定集合的最小元素 |
static T min(Collection<? extends T> coll, Comparator<? super T> comp) | 根据指定比较器引发的顺序返回给定集合的最小元素 |
static void copy(List<? super T> dest, List<? extends T> src) | 将一个列表中的所有元素复制到另一列表中 |
static void reverse(List<?> list) | 反转指定列表中元素的顺序 |
static void shuffle(List<?> list) | 使用默认的随机源随机置换指定的列表 |
static <T extends Comparable<? super T>> void sort(List list) | 根据其元素的自然顺序将指定列表按升序排序 |
static void sort(List list, Comparator<? super T> c) | 根据指定比较器指定的顺序对指定列表进行排序 |
static void swap(List<?> list, int i, int j) | 交换指定列表中指定位置的元素 |
