Java集合【开发的重点*】
一、概念
1. 集合：是一种工具，也是一种容器，用于存储数量不等的多个对象。
2. 集合相关的接口和类位于 java.util 包中。
3. 学习集合从以下 4个点入手：
(1) 集合接口的特点
(2) 集合接口中功能方法
(3) 集合接口对应的实现类
(4) 集合的遍历方式
二、Collection集合体系
1. 父接口：Collection接口
(1) 特点：存储任意类型Object对象。
(2) 方法：
a. boolean add(Object o):将o对象添加到集合中。【开发重点】
b. boolean contains(Object o):判断当前集合中是否包含 o元素，包含-true;否则-false.
c. boolean remove(Object o)：将 o对象从当前集合中移除、删除。
d. int size() : 获取集合中有效元素的个数
(3) 实现类：没有直接的实现类，详见子接口。
(4) 遍历：详见子接口。
2. 子接口：List接口
(1) 特点：存储任意类型的Object对象，有序、有下标、元素允许重复。
【基础重点】下标的范围： 0 ~ 有效元素个数 - 1
（0 ~ size - 1）
(2) 方法：部分继承于父接口 Collection接口，其余为定义的方法：
a. boolean add(Object o):将元素存储到List集合，默认存储在集合的尾部。【重点】
b. add(int index，Object o):将指定的元素插入到集合对应的下标位置。
c. Object get(int index):返回指定下标对应集合元素。
d. Object remove(int index):删除指定下标对应的元素，返回值代表被删除的对象。
e. Object set(int index , Object o):将指定下标对应元素进行修改，修改为o对象。返回值代表被修改之前的元素。
(3) 实现类：ArrayList，底层用数组实现的
a. ArrayList:底层数组实现的，查询操作时效率较高，增删操作效率较低。
JDK2.0版本，线程不安全，运行效率较高。
注意：JDK1.7版本，创建ArrayList对象时，并没有完成数组空间分配，而是第一次往集合中存储元素(add方法时)，才完成数组空间分配，数组的初始长度为10，每次扩充为1.5倍。
b. Vector: 底层数组实现的，查询操作时效率较高，增删操作效率较低。
JDK1.0版本，线程安全，效率较低。
c. LinkedList：底层链表实现，查询操作时效率较低，增删效率较高。
线程不安全，运行效率较高。
面试题目：写出ArrayList 和 LinkedList区别？
(4) 遍历：将集合中元素进行一一的访问。
a. 下标遍历：通过集合中的下标对集合元素进行一一访问
for(int i=0;i<集合名.size(); i++){
// 通过下标 i ，获取集合中每一个元素： get方法
}
b. forEach遍历：【开发应用重点】
for(数据类型 变量名 : 要遍历的集合名) {
// 直接利用变量名操作集合元素即可
}
注意：变量的数据类型取决于集合的泛型类型。
forEach遍历的底层原理：迭代器遍历
I. 获取迭代器对象：
Iterator it = 集合名.iterator();
II. 迭代器中方法：
① hasNext() : 判断迭代器中是否还有要操作的元素，有-true；没有-false。
② Object next() : 调用一次，返回迭代器中的下一个元素。
III.迭代器的遍历方式：
Iterator it = 集合名.iterator();
// 遍历迭代器
while(it.hasNext()){
// 通过next方法获取迭代器中下一个元素
System.out.println(it.next());
}
3. 泛型
(1) 泛型集合：安全性的集合，可以对集合中数据统一管理，并且强制约束集合的元素类型一致。【重点】
List<数据类型> 集合名 = new ArrayList<数据类型>();
(2) 泛型类：
a. 语法:
class 类名<泛型标识1,泛型标识2>{
// 将 泛型标识作为数据类型应用
}
注意：通常用：K/V/E/T等作为泛型标识。
b. 应用：在创建对象时，需要制定泛型的数据类型。
类名<数据类型> 对象名 = new 类名<数据类型>();
注意：前后数据类型要一致；
基本数据类型不能作为泛型的类型，需要应用基本数据类型对应的包装类型；
如果创建对象时，没有指定泛型的类型，则默认为Object类型；
如果定义类型有多个泛型标识，要么按顺序指定所有的泛型数据，要么都不指定。
4. 集合工具类：Collections
(1) Collections：用于操作集合元素的工具类，类中提供了大量的静态方法用于操作集合元素，例如元素排序、倒置等操作。
(2) 常用的方法：
a. static void reverse(List list)：将集合中元素进行倒置。
b. static void shuffle(List list)：对集合中元素进行随机显示。
c. static void sort(List list)： 对集合中元素进行排序。
注意：如果参与排序的集合中元素为自定义类型的对象，则对应的类需要实现
java.lang.Comparable接口，同时实现接口中compareTo方法，指定排序规则。
I. 第一种比较器 java.lang.Comparable接口，接口中有一个 int compareTo(T t) ,将当前对象this
和 t 进行比较，参与比较的对象对应的类需要实现此接口，同时实现此方法。-》内置比较器
II. 第二种比较器： java.util.Comparator 接口，接口中定义了 int compare(T o1, T o2) ,将o1和o2进行比较，定义在参与比较对象的类的外面。 ---》外置比较器
面试题目：写出 Collection 和 Collections的区别。
解析：Collection是 Java 中Collection集合体系的父接口，有List和Set等子接口。
Collections：是操作集合元素的工具类，类中定义大量的静态方法。
---》内置比较器
public class Student implements Comparable<Student>{
private String name;
private Integer age;
private Double score;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, Integer age, Double score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Double getScore() {
return score;
}
public void setScore(Double score) {
this.score = score;
}
@Override
public String toString() {
return "name=" + name + ", age=" + age + ", score=" + score;
}
@Override
public int compareTo(Student o) {
/* 将 this 和 o 具体比较
* this.age 大于 o.age 整数 1
* 小于 负数 -1
* this.age 等于 o.age 0
*
*/
// System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
if(this.age>o.age){
return 1;
}else if(this.age<o.age){
return -1;
}else{
//年龄相同的情况下：按照成绩
if(this.score>o.score){
return 1;
}else if(this.score<o.score){
return -1;
}else{
// 年龄相同、成绩相同，按照姓名进行排序
// return this.name.compareTo(o.name);
if(this.name.compareTo(o.name)>0){
return 1;
}else if(this.name.compareTo(o.name)<0){
return -1;
}else{
return 0;
}
}
}
}
---》外置比较器
public class TestSort2 {
public static void main(String[] args) {
ArrayList<Worker> list = new ArrayList<Worker>();
list.add(new Worker("wangwang",49,20000.0));
list.add(new Worker("wanqing",45,12000.0));
list.add(new Worker("jinshuai",47,16000.0));
//匿名内部类-->实现比较器
/*Comparator<Worker> c=new Comparator<Worker>(){
public int compare(Worker w1,Worker w2){
// 参与比较的对象：将 w1 和 w2进行比较
if(w1.getAge()>w2.getAge()){
return 1;
}else if(w1.getAge()<w2.getAge()){
return -1;
}else {
return 0;
}
}
};
Collections.sort(list, c);*/
Collections.sort(list, new Comparator<Worker>(){
@Override
public int compare(Worker w1, Worker w2) {
// 参与比较的对象：将 w1 和 w2进行比较
if(w1.getAge()>w2.getAge()){
return 1;
}else if(w1.getAge()<w2.getAge()){
return -1;
}else {
return 0;
}
}
});
for(Worker w:list){
System.out.println(w);
}
}
}
public class Worker {
private String name;
private Integer age;
private Double salary;
public Worker() {
super();
// TODO Auto-generated constructor stub
}
public Worker(String name, Integer age, Double salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "name=" + name + ", age=" + age + ", salary=" + salary;
}
}
5. 子接口：Set接口
(1) 特点：存储多个任意类型的对象，无序、无下标、元素 的内容不允许重复。
(2) 方法：继承于父接口 Collection 中的方法。
(3) 实现类：HashSet 【开发应用重点+面试重点】
a. 自定义类型的对象存储在HashSet中，如何保证 HashSet元素内容不重复？
i. 覆盖 hashCode方法
原则：必须保证相同内容的对象返回相同的哈希码值，为了提高效率，尽可能的做到，不同内容的
对象返回不同的哈希码值
覆盖准则：通常将所有的属性拼凑为一个 int 类型的结果进行返回。
案例： public int hashCode(){
return this.name.hashCode()+this.age.hashCode(); // age 包装类型
}
ii. 覆盖 equals方法
必须保证相同内容的对象返回true -> 拒绝添加到HashSet集合中。
b. HashSet保证元素不重复执行的原理：对象往HashSet集合中存储时，当前对象调用自身hashCode方法，获取哈希码值，从而获取对应存储下标，如果存储下标上没有存储任何元素，则当前对象直接存储，但是如果存储下标上已经有存储了其他对象，则调用equals方法，进行比较对象的内容是否相同，equals方法的结果为true,代表相同内容的对象，则HashSet集合拒绝添加，equals方法结果为false，则代表内容不同的对象，则成功添加到HashSet集合中。
(4) 遍历方式：forEach（底层原理迭代器遍历）
(5) SortedSet：是 Set的子接口，无序、无下标、对元素内容进行排序。【了解】
a. 常用的实现类TreeSet
注意：如果自定类型的对象存储在TreeSet中，需要实现 java.lang.Comparable 接口，同时实现：
compareTo方法，方法中指定排序的规则。compareTo返回值结果如果为0，则TreeSet视为相同内容的对象。(TreeSet去除重复内容的对象，利用compareTo返回值，结果为0，相同对象)
(6) LinkedHashSet：按照添加顺序进行集合元素存储，同时元素内容不允许重复。
注意：LinkedHashSet是 HashSet的子类，所以如果自定类型的对象存储在LinkedHashSet中，为了保证元素内容不重复，则需要对象对应的类覆盖 hashCode方法 和 equals方法(要求和 父类HashSet一致)。
三、Map集合体系
1. Map集合的特点：【基础重点】
(1) 存储任意的 键值对 (key-value)，Map中一个集合元素是一个键值对
(2) 键：无序、无下标、不允许重复(唯一)
(3) 值：无序、无下标、允许重复
2. Map 集合中的方法
(1) V put(K key,V value) : 往Map集合中添加一个键值对，如果键在Map中没有存在，则直接添加，返回值为null；如果键在Map中已经存在，则新的Value覆盖原有的value数据，被覆盖的value数据作为返回值进行返回。【开发重点】
(2) V remove(K key)：根据键，删除对应的键值对，被删除的值(value)作为返回值返回。
(3) V get(K key)：根据键，返回对应的值(value)。【重点】
(4) boolean containsKey(K key)：判断Map集合中是否包含指定的键，包含-true；不包含-false.
(5) boolean containsValue(V value)：判断Map集合中是否包含指定的值，包含-true;不包含-false.
(6) int size() : 获取Map中键值对的个数。
3. 实现类：HashMap
注意：如果自定类型的对象存储在HashMap的键上，为保证键的不允许重复，则自定义类型的对象对应的类需要覆盖hashCode方法和equals方法；但是开始通常用 String/Integer类型的数据作为键。
(1) HashMap: JDK1.2 版本，线程不安全，运行效率较高，允许null 作为 key/value。【开发重点】
(2) Hashtable : JDK1.0版本，线程安全，运行效率慢，不允许null作为key/value。
(3) Properties：是 Hashtable的子类，要求 键和值都是String类型。开发时，通常用于读取配置文件。
(4) SortedMap : 是 Map子接口，可以对键完成自动排序。实现类：TreeMap
(5) LinkedHashMap：是 HashMap的子类，按照添加的顺序完成键值对的存储。
面试题目：HashMap 和 Hashtable的区别。
4. 遍历：
(1) 第一种遍历方式：键遍历，通过 keySet()方法获取Map 所有的键 【开发应用重点】
Set< K > ks = map.keySet(); // 获取所有的键
// 利用 foreach遍历 set集合
for(K key : ks){
// 通过 map 的 get方法，获取键对应的值
V value = map.get(key);
// 利用 key 和 value 操作每一个键和值即可
}
(2) 第二种遍历方式：值遍历 ，通过 values() 获取 Map中所有的值
Collection< V > vs = map.values();
//利用 foreach 遍历 Collection集合
for(V value:vs){
// 通过 value 操作对应的值
}
(3) 第三种遍历方式：键值对遍历，通过 entrySet方法获取Map中所有键值对
Set< Map.Entry< K,V>> kvs = map.entrySet();
// 通过foreach遍历 set集合 获取每一个键值对(Entry)
for(Map.Entry< K,V> kv : kvs ){
// 利用 Entry中提供两个方法 getKey 和 getValue 获取键和值的信息
K key = kv.getKey(); // 从键值对中获取键的信息
V value = kv.getValue() ; // 从键值对中获取值的信息
// 通过 key 和 value 操作键和值
}
