Java基础01-集合1、泛型

集合、泛型

第一章：集合1

1. 什么是集合

• 定义：在Java中，集合是一种可以存储多个数据的容器。

• 代码：

         ArrayList<String> list = new ArrayList<>();
         list.add("张三");
         list.add("王五");
         list.add("赵六");
         System.out.println(list); // [张三, 王五, 赵六]

2. 集合和数组的区别

• 区别：数组的长度是固定的，集合的长度是可变的。

• 代码：

         String[]strs = new String[2];
         strs[0] = "张三";
         strs[1] = "李四";
         // strs[2] = "赵六"; // 运行时报错java.lang.ArrayIndexOutOfBoundsException
     ​
         ArrayList<String> list = new ArrayList<>();
         System.out.println(list.size());
         list.add("张三");
         list.add("王五");
         list.add("赵六");
         System.out.println(list.size());  

3. 集合框架Collection

• 集合按照其存储结构可以分为两大类，本篇先学习Collection

• Collection集合介绍

  • 单列集合类的根接口

  • 有两个子接口

    • java.util.List；特点是：内容可重复，有序

    • java.util.Set； 特点是：内容不可重复，无序

  • 定义了单例集合最共性的方法。

• 图解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(): 把集合中的元素，存储到数组中。

  • 代码：

          List<String> list = new ArrayList<>();
          // 添加元素
          list.add("张三");
          list.add("李四");
          System.out.println(list);
          // 移除元素
          list.remove("张三");
          System.out.println(list);
          // 判断集合中是否包含某个元素
          boolean isHas = list.contains("张三");
          System.out.println(isHas); // false
          // 判断当前集合是否为空
          boolean isEmpty = list.isEmpty();
          System.out.println(isEmpty);
          // 清空元素
          list.clear();
          System.out.println(list);
          // 集合的长度
          System.out.println(list.size());
          // 集合中的元素存储到一个数组中
          Object[]s =  list.toArray();

4. 遍历集合

• Iterator方式

  • 介绍

    ​ Iterator，是一个迭代器接口。Collection中的成员方法iterator()被调用后，会返回一个Iterator对象。利用这个对象可以实现遍历集合。

    ​ 如何遍历呢？在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

  • Iterator对象的成员方法：

    • hasNext(); 检测集合中是否存在下一个元素

    • next(); 找到并获取下一个元素

  • 迭代器的原理

    ​ 在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

  • 代码：

           List<String> list = new ArrayList<>();
           list.add("张三");
           list.add("李四");
           list.add("王五");
           // 得到一个迭代器对象
           Iterator<String> it = list.iterator();
           while (it.hasNext()) {
             String str = it.next();
             System.out.println(str);
           }

• 增强for

  • 介绍

    ​ 增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

  • 使用格式

      for(元素的数据类型  变量 : Collection集合or数组){       //写操作代码  }

  • 代码：

      for (String name:list) {    System.out.println(name);  }

第二章：泛型

1. 什么是泛型

​ 泛型，未知的类型，可以在类或方法中预支地使用未知的类型。

2. 泛型的好处

​ 可以避免类型转换的麻烦。

3. 定义和使用含有泛型的类

• 格式：修饰符 class 类名<代表泛型的变量> { }

• 使用泛型：在创建对象的使用。也就是在创建对象时确定泛型的类型。

• 代码：

     public class ArrayList<E> {
         public boolean add(E e){ }
         ...
     }
     ​
     public class MainDemo{
       public static void main(String[] args) {
         ArrayList<String> list = new ArrayList<>();
         list.add("张三");
       }
     }

4. 定义和使用含有泛型的方法

• 格式：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

• 代码：

     public static void main(String[] args) {
        methon1("张三");
     }
     public static  <M> void methon1(M m){
        System.out.println(m);
     }

5. 定义和使用含有泛型的接口

• 格式：修饰符 interface接口名<代表泛型的变量>

• 代码：

     public interface TestInterface<T> {
       public abstract void show(T t);
     }
     ​
     public class<T> TestImpl implements TestInterface<T> {
       @Override
       public T void show(T o) {
         System.out.println(o);
       }
     }
     ​
     public class Main01 {
       public static void main(String[] args) {
         TestImpl<String> t = new TestImpl<>();
         t.show("我的信息");
     ​
       }
   
     }

6. 泛型通配符

• 介绍

  不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

  此时只能接受数据,不能往该集合中存储数据。

• 代码：

    public static void main(String[] args) {
         ArrayList<String> list1 = new ArrayList<>();
         list1.add("张三");
         list1.add("李四");
         ArrayList<Integer> list2 = new ArrayList<>();
         list2.add(1);
         list2.add(2);
         print(list1);
         print(list2);
       }
       // 定义一个方法打印集合，不确定未来集合中的元素类型，<>中不能写入Object中，因为泛型中不存在继承关系。
       public static void print(ArrayList<?> list){
         System.out.println(list);
       }

7. 泛型通配符受限使用

• 受限1：类型名称 <? extends 类 > 对象名称

  • 只能接收该类型或该类型的子类

• 受限2： 类型名称 <? super 类 > 对象名称

  • 只能接收该类型或该类型的父类

• 代码：

     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){}

第三章：综合案例斗地主

• 需求：

  • 实现发牌功能，并且展示底牌。

• 代码：

     package it.leilei.cn.demo05;
     ​
     import java.util.ArrayList;
     import java.util.Collection;
     import java.util.Collections;
     ​
     public class Main01 {
       public static void main(String[] args) {
         // 1. 准备牌
         // 牌的花色
         String[]colors = {"♥","♠","♣","♦"};
         // 牌的数字
         String[]nums = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
         // 2. 组装装牌
         ArrayList<String> poker = new ArrayList<>();
         for (String num:nums) {
           for (String color:colors) {
             poker.add(num + color);
           }
         }
         poker.add("大王");
         poker.add("小王");
     ​
         // 3. 发牌
         ArrayList<String> list1 = new ArrayList<>();
         ArrayList<String> list2 = new ArrayList<>();
         ArrayList<String> list3 = new ArrayList<>();
         ArrayList<String> diPai = new ArrayList<>();
     ​
         // 打乱牌
         Collections.shuffle(poker);
     ​
         for (int i = 0,len = poker.size(); i < len;i++) {
           if(i>=51) {
             diPai.add(poker.get(i));
           }else if(i%3==0) {
             list1.add(poker.get(i));
           }else if(i%3==1) {
             list2.add(poker.get(i));
           }else if(i%3==2) {
             list3.add(poker.get(i));
           }
         }
     ​
         System.out.println("周星驰：" + list1);
         System.out.println("刘德华：" + list2);
         System.out.println("周润发：" + list3);
         System.out.println("底牌：" + diPai);
     ​
       }
     }

    ​