1.Collection集合
- 集合是java中提供的一种容器,可以用来存储多个数据。
- 集合和数组既然都是容器,它们的区别;
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候,使用集合进行存储。
集合框架
- JAVASE提供了满足各种需求的API,在使用这些API前,先了解其继承与接口操作架构,才能了解何时采用哪个类,以及类之间如何彼此合作,从而达到灵活应用。
Collection 常用方法
- java.util.Collection是所有单列集合的父接口,所以Collection中定义了单列集合(List和set)通用的一些方法,可用于操作所有的单列集合。
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()
: 把集合中的元素,存储到数组中。
import java.util.ArrayList;
import java.util.Collection;
public class Demo1Collection {
public static void main(String[] args) {
// 使用多态形式创建集合对象
Collection<String> coll = new ArrayList<String>();
// 使用方法
// 添加功能 boolean add(String s)
coll.add("小李广");
coll.add("扫地僧");
coll.add("石破天");
System.out.println(coll);
// boolean contains(E e) 判断o是否在集合中存在
System.out.println("判断 扫地僧 是否在集合中"+coll.contains("扫地僧"));
//boolean remove(E e) 删除在集合中的o元素
System.out.println("删除石破天:"+coll.remove("石破天"));
System.out.println("操作之后集合中元素:"+coll);
// size() 集合中有几个元素
System.out.println("集合中有"+coll.size()+"个元素");
// Object[] toArray()转换成一个Object数组
Object[] objects = coll.toArray();
// 遍历数组
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
// void clear() 清空集合
coll.clear();
System.out.println("集合中内容为:"+coll);
// boolean isEmpty() 判断是否为空
System.out.println(coll.isEmpty());
}
}
2、Iterator迭代器
Iterator接口
- java.util.Iterator接口即迭代器,对集合/数组进行遍历。
- 迭代:即Collection集合元素的通用获取方法在取元素前先判断集合中有没有元素,如果有则将元素取出,继续再判断,如果有再取出,直到全部取出,这种取出方式就叫迭代。
- 常用方法
public E next()
:返回迭代的下一个元素。public boolean hasNext()
:如果仍有元素可以迭代,则返回 true。
- Iterator迭代器是一个接口,无法直接使用,需用Iterator接口的实现类对象获取实现类的方式。Collection接口有一个方法叫 iterator() 这个方法返回的是迭代器的实现类对象。
Iterator<E> iterator()
:返回在此Collection的元素上进行迭代的迭代器。- 迭代器使用步骤:
- 1、使用集合中的方法
iterator()
获取迭代器的实现类对象,使用Iterator接口接收(多态写法); - 2、使用Iterator接口中的hasNext方法判断还有没有下一个元素;
- 3、使用Iterator接口中的next方法取出集合中的下一个元素。
- 1、使用集合中的方法
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<>(); //多态写法创建一个集合
coll.add("XX1");
coll.add("XX2");
coll.add("XX3");
Iterator<String> it = coll.iterator(); //1、使用Collection的方法iterator()创建Iterator接口的实现类对象
while(it.hasNext()){ //2、先判断是否有下一个元素
String s = it.next(); //3、若有,再取出元素
System.out.println(s);
}
}
}
迭代器的实现原理
增强for循环
- 增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。
Collection<E> extends Iterator<E>
:所有单列集合都可以使用增强for。public iterface Iterable<T>
:实现这个接口允许对象成为“foreach”语句的目标。- 格式:
for(元素的数据类型 变量 : Collection集合or数组){ //写操作代码 }
import java.util.ArrayList;
public class ForeachDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("XX1");
list.add("XX2");
list.add("XX3");
for(String s :list){ //增强for循环遍历集合
System.out.println(s);
}
int[] arr = {1,2,3};
for(int i : arr){ //增强for循环遍历数组
System.out.println(i);
}
}
}
结果:
XX1
XX2
XX3
1
2
3
3、泛型
- 泛型是一种未知的数据类型,当不知道使用什么数据类型时,可以使用泛型,泛型也可以看成是一个变量,用来接收数据类型。
- 使用泛型的好处:
- 避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型。
- 把运行期异常(代码运行之后抛出异常)提升到了编译期异常(写代码的时候会报错)。
- 弊端:泛型是什么类型,只能存储什么类型的数据。
public class GenericDemo {
public static void main(String[] args) {
Collection coll = new ArrayList(); //无泛型
coll.add("abc");
coll.add("itcast");
coll.add(5);//由于集合没有做任何限定,任何类型都可以给其中存放
Iterator it = coll.iterator();
while(it.hasNext()){
//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
String str = (String) it.next();
System.out.println(str.length());
}
//程序在运行时发生了问题java.lang.ClassCastException。
}
}
public class GenericDemo2 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<String>(); //使用泛型
list.add("abc");
list.add("itcast");
// list.add(5);//当集合明确类型后,存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
}
定义和使用含有泛型的类
- 定义一个含有泛型的类,模拟ArrayList集合,泛型可以接收任意的数据类型:Integer、String、Student…创建对象的时候确定泛型的数据类型。
//定义含有泛型的类
public class GenericClass<E> {
private E name;
public E getName(){return name;}
public void setName(E name){this.name = name;}
}
//使用含有泛型的类
public class DemoGenericClass {
public static void main(String[] args) {
GenericClass gc = new GenericClass(); //不写泛型,默认为Object类型
gc.setName("XX"); //String类型可以自动转化为Object类型
Object obj = gc.getName();
System.out.println(obj); //XX
GenericClass<Integer> gc2 = new GenericClass<>(); //泛型为Integer
gc2.setName(1); //只能传入Integer类型的参数
Integer name = gc2.getName();
System.out.println(name); //1
}
}
定义和使用含有泛型的方法
- 定义含有泛型的方法:泛型定义在方法的修饰符和返回值之间。
- 格式:
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){ 方法体; }
- 含有泛型的方法在调用方法的时候确定泛型的数据类型,传递什么类型的参数,泛型就是什么类型。
//定义一个含有泛型的方法
public class GenericMethod {
public <M> void method(M m){
System.out.println(m);
}
public static <S> void method02(S s){ //定义一个含有泛型的静态方法
System.out.println(s);
}
}
//使用含有泛型的方法
public class DemoGenericMethod {
public static void main(String[] args) {
GenericMethod gm = new GenericMethod();
gm.method(10); //10 参数是整数,则泛型为Integer
gm.method("XX"); //XX String
gm.method(true); //true Boolean
GenericMethod.method02("静态方法"); //静态方法 类名.静态方法
GenericMethod.method02(1); //1
}
}
定义和使用含有泛型的接口
- 含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型。 如:
public interface Iterator<E>{E next();}
public final class Scanner implements Iterator<String>{ public String next(){}}
Scanner类实现了Iterator接口,并指定了接口的泛型为String,所以重写的next方法泛型默认为String。 - 含有泛型的接口,第二种使用方式:接口是什么泛型,实现类就用什么泛型,类跟着接口走,就相当于定义了一个含有泛型的类,创建对象时确定泛型类型。如:
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 interface GenericInterface<I> {
public abstract void method(I i); //抽象方法
}
//使用第一种方式定义实现类
public class GenericInterfaceImpl01 implements GenericInterface<String>{ //实现类指定泛型
@Override
public void method(String s) {
System.out.println(s);
}
}
//使用第二种方式定义实现类
public class GenericInterfaceImpl02<I> implements GenericInterface<I> { //实现类不指定泛型
@Override
public void method(I i) {
System.out.println(i);
}
}
//使用含有泛型的接口
public class DemoGenericInterface {
public static void main(String[] args) {
//第一种方式
GenericInterfaceImpl01 gi1 = new GenericInterfaceImpl01(); //以及在实现类指定泛型
gi1.method("只能是字符串"); //只能是字符串
//第二种方式
GenericInterfaceImpl02<String> gi2 = new GenericInterfaceImpl02<>(); //创建实现类对象时才指定泛型
gi2.method("XX"); //XX
GenericInterfaceImpl02<Integer> gi3 = new GenericInterfaceImpl02<>();
gi3.method(10); //10
GenericInterfaceImpl02<Double> gi4 = new GenericInterfaceImpl02<>();
gi4.method(3.3); //3.3
}
}
泛型的通配符
- 当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?> 表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。
- 使用方式:不能创建对象使用,只能作为方法的参数使用。
public static void main(String[] args) {
Collection<Intger> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){}
//?代表可以接收任意类型
通配符高级使用----受限泛型
-
之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
-
泛型的上限:
- 格式:
类型名称 <? extends 类 > 对象名称
- 意义: 只能接收该类型及其子类
- 格式:
-
泛型的下限:
- 格式:
类型名称 <? super 类 > 对象名称
- 意义: 只能接收该类型及其父类型
- 格式:
// 比如:现已知Object类,String 类,Number类,Integer类,其中Number是Integer的父类
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<Number>();
Collection<Object> list4 = new ArrayList<Object>();
getElement(list1);
getElement(list2);//报错
getElement(list3);
getElement(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
// 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
4、集合的综合案例
- 按照斗地主的规则,完成洗牌发牌的动作。
具体规则:使用54张牌打乱顺序,三个玩家参与游戏,三人交替摸牌,每人17张牌,最后三张留作底牌。 - 案例分析:
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
public class DouDiZhu {
public static void main(String[] args) {
//1、准备牌
ArrayList<String> poker = new ArrayList<>(); //存54张牌
String[] colors = {"♠","♥","♣","♦"};
String[] numbers ={"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
poker.add("大王");
poker.add("小王");
for(String color : colors){ //循环嵌套组装52张牌
for(String number : numbers){
poker.add(color+number);
}
}
//2、洗牌
Collections.shuffle(poker);
//3、发牌
ArrayList<String> player01 = new ArrayList<>();
ArrayList<String> player02 = new ArrayList<>();
ArrayList<String> player03 = new ArrayList<>();
ArrayList<String> diPai = new ArrayList<>();
for (int i = 0; i < poker.size(); i++) {
String p = poker.get(i);
if (i >= 51) { //先判断底牌(i>=51),否则牌就没了
diPai.add(p);
} else if (i % 3 == 0) {
player01.add(p);
} else if (i % 3 == 1) {
player02.add(p);
} else if (i % 3 == 2) {
player03.add(p);
}
}
//4、看牌
System.out.println("玩家1的牌:" + player01);
System.out.println("玩家2的牌:" + player02);
System.out.println("玩家3的牌:" + player03);
System.out.println("底牌:" + diPai);
}
}
结果:
玩家1的牌:[♣3, ♣5, ♣K, 大王, ♣Q, ♥7, ♦2, ♣7, ♦8, ♠2, ♥2, ♦A, ♦6, 小王, ♦K, ♠9, ♣J]
玩家2的牌:[♥4, ♣4, ♥10, ♥Q, ♥A, ♥5, ♣2, ♠J, ♣A, ♦3, ♠5, ♠3, ♦7, ♠8, ♣9, ♣10, ♥9]
玩家3的牌:[♠4, ♦4, ♠Q, ♦9, ♦10, ♥J, ♣8, ♥K, ♥6, ♣6, ♠6, ♠K, ♦Q, ♥3, ♦J, ♥8, ♠A]
底牌:[♠10, ♦5, ♠7]