集合
一、集合类概述
（1）为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类，java根据存储元素以及取出元素的特点不同，提供不同存储容器，统称为集合。
（2）数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
（3）集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
注：未来在开发中，一个集合只能存储一种数据类型的元素
二、Collection接口
1、概述
Collection：集合层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List
通过观察api发现，Collection是一个接口，我们无法直接对其创建对象，要想使用Collection接口中的方法，应该找一个它具体的实现子类
利用这个实现子类对象，来使用Collection中的方法。
Collection又向下分了两种类型的集合：List(元素可以发生重复)和Set(元素唯一)
Collection(接口)
- List(接口)
ArrayList(具体实现子类)
- Set(接口)
我们找到了Collection中其中一个实现子类：ArrayList,我们借助创建该类的对象，来学习并使用
Collection c1 = new ArrayList();
Collection接口中的方法
我们可以使用ArrayList的无参构造方法来创建
2、成员方法
boolean add(E e) 向集合中添加元素
boolean remove(Object o) 从集合中删除某个元素
void clear() 清空集合中的元素
boolean contains(Object o) 判断元素是否包含某个元素
boolean isEmpty() 判断集合是否为空
int size() 判断集合中元素个数
boolean addAll(Collection c)直接添加另一个集合中所有单元素
boolean removeAll(Collection c)从一个集合中移除另一个集合中所有的元素
boolean containsAll(Collection c)判断A集合中是否包含B集合所有元素
boolean retainAll(Collection c ) A集合与B集合做交集，重复的部分覆盖到A集合中，B集合不变
Object[] toArray() //将集合类型转成数组类型
Iterator iterator() //Conection自带的迭代器
3、Collection集合如何遍历？
学习集合的4个步骤：
1、如何创建集合对象？
Collection c1 = new ArrayList();
2、如何创建元素对象？
String s1 = "hello";
String s2 = "java";
String s3 = "world";
String s4 = "hello";
String s5 = "hadoop";
3、如何将元素对象添加到集合中？
c1.add(s1);
c1.add(s2);
c1.add(s3);
c1.add(s4);
c1.add(s5);
4、如何遍历集合？
4.1存储字符串并遍历
方式1：Object[] toArray() 把集合转成数组，可以实现集合的遍历
Object[] arr = c1.toArray(); //注意：这里返回值类型是Object类型，而集合中的元素是一个字符串
for (int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
方式2：Iterator iterator() 迭代器遍历，Collection集合的专用遍历方式
对 Collection 进行迭代的迭代器，依赖于集合而存在
调用Collection接口中的iterator()方法获取集合对应的迭代器对象
迭代器对象中存储了集合中每一个元素，Iterator类中有方法(next()移动指针(游标)，取每一个元素,hasnext()判断集合下一个位置是否有元素)可以给我们使用获取元素对象
Iterator iterator = c1.iterator(); //Iterator iterator = new Itr()
Object next = iterator.next();
System.out.println(next);
Object next1 = iterator.next();
System.out.println(next1);
Object next2 = iterator.next();
System.out.println(next2);........
通过观察源码发现，Itr类中只有next方法有返回值是Object类型的，该方法就是获取元素的方法
我们应该在next方法调用之前，先看一看迭代器中下一个位置上是否有元素，若有元素，才进行调用
Iterator接口中提供了一个方法hasNext()，帮助我们判断下一个位置上是否有元素
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
Itr() {}
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
注意：迭代器iterator只能遍历一次集合中的元素，若还想在遍历一次，则创建一个新的迭代器
迭代器的特点是对 Collection 进行迭代的迭代器，依赖于集合而存在的，只有集合去调用iterator()方法，才能获取集合中的元素
4.2存储自定义对象并遍历 Student(name,age)
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo4 {
public static void main(String[] args) {
//1、创建Collection集合对象
Collection c1 = new ArrayList();
//2、创建元素对象
Student s1 = new Student("小花", 3);
Student s2 = new Student("小白", 5);
Student s3 = new Student("小黑", 6);
Student s4 = new Student("小黄", 2);
//3、将元素对象添加到集合中
c1.add(s1);
c1.add(s2);
c1.add(s3);
c1.add(s4);
// 4、遍历集合
// 方式1：转数组再遍历
Object[] array = c1.toArray();
for (int i = 0; i < array.length; i++) {
Object o = array[i]; //Object o = new Student("小花", 3)
//System.out.println(o); //Student{name='小花', age=3}
Student s = (Student) o;//下转型，因Object类中没有getName()和getAge()方法
System.out.println("姓名：" + s.getName() + ", 年龄：" + s.getAge());
}
System.out.println("------------------------------");
//方式2：迭代器遍历
Iterator iterator = c1.iterator();
while (iterator.hasNext()){
Object o = iterator.next();
Student s = (Student) o;
System.out.println("姓名：" + s.getName() + ", 年龄：" + s.getAge());
}
}
}
三、Iterator接口的原理讲解
为什么不定义成一个类，而是一个接口
假设迭代器定义的是一个类，这样我们就可以创建该类的对象，调用该类的方法实现集合的遍历。但是呢？我们想想，Java中提供了很多集合类，而这些集合类的数据结构是不同的，所以，存储的方式和遍历的方式应该是不同的。进而它们的遍历方式也应该不是一样的，所以，就没有定义迭代器类，而是将其定义成一个接口，通过内部类的方式实现这个接口，将来不同集合实现不同的接口，也体现了不同集合的特点。
四、List接口概述
4.1 List接口概述
有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行★精确地★控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
Collection的子接口：List
特点：有序且元素可以发生重复的集合，且有索引下标的概念。
4.2 List子类
（1）ArrayList
（2）Vector
（3）LinkedList
4.3 List接口成员方法
//List接口中特有的成员方法：（因为List集合有索引的概念，针对索引的操作多了一些方法）
void add(int index,E element) //指定位置索引添加元素到集合中,注意紧跟着最后一个元素后面的索引可以赋值，其他的索引不行
li1.add(2,s5);
E remove(int index) //指定索引删除某个元素，返回被删除的元素
E get(int index) //根据索引获取集合中的元素对象
E set(int index,E element) //指定位置索引，修改元素，返回原本位置上的元素对象
ListIterator listIterator() //List集合专有的迭代器
//一个迭代器对象只有一个游标可以移动
//listIterator()通过观察子类源码发现，底层是返回了一个ListItr类的对象
//ListItr类是继承自Itr类，也拥有hasNext()和next()方法
ListIterator listIterator = li1.listIterator();
while (listIterator.hasNext()){
Object o1 = listIterator.next();
System.out.println(o1);
}
4.4 ListIterator接口的成员方法
boolean hasPrevious() //判断前一个位置上是否有元素
E previous() //将游标向前移动一位，并获取位置上的元素
注意：要想倒着遍历，必选先将迭代器的游标移动到最后一位。
五、ArrayList类概述及使用
5.1 ArrayList类概述
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
5.2 ArrayList案例
存储字符串并遍历
public class ArrayListDemo1 {
public static void main(String[] args) {
//存储字符串并遍历
ArrayList list1 = new ArrayList();
list1.add("hello");
list1.add("world");
list1.add("java");
list1.add("apple");
list1.add("hello");
Iterator iterator = list1.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
存储自定义对象并遍历
import java.util.ArrayList;
/*
去除集合中自定义对象的重复值(对象的成员变量值都相同)
我们按照处理字符串的方式来处理自定义对象，发现自定义对象并没有去重
我们需要取看一看contains()方法的底层逻辑，是调用了元素类中的equals方法进行比较的，而我们自己自定义的类中并没有重写equals方法
所以用的是父亲Object类中的equals方法，比较的是地址值【拿当前的元素与新集合中每一个元素进行比较】，每一个学生对象都是new出来
他们的地址值肯定是不一样的，比较结果永远是false
我们现在要比较成员变量值，Student类重写equals方法即可
*/
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList();
Student s1 = new Student("小黑", 18);
Student s2 = new Student("小白", 17);
Student s3 = new Student("小花", 18);
Student s4 = new Student("小红", 19);
Student s5 = new Student("小黑", 18);
list1.add(s1);
list1.add(s2);
list1.add(s3);
list1.add(s4);
list1.add(s5);
System.out.println("list1: " + list1);
System.out.println("=======================");
//再创建新的集合，遍历旧集合将元素添加到新集合中
//再添加之前，判断一下新集合是否有该元素，若存在，就不添加
ArrayList list2 = new ArrayList();
for (int i = 0; i < list1.size(); i++) {
Student s = (Student) list1.get(i);
/*
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < this.size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
*/
if(!list2.contains(s)){
list2.add(s);
}
}
System.out.println("list2: " + list2);
}
}
六、Vector类概述及使用
6.1 Vector类概述
底层数据结构是数组，查询快，增删慢
线程安全，效率低
6.2 Vector类特有功能
public void addElement(E obj) 等价于 add()
public E elementAt(int index) 等价于 get()
public Enumeration elements() 等价于iterator迭代器
6.3 Vector案例（同上）
存储字符串并遍历
public class VectorDemo1 {
public static void main(String[] args) {
Vector vector = new Vector();
vector.add("hello");
vector.add("world");
vector.add("java");
vector.add("hadoop");
vector.add("hello");
vector.addElement("flink"); // 从效果上来看和调用add方法一样，都是在集合的末尾处添加元素，将来就使用add来替代它
Iterator iterator = vector.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("==============================");
//public E elementAt(int index) 根据索引获取元素
System.out.println(vector.elementAt(2)); // 从效果上来看和调用get方法一样，都是根据索引获取元素，将来就使用get来替代它
System.out.println(vector.get(2));
System.out.println("==============================");
//public Enumeration elements() 获取一个存储所有集合元素的容器，类似于迭代器
// 从效果上来看和使用迭代器一样，都是先判断下一个位置是否有元素，然后再获取，将来就使用迭代器来替代它
Enumeration elements = vector.elements();
while (elements.hasMoreElements()){
Object o = elements.nextElement();
System.out.println(o);
}
}
}
存储自定义对象并遍历(同上)
七、LinkedList类概述及使用
7.1 LinkedList类概述
底层数据结构是双链表，查询慢，增删快
线程不安全，效率高
7.2 LinkedList类特有功能
public void addFirst(E e)及addLast(E e) //在元素第一个位置和最后一个位置插入元素
public E getFirst()及getLast() //获取元素第一个位置和最后一个位置的元素
public E removeFirst()及public E removeLast() //去除元素第一个位置和最后一个位置的元素
7.3 LinkedList案例
存储字符串并遍历（同上）
存储自定义对象并遍历（同上）·
-- List集合练习
ArrayList
(1) 去除集合中字符串的重复值(字符串的内容相同)
public class ArrayListTest1 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("java");
list.add("hello");
list.add("java");
list.add("hadoop");
list.add("hbase");
ArrayList list1 = new ArrayList();
for (int i=0;i<list.size();i++){
String s = (String) list.get(i); //因为List集合没有get()方法，需要借助String中的方法
if (!list1.contains(s)){
list1.add(s);
}
}
System.out.println(list1);
}
}
(2) 去除集合中自定义对象的重复值(对象的成员变量值都相同)
import java.util.ArrayList;
/*
去除集合中自定义对象的重复值(对象的成员变量值都相同)
我们按照处理字符串的方式来处理自定义对象，发现自定义对象并没有去重
我们需要取看一看contains()方法的底层逻辑，是调用了元素类中的equals方法进行比较的，而我们自己自定义的类中并没有重写equals方法
所以用的是父亲Object类中的equals方法，比较的是地址值【拿当前的元素与新集合中每一个元素进行比较】，每一个学生对象都是new出来
他们的地址值肯定是不一样的，比较结果永远是false
我们现在要比较成员变量值，Student类重写equals方法即可
*/
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList();
Student s1 = new Student("小黑",12);
Student s2 = new Student("小黄",11);
Student s3 = new Student("小红",15);
Student s4 = new Student("小雅",9);
Student s5 = new Student("小黑",18);
list1.add(s1);
list1.add(s2);
list1.add(s3);
list1.add(s4);
list1.add(s5);
System.out.println("list1: " + list1);
System.out.println("=======================");
//再创建新的集合，遍历旧集合将元素添加到新集合中
//再添加之前，判断一下新集合是否有该元素，若存在，就不添加
ArrayList list2 = new ArrayList();
for (int i = 0; i < list1.size(); i++) {
Student s = (Student) list1.get(i);
/*
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < this.size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
*/
if(!list2.contains(s)){
list2.add(s);
}
}
System.out.println("list2: " + list2);
}
}
八、Set接口概述
元素唯一且无序，没有索引
分类
(1)HashSet
概述：底层数据结构是哈希表，hashCode()和equals()保证元素的唯一性
子类：LinkedHashSet(底层数据结构是哈希表和双链表，哈希表保证元素的唯一性，双链表保证有序)
(2)TreeSet
概述：底层数据结构是红黑树，可以设置自然排序或比较器排序
自然排序：使用无参构造方法创建TreeSet集合对象，要求元素类实现Comparable<元素类>接口，重写compareTo方法
public class Student2 implements Comparable<Student2> {
private String name;
private int age;
public Student2() {
}
public Student2(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student2 o) {
//这个方法的返回值,决定待插入的元素的顺序,是左边还是右边还是不添加
//这里的逻辑需要我们自己编写
//显式条件:按照年龄从小到大排序
//k.compareTo(t.key)
// this -- k
// o -- t.key
int i = this.age - o.age;
//隐式条件 当年龄一样的时候,比较姓名
return (i == 0) ? this.name.compareTo(o.name) : i;
}
}
比较器排序：使用有参构造方法创建TreeSet集合对象，将实现了Comparator接口且重写compare方法的对象当作构造方法的参数使用
public class TreeSetDemo3 {
public static void main(String[] args) {
TreeSet<Student3> set1 = new TreeSet<>(new Comparator<Student3>() {
@Override
public int compare(Student3 o1, Student3 o2) {
//cpr.compare(key, t.key);
// o1 - key - 待插入的元素
// o2 - t.key - 根的元素
//需求:按照年龄从小到大排序,并去重
int i = o1.getAge() - o2.getAge();
return (i == 0) ? o2.getName().compareTo(o1.getName()) : i;
}
});
九、Map集合
概述：存储元素的特点是每一个元素是一个键值对
Map接口和Collection接口的不同
(1)Map是双列的,Collection是单列的
(2)Map的键唯一,Collection的子体系Set是唯一的
(3)Map集合的数据结构值针对键有效，跟值无关
(4)Collection集合的数据结构是针对元素有效
Map集合共有的特点：
1、Map集合中的元素，键是唯一的，不会在一个Map集合发现两个相同的键
2、Map集合中，值是可以发生重复的
3、Map集合的唯一性，排序都是针对键来说的，值是跟着键走的
成员方法：
V put(K key,V value) //向集合中添加键值对元素 返回的是被覆盖的键对应的那个值
V remove(Object key) //根据键删除一个键值对元素 返回被删除键值对的值
void clear() //清空集合中所有的键值对
boolean containsKey(Object key) //判断键是否存在
boolean containsValue(Object value) //判断值是否存在
boolean isEmpty() //判断集合是否为空
int size() //获取集合中的键值对的个数
V get(Object key) //获取所有的键
Set<K> keySet() //循环遍历每个键
Collection<V> values() //获取所有的值
Set<Map.Entry<K,V>> entrySet() //循环遍历每个键值对组成的对象
方式一：先一次性获取所有的键，遍历键根据键找到值。keySet() 获取map集合中所有的键，返回所有的键组成的一个Set集合
Set<Integer> keys = map1.keySet();
//遍历键集合，得到每一个键
for (Integer key : keys) {
//get() 根据键获取值
String value = map1.get(key);
System.out.println(key + "-" + value);
}
方式二：可以拿到每一键值对组成的一个对象，遍历这个对象中的元素得到每一个键值对中的键和值。
Set<Map.Entry<Integer, String>> entries = map1.entrySet();
for (Map.Entry<Integer, String> entry : entries) {
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"-"+value);
}
分类
HashMap:键是哈希表结构，可以保证键的唯一性
hashMap案例
HashMap<String,String>
HashMap<Integer,String>
HashMap<String,Student>
HashMap<Student,String>
面试题：HashMap和Hashtable的区别
区别1：HashMap中的键和值都允许为null值,Hashtable的键和值都不允许null
区别2：HashMap是线程不安全的，Hashtable是线程安全的，因为它的方法基本都有synchronized
子类：LinkedHashMap(Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序)
HashMap的方法同样适用子类
TreeMap:底层数据结构是红黑树,可以保证键的排序和唯一性
TreeMap案例
HashMap<String,String>
HashMap<Student,String>
例："aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapTest1 {
public static void main(String[] args) {
String s = "aababcabcdabcde";
//创建TreeMap集合
TreeMap<Character, Integer> map1 = new TreeMap<>();
//将字符串转成一个字符数组
char[] chars = s.toCharArray();
//遍历字符数组，得到每一个字符
for (char c : chars) {
//将字符作为键存储在Map集合中
//先判断集合中是否有该键，若没有，就赋值该字符为键，1为值存储【c, 1】
//若集合已经存在该键了，在原来键对应的值基础之上加1 【c,1】-> 【c,2】
if (!map1.containsKey(c)) {
map1.put(c, 1);
} else {
map1.put(c, map1.get(c) + 1);
}
}
//遍历集合，以指定的格式拼接输出
StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character, Integer>> entries = map1.entrySet();
for (Map.Entry<Character, Integer> entry : entries) {
Character key = entry.getKey();
Integer value = entry.getValue();
sb.append(key).append("(").append(value).append(")");
}
String resStr = sb.toString();
System.out.println("结果为：" + resStr);
}
}
集合的嵌套遍历
ArrayList嵌套HashMap
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class TreeMapTest2 {
public static void main(String[] args) {
ArrayList<HashMap<Integer, String>> shuJia = new ArrayList<>();
HashMap<Integer, String> clazz1 = new HashMap<>();
clazz1.put(1001,"小红");
clazz1.put(1002,"小白");
clazz1.put(1003,"小小");
clazz1.put(1001,"小龙");
HashMap<Integer, String> clazz2 = new HashMap<>();
clazz2.put(1001,"小黑");
clazz2.put(1002,"小虎");
HashMap<Integer, String> clazz3 = new HashMap<>();
clazz3.put(1001,"小民");
clazz3.put(1002,"小真");
clazz3.put(1003,"小国");
shuJia.add(clazz1);
shuJia.add(clazz2);
shuJia.add(clazz3);
for (HashMap<Integer, String> clazz : shuJia) {
System.out.println("======================================");
Set<Map.Entry<Integer, String>> entries = clazz.entrySet();
for (Map.Entry<Integer, String> entry : entries) {
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"-"+value);
}
}
}
}
十、增强for循环概述及其使用
增强for概述
简化数组和Collection集合的遍历
格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
好处：简化遍历
注意事项：增强for的目标要判断是否为null
十一、Collections类概述和成员方法
概述：是java提供给我们专门针对集合做操作的工具类
静态成员方法：
public static <T> void sort(List<T> list) //对List集合进行升序排序
public static <T> int binarySearch(List<?> list,T key) //在针对List集合中二分查找某个元素，返回该元素的下标索引
public static <T> T max(Collection<?> coll) //返回集合中最大的元素
public static void reverse(List<?> list) //将集合中的元素反转
public static void shuffle(List<?> list) //将集合中的元素打乱
将不安全的集合变成安全的
static
返回由指定集合支持的同步（线程安全）集合。
举例：我们之前说过Vector即便是线程安全的，我们今后也不用，原因是我们可以通过Collections工具类对ArrayList或其他不安全的集合做操作，变成安全的。
ArrayList<String> list1 = new ArrayList<>();
List<String> list2 = Collections.synchronizedList(list1);
后续用list2,跟不安全的用法一模一样，没有任何区别，只是后续这个List集合是安全的了。
static
返回由指定列表支持的同步（线程安全）列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
返回由指定地图支持的同步（线程安全）映射。
static
返回由指定集合支持的同步（线程安全）集。