1.ArrayList

1.1回顾

  • 集合：存放多个数据类型或者是对象的容器

  • 持有的数据：
  • 单一数据—可以定义对应类型的变量直接持有
  • 多个数据—可以使用数组的方式记录，通过索引来访问数据
  • 在oop的基础上，可以使用集合的方式进行记录，常用ArrayList

  • 基本使用：
  • 1.创建集合对象
  • 2.向集合中添加数据
  • 3.从集合中获取元素/其他信息
方法声明 功能描述
boolean add（Object obj） 将指定元素obj追加到集合的末尾
Object get（int index） 返回集合中指定位置上的元素
int size（） 返回集合中的元素个数 
  1. package com.igeek_Collection.ArrayList.ArrayList_01;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-14:05
  6.  */
  8. import java.sql.SQLOutput;
  9. import java.util.ArrayList;
  11. public class ArrayListDemo {
  12.     public static void main(String[] args) {
  13.         //创建集合对象
  14.         ArrayList<Integer> list=new ArrayList<>();
  15.         list.add(20);
  16.         list.add(30);
  17.         list.add(40);
  19.         //从集合中获取元素
  20.         Integer i= list.get(1);
  21.         System.out.println(i);
  23.         //获取长度
  24.         Integer l=list.size();
  25.         System.out.println(l);
  27.         //遍历
  28.         for (int j = 0; j < list.size() ; j++) {
  29.             System.out.println(list.get(j));
  30.         }
  31.     }
  32. }

1.2 练习

  1. package com.igeek_Collection.ArrayList.ArrayList_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-14:32
  6.  */
  8. import java.util.ArrayList;
  9. import java.util.Iterator;
  11. /**
  12.  * 实现功能：
  13.  *
  14.  * 定义一个测试类，在测试类中定义一个集合，集合中存储3个数据--Person对象，这三个人的属性分别为
  15.  * Jack  18
  16.  * rose  16
  17.  * aobama 60
  18.  *
  19.  * 最终遍历的集合，分别打印三个人的姓名，年龄
  20.  * 并打印三个人的总年龄
  21.  */
  22. public class ArrayListDemo {
  23.     public static void main(String[] args) {
  24.         //创建集合对象
  25.         ArrayList<Person> list=new ArrayList<>();
  26.         //添加对象
  27.         list.add(new Person("Jack",18));
  28.         list.add(new Person("Rose",16));
  29.         list.add(new Person("AObama",60));
  30. //        System.out.println(list);
  32.         //调用Iterator方法，获取迭代器的对象
  33.         Iterator<Person> iterator= list.iterator();
  35.         //声明一个变量用来保存年龄
  36.         int sum=0;
  38.         //迭代集合
  39.         while (iterator.hasNext()){//问
  40.             //取
  41.             Person p= iterator.next();
  42.             System.out.println(p.getName()+":"+p.getAge());
  44.             //年龄累加
  45.             sum+=p.getAge();
  46.         }
  47.         System.out.println("三个人的总年龄是："+sum);
  48.     }
  49. }

2.Iterator—迭代器

迭代器的使用：

  • 迭代器：就是一个用来遍历数据的工具

  • 在java中不止ArrayList一种集合，java中提供了众多的集合

  • 不同的容器（集合），提供了不同的数据存储
  • 不同的集合特点不同，ArrayList是有序且可重复的集合
    *但是由于集合的不同，所以有些集合是没有下标的，就不可以使用get（）方法来获取数据

  • 可以通过迭代器来处理：
  • 所有的集合通过获取元素的方法并不是唯一的，但是可以通过统一使用迭代器来处理

  • 迭代器：Iterator—接口

  • 利用迭代器进行遍历的时候需要以下几步：
  • 1.问—是否存在下一个元素
  • 2.取—把这个存在的下一个元素取出
  • 3.删—可以处理
  • Iterator接口的常用方法如下：

image.png
hasNext()方法：用来判断集合中是否有下一个元素可以迭代。如果返回true,说明可以迭代。
next()方法：用来返回迭代的下一个元素，并把指针向后移动一位。

  1. while (iterator.hasNext()){//问
  2.             //取
  3.             Integer thisNumber= iterator.next();
  4.             System.out.println(thisNumber);
  5.         }

  • 理解：
  • 在迭代器中其实有一个指针，通过指针来进行问取操作 ```java package com.igeek_Collection;

/**

  • @author Lynn
  • @create 2020-12-07-14:13 */

import java.util.ArrayList; import java.util.Iterator;

public class IteratorDemo { public static void main(String[] args) { ArrayList list=new ArrayList<>(); list.add(20); list.add(30); list.add(40); list.add(40);

  1.     //利用迭代器来处理--import java.util.Iterator;
  2.     //Iterator是一个接口，不能直接实例化，要通过集合去获取
  3.     Iterator<Integer> iterator= list.iterator();
  4.     //使用迭代器来遍历
  5.     while (iterator.hasNext()){//问
  6.         //取
  7.         Integer thisNumber= iterator.next();
  8.         System.out.println(thisNumber);
  9.     }
  10. }

}

  1. <a name="lt8e5"></a>
  2. # 3.当前案例用于演示制造异常--这个异常在以后的操作中可能会出现
  3. ```java
  4. package com.igeek_Collection.ArrayList.ArrayList_03;
  6. /**
  7.  * @author Lynn
  8.  * @create 2020-12-07-14:58
  9.  */
  11. import com.igeek_Collection.ArrayList.ArrayList_02.Person;
  13. import java.util.ArrayList;
  14. import java.util.Iterator;
  16. /**
  17.  * 当前案例用于演示制造异常--这个异常在以后的操作中可能会出现
  18.  *
  19.  * 使用集合的存储多个对象的时候，当遇到16岁的人时就添加一个90岁的人
  20.  * 该案例中，可能会出现并发修改异常，迭代器所认为的集合状态和集合真正的状态不统一，所以报错
  21.  */
  22. public class CurrentModificationDemo {
  23.     public static void main(String[] args) {
  24.         //创建集合对象
  25.         ArrayList<Person> list = new ArrayList<>();
  26.         //添加对象
  27.         list.add(new Person("Jack", 18));
  28.         list.add(new Person("Rose", 16));
  29.         list.add(new Person("AObama", 60));
  30.         list.add(new Person("Lucy", 25));
  31.         list.add(new Person("Tom", 30));
  32.         list.add(new Person("Jerry", 90));
  34.         //调用迭代器
  35.         Iterator<Person> iterator = list.iterator();
  37.         //制造异常--添加元素
  38.         while (iterator.hasNext()) {
  39.             Person p = iterator.next();
  40.             System.out.println(p.getAge() + "岁的" + p.getName());
  42.             //判断--年龄是不是为16岁
  43.             if (p.getAge() == 16) {
  44.                 //存在则添加90岁的人
  45.                 list.add(new Person("Jerry", 90));
  46.             }
  47.         }
  48.     }
  49. }

4.当前案例用于演示制造异常—这个异常在以后的操作中可能会出现—解决方案

  1. package com.igeek_Collection.ArrayList.ArrayList_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-14:58
  6.  */
  8. import com.igeek_Collection.ArrayList.ArrayList_02.Person;
  10. import java.util.ArrayList;
  11. import java.util.Iterator;
  13. /**
  14.  * 当前案例用于演示制造异常--这个异常在以后的操作中可能会出现--解决方案
  15.  *
  16.  * 使用集合的存储多个对象的时候，当遇到16岁的人时就添加一个90岁的人
  17.  * 该案例中，可能会出现并发修改异常，迭代器所认为的集合状态和集合真正的状态不统一，所以报错
  18.  */
  19. public class CurrentModificationDemo2 {
  20.     public static void main(String[] args) {
  21.         //创建集合对象
  22.         ArrayList<Person> list = new ArrayList<>();
  23.         //添加对象
  24.         list.add(new Person("Jack", 18));
  25.         list.add(new Person("Rose", 16));
  26.         list.add(new Person("AObama", 60));
  27.         list.add(new Person("Lucy", 25));
  28.         list.add(new Person("Tom", 30));
  30.         //调用迭代器
  31.         Iterator<Person> iterator = list.iterator();
  33.         //制造异常--添加元素
  34.         while (iterator.hasNext()) {
  35.             Person p = iterator.next();
  36.             System.out.println(p.getAge() + "岁的" + p.getName());
  38.             //判断--年龄是不是为16岁
  39.             if (p.getAge() == 16) {
  40.                 //存在则添加90岁的人
  41.                 list.add(new Person("Jerry", 90));
  42.                 //1.当遇到16岁的人的时候，就退出当前操作
  43.                 break;
  44.             }
  45.         }
  46.         //2.曲线救国--重新迭代集合中的数据--重新获取迭代器
  47.         Iterator<Person> iterator2 = list.iterator();
  48.         while (iterator2.hasNext()){
  49.             //如果有就取出
  50.             Person p2=iterator2.next();
  51.             System.out.println(p2.getAge() + "岁的" + p2.getName());
  52.         }
  53.     }
  54. }

5.增强for循环

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

  1. package com.igeek_Collection.ForEach;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-15:22
  6.  */
  8. import java.util.ArrayList;
  10. /**
  11.  * 增强for循环：
  12.  * 用来完成容器中获取元素的
  13.  *
  14.  * 格式：
  15.  * for（容器内的类型 临时变量：容器的引用）{
  16.  *     内部可以直接使用临时变量来访问数据
  17.  * }
  18.  *
  19.  * 注意：增强for循环的底层就是一个Iterator，因为迭代器在处理数据的时候有可能会出现并发修改的异常，
  20.  * 所以增强for循环中就不进行数据的添加或者删除操作，只是用于查看数据
  21.  *
  22.  * 可以理解为是迭代器的一个实用展示
  23.  */
  24. public class ForEachDemo {
  25.     public static void main(String[] args) {
  26.         //创建一个集合对象
  27.         ArrayList<Integer> list=new ArrayList<>();
  28.         list.add(10);
  29.         list.add(100);
  30.         list.add(1000);
  31.         list.add(10000);
  33.         //使用增强for循环遍历
  34.         for(Integer thisNumber:list){
  35.             System.out.println(thisNumber);
  36.         }
  38.         System.out.println("----------------------");
  40.         //遍历字符串类型的数组
  41.         String[] arr={"王嘉尔","王一博","卡卡西","猪猪侠"};
  42.         for(String name:arr){
  43.             System.out.println(name);
  44.         }
  45.     }
  46. }

6.类泛型使用的测试：

  1. package com.igeek_Collection.Izidingyifanxing;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-15:37
  6.  */
  8. /**
  9.  * 演示自定义泛型的使用--类使用类型
  10.  *
  11.  * 泛型是jdk5.0推出的新特性
  12.  *
  13.  * 在一个类中定义成员变量，使用泛型
  14.  *
  15.  * 不指定其数据类型，是一个不确定的数据类型
  16.  * 创建不同对象的时候，指定不同的数据类型
  17.  */
  18. public class MyClass<T> {
  19.     //我的泛型字段
  20.     private T myFiled;
  22.     public MyClass() {
  23.     }
  25.     public MyClass(T myFiled) {
  26.         this.myFiled = myFiled;
  27.     }
  29.     public T getMyFiled() {
  30.         return myFiled;
  31.     }
  33.     public void setMyFiled(T myFiled) {
  34.         this.myFiled = myFiled;
  35.     }
  36. }
  1. package com.igeek_Collection.Izidingyifanxing;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-15:41
  6.  */
  8. /**
  9.  * 类泛型使用的测试：
  10.  *
  11.  * 泛型类：在类中使用泛型
  12.  *
  13.  * 定义：类型的后面<变量>  如：class<E>
  14.  * 使用：创建对象的时候确定类型
  15.  *
  16.  * 一般定义的泛型使用：E  T  K  V
  17.  */
  18. public class MyClassTypeDemo {
  19.     public static void main(String[] args) {
  20.         //测试自己定义的类泛型
  21.         MyClass<String> my=new MyClass();
  22.         //调用使用泛型类的方法
  23.         my.setMyFiled("王嘉尔");
  24.         String myFiled=my.getMyFiled();
  25.         System.out.println(myFiled);
  27.         System.out.println("-----------------------------");
  29.         //创建对象的时候指定Integer
  30.         MyClass<Integer> my1=new MyClass();
  31.         my1.setMyFiled(88);
  32.         System.out.println(my1.getMyFiled());
  33.     }
  34. }

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

  1. package com.igeek_Collection.Izidingyifanxing.fanxingfangfa;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-16:06
  6.  */
  8. /**
  9.  * 演示泛型方法--在类中定义一个成员变量，使用泛型
  10.  *
  11.  * 格式：
  12.  * 修饰符<T,Q,E············> 返回值的类型 方法名(T t,Q q········){
  13.  *     //方法上定义的泛型在返回值的前面
  14.  * }
  15.  */
  16. public class MyClassType {
  18.     //定义泛型的方法
  19.     public <T> void method(T t){
  20.         System.out.println(t);
  21.     }
  22. }
  1. package com.igeek_Collection.Izidingyifanxing.fanxingfangfa;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-16:06
  6.  */
  8. import com.igeek_Collection.Izidingyifanxing.fanxingfangfa.MyClassType;
  10. /**
  11.  * 测试泛型方法
  12.  *
  13.  * 泛型方法：方法的返回值面前加上<变量>
  14.  *     使用：调用方法的时候确定类型
  15.  */
  16. public class MyClassTypeDemo2 {
  17.     public static void main(String[] args) {
  18.         //实例化自己定义的类
  19.         MyClassType my=new MyClassType();
  20.         //调用方法的时候确定类型
  21.         my.method("ABC");//String
  22.         my.method(12);   //Integer
  23.         my.method(12.12);//Double
  24.         my.method(true); //Boolean
  25.         my.method('A'); //Character
  26.     }
  27. }

8.泛型接口

  1. package com.igeek_Collection.Izidingyifanxing.fanxingfangfa3;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-16:15
  6.  */
  8. /**
  9.  * 自定义泛型的接口
  10.  *
  11.  * 接口用于规范子类的内容--写抽象方法
  12.  */
  13. public interface MyInterType<T> {
  15.     //接口中的方法使用接口泛型
  16.     public void method(T t);
  17. }
  1. package com.igeek_Collection.Izidingyifanxing.fanxingfangfa3;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-16:17
  6.  */
  9. /**
  10.  * 接口的实现类
  11.  *
  12.  * 定义类的时候，仍然不实现接口的数据类型
  13.  * 则此时相当于将这种不确定的数据类型使用到了子类当中
  14.  * 包含不确定的数据类型的类就是泛型类
  15.  *
  16.  *
  17.  * 在实现接口的时候，必须实现接口中所有的抽象方法和泛型--用于父类中不确定子类具体类型的时候使用
  18.  */
  19. public class MyClassInter<T> implements MyInterType<T> {
  20.     @Override
  21.     public void method(T t) {
  22.         System.out.println(t);
  23.     }
  24. }
  1. package com.igeek_Collection.Izidingyifanxing.fanxingfangfa3;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-16:21
  6.  */
  9. /**
  10.  * 测试泛型接口--在使用的时候才会确定类型
  11.  */
  12. public class MyClassInterTest {
  13.     public static void main(String[] args) {
  14.         //实例化子类
  15.         MyClassInter<String> my=new MyClassInter<>();
  16. //        my.method(23232326262333);//泛型不匹配
  17.         my.method("年轻的时候不拼搏，老了拿什么谈曾经");
  18.     }
  19. }
  1. package com.igeek_Collection.Izidingyifanxing.fanxingfangfa4;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-07-16:38
  6.  */
  10. import java.util.ArrayList;
  12. /**
  13.  * 泛型的作用：约束数据类型
  14.  * 优点：
  15.  * 1.提高了程序的安全性：将运行期的问题提前到编译期进行处理
  16.  * 2.提高了程序的性能：省去了类型之间转换的时间
  17.  *
  18.  * 泛型的通配符:
  19.  * 演示--谨慎使用--用于汇总数据
  20.  */
  21. public class Demo {
  22.     public static void main(String[] args) {
  23.         //定义一个集合
  24.         ArrayList<String> list=new ArrayList<>();
  25.         list.add("王");
  26.         list.add("嘉");
  27.         list.add("尔");
  29.         ArrayList<Integer> listB=new ArrayList<>();
  30.         listB.add(1);
  31.         listB.add(2);
  32.         listB.add(3);
  34.         //利用泛型的最高级别处理--泛型一定是对象类型--顶级父类--Object
  35.         Object o=new String();//向上造型
  36.         ArrayList<Object> listA=new ArrayList<>(list);
  37.         listA.add("好");
  38.         listA.add("帅");
  39.         System.out.println(listA);
  41.         ArrayList<Object> listA1=new ArrayList<>(listB);
  42.         listA1.add("好");
  43.         listA1.add("帅");
  44.         System.out.println(listA1);
  45.     }
  46. }

9.扑克牌案例

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-12-08-9:10
  4.  */
  6. import java.util.ArrayList;
  7. import java.util.Collections;
  9. /**
  10.  * 按照斗地主的规则，完成洗牌发牌的动作。
  11.  * ♣♦♠♥大☺小☺
  12.  * 具体规则：
  13.  * 使用54张牌打乱顺序
  14.  * 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
  15.  * 3.2    斗地主需求分析:
  16.  * A:准备牌：
  17.  * 牌可以设计为一个ArrayList<String>,每个字符串为一张牌。
  18.  * 每张牌由花色、数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
  19.  * 牌由Collections类的shuffle方法进行随机排序。
  20.  * B:发牌：
  21.  * 将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
  22.  * C:看牌：
  23.  * 直接打印每个集合
  24.  */
  25. public class CardDemo {
  26.     public static void main(String[] args) {
  27.         //准备牌
  28.         //集合中记录的是54张牌
  29.         ArrayList<String> list=new ArrayList<>();
  31.         //定义花色--定义一个集合用于存在花色
  32.         ArrayList<String> colors=new ArrayList<>();
  33.         colors.add("♣");
  34.         colors.add("♦");
  35.         colors.add("♠");
  36.         colors.add("♥");
  38.         //定义一个集合用于存放数字
  39.         ArrayList<String> numbers=new ArrayList<>();
  40.         //使用循环赋值
  41.         for (int i = 2; i <=10 ; i++) {
  42.             numbers.add(i+"");
  43.         }
  44.         numbers.add("J");
  45.         numbers.add("Q");
  46.         numbers.add("K");
  47.         numbers.add("A");
  49.         //嵌套迭代的方式完成每张牌的组装--放了52张
  50.         //利用增强for循环
  51.         for (String thisColor:colors){//外层循环遍历花色
  52.             for (String thisNumber:numbers){//内层循环遍历数字
  53.                 //通过花色与数字对应成每张牌
  54.                 String thisCard=thisColor+thisNumber;//字符串的拼接
  55.                 //将拼接好的牌放入整副牌的集合中
  56.                 list.add(thisCard);
  57.             }
  58.         }
  59.         //补充大小王
  60.         list.add("大☺");
  61.         list.add("小☺");
  63.         //测试
  64. //        System.out.println(list);
  66.         //洗牌---直接调用方法
  67.         //Collections是一个集合工具类，提供了很多的集合中处理的静态方法
  68.         Collections.shuffle(list);
  69.         //测试
  70. //        System.out.println(list);
  72.         //发牌---将每个人以及底牌设置为一个集合，最后的3张底牌直接存放到底牌中，
  73.         //剩余牌通过对3进行取余依次发牌
  74.         ArrayList<String> player1=new ArrayList<>();
  75.         ArrayList<String> player2=new ArrayList<>();
  76.         ArrayList<String> player3=new ArrayList<>();
  77.         ArrayList<String> dipai=new ArrayList<>();
  79.         //使用普通for循环，通过下标进行处理
  80.         //除了最后的三张牌，其他的都发给玩家
  81.         for (int i = 0; i < list.size()-3; i++) {
  82.             //获取当前这张牌
  83.             String thisCard= list.get(i);
  84.             //对3进行取余
  85.             if (i%3==0){
  86.                 player1.add(thisCard);
  87.             }else if (i%3==1){
  88.                 player2.add(thisCard);
  89.             }else {
  90.                 player3.add(thisCard);
  91.             }
  92.         }
  94.         //最后的3张底牌--从倒数第3张牌开始发
  95.         for (int i = list.size()-3; i < list.size() ; i++) {
  96.             //抽取这张牌
  97.             String thisCard= list.get(i);
  98.             dipai.add(thisCard);
  99.         }
  101.         //看牌
  102.         System.out.println(player1);
  103.         System.out.println(player2);
  104.         System.out.println(player3);
  105.         System.out.println(dipai);
  106.     }
  107. }