@学习记录
开始学习Java
遵从同学的指导，从Java se开始学习
黑马的JavaSE零基础入门【Collection、泛型】
第一章 Collection集合
1.1 集合概述
day13-02 Collection集合概述
1.2 集合框架
day13-03 Collection集合概述
纠错：顶层而不是底层
1.3 Collection常用功能
day13-04 Collection集合常用功能
package day13.Demo01;
import java.util.ArrayList;
import java.util.Collection;
/*
java.util.Collection接口
所有单列集合的最顶层的接口，里边定义了所有单列集合共性的方法
任意的单列集合都可以使用Collection接口中的方法
共性的方法：
public boolean add(E e); 把给定的对象添加到当前集合中
public void clear(); 清空集合中所有的元素
public boolean remove(E e); 把给定的对象在当前集合中删除
public boolean contains(E e); 判断当前集合中是否包含给定的对象
public boolean isEmpty(); 判断当前集合是否为空
public int size(); 返回集合中元素的个数
public Object[] toArray(); 把集合中的元素存储到数组
*/
public class Demo01Collection {
public static void main(String[] args) {
// 创建集合对象，可以使用多态
Collection<String> collection = new ArrayList<>(); // set接口下的集合也可以使用上述方法
System.out.println(collection); // [] 重写了toString方法
System.out.println("====================");
// public boolean add(E e); 把给定的对象添加到当前集合中
// 返回值是一个boolean值，一般是true，所以可以不用接收
collection.add("a");
System.out.println(collection);
collection.add("aseg");
collection.add("g");
collection.add("seg");
collection.add("fgdj");
collection.add("myt");
collection.add("eht");
System.out.println(collection);
System.out.println("====================");
// public boolean remove(E e); 把给定的对象在当前集合中删除
// 返回值是一个boolean值，集合中存在，删除元素，返回true;否则，返回false
boolean remove = collection.remove("g");
System.out.println(remove);
System.out.println(collection);
boolean remove1 = collection.remove("jsiod");
System.out.println(remove1);
System.out.println("====================");
// public boolean contains(E e); 判断当前集合中是否包含给定的对象
boolean contains = collection.contains("jdofig");
System.out.println(contains);
boolean contains1 = collection.contains("fgdj");
System.out.println(contains1);
System.out.println("====================");
// public boolean isEmpty(); 判断当前集合是否为空
boolean empty = collection.isEmpty();
System.out.println(empty);
System.out.println("====================");
// public int size(); 返回集合中元素的个数
System.out.println(collection.size());
System.out.println("====================");
// public Object[] toArray(); 把集合中的元素存储到数组
Object[] array = collection.toArray();
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("====================");
// public void clear(); 清空集合中所有的元素,但是不删除集合，集合还存在
collection.clear();
System.out.println(collection); // []
System.out.println(collection.isEmpty());
}
}
第二章 Iterator迭代器（Collection集合的遍历）
2.1 Iterator接口
day13-05 Iterator接口介绍
/*
java.util.Iterator接口：迭代器（随集合进行遍历）
有两个常用的方法：
1. boolean hasNext(); 如果仍有元素可以迭代，返回true，否则，返回false
2. E next(); 返回迭代的下一个元素
Iterator迭代器是一个接口，无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
Collection接口中iterator()的方法，返回的就是迭代器的实现类对象
Iterator<E> iterator(); 返回在此collection 的元素上进行迭代的迭代器
【迭代器的使用步骤】：
1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）
2.使用Iterator接口中的方法hasNext()判断是否有下一个元素
3.使用Iterator接口中的方法Next()去除集合中的下一个元素
*/
day13-06 迭代器的代码实现
package day13.Demo02;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
java.util.Iterator接口：迭代器（随集合进行遍历）
有两个常用的方法：
1. boolean hasNext(); 如果仍有元素可以迭代，返回true，否则，返回false
2. E next(); 返回迭代的下一个元素
Iterator迭代器是一个接口，无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
Collection接口中iterator()的方法，返回的就是迭代器的实现类对象
Iterator<E> iterator(); 返回在此collection 的元素上进行迭代的迭代器
【迭代器的使用步骤】：
1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）
2.使用Iterator接口中的方法hasNext()判断是否有下一个元素
3.使用Iterator接口中的方法Next()去除集合中的下一个元素
*/
public class Demo01Iterator {
public static void main(String[] args) {
// 创建一个集合对象
Collection<String> collection = new ArrayList<>();
// 添加元素
collection.add("一");
collection.add("二");
collection.add("三");
collection.add("四");
collection.add("五");
collection.add("六");
// 获取迭代器实现类对象
Iterator<String> iterator = collection.iterator();
boolean b = iterator.hasNext();
System.out.println(b);
iterator.next();
boolean b1 = iterator.hasNext();
System.out.println(b1);
System.out.println("==============");
// 迭代器的循环优化
// 不知道集合中元素的个数，可以用while
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
2.2 迭代器的实现原理
day13-07 迭代器的实现原理
2.3 增强for(专门用来遍历数组和集合)
它的内部原理其实是一个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
练习1：遍历数组
练习2：遍历集合
day13-08 增强for循环
package day13.Demo02;
import java.util.ArrayList;
import java.util.Collection;
/*
增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写
是JDK1.5之后出现的新特性
Collection<E>extends Iterable<E>; 所有的单列集合都可以使用增强for
public interface Iterable<T>实现这个接口允许对象成为foreach语句的目标
增强for循环：用来遍历集合和数组
格式：
for(集合/数组的数据类型 变量名: 集合名/数组名) {
System.out.println(变量名);
}
*/
public class Demo02Foreach {
public static void main(String[] args) {
demo01();
System.out.println("============");
demo02();
}
// 使用增强for循环遍历数组
private static void demo01() {
int[] array = {
1,2,3,4,5};
for (int i: array) {
System.out.println(i);
}
}
// 使用增强for循环遍历集合
private static void demo02() {
Collection<String> collection = new ArrayList<>();
collection.add("熊");
collection.add("饼干");
collection.add("可乐");
collection.add("数字");
collection.add("钥匙串");
collection.add("口罩");
for (String str: collection) {
System.out.println(str);
}
}
}
第三章 泛型
3.1 泛型概述
day13-09 泛型的概念
3.2 使用泛型的好处
day13-10 使用泛型的好处
package day13.Demo03;
import java.util.ArrayList;
import java.util.Iterator;
/*
*/
public class Demo01Generic {
public static void main(String[] args) {
// show01();
// System.out.println("===============");
show02();
}
// 创建集合对象，不使用泛型
// 好处：集合的默认类型是Object类型，可以存储任意类型的数据
// 弊端：不安全，会引发异常
private static void show01() {
ArrayList list = new ArrayList();
list.add("cvnuio");
list.add(47);
// 使用迭代器遍历集合
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println(obj);
// 想要使用String类特有的方法.length方法获取字符串的长度
// 需要向下转型
String str = (String) obj;
System.out.println(str.length()); // 会抛出类型转换异常，不能把Integer类型转换为String类型
}
}
/*
创建集合对象，使用泛型
好处：
1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
2.把运行期异常提升到了编译期
弊端：泛型是什么类型，只能存储什么类型的数据
*/
private static void show02() {
ArrayList<String> list = new ArrayList<>();
list.add("bgo");
// list.add(345);
// 使用迭代器遍历集合
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
System.out.println(s);
System.out.println(s.length());
}
}
}
3.3 泛型的定义与使用
定义和使用含有泛型的类
含有泛型的方法
含有泛型的接口
day13-11 定义和使用含有泛型的类
package day13.Demo03;
/*
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知的数据类型，不确定数据类型时，可以使用泛型
泛型可以接收任意的数据类型，可以是Integer, String, Student...
创建对象的时候确定泛型的数据类型
*/
public class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
package day13.Demo03;
public class Demo02GenericClass {
public static void main(String[] args) {
// 不写泛型，默认Object类型
GenericClass genericClass = new GenericClass();
genericClass.setName("hcoiv");
Object obj = genericClass.getName();
// 创建GenericClass对象，泛型使用Integer类型
GenericClass<Integer> genericClass1 = new GenericClass<>();
genericClass1.setName(86);
Integer name = genericClass1.getName();
System.out.println(name);
// 创建GenericClass对象，泛型使用String类型
GenericClass<String> genericClass2 = new GenericClass<>();
genericClass2.setName("cvou");
String name1 = genericClass2.getName();
System.out.println(name1);
}
}
day13-12 定义和使用含有泛型的方法
package day13.Demo03;
/*
定义一个含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间
格式：
修饰符 <泛型> 返回值类型 方法名（参数列表（使用泛型）） {
方法体
}
含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型
*/
public class GenericMethod<E> {
// 定义一个含有泛型的方法
public <M> void method (M m) {
System.out.println(m);
}
// 定义一个含有泛型的静态方法
public static <S> void method1(S s) {
System.out.println(s);
}
}
package day13.Demo03;
/*
测试含有泛型的方法
*/
public class Demo03GenericMethod {
public static void main(String[] args) {
// 创建对象
GenericMethod genericMethod = new GenericMethod();
// 传递的数据的类型决定泛型的类型
genericMethod.method("dfnpi");
genericMethod.method(340);
genericMethod.method(false);
System.out.println("===================");
// 静态方法，通过类型.方法名可以直接调用
GenericMethod.method1("vnouifds");
GenericMethod.method1(165);
}
}
day13-13 定义和使用含有泛型的接口
package day13.Demo03;
/*
定义含有泛型的接口
*/
public interface GenericInterface<I> {
public abstract void method(I i);
}
package day13.Demo03;
/*
含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
public interface Iterator<E> {
E.next();
}
Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String
public final class Scanner implements Iterator<String> {
public String next() {}
}
*/
public class GenericInterfaceImpl1 implements GenericInterface<String> {
@Override
public void method(String s) {
System.out.println(s);
}
}
package day13.Demo03;
/*
含有泛型的接口，第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
public interface List<E> {
boolean add(E e);
E get(int index);
}
public class ArrayList<E> implements List<E> {
public boolean add(E e);
public E get(int index);
}
*/
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
@Override
public void method(I i) {
System.out.println(i);
}
}
package day13.Demo03;
/*
测试含有泛型的接口
*/
public class Demo04GenericInterface {
public static void main(String[] args) {
// 创建GenericInterfaceImpl1对象
GenericInterfaceImpl1 impl1 = new GenericInterfaceImpl1();
impl1.method("cvhnods");
System.out.println("====================");
// 创建GenericInterfaceImpl2对象
GenericInterfaceImpl2<String> impl2 = new GenericInterfaceImpl2();
impl2.method("fho");
GenericInterfaceImpl2<Integer> impl3 = new GenericInterfaceImpl2();
impl3.method(156);
}
}
3.4 泛型通配符
通配符基本使用
通配符高级使用——受限泛型
day13-14 泛型通配符
package day13.Demo03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
泛型的上限限定：? extends E 代表使用的泛型只能是E类型的子类/本身
泛型的下限限定：? super E 代表使用的泛型只能是E类型的父类/本身
*/
public class Demo06Generic {
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<>();
Collection<String> list2 = new ArrayList<>();
Collection<Number> list3 = new ArrayList<>();
Collection<Object> list4 = new ArrayList<>();
getElement1(list1);
getElement1(list2); // 报错
getElement1(list3);
getElement1(list4); // 报错
getElement2(list1); // 报错
getElement2(list2); // 报错
getElement2(list3);
getElement2(list4);
// 类与类之间的继承关系：
// Integer extends Number extends Object
// String extends Object
}
// 泛型的上限限定：Number类型或其子类
private static void getElement1(Collection<? extends Number> list) {
}
// 泛型的下限限定：Number类型或其父类
private static void getElement2(Collection<? super Number> list) {
}
}
第四章 集合综合案例
4.1 案例介绍
按照斗地主的规则，完成洗牌发牌的动作。
具体规则：使用54张牌打乱顺序，三个玩家参与游戏，三人交替摸牌，没人17张牌，最后三张留作底牌
4.2 案例分析
day13-15 斗地主案例的需求分析
4.3 代码实现
day13-16 斗地主案例的代码实现
package day13.Demo04;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
/*
斗地主综合案例：
1.准备牌
2.洗牌
3.发牌
4.看牌
*/
public class DouDiZhu {
public static void main(String[] args) {
// 1.准备牌
// 定义一个存储54张牌的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.add("大王");
poker.add("小王");
// 循环嵌套遍历两个数组，组装52张牌
// 增强for循环遍历集合/数组
for (String color: colors) {
for (String number: numbers) {
poker.add(color + number);
}
}
// 2.洗牌
// 使用集合的工具类Collections中的方法
// static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换
Collections.shuffle(poker);
// 3.发牌
// 定义四个集合，存储玩家的牌和底牌
ArrayList<String> player1 = new ArrayList<>();
ArrayList<String> player2 = new ArrayList<>();
ArrayList<String> player3 = new ArrayList<>();
ArrayList<String> diPai = new ArrayList<>();
// 遍历poker集合，获取每一张牌
// 使用poker集合的索引，给3个玩家轮流发牌
// 剩余3张牌给底牌
// 注意：先判断i >= 51，否则牌就发没了
for (int i = 0; i < poker.size(); i++) {
// 获取每一张牌
String s = poker.get(i);
if (i >= 51) {
diPai.add(s);
} else if (i % 3 == 0) {
player1.add(s);
} else if (i % 3 == 1) {
player2.add(s);
} else if (i % 3 == 2) {
player3.add(s);
}
}
// 4.看牌
System.out.println("player1:" + player1);
System.out.println("player2:" + player2);
System.out.println("player3:" + player3);
System.out.println("dipai:" + diPai);
}
}