这里写自定义目录标题

P23801.Collection集合概述1、数组和集合的区别？ P23902.集合框架介绍P24003.2Collection集合-复习P24103.Collection集合常用功能P24204.Iterator接口介绍P24305.迭代器的代码实现P24406.迭代器的实现原理P24507.2迭代器&增强for-复习P24608_增强for循环P24810_使用泛型的好处P24911_定义和使用含有泛型的类P25012_定义和使用含有泛型的方法(1)P25113_定义和使用含有泛型的接口P25214_2泛型的使用-复习P25314_泛型通配符P25415_斗地主案例的需求分析P25516_斗地主案例的代码实现

P23801.Collection集合概述

1、数组和集合的区别？

1、可变。 2、 集合只能存储对象。 数组是基本数据类型和对象都可以。 int[] arr = new int[10]; Student[] arr = new Student[3];

P23902.集合框架介绍

P24003.2Collection集合-复习

package demo06; import java.util.ArrayList; import java.util.Collection; public class Demo { public static void main(String[] args) { Collection<String> coll = new ArrayList<>(); coll.add("aaa"); coll.add("bbb"); coll.add("ccc"); System.out.println(coll); // [aaa, bbb, ccc] boolean result = coll.remove("aaa"); System.out.println(result); // true System.out.println(coll); // [bbb, ccc] coll.clear(); System.out.println(coll); // [] boolean result2 = coll.contains("ccc"); System.out.println(result2); System.out.println(coll.isEmpty()); System.out.println(coll.size()); Object[] arr = coll.toArray(); for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }

P24103.Collection集合常用功能

集合的长度=元素的个数，一样的意思。

package com.itheima.demo01.Collection; 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> coll = new ArrayList<>(); //Collection<String> coll = new HashSet<>();也是可以的，但是重复元素，只显示一次。 System.out.println(coll);//[]，打印的不是地址，说明重写了toString方法 /* public boolean add(E e)：把给定对象添加到当前集合中。 返回值是一个boolean值，一般都返回true，所以可以不接收。 */ boolean b1 = coll.add("张三"); System.out.println("b1:"+b1);//b1:true System.out.println(coll);//[张三] coll.add("李四"); coll.add("王五"); coll.add("赵六"); coll.add("田七"); System.out.println(coll);//[张三, 李四, 王五, 赵六, 田七] /* public boolean remove(E e)：把给定对象在当前集合中删除. 返回值是一个boolean值，集合中存在元素，删除元素，返回true 集合中不存在元素，删除失败，返回false */ boolean b2 = coll.remove("赵六"); System.out.println("b2："+b2);//true boolean b3 = coll.remove("艾克"); System.out.println("b3："+b3);//false System.out.println(coll); /* public boolean contains(E e)：判断当前集合是否包含给定对象。 包含返回true 不包含返回false */ boolean b4 = coll.contains("李四"); System.out.println("b4："+b4); boolean b5 = coll.contains("艾克"); System.out.println("b5："+b5); /* public boolean isEmpty()：判断当前集合是否为空。 集合为空返回true 集合不为空返回false */ boolean b6 = coll.isEmpty(); System.out.println("b6："+b6); /* public int size()：返回集合中元素的个数 */ int size = coll.size(); System.out.println("size："+size); /* public Object[] toArray()：把集合中的元素，存储到数组中 */ Object[] arr = coll.toArray(); for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } /* public void clear()：清空集合中所有的元素。但是不删除集合，集合还存在 */ coll.clear(); System.out.println(coll);//[] System.out.println(coll.isEmpty()); } }

P24204.Iterator接口介绍

P24305.迭代器的代码实现

package com.itheima.demo02.Iterator; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /* java.util.Iterator接口：迭代器(对集合进行遍历) 有两个常用的方法： boolean hasNext() 如果仍有元素可以迭代，则返回 true。 E next() 返回迭代的下一个元素。 void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。 Iterator迭代器,是一个接口我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊 Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现类对象 Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。 迭代器的使用步骤(重点)： 1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态) 2.使用Iterator接口中的方法hasNext判断还有没有下一个元素 3.使用Iterator接口中的方法取出集合的下一个元素 */ public class Demo01Iterator { public static void main(String[] args) { //创建一个集合对象 //ArrayList arrayList = new ArrayList(); Collection<String> coll = new ArrayList<>();//使用多态 //往集合添加元素 coll.add("姚明"); coll.add("科比"); coll.add("麦迪"); coll.add("詹姆斯"); coll.add("字母哥"); /* 1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态) 注意： Iterator<E>接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型 */ //多态 接口 实现类对象 Iterator<String> it = coll.iterator(); /* 发现使用迭代器取出集合中元素的代码，是一个重复的过程 所以我们可以使用循环优化 不知道集合有多少个元素，使用while循环 循环结束的条件，hasNext方法返回false */ while(it.hasNext()){ String e = it.next(); System.out.println(e); } System.out.println("-------------"); for (Iterator<String> it2 = coll.iterator(); it2.hasNext(); /*i++*/) { String e = it2.next();//不需要步进表达式，因为获取的同时，他会自动往后面移动 System.out.println(e); } //两者相比，while循环更好看 /*//2.使用Iterator接口中的方法hasNext判断还有没有下一个元素 boolean b = it.hasNext(); System.out.println(b);//true //3.使用Iterator接口中的方法取出集合的下一个元素 String s = it.next(); System.out.println(s); b = it.hasNext(); System.out.println(b); s = it.next(); System.out.println(s); b = it.hasNext(); System.out.println(b); s = it.next(); System.out.println(s); b = it.hasNext(); System.out.println(b); s = it.next(); System.out.println(s); b = it.hasNext(); System.out.println(b); s = it.next(); System.out.println(s); b = it.hasNext(); System.out.println(b); s = it.next();//NoSuchElementException，没有元素，再取出元素会抛出异常 System.out.println(s);*/ } }

P24406.迭代器的实现原理

P24507.2迭代器&增强for-复习

Iterator<String> iterator = coll.iterator(); while(iterator.hasNext()){ String next = iterator.next(); System.out.println(next); } for (String s : coll) { System.out.println(s); } int[] arr = {1,2,3}; for (int i : arr) { System.out.println(i); }

P24608_增强for循环

package com.itheima.demo02.Iterator; import java.util.ArrayList; /* 增强for循环：底层使用的也是一个迭代器，使用for循环的格式，简化了迭代器的书写 是JDK1.5之后出现的新特性 Collection<E>extends Iterable<E>:所有单列集合都可以使用增强for public interface Iterable<T>实现这个接口允许对象成为"foreach"语句的目标 增强for循环：用来遍历集合和数组 格式： for(集合/数组的数据类型 变量名: 集合名/数组名){ sout(变量名); } */ public class Demo02Foreach { public static void main(String[] args) { demo01(); demo02(); } //使用增强for循环遍历集合 private static void demo02() { ArrayList<String> list = new ArrayList<>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); for (String s : list){ System.out.println(s); } } //使用增强for循环遍历数组 private static void demo01() { int[] arr = {1, 2, 3, 4, 5}; for (int i :arr) { System.out.println(i); } System.out.println("=========="); } }

P24810_使用泛型的好处

package com.itheima.demo03.Generic; import java.util.ArrayList; import java.util.Iterator; public class Demo01Generic { public static void main(String[] args) { show01(); show02(); } /* 创建集合对象，使用泛型 好处: 1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型 2.把运行期异常(代码运行之后会抛出异常)，提升到了编译期(写代码的时候会报错) 弊端： 泛型是什么类型，只能存储什么类型的数据 */ private static void show02() { ArrayList<String> list = new ArrayList<>(); list.add("abc"); // list.add(1);//存储的是什么类型，取出的就是什么类型 //使用迭代器遍历list集合 Iterator<String> it = list.iterator(); while(it.hasNext()){ String s = it.next(); System.out.println(s+"->"+s.length()); } } /* 创建集合对象，不使用泛型 好处: 集合不使用泛型，默认类型就是Object类型，可以存储任意类型的数据 坏处：不安全，容易引发异常 */ private static void show01() { ArrayList list = new ArrayList(); list.add("abc"); list.add(1);//不能把Integer类型转换为String类型 //使用迭代器遍历list集合 //获取迭代器 Iterator it = list.iterator();//集合中有迭代器的实现，用迭代器接口接受，是多态 //使用迭代器中的方法hasNext和next遍历集合 while(it.hasNext()){ //取出元素也是Object类型 Object obj = it.next(); System.out.println(obj); System.out.println("======="); //想要使用String类特有的方法，length获取字符串的长度。 // 不能使用，因为多态不能使用子类的特有方法 //Object obj = "abc"; //需要向下转型 //会抛出ClassCastException类型转换异常，不能把Integer类型转换为String类型 // String s = (String)obj; // System.out.println(s.length()); } } }

P24911_定义和使用含有泛型的类

package com.itheima.demo03.Generic; /* 定义一个含有泛型的类，模拟ArrayList集合 泛型是一个未知的数据类型，当我们不确定什么什么数据类型的时候，可以使用泛型 泛型可以接收任意的数据类型，可以使用Integer,String,Student... 创建对象的时候确定泛型的数据类型 */ public class GenericClass<E> {//这个就是一个含有泛型的类 private /*String*/ E name; public /*String*/ E getName() { return name; } public void setName(/*String*/ E name) { this.name = name; } } package com.itheima.demo03.Generic; public class Demo02GenericClass { public static void main(String[] args) { //不写泛型，默认为Object类型 GenericClass gc = new GenericClass(); gc.setName("只能是字符串"); Object obj = gc.getName(); //创建对象时候，确定泛型。 //创建GenericClass对象，泛型使用Integer类型 GenericClass<Integer> gc2 = new GenericClass<>(); gc2.setName(1); Integer name = gc2.getName(); System.out.println(name); //创建GenericClass对象，泛型使用String类型 GenericClass<String> gc3 = new GenericClass<>(); gc3.setName("小明"); String name1 = gc3.getName(); System.out.println(name1); } }

P25012_定义和使用含有泛型的方法(1)

package com.itheima.demo03.Generic; /* 定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间 格式: 修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){ 方法体; } 含有泛型的方法，在调用方法的时候确定泛型的数据类型 传递什么类型的参数，泛型就是什么类型 */ public class GenericMethod { //定义一个含有泛型的方法 public <M> void method01(M m){ System.out.println(m); } //定义一个含有泛型的静态方法 public static <S> void method02(S s){ System.out.println(s); } } package com.itheima.demo03.Generic; /* 测试含有泛型的方法 */ public class Demo03GenericMethod { public static void main(String[] args) { GenericMethod gm = new GenericMethod(); /* 调用含有泛型的方法method01 传递什么类型，泛型就是什么类型 */ gm.method01(10);//传递什么类型，泛型就是什么类型 gm.method01("哈哈哈讨厌啦你"); gm.method01(8.8); gm.method02("静态方法，不建议创建对象使用"); //因为静态方法可以通过类型点.方法使用 //还有一种就是比较常用的成员变量名点.方法使用 //静态方法，通过类名.方法名(参数)可以直接使用 GenericMethod.method02("福乐，色！静态方法！！！"); GenericMethod.method02(1);//它也可以传递任意的数据类型 } }

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

package com.itheima.demo03.Generic; import java.util.Iterator; /* 定义含有泛型的接口 */ public interface GenericInterface<I> { public abstract void method(I i); } package com.itheima.demo03.Generic; /* 测试含有泛型的接口 */ public class Demo04GenericInterface { public static void main(String[] args) { //含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型。实现类定义了泛型 GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1(); gi1.method("字符串"); //含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就是用什么泛型，类跟着接口走 GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>(); gi2.method(1); GenericInterfaceImpl2<String> gi3 = new GenericInterfaceImpl2<>(); gi3.method("hhhh"); } } package com.itheima.demo03.Generic; /* 含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型。实现类定义了泛型 public interface Iterator<E>{//这个是迭代器的接口 E next(); } Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String public final class Scanner implements Iterator<String>{ //这是Scanner类，它实现了Iterator的接口 public String next(){} } */ public class GenericInterfaceImpl1 implements GenericInterface<String>{ @Override public void method(String s) { System.out.println(s); } } package com.itheima.demo03.Generic; /* 含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就是用什么泛型，类跟着接口走 就相当于定义了一个有泛型的类，创建对象的时候确定泛型的类型 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); } }

P25214_2泛型的使用-复习

package demo03; import java.util.ArrayList; public class Test01 { public static void main(String[] args) { MyClas<String> stringMyClas = new MyClas<>(); stringMyClas.method("hhhhhh"); MyInterImpl<String> impl = new MyInterImpl<>(); impl.method("sdsdfs"); ArrayList<String> list1= new ArrayList<>(); list1.add("ds"); list1.add("ds"); list1.add("ds"); ArrayList<Integer> list2 = new ArrayList<>(); list2.add(1); list2.add(1); list2.add(1); print(list1); } public static void print(ArrayList<?> list){ for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } } } package demo03; public class MyClas<E> { public E method(E e){ System.out.println(e); return e; } } package demo03; public class MyInterImpl<E> implements MyInter<E> { @Override public void method(Object o) { System.out.println(o); } } package demo03; public interface MyInter<E> { public abstract void method(E e); }

P25314_泛型通配符

package com.itheima.demo03.Generic; import java.util.ArrayList; import java.util.Iterator; /* 泛型的通配符: ?:代表任意的数据类型 使用方式: 不能创建对象使用 只能作为方法的参数使用 */ public class Demo05Generic { public static void main(String[] args) { ArrayList<Integer> list01 = new ArrayList<>(); list01.add(1); list01.add(2); ArrayList<String> list02 = new ArrayList<>(); list02.add("a"); list02.add("b"); printArray(list01); printArray(list02); //ArrayList<?> list03 = new ArrayList<?>(); } /* 定义一个方法,能遍历所有类型的ArrayList集合 这时候我们不知道ArrayList集合使用什么数据类型,可以泛型的通配符?来接收数据类型 注意: 泛型没有继承概念的 */ public static void printArray(ArrayList<?> list){ //使用迭代器遍历集合 Iterator<?> it = list.iterator(); while(it.hasNext()){ //it.next()方法,取出的元素是Object,可以接收任意的数据类型 Object o = it.next(); System.out.println(o); } } }

P25415_斗地主案例的需求分析

P25516_斗地主案例的代码实现

package com.itheima.demo04.Test; import java.util.ArrayList; 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集合中 poker.add("大王"); poker.add("小王"); //循环嵌套遍历两个数组，组装52张牌 for (String number : numbers) { for (String color : colors) { //把组装好的牌存储到poker集合中 poker.add(color+number); } } /* 2.洗牌 使用集合的工具类Collections中的方法 static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。 */ Collections.shuffle(poker); // System.out.println(poker); /* 3.发牌 */ //定义4个集合，存储玩家的牌和底牌 ArrayList<String> play01 = new ArrayList<>(); ArrayList<String> play02 = new ArrayList<>(); ArrayList<String> play03 = new ArrayList<>(); ArrayList<String> dipai = new ArrayList<>(); /* 遍历poker集合，获取每一张牌 使用poker集合的索引%3给3个玩家轮流发牌 剩余3张牌给底牌 注意: 先判断底牌(i>=51),否则牌就发没了 */ for (int i = 0; i < poker.size(); i++) { //获取每一张牌 String p = poker.get(i); //轮流发牌 if(i>=51){ //该底牌发牌 dipai.add(p); }else if(i%3==0){ //给玩家1发牌 play01.add(p); }else if(i%3==1){ //给玩家2发牌 play02.add(p); }else if(i%3==2){ //给玩家3发牌 play03.add(p); } } //4.看牌 System.out.println("刘德华"+play01); System.out.println("周润发"+play02); System.out.println("周星驰"+play03); System.out.println("底牌"+dipai); } }