@学习记录

开始学习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 斗地主案例的需求分析

扫描二维码关注公众号，回复： 12678130 查看本文章

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);


    }
}