01.第一章：Collection集合_集合概述
1).我们知道“集合类”的作用：存储大量对象(引用)。
2).数组的缺点：长度固定；
集合的优点：长度可变；操作比较方便；
3).Java内部提供了大量的“集合类”--按照不同的“存、取方式”。每种集合类的存、取的方式都不相同，就会导致对于“集合内的元素”的“添加、修改、删除、查询”等操作的效率不同。有些存储方式会导致：查询慢，但添加、删除元素快；但有些存储方式会导致：查询快，但添加、删除元慢。这些“存储方式”--数据结构
4).常见的数据结构：
1).数组--ArrayList：查询快；增删慢；
2).链表--LinkedList：查询慢；增删快
3).哈希表--HashSet:查询、增删都快；但所有操作都需要产生一个哈希值；
4).树--TreeSet:对元素排序；
5).图--Map
6).栈--后进先出；
7).队列--先进先出；
5).Java集合体系结构图：
02.第一章：Collection集合_Collection接口中的常用功能：
添加：
1).public boolean add(E e) : 添加一个元素；
添加成员返回：true，对于List集合，永远返回true;
对于Set集合，当添加重复元素时，返回：false;
删除：
2).public void clear():清空集合；
3).public boolean remove(Object o):在集合中删除元素o，成功删除返回true，如果
集合中没有此元素，返回false。
判断：
4).public boolean contains(Object o):判断集合中是否存在对象o,
存在返回true,否则返回false。
5).public boolean isEmpty():判断集合是否为“空集合”
获取：
6).public int size():返回集合内元素的数量；
7).public Object[] toArray():将集合内的所有元素转换为Object数组；
8).public Iterator iterator():获取一个迭代器；用于遍历集合元素的一个对象；
03.第二章：迭代器_迭代器Iterator接口的使用：
public class Demo {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("孙悟空");
list.add("珠宝街");
list.add("铁扇公主");
list.add("红孩儿");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
04.第二章：迭代器_迭代器的实现原理：
常见错误：
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("孙悟空");
list.add("珠宝街");
list.add("铁扇公主");
list.add("红孩儿");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(it.next());
}
}
05.第二章：迭代器_增强for：
1).作用：
1).遍历“数组”：
int[] arr = {1,43,24,32,54};
for(int n : arr){//编译成：普通for循环
System.out.println(n);
}
2).遍历“Collection集合”：
ArrayList<String> list = new ArrayList<>();
list.add("孙悟空");
list.add("猪八戒");
list.add("沙和尚");
list.add("唐三藏");
for(String s : list){//编译成：迭代器
System.out.println(s);
}
06.第三章：泛型_泛型概述及好处：
ArrayList<**String**> list = new ArrayList<>();
好处：可以约束这个集合中只能存储String类型，如果存储其它类型，编译器直接报错；可以减少很多我们在使用集合时容易发生的类型转换错误。
07.第三章：泛型_定义和使用含有泛型的类：
1).定义“支持泛型的类”：
public class MyArrayList<E> {
public void add(E e){
}
public E get() {
return null;
}
}
2).使用：
public static void main(String[] args) {
MyArrayList<String> list = new MyArrayList();
list.add(string类型);
list.get();//String类型；
}
3).“定义泛型”的语法：
class MyArrayList<E>{
}
格式说明：
1).<E>：表示定义“泛型”；
2).E:是随意定义，可以是一个字符，也可以是多个字符；
3).可以同时定义“多个泛型”，中间用“，”号隔开；
public class MyArrayList<E,A,B,C> {
public void add(E e){
}
public E get() {
return null;
}
public void show(A a,B b){
}
public void fun(C c){
}
}
08.第三章：泛型_含有泛型的方法：
1).示例代码：
public class MyArrayList {
public static <T> void show(T t1,T t2,T t3,T t4,T t5){
System.out.println("t1 = " + t1);
System.out.println("t2 = " + t2);
}
}
测试类：
public class Demo {
public static void main(String[] args) {
MyArrayList.<Integer>show(10,20,30,40,50);
MyArrayList.<String>show("aa","bb","cc","dd","ee");
}
}
09.第三章：泛型_含有泛型的接口：
定义具有泛型的接口，同泛型类一样：
public interface IA<E>{
public void show(E e);
}
10.第三章：泛型_泛型通配符：
1).<?> : 表示：具有“任何泛型”的集合都可以：
public static void main(String[] args) {
Collection<Student> stu = new ArrayList<>();
print1(stu);
Collection<Teacher> tea = new ArrayList<>();
print1(tea);
Collection<String> str = new ArrayList<>();
print1(str);
}
//定义一个方法，可以接收"具有任何泛型的集合对象"
public static void print1(Collection<?> list){
}
2).<? extends E> : 表示：具有“E或者E的任何子类泛型”的集合都可以：
public static void main(String[] args) {
Collection<Student> stu = new ArrayList<>();
print2(stu);//OK的
Collection<Teacher> tea = new ArrayList<>();
print2(tea);//OK的
Collection<String> str = new ArrayList<>();
print2(str);//错误
}
//定义一个方法，可以接收"具有Student和Teacher泛型的集合"
public static void print2(Collection<? extends Person> list){
}
3).<? super E> : 表示：具有“E或者E的任何父类泛型”的集合都可以：
public static void main(String[] args) {
Collection<Student> stu = new ArrayList<>();
print3(stu);//OK的
Collection<Teacher> tea = new ArrayList<>()
// print3(tea);//编译错误
Collection<Person> per = new ArrayList<>();
print3(per);//OK的
Collection<Object> obj = new ArrayList<>();
print3(obj);//OK的
}
//定义一个方法，可以接收"具有Student和Person泛型的集合"
public static void print3(Collection<? super Student> list){
}
学习目标总结：
01.能够说出集合与数组的区别
1).数组：长度固定；可以基本类型数组、引用类型数组；
2).集合：长度可变；只能存储“引用类型”；
02.说出Collection集合的常用功能
1).添加：
public boolean add(Object o)：
2).删除：
public void clear():
public boolean remove(Object o):
3).判断：
public boolean contains(Object o):判断参数o在集合中是否存在；
public boolean isEmpty():判断集合是否为“空”；
4).获取：
public int size():获取集合内元素的数量；
public Object[] toArray():将集合转换为数组；
public Iterator iterator():获取一个“迭代器”：
03.能够使用迭代器对集合进行取元素
Collection<String> list =new ArrayList<>();
...
Iterator<String> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
04.能够说出集合的使用细节
Collection<String> list = new ArrayList<>();
list.add(...);
list.add(...);
for(String s : list){//增强for，底层是：迭代器
System.out.println(s);
}
05.能够使用集合存储自定义类型
Collection<Student> list = new ArrayList<>();
list.add(new Student("黄磊",18));
......
......
for(Student stu : list){
System.out.println(stu);
}
06.能够使用foreach循环遍历集合
for(Student stu : list){
System.out.println(stu);
}
07.能够使用泛型定义集合对象
ArrayList<String> list = new ArrayList();
08.能够理解泛型上下限
1).泛型的上限：<? extends Student>:具有Student或者Student的子类泛型；
2).泛型的下限：<? super Student> : 具有Student或者Student的父类类型；
09.能够阐述泛型通配符的作用
1).泛型通配符的作用：规定泛型的范围；
1).<?> : 可以是任何泛型；
2).<? extends E> ：上限为E
3).<? super E> : 下限为E