1/2 概述
- 数组和集合都是容器
- 数组的长度是不可变的，集合是可变的
- 数组中的数据要一致，可以是基本数据类型，也可以是对象
- 集合中只能存储对象
3 集合框架介绍
Collection集合体系图.png
image.png
4 Collection集合常用方法
| 方法 | 代码指令 |
|---|---|
| 添加一个元素 | list.add("hello"); |
| 清空集合 | list.clear(); |
| 删除元素 | list.remove("hello"); |
| 判断集合中是否包含某个元素 | boolean res2 = list.contains("hello"); |
| 判断集合是否为空 | boolean res = list.isEmpty(); |
| 获取集合的长度 | int length = list.size(); |
| 将集合转为数组 | Object[] obj = list.toArray(); |
5 Iterator接口介绍,也叫迭代器
6 Iterator使用
- 使用集合中的方法iterator()获取迭代器接口实现类的对象，Iterator
也是有泛型的，它的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型 - 使用迭代器接口中boolean hasNext()方法判断有没有迭代完？
- 如果还有元素，使用接口中的next()获取元素
package demo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class demo1 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("hello");
list.add("world");
list.add("fuck");
// 使用集合中的方法iterator()获取迭代器接口实现类的对象
Iterator it = list.iterator();
while (it.hasNext()) {
String resFinal = it.next();
System.out.println(resFinal);
}
}
}
7 迭代器的实现原理
image.png
8 增强for循环遍历数组和集合
package demo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class demo1 {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
ArrayList list = new ArrayList<>();
list.add("hello");
list.add("world");
// 遍历集合
for (String i:list
) {
System.out.println(i);
}
// 遍历数组
for (int num:array
) {
System.out.println(num);
}
}
}
f循环增强版foreach格式：
for (集合/数组中的数据类型，命名:集合/数组名称
) {
System.out.println(命名);
}
9 泛型的概述
泛型是一种未知的数据类型，当我们不确定使用哪种数据类型的时候，可以暂时使用泛型来占位代替
10 请说出使用泛型的好处
11 定义和使用含有泛型的类
泛型可以使用任意的数据类型，创建对象的时候确定泛型的类，更加灵活
11-1 创建一个泛型的类Student
package demo1;
public class Student {
private E name;
public Student() {
}
public Student(E name) {
this.name = name;
}
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
11-2 使用泛型创建好的学生类
package demo1;
public class demo {
public static void main(String[] args) {
// 类型是字符串
Student stu1 = new Student<>();
stu1.setName("wangsiyu");
// 类型是int
Student stu2 = new Student<>();
stu2.setName(666);
// 使用泛型的好处是更加灵活，且将类型错误定位在编译阶段，而不是运行阶段
}
}
12 定义和使用含有泛型的方法
12-1 定义类
package demo1;
public class Student {
private String name;
public Student() {
}
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void method(E e){
System.out.println(e);
}
}
12-2 使用含有泛型方法的类
package demo1;
public class demo {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.method("hello");
stu1.method(666);
stu1.method(true);
}
}
13 定义和使用含有泛型的接口
13-1 第一种方式：
1:首先创建一个含有泛型的接口
package demo1;
public interface GenericInterface {
public abstract void method(E e);
}
2:创建一个泛型接口的实现类
package demo1;
public class GenericInterfaceImpl implements GenericInterface{
// 覆盖重写接口中的抽象方法
@Override
public void method(String s){
System.out.println(s);
}
}
3 创建实现类的对象使用
package demo1;
public class demo1 {
public static void main(String[] args) {
GenericInterfaceImpl gi = new GenericInterfaceImpl();
gi.method("wangsiyu");
}
}
13-2 第二种方法：
1:首先创建一个含有泛型的接口
package demo1;
public interface GenericInterface {
public abstract void method(E e);
}
第二步： 创建泛型接口的实现类
package demo1;
public class GenericInterfaceImpl implements GenericInterface{
// 覆盖重写接口中的抽象方法
@Override
public void method(E e){
System.out.println(e);
}
}
第三步：创建实现类的对象使用
package demo1;
public class demo1 {
public static void main(String[] args) {
GenericInterfaceImpl gi = new GenericInterfaceImpl();
gi.method("wangsiyu");
GenericInterfaceImpl gi1 = new GenericInterfaceImpl();
gi1.method(666);
}
}
14 泛型 通配符
package demo1;
import java.util.ArrayList;
import java.util.Iterator;
public class demo1 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList<>();
list1.add("hello");
list1.add("world");
ArrayList list2 = new ArrayList<>();
list2.add(1);
list2.add(2);
method(list1);
method(list2);
}
// 定义一个方法，能够遍历所有的ArrayList方法,我们不知道Arraylist是什么类型，所以接收参数时，可以使用通配符接收
public static void method(ArrayList e){
Iterator it = e.iterator();
while (it.hasNext()){
Object res = it.next();
System.out.println(res);
}
}
}
15 泛型知识总结
15-1 泛型类和泛型方法的基本使用（可以在创建对象的时候指定方法中的数据类型，更加灵活）
创建一个学生类（泛型）
package demo1;
public class Student {
public void method(E e){
System.out.println(e);
}
}
使用泛型的学生类创建对象
package demo1;
public class demo {
public static void main(String[] args) {
// 创建对象的时候才能确定类型
Student stu = new Student<>();
stu.method("hello");
Student stu2 = new Student<>();
stu2.method(666);
}
}
15-2 泛型接口和泛型方法
创建一个泛型接口
package demo1;
public interface StudentInterface {
public abstract void method(E e);
}
创建泛型接口的实现类
package demo1;
public class StudentInterfaceImpl implements StudentInterface {
@Override
public void method(E e){
System.out.println(e);
}
}
创建接口实现类的对象
package demo1;
public class demo {
public static void main(String[] args) {
StudentInterfaceImpl obj1 = new StudentInterfaceImpl<>();
obj1.method("hello");
StudentInterface obj2 = new StudentInterfaceImpl<>();
obj2.method(666);
}
}
15-3 泛型通配符
package demo1;
import java.util.ArrayList;
public class demo {
public static void main(String[] args) {
ArrayList arr1 = new ArrayList<>();
ArrayList arr2 = new ArrayList<>();
arr1.add("hello");
arr1.add("world");
arr2.add(444);
arr2.add(666);
method(arr1);
method(arr2);
}
// 写一个方法，可以将所有类型的ArrarList类型遍历出来
public static void method(ArrayList s){
System.out.println(s);
}
}
16 实例 斗地主的案例
image.png
package demo1;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class demo {
public static void main(String[] args) {
//创建一副扑克牌
String[] style = {"♥","♠","♣","♦"};
String[] num = {"1","2","3","4","5","6","7","8","9","10","J","Q","K"};
ArrayList card = new ArrayList<>();
card.add("大王");
card.add("小王");
for (int i = 0; i < style.length; i++) {
for (int i1 = 0; i1 < num.length; i1++) {
card.add(style[i]+num[i1]);
}
}
// 打乱扑克牌
Collections.shuffle(card);
// 分发扑克牌
ArrayList one = new ArrayList<>();
ArrayList two = new ArrayList<>();
ArrayList three = new ArrayList<>();
ArrayList last = new ArrayList<>();
for (int i = 0; i < card.size(); i++) {
if(i>=51){
last.add(card.get(i));
}
else if(i%3==0){
one.add(card.get(i));
}
else if(i%3==1){
two.add(card.get(i));
}
else if(i%3==2){
three.add(card.get(i));
}
}
// 看牌
System.out.println(one);
System.out.println(two);
System.out.println(three);
System.out.println(last);
}
}