Java基础班学习笔记（12）集合框架
1:对象数组(掌握)
(1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
(2)案例：
用数组存储5个学生对象，并遍历数组。
2:集合(Collection)(掌握)
(1)集合的由来?
我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组
而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
(2)集合和数组的区别?
A:长度区别
数组固定
集合可变
B:内容区别
数组可以是基本类型，也可以是引用类型
集合只能是引用类型
C:元素内容
数组只能存储同一种类型
集合可以存储不同类型(其实集合一般存储的也是同一种类型)
(3)集合的继承体系结构?
由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。
Collection
|--List
|--ArrayList
|--Vector
|--LinkedList
|--Set
|--HashSet
|--TreeSet
(4)Collection的功能概述(自己补齐)
A:添加功能
B:删除功能
C:判断功能
D:获取功能
E:长度功能
F:交集(了解)
G:把集合转数组(了解)
(5)Collection集合的遍历
A:把集合转数组(了解)
B:迭代器(集合专用方式)
(6)迭代器
A:是集合的获取元素的方式。
B:是依赖于集合而存在的。
C:迭代器的原理和源码。
a:为什么定义为了一个接口而不是实现类?
b:看了看迭代器的内部类实现。
(7)Collection集合的案例(遍历方式 迭代器)
集合的操作步骤：
A:创建集合对象
B:创建元素对象
C:把元素添加到集合
D:遍历集合
A:存储字符串并遍历
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class CollectionDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//创建并添加元素
c.add("hello");
c.add("world");
c.add("java");
//遍历集合
Iterator it = c.iterator();
while(it.hasNext()) {
String s =(String) it.next();
System.out.println(s);
}
}
}
B:存储自定义对象并遍历
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
//getXxx()/setXxx()
}
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class StudentDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//创建学生对象
Student s1 = new Student("林青霞",27);
Student s2 = new Student("风清扬",30);
Student s3 = new Student("刘意",30);
Student s4 = new Student("武鑫",25);
Student s5 = new Student("刘晓曲",16);
//添加元素
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(s5);
//遍历集合
Iterator it = c.iterator();
while(it.hasNext()) {
Student s = (Student)it.next();
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
3:集合(List)(掌握)
(1)List是Collection的子接口
特点：有序(存储顺序和取出顺序一致)，可重复。
(2)List的特有功能：(自己补齐)
A:添加功能
B:删除功能
C:获取功能
D:迭代器功能
E:修改功能
(3)List集合的特有遍历功能
A:由size()和get()结合。
B:代码演示
//创建集合对象
List list = new ArrayList();
//创建并添加元素
list.add("hello");
list.add("world");
list.add("java");
//遍历集合
Iterator it = list.iterator();
while(it.hasNext()) {
String s =(String) it.next();
System.out.println(s);
}
System.out.println("----------");
for(int x=0; x<list.size(); x++) {
String s =(String) list.get(x);
System.out.println(s);
}
(4)列表迭代器的特有功能；(了解)
可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
(5)并发修改异常
A:出现的现象
迭代器遍历集合，集合修改集合元素
B:原因
迭代器是依赖于集合的，而集合的改变迭代器并不知道。
C:解决方案
a:迭代器遍历，迭代器修改(ListIterator)
元素添加在刚才迭代的位置
b:集合遍历，集合修改(size()和get())
元素添加在集合的末尾
(6)常见数据结构
A:栈 先进后出
B:队列 先进先出
C:数组 查询快，增删慢
D:链表 查询慢，增删快
(7)List的子类特点(面试题)
ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
到底使用谁呢?看需求?
分析：
要安全吗?
要：Vector(即使要，也不使用这个，后面再说)
不要：ArrayList或者LinkedList
查询多；ArrayList
增删多：LinkedList
什么都不知道，就用ArrayList。
(8)List集合的案例(遍历方式 迭代器和普通for)
A:存储字符串并遍历
B:存储自定义对象并遍历
-----------------------------------------------------------------------------------------------------------
1:List的子类(掌握)
(1)List的子类特点
ArrayList:
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
Vector:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
LinkedList:
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
(2)ArrayList
A:没有特有功能需要学习
B:案例
a:ArrayList存储字符串并遍历
b:ArrayList存储自定义对象并遍历
(3)Vector
A:有特有功能
a:添加
public void addElement(E obj) -- add()
b:获取
public E elementAt(int index) -- get()
public Enumeration<E> elements() -- iterator()
B:案例
a:Vector存储字符串并遍历
b:Vector存储自定义对象并遍历
(4)LinkedList
A:有特有功能
a:添加
addFirst()
addLast()
b:删除
removeFirst()
removeLast()
c:获取
getFirst()
getLast()
B:案例
a:LinkedList存储字符串并遍历
b:LinkedList存储自定义对象并遍历
(5)案例：
A:去除集合中的多个字符串的重复元素
如果字符串的内容相同，即为重复元素
B:去除集合中的多个自定义对象的重复元素
如果自定义对象的成员变量值都相同，即为重复元素
C:用LinkedList模拟一个栈数据结构的集合类，并测试。
你要定义一个集合类，只不过内部可以使用LinkedList来实现。
2:泛型(掌握)
(1)泛型概述
是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式：
<数据类型>
注意：该数据类型只能是引用类型。
(3)好处：
A:把运行时期的问题提前到了编译期间
B:避免了强制类型转换
C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型的前世今生
A:泛型的由来
Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
B:泛型类
C:泛型方法
D:泛型接口
E:泛型高级通配符
?
? extends E
? super E
(5)我们在哪里使用呢?
一般是在集合中使用。
3:增强for循环(掌握)
(1)是for循环的一种
(2)格式：
for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {
使用该变量即可，该变量其实就是数组或者集合中的元素。
}
(3)好处：
简化了数组和集合的遍历
(4)弊端
增强for循环的目标不能为null。建议在使用前，先判断是否为null。
4:静态导入(了解)
(1)可以导入到方法级别的导入
(2)格式：
import static 包名....类名.方法名;
(3)注意事项：
A:方法必须是静态的
B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。
所以一般我们并不使用静态导入，但是一定要能够看懂。
5:可变参数(掌握)
(1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
(2)格式：
修饰符 返回值类型 方法名(数据类型... 变量) {}
注意：
A:该变量其实是一个数组名
B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
(3)Arrays工具类的一个方法
asList()把数组转成集合。
注意：这个集合的长度不能改变。
6:练习(掌握)
A:集合的嵌套遍历
B:产生10个1-20之间的随机数，要求随机数不能重复
C:键盘录入多个数据，以0结束，并在控制台输出最大值
7:要掌握的代码
集合存储元素，加入泛型，并可以使用增强for遍历。
===========================================================================
1:登录注册案例(理解)
2:Set集合(理解)
(1)Set集合的特点
无序,唯一
(2)HashSet集合(掌握)
A:底层数据结构是哈希表(是一个元素为链表的数组)
B:哈希表底层依赖两个方法：hashCode()和equals()
执行顺序：
首先比较哈希值是否相同
相同：继续执行equals()方法
返回true：元素重复了，不添加
返回false：直接把元素添加到集合
不同：就直接把元素添加到集合
C:如何保证元素唯一性的呢?
由hashCode()和equals()保证的
D:开发的时候，代码非常的简单，自动生成即可。
E:HashSet存储字符串并遍历
F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)
(3)TreeSet集合
A:底层数据结构是红黑树(是一个自平衡的二叉树)
B:保证元素的排序方式
a:自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
b:比较器排序(集合具备比较性)
让集合构造方法接收Comparator的实现类对象
C:把我们讲过的代码看一遍即可
(4)案例：
A:获取无重复的随机数
B:键盘录入学生按照总分从高到底输出
3:Collection集合总结(掌握)
Collection
|--List 有序,可重复
|--ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高
|--Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低
|--LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高
|--Set 无序,唯一
|--HashSet
底层数据结构是哈希表。
如何保证元素唯一性的呢?
依赖两个方法：hashCode()和equals()
开发中自动生成这两个方法即可
|--LinkedHashSet
底层数据结构是链表和哈希表
由链表保证元素有序
由哈希表保证元素唯一
|--TreeSet
底层数据结构是红黑树。
如何保证元素排序的呢?
自然排序
比较器排序
如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定
4:针对Collection集合我们到底使用谁呢?(掌握)
唯一吗?
是：Set
排序吗?
是：TreeSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。
否：List
要安全吗?
是：Vector
否：ArrayList或者LinkedList
查询多：ArrayList
增删多：LinkedList
如果你知道是List，但是不知道是哪个List，就用ArrayList。
如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。
如果你知道用集合，就用ArrayList。
5:在集合中常见的数据结构(掌握)
ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序
===========================================================
1:Map(掌握)
(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
(2)Map和Collection的区别?
A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对
B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍
(3)Map接口功能概述(自己补齐)
A:添加功能
B:删除功能
C:判断功能
D:获取功能
E:长度功能
(4)Map集合的遍历
A:键找值
a:获取所有键的集合
b:遍历键的集合,得到每一个键
c:根据键到集合中去找值
B:键值对对象找键和值
a:获取所有的键值对对象的集合
b:遍历键值对对象的集合，获取每一个键值对对象
c:根据键值对对象去获取键和值
代码体现：
Map<String,String> hm = new HashMap<String,String>();
hm.put("it002","hello");
hm.put("it003","world");
hm.put("it001","java");
//方式1 键找值
Set<String> set = hm.keySet();
for(String key : set) {
String value = hm.get(key);
System.out.println(key+"---"+value);
}
//方式2 键值对对象找键和值
Set<Map.Entry<String,String>> set2 = hm.entrySet();
for(Map.Entry<String,String> me : set2) {
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"---"+value);
}
(5)HashMap集合的练习
A:HashMap<String,String>
B:HashMap<Integer,String>
C:HashMap<String,Student>
D:HashMap<Student,String>
(6)TreeMap集合的练习
A:TreeMap<String,String>
B:TreeMap<Student,String>
(7)案例
A:统计一个字符串中每个字符出现的次数
B:集合的嵌套遍历
a:HashMap嵌套HashMap
b:HashMap嵌套ArrayList
c:ArrayList嵌套HashMap
d:多层嵌套
2:Collections(理解)
(1)是针对集合进行操作的工具类
(2)面试题：Collection和Collections的区别
A:Collection 是单列集合的顶层接口，有两个子接口List和Set
B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等
(3)常见的几个小方法：
A:public static <T> void sort(List<T> list)
B:public static <T> int binarySearch(List<?> list,T key)
C:public static <T> T max(Collection<?> coll)
D:public static void reverse(List<?> list)
E:public static void shuffle(List<?> list)
(4)案例
A:ArrayList集合存储自定义对象的排序
B:模拟斗地主洗牌和发牌
C:模拟斗地主洗牌和发牌并对牌进行排序
1:集合(自己补齐)
Collection(单列集合)
List(有序,可重复)
ArrayList底层数据结构是数组,查询快,增删慢线程不安全,效率高Vector底层数据结构是数组,查询快,增删慢线程安全,效率低LinkedList底层数据结构是链表,查询慢,增删快线程不安全,效率高
Set(无序,唯一)
HashSet底层数据结构是哈希表。哈希表依赖两个方法：hashCode()和equals()执行顺序：首先判断hashCode()值是否相同是：继续执行equals(),看其返回值是true:说明元素重复，不添加是false:就直接添加到集合否：就直接添加到集合最终：自动生成hashCode()和equals()即可LinkedHashSet底层数据结构由链表和哈希表组成。由链表保证元素有序。由哈希表保证元素唯一。TreeSet底层数据结构是红黑树。(是一种自平衡的二叉树)如何保证元素唯一性呢?根据比较的返回值是否是0来决定如何保证元素的排序呢?两种方式自然排序(元素具备比较性)让元素所属的类实现Comparable接口比较器排序(集合具备比较性)让集合接收一个Comparator的实现类对象
Map(双列集合)
A:Map集合的数据结构仅仅针对键有效，与值无关。
B:存储的是键值对形式的元素，键唯一，值可重复。
HashMap
底层数据结构是哈希表。线程不安全，效率高
哈希表依赖两个方法：hashCode()和equals()
执行顺序：
首先判断hashCode()值是否相同
是：继续执行equals(),看其返回值
是true:说明元素重复，不添加
是false:就直接添加到集合
否：就直接添加到集合
最终：
自动生成hashCode()和equals()即可
LinkedHashMap
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
Hashtable
底层数据结构是哈希表。线程安全，效率低
哈希表依赖两个方法：hashCode()和equals()
执行顺序：
首先判断hashCode()值是否相同
是：继续执行equals(),看其返回值
是true:说明元素重复，不添加
是false:就直接添加到集合
否：就直接添加到集合
最终：
自动生成hashCode()和equals()即可
TreeMap
底层数据结构是红黑树。(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象
2:到底使用那种集合(自己补齐)
看需求。
是否是键值对象形式:
是：Map
键是否需要排序:
是：TreeMap
否：HashMap
不知道，就使用HashMap。
否：Collection
元素是否唯一:
是：Set
元素是否需要排序:
是：TreeSet
否：HashSet
不知道，就使用HashSet
否：List
要安全吗:
是：Vector(其实我们也不用它,后面我们讲解了多线程以后，我在给你回顾用谁)
否：ArrayList或者LinkedList
增删多：LinkedList
查询多：ArrayList
不知道，就使用ArrayList
不知道，就使用ArrayList
3:集合的常见方法及遍历方式
Collection:
add()
remove()
contains()
iterator()
size()
遍历：
增强for
迭代器
|--List
get()
遍历：
普通for
|--Set
Map:
put()
remove()
containskey(),containsValue()
keySet()
get()
value()
entrySet()
size()
遍历：
根据键找值
根据键值对对象分别找键和值
作业：
我讲解过的任意一个集合，我要求你存储什么，你就能够存储什么。
并且，还要能够遍历出来。
4:ArrayList,LinkedList,HashSet,HashMap(掌握)
存储字符串和自定义对象数据并遍历
5:集合的嵌套遍历(理解)
