第一章 Collection集合
1.1 集合概述
- 集合：是Java中提供的一种容器，可以用来存储多个数据
- 集合和数组都是容器，区别：
- 数组的长度是固定的，集合的长度是可变的
- 数组中存储的是同一类型的元素，可以存储基本数据类型的值和对象。集合只能存储对象，而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
int[] arr = new int[10]; //基本数据类型
Student[] stu = new Student[3]; //对象
1.2 集合的框架
- 学习集合的目标：
- 会使用集合存储数据
- 会遍历集合，把数据取出来
- 掌握每种集合的特性
- 集合框架的学习方式：
- 学习顶层：学习顶层结构/抽象类中共性的方法，所有的子类都可以使用
- 使用底层：顶层不是借口就是抽象类，无法创建对象使用，需要使用底层的子类创建对象使用
- List接口：Vector,ArrayList,LinkedList
- 有序的集合（存储和取出元素顺序相同）
- 允许存储重复的元素
- 有索引，++可以使用普通的for循环++遍历
- Set接口：TessSet,HashSet|LinkedHashSet
- 有序无序都有：
- TessSet和HashSet——>无序集合(存储和取出元素顺序不一定相同)
- LinkedHashSet——>有序集合
- 不允许存储重复的元素
- 没有索引，++不能使用普通的for循环++遍历
- Collection接口：List和Set两个子接口
- 定义的是所有单列集合中共性的方法
- 所有的单列集合都可以使用共性的方法
- 没有带索引的方法
- 注：继承–>子类共性抽取，形成父类（接口）
1.3 Collection集合
- 单列集合的体系结构：
- List：
- ArrayList：底层是数组实现的，查询快，增删慢
- LinkedList：底层是链表实现的，查询慢，增删快
- Set：
- HashSet：底层是哈希表+（红黑树）实现的，无索引，不可以存储重复元素，存取无序
- LinkedHashSet：底层是哈希表+链表实现的，无索引，不可以存储重复的元素，可以保证存取顺序【!】
- TreeSet：底层是二叉树实现的，一般用于排序
- Collection集合常用的方法：
- boolean add(E e);
Collection<String> coll = new ArrayList<>();
coll.add("Hello");
coll.add("World");
coll.add("Java");
System.out.println(coll); //[Hello, World, Java]
- boolean remove(E e);
Collection<String> coll = new ArrayList<>();
coll.add("Hello");
coll.add("World");
coll.add("Java");
boolean result = coll.remove("Hello");
System.out.println(result); //true
System.out.println(coll); //[World, Java]
- void clear();
Collection<String> coll = new ArrayList<>();
coll.add("Hello");
coll.add("World");
coll.add("Java");
coll.clear();
System.out.println(coll); //[]
- boolean contains(E e);
Collection<String> coll = new ArrayList<>();
coll.add("Hello");
coll.add("World");
coll.add("Java");
boolean result = coll.contains("Java");
System.out.println(result); //true
boolean result1 = coll.contains("Demo");
System.out.println(result1); //false
- boolean isEmpty();
Collection<String> coll = new ArrayList<>();
coll.add("Hello");
coll.add("World");
coll.add("Java");
boolean result = coll.isEmpty();
System.out.println(result); //false
- int size();
Collection<String> coll = new ArrayList<>();
coll.add("Hello");
coll.add("World");
coll.add("Java");
int size = coll.size();
System.out.println(size); //3
- Object[] toArray();
Collection<String> coll = new ArrayList<>();
coll.add("Hello");
coll.add("World");
coll.add("Java");
Object[] obj = coll.toArray();
//如果不是数组不能使用Arrays.toString方法
System.out.println(Arrays.toString(obj)); //[Hello, World, Java]
1.4 Collection集合常用功能
- （API）Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。
- java.util.Collection接口
- 所有单利集合的最顶层接口，里面定义了所有单利集合共性方法，任意的单利集合都可以使用Collection接口中的方法
- 共性的方法：
public static void main(String[] args) {
//创建集合对象
Collection<String> coll = new ArrayList<>();
System.out.println(coll); //[]——>重写了toString方法
//add——返回值boolean，一般都是true，所以不用写
boolean b1 = coll.add("张三");
System.out.println("b1:" + b1); //b1:true
coll.add("李四");
coll.add("王五");
coll.add("赵六");
coll.add("田七");
System.out.println(coll); //[张三, 李四, 王五, 赵六, 田七]
//remove——返回值boolean，存在元素删除，返回true
boolean b2 = coll.remove("赵六");
System.out.println("b2=" + b2); //b2=true
boolean b3 = coll.remove("赵四");
System.out.println("b3=" + b3); //b3=false
System.out.println(coll); //[张三, 李四, 王五, 田七]
//contains——boolean，包含返回true
boolean b4 = coll.contains("李四");
System.out.println("b4=" + b4); //b2=true
boolean b5 = coll.contains("赵四");
System.out.println("b5=" + b5); //b2=true
//isEmpty——boolean,为空返回true
boolean b6 = coll.isEmpty();
System.out.println("b6:" + b6); //b6:false
//size——返回集合中元素的个数
int size = coll.size();
System.out.println("size:" + size); //size:4
//toArray——把集合中的元素，存储到数组中
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " "); //张三 李四 王五 田七
}
System.out.println();
//clear——清空集合元素
coll.clear();
System.out.println(coll); //[]
System.out.println(coll.isEmpty()); //true
}
//结果：
[]
b1:true
[张三, 李四, 王五, 赵六, 田七]
b2=true
b3=false
[张三, 李四, 王五, 田七]
b4=true
b5=false
b6:false
size:4
张三 李四 王五 田七
[]
第二章 Iterator迭代器
2.1 Iterator接口
- 迭代的产生：
- 在程序开发中，经常需要遍历集合中的所有元素。（例如Set集合无索引：不能使用普通的for循环遍历）
- 针对这种需求，JDK专门提供了一个接口
- 通用的取出集合中元素的方式，不管哪个集合，都可以用迭代器取出元素
- 迭代的概念：（取出方式专业术语：迭代）
- 迭代：对Collection集合元素的通用获取方式。
- 取元素之前先判断有没有元素，如果有就取出来，在判断有没有元素，一直把所有的元素取出来。
- 遍历的过程中，不能对集合中的元素进行增删改查
- java.util.Iterator接口：迭代器（对集合进行遍历）
- 两个常用的方法：hasNext,next
- boolean hasNext()——（判断还有没有下一个元素）
- E next()——（取出集合中的下一个元素）
- 获取实现类的方式：（Collection接口中的iterator方法）
- Iterator迭代器，是一个接口，我们无法直接使用它，需要使用Iterator接口的实现类对象。
- Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现类对象
- Iterator iterator()
- 返回在此 collection 的元素上进行迭代的迭代器。
- 迭代器的使用步骤【重点】：
- 使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）
- 使用Iterator接口中的方法hasNext判断还有没有下一个元素
- 使用Iterator接口中的方法next取出集合中的下一个元素（并且将指针移动一位）
2.2 Iterator的代码实现
- 注：Iterator接口也是泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
- 注：没有元素，再取元素（next）：会抛出NOSuchElementException没有元素异常
- 通过2.1步骤发现，迭代器取出元素是一个重复的过程，所以可以用循环优化
- 不知道集合中有多少元素，所以使用while循环
- 循环条件：hasNext方法返回false
//创建一个集合对象
Collection<String> coll = new ArrayList<>();
//添加元素
coll.add("姚明");
coll.add("库里");
coll.add("詹姆斯");
coll.add("科比");
coll.add("乔丹");
//1. 使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）
//左边接口，右边实现类对象
Iterator<String> it = coll.iterator();
while(it.hasNext()){
String e = it.next();
System.out.println(e);
}
- for循环作为了解
- 因为next()方法不仅取下一个元素（并且将指针移动一位）
for(Iterator<String> it2 = coll.iterator(); it.hasNext;){
String e = it.next();
System.out.println(e);
}
2.3 Iterator的实现原理
2.4 增强for循环
- 增强for循环（也称为for each循环），是JDK1.5以后出现的一个高级for循环
- 专门用来遍历数组和集合的【重点】。它的内部原理其实是一个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删改查【!】
- 必须有被遍历的目标，目标只能是Collection集合和数组
- public interface Collectionextends Iterable
- 格式：
for(集合/数组的数据类型 变量名 : 集合/数组名){
//循环体语句;
}
public class Demo02Foreach {
public static void main(String[] args) {
//使用增强for遍历数组
demo01(); //1 2 3 4 5
System.out.println();
//使用增强for遍历集合
doem02(); //aaa bbb ccc ddd
}
//使用增强for遍历数组
private static void demo01() {
int[] arr = {1, 2, 3, 4, 5};
for(int i : arr){
System.out.print(i + " ");
}
}
//使用增强for遍历集合
private static void doem02() {
ArrayList<String> listA = new ArrayList<>();
listA.add("aaa");
listA.add("bbb");
listA.add("ccc");
listA.add("ddd");
for(String s : listA){
System.out.print(s + " ");
}
}
}
2.5 迭代器&增强for总结
- 迭代器&增强for的初衷
- 随着集合学习的增加，List接口下有索引还是可以使用for循环的，但是Set接口中有无索引的，就不能使用for循环了。——>所以提供了通用的遍历方式
- Iterater迭代器遍历——>集合
- 增强for循环遍历——>集合，数组
public static void main(String[] args) {
Collection<String> coll = new ArrayList<>();
coll.add("Hello");
coll.add("World");
coll.add("Java");
//使用迭代器遍历集合
Iterator<String> it = coll.iterator();
while (it.hasNext()){
String s = it.next();
System.out.print(s + " ");
}
System.out.println();
System.out.println("=========");
//使用增强for循环遍历集合
for(String a : coll){
System.out.print(a + " ");
}
System.out.println();
System.out.println("=========");
//使用增强for循环遍历数组
int[] arr = {1, 2, 3, 4, 5};
for(int b : arr){
System.out.print(b + " ");
}
}
//结果：
Hello World Java
=========
Hello World Java
=========
1 2 3 4 5
第三章 泛型
3.1 泛型的概念
- 泛型：
- 可以看成一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。
- 也可以看成是一个变量，可以接收任意的数据类型
E e：Element元素
T t：Type类型
- 例：ArrayList集合在定义的时候，不知道集合中会存储什么类型的数据，所以使用泛型。
- ArrayList集合中泛型的应用
public class ArrayList<E> {
public boolean add(E e) {}
public E get(int index) {}
}
- 创建集合对象的使用，就会确定泛型的数据类型
ArrayList<String> listA = new ArrayList<>();
- 这时候E就被确定为String
public class ArrayList<String> {
public boolean add(String e) {}
public String get(int index) {}
}
3.2 使用泛型的好处
- 创建集合对象，不使用泛型：
- 好处：
- 集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
- 弊端：
public class Demo01Generic {
public static void main(String[] args) {
show01();
}
//创建集合对象，不使用泛型
private static void show01() {
ArrayList listA = new ArrayList();
listA.add("abc");
listA.add(1);
//使用迭代器遍历listA集合
Iterator it = listA.iterator();
while (it.hasNext()){
//取出元素也是Object类型
Object arr = it.next();
System.out.print(arr + " "); //abc 1
//想要使用String特有的length方法，多态Object arr = "abc";
//需要向下转型
//会抛出ClassCastException类型转换异常，不能把Integer类型转换为String类型
String s = (String)arr;
System.out.println(s);
}
}
}
- 注：多态的弊端：不能使用子类特有的方法（需要向下转型）
- 创建集合对象，使用泛型：
- 好处：
- 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
- 把运行期异常（代码运行之后会抛出的异常），提示到了编译期（写代码的时候会抛出的异常）
- 弊端：
public class Demo01Generic {
public static void main(String[] args) {
show02();
}
//创建集合对象，使用泛型
private static void show02() {
ArrayList<String> listB = new ArrayList();
listB.add("abc");
listB.add("bcd");
Iterator<String> it = listB.iterator();
while (it.hasNext()){
String arr = it.next();
System.out.print(arr + "->" + arr.length() + " ");
}
}
}
//结果：
abc->3 bcd->3
3.3 定义与使用含有泛型的类
- 定义格式：
public class 类名称<E> {
private E 成员变量名;
public E getName() {
return 成员变量名;
}
public void setName(E 成员变量名) {
this.成员变量名 = 成员变量名;
}
}
- 定义一个含有泛型的类：（模拟ArrayList集合）
//定义一个泛型类：GenericCalss.java
public class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
//主方法：Demo01GenericCalss.java
public static void main(String[] args) {
//不写泛型，默认是Object类型
GenericClass gc = new GenericClass();
gc.setName("不使用泛型只能是字符串");
Object name = gc.getName();
System.out.println(name); //不使用泛型只能是字符串
//创建对象，泛型使用Integer类型
GenericClass<Integer> gc1 = new GenericClass<>();
gc1.setName(234);
Integer name1 = gc1.getName();
System.out.println(name1); //234
//创建对象，泛型使用String类型
GenericClass<String> gc2 = new GenericClass<>();
gc2.setName("String类型的泛型");
String name2 = gc2.getName();
System.out.println(name2); //String类型的泛型
}
//结果：
不使用泛型只能是字符串
234
String类型的泛型
3.4 定义与使用含有泛型的方法
- 泛型定义在方法的位置：
- 普通方法：修饰符和返回值类型之间
- 静态方法：static和返回值类型之间
- 定义格式：
修饰符 <泛型> 返回值类型 方法名 （参数（使用泛型））{
方法体;
}
- 含有泛型的方法，在调用泛型方法的时候，确定泛型的数据类型
//定义一个含有泛型方法的类：GenericMethod.java
public class GenericMethod {
//定义一个含有泛型的方法
public <M> M method01(M m){
return m;
}
//定义一个含有泛型的静态方法
public static <M> void method02(M m){
System.out.println(m);
}
}
//主方法：Demo03GenericMethod.java
public static void main(String[] args) {
//创建一个对象
GenericMethod gm = new GenericMethod();
//调用泛型方法method01
System.out.println(gm.method01(10));
System.out.println(gm.method01(2.2));
System.out.println(gm.method01(true));
System.out.println(gm.method01("abcd"));
System.out.println("============");
GenericMethod.method02(20);
GenericMethod.method02("jjj");
}
//结果：
10
2.2
true
abcd
============
20
jjj
3.5 定义与使用含有泛型的接口
- 定义格式：
public interface 接口名<I> {
public abstract void 方法名(I i);
}
- 使用方法：
- 定义接口的实现类，实现接口，并且指定接口的泛型
public class 实现类名 implements 接口名<直接指定泛型类型>
- 【常用】接口使用什么泛型，实现类就使用什么泛型，实现类跟着接口走
- 就相当于定义了一个含有泛型的类——创建对象的时候确定泛型
public class 实现类名<泛型> implements 接口名<泛型>
//定义的接口
public interface GenericInterface<I> {
public abstract void method(I i);
}
//第一种方法的实现类
public class GenericInterfaceImpl implements GenericInterface<String> {
@Override
public void method(String s) {
System.out.println(s);
}
}
//第二种方法的实现类
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
@Override
public void method(I i) {
System.out.println(i);
}
}
//主方法
public static void main(String[] args) {
//创建GenericInterfaceImpl对象
GenericInterfaceImpl gi1 = new GenericInterfaceImpl();
gi1.method("abc");
//创建GenericInterfaceImpl2对象
GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
gi2.method(234);
}
//结果：
abc
234
3.6 泛型通配符
- 当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。
- 一旦使用了泛型通配符，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
- 通配符的基本使用
- 不知道使用什么类型接收【重点】的时候，此时可以使用?,?表示未知通配符
- 使用方式：
- 不能创建对象使用
- 只能作为方法的参数使用
- 注：泛型没有继承概念的
- ArrayList listA = new ArrayList(); //错
public class Demo05Generic {
public static void main(String[] args) {
ArrayList<Integer> listA = new ArrayList<>();
listA.add(1);
listA.add(2);
ArrayList<String> listB = new ArrayList<>();
listB.add("abc");
listB.add("def");
printArray(listA);
printArray(listB);
}
//定义一个方法可以遍历所有类型的ArrayList集合
//这时候我们不知道ArrayList集合使用的什么数据类型，可以使用泛型的？通配符来接收数据
public static void printArray(ArrayList<?> list){
//使用迭代器遍历集合
Iterator<?> it = list.iterator();
while (it.hasNext()){
Object next = it.next();
System.out.print(next + " ");
}
}
}
//结果：
1 2 abc def
3.7 泛型通配符高级使用—受限泛型（了解）
- 之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。
- 但是在Java的泛型中，可以指定一个泛型的上限和下限
- 泛型的上限：
- 格式：
类型名称 <? extends 类> 对象名称
- 意义：
- 泛型的下限：
- 格式：
类型名称 <? super 类> 对象名称
- 意义：
- 对比：
- 泛型的上限限定：？ extends E
- 泛型的下限限定：？ super E
- 代表使用的泛型只能是E类型的父类/本身
3.8 泛型的总结
第四章 集合总和案例
4.1 案例介绍
4.2 案例分析
- 工具类Collections类中的shuffle方法——会随机打乱集合中元素的顺序
- static void shuffle(List<?> list)
- 使用指定的随机源对指定列表进行置换
4.3 案例实现
/*
斗地主
1. 准备牌
2. 洗牌
3. 发牌
4. 看牌
*/
public static void main(String[] args) {
//1.准备牌
//定义一个ArrayList集合，泛型用String
ArrayList<String> poker = new ArrayList<>();
//定义两个数字，一个存储花色，一个存储牌序号
String[] colors = {"♠", "♥", "♣", "♦"};
String[] numbers = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
//先把大王小王存储到poker集合中
poker.add("大王");
poker.add("小王");
//用增强for循环嵌套遍历两个数字组合成52张牌
for (String color : colors) {
for (String number : numbers) {
//System.out.println(color + number);
//把组装的牌存到poker集合中
poker.add(color + number);
}
}
//2.洗牌(工具类Collections类中的shuffle方法)
Collections.shuffle(poker);
//3.发牌（定义四个集合：玩家的牌和底牌）
ArrayList<String> palyer01 = new ArrayList<>();
ArrayList<String> palyer02 = new ArrayList<>();
ArrayList<String> palyer03 = new ArrayList<>();
ArrayList<String> diPai = new ArrayList<>();
//遍历poker集合，获取每一张牌
//使用poker的索引%3给三个玩家轮流发牌
//剩余三张给底牌
//注：先判断底牌(i >= 51),否则没牌了
for (int i = 0; i < poker.size(); i++) {
//获取每一张牌
String p = poker.get(i);
if(i >= 51){//发底牌
diPai.add(p);
}else if(i % 3 == 0){//给玩家一
palyer01.add(p);
}else if(i % 3 == 1){//给玩家二
palyer02.add(p);
}else if(i % 3 == 2){//给玩家三
palyer03.add(p);
}
}
//4.看牌
System.out.println("刘德华的牌：" + palyer01);
System.out.println("周润发的牌：" + palyer02);
System.out.println("周星驰的牌：" + palyer03);
System.out.println("底牌牌：" + diPai);
}
//结果：
刘德华的牌：[♣Q, ♥3, ♥10, ♣3, ♥8, ♠10, ♠9, ♥Q, ♠Q, ♠A, ♦3, ♦8, ♦9, ♠4, ♠5, ♦10, ♠2]
周润发的牌：[♥6, 大王, ♥4, 小王, ♥2, ♦2, ♥9, ♥5, ♣10, ♣A, ♦5, ♦4, ♠8, ♦A, ♦J, ♥A, ♦Q]
周星驰的牌：[♥K, ♠6, ♠K, ♣7, ♥J, ♣K, ♣2, ♣5, ♣J, ♠7, ♦6, ♠J, ♦K, ♦7, ♣4, ♥7, ♠3]
底牌牌：[♣6, ♣8, ♣9]
