二、Collection、泛型

一、Collection集合

1.1 概述

集合：长度可变的，存放对象

数组：长度不可变，存放基本类型

1.2 框架

API：类和接口

学习集合的目标：

  1. 会使用集合存储数据
  2. 会遍历集合，把数据取出来
  3. 掌握各种集合的特性

Collection接口

  1. 定义的所有单例集合中的共性方法
  2. 所有单例集合可以使用共性的方法
  3. 没有带索引的方法

  • List接口

    1. 有序的集合（存储和取出元素顺序相同）
    2. 允许存储重复的元素
    3. 有索引，可以使用普通的for循环遍历
    • Vector集合
    • ArrayList集合
    • LinkedList集合

  • Set接口

    1. 不允许存储重复元素
    2. 没有索引（不能使用普通的for循环遍历）
    • TreeSet集合 无序
    • HashSet集合 无序
      • LinkedHashSet集合 有序

集合框架的学习方式：

  1. 学习顶层：学习顶层接口/抽象类中共性的方法，所有子类都可以使用
  2. 使用底层：底层不是接口就是抽象类，无法创建对象使用，需要使用底层的子类创建对象使用

1.3 Collection常用功能

java.util.Connection

所有单列集合的最顶层接口，里面定义了所有单列集合共性的方法

  • 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()
Collection<String> coll =new ArrayList<>();
coll.add("张三");
coll.add("李四");
Object[] array = coll.toArray();
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}
System.out.println(coll.size());
System.out.println(coll);
coll.remove("张三");
System.out.println(coll);
System.out.println(coll.contains("李四"));
System.out.println(coll.isEmpty());
coll.clear();
System.out.println(coll);
System.out.println(coll.isEmpty());

二、Iterator迭代器

2.1 常用方法

java.util.Iterator
有两个常用的方法

  • boolean hasnext() 判断集合中是否还有下一个元素

  • E next()取出集合中的下一个元素

Iterator迭代器，是一个接口，无法直接使用，通过Collection接口中的一个方法 iterator(),返回
迭代器的使用步骤：

  1. 使用集合中的方法iterator()获取迭代器的实现对象，使用Iterator接口接收（多态）
  2. 使用Iterator接口中的方法hasNext判断是否有下一个元素
  3. 使用Iterator接口中的方法next取出集合中的下一个元素
Collection<String> coll = new ArrayList<>();
coll.add("A");
coll.add("B");
coll.add("C");
coll.add("D");
Iterator<String> iterator = coll.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next());
}

2.2 增强for循环

底层也是迭代器，使用for循环的格式简化了迭代器的书写

for(集合/数组的数据类型 变量名：集合名){

​ sout（变量名）;

}

三、泛型

3.1 泛型概述

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型

泛型也可以看成是一个变量，用来接收数据类型

​ E e ：Element元素

​ T t ：Type 类型

3.2 使用泛型的好处

创建集合对象，不使用泛型：

好处：

​ 集合不使用泛型，默认Object，可以存储任意类型的数据

弊端：

​ 不安全，会引发异常

ArrayList<Object> arrayList = new ArrayList<>();
arrayList.add("abc");
arrayList.add(1);
Iterator<Object> iterator = arrayList.iterator();
while (iterator.hasNext()){
    Object next = iterator.next();
    String s = (String) next;
    System.out.println(s.length());
}
----结果----
3
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at com.dy.Demo01Iterator.main(Demo01Iterator.java:15)

创建集合对象，使用泛型：

好处:

  1. 避免了类型转换的麻烦，存储是什么类型，取出就是什么类型
  2. 把运行期异常（代码运行后抛出的异常），提升到了编译期（写代码的时候）

弊端：

​ 泛型是什么类型，就只能存什么类型

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("abc");
Iterator<String> iterator = arrayList.iterator();
while (iterator.hasNext()){
    String next = iterator.next();
    System.out.println(next.length());
}

3.3 泛型的定义与使用

含有泛型的类

定义一个含有泛型的类，模拟ArrayList集合

泛型是一个未知的数据类型，我们不确定使用什么数据类型的时候，可以使用泛型

泛型可以接收任意数据类型，Integer，String。。。

创建对象的时候确定数据类型

public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

含有泛型的方法

定义含有泛型的方法：泛型定义在修饰符合返回类型之间
public void 方法名(参数列表(使用泛型)){
}

public class GenericMethod {
    public <E> void method01(E e){
        System.out.println(e);
    }

    public static <E> void  method02(E e){
        System.out.println(e);
    }
}

含有泛型的接口

接口

package com.dy;

public interface GenericInterface<E> {
    public abstract void methoid(E e);
}

接口实现类1：

package com.dy;

/*
定义含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
 */
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void methoid(String s) {
        System.out.println(s);
    }
}

接口实现类2：

package com.dy;
/*
含有泛型接口的第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
 */
public class GenericInterfaceImpl2<E> implements GenericInterface<E>{
    @Override
    public void methoid(E e) {
        System.out.println(e);
    }
}

主函数：

package com.dy;

public class Demo01GenericClass {
    public static void main(String[] args) {
        GenericInterfaceImpl1 impl1 = new GenericInterfaceImpl1();
        impl1.methoid("adc");

        GenericInterfaceImpl2<Integer> impl2 = new GenericInterfaceImpl2<>();
        impl2.methoid(1);
    }
}

3.4 泛型的通配符

泛型的使用

不知道使用什么类型来接收的时候，可以使用通配符

泛型的通配符：

？：代表任意的数据类型

使用方式：

不能创建对象使用

只能作为方法的参数使用

public class Demo02Generic {
    public static void main(String[] args) {
        ArrayList<String> list01 = new ArrayList<>();
        list01.add("a");
        list01.add("b");
        ArrayList<Integer> list02 = new ArrayList<>();
        list02.add(1);
        list02.add(2);
        printArray(list01);
        printArray(list02);
    }
    public static void printArray(ArrayList<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

泛型的上限和下限

四、斗地主示例

斗地主综合案例

  • 1.准备牌
  • 2.洗牌
  • 3.发牌
  • 4.看牌
package com.dy;

import java.util.ArrayList;
import java.util.Collections;

/**
 * 斗地主综合案例
 * 1.准备牌
 * 2.洗牌
 * 3.发牌
 * 4.看牌
 */
public class douDiZhu {
    public static void main(String[] args) {
        //1.准备牌
        ArrayList<String> poker = new ArrayList<>();
        poker.add("大王");
        poker.add("小王");
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        for (String number : numbers) {
            for (String color : colors) {
                poker.add(color+number);
            }
        }
        System.out.println(poker);
        //2.洗牌
        Collections.shuffle(poker);
        System.out.println(poker);
        //3.发牌
        ArrayList<String> play01 = new ArrayList<>();
        ArrayList<String> play02 = new ArrayList<>();
        ArrayList<String> play03 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        System.out.println(poker.size());
        for (int i = 0; i < poker.size(); i++) {
            if (i>=51){
                dipai.add(poker.get(i));
            }else if(i%3==0){
                play01.add(poker.get(i));
            }else if(i%3==1){
                play02.add(poker.get(i));
            }else if(i%3==2){
                play03.add(poker.get(i));
            }
        }
        System.out.println("play01:"+play01);
        System.out.println("play02:"+play02);
        System.out.println("play03:"+play03);
        System.out.println("dipai:"+dipai);
    }
}
posted @ 2021-08-31 15:06  盐汽水mua  阅读(43)  评论(0)    收藏  举报