Collection\泛型(Collection\Generics)知识总结
Collection\泛型(Collection\Generics)知识总结
1.1 集合概述
集合：集合是java中提供的一种容器，用来存储多个数据。
集合和数组的区别：
数组的长度是固定的，集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致，在开发中一般当对象多的时候，使用集合进行存储。
1.2Collection集合
1.单列集合体系结构
集合的框架：
（绿线是继承关系）
List集合∶有索引、可以存储重复元素、可以保证存取顺序
ArrayList:底层是数组实现的，查询块，增删慢
LinkedList:底层是链表实现的，查询慢、增删快
Set集合∶无索引、不可以存储重复元素、存取无序
HashSet:底层是哈希表+(红黑树)实现的，无索引、不可以存储重复元素、存取无序LinkedHashSet:底层是哈希表+链表实现的，无索引、不可以存储重复元素、可以保证存取顺序
TreeSet：底层是二叉树实现，一般用于排序
2.Collection集合常用方法
boolean add(E e); 向集合中添加元素
boolean remove(E e); 删除集合中的某个元素
void clear(); 清空集合中所有的元素
boolean contaions(E e); 判断集合中是否包含某个元素
boolean isEmpty(); 判断集合是否为空
int size(); 获取集合的长度
Object[] toArray(); 将集合转成一个数组
代码：
public class Text01 { public static void main(String[] args) { Collection<String> coll = new ArrayList<>(); coll.add("Hello"); coll.add("java"); boolean result = coll.remove("Hello"); //result = true coll.clear(); System.out.println(coll); coll.add("Hello"); coll.add("java"); Object[] obj = coll.toArray(); System.out.println(obj);//[Ljava.lang.Object;@f0d1e0b for(int a = 0;a<obj.length;a++){ System.out.println(obj[a]); /*Hello java*/ } } }
1.3 Iterator迭代器
1.概念
在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口 java.util.Iterator 。
Iterator 接口也是Java集合中的一员，但它与 Collection 、 Map 接口有所不同， Collection 接口与 Map 接口主要用于存储元素，而 Iterator 主要用于迭代访问（即遍历） Collection 中的元素，因此 Iterator 对象也被称为迭代器。
想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：
public Iterator iterator() : 获取集合对应的迭代器，用来遍历集合中的元素的。
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个
元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业
术语称为迭代。
Iterator接口的常用方法如下：
public E next() :返回迭代的下一个元素。
public boolean hasNext() :如果仍有元素可以迭代，则返回 true。
Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象
Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
2.迭代器的使用步骤：
1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
2.使用Iterator接口中的方法hasNaxt判断还有没有下一个元素
3.使用Iterator接口中的方法next取出集合中的下一个元素
代码：
public class Demo001 { public static void main(String[] args) { Collection<String> coll = new ArrayList(); coll.add("a"); coll.add("b"); coll.add("c"); //获取迭代器 Iterator<String> iterator = coll.iterator(); //hasNext boolean flag = iterator.hasNext(); System.out.println(flag); //true while (iterator.hasNext()){ //next取出 String s = iterator.next(); System.out.println(s);//a b c } System.out.println("---------------------"); for(Iterator<String> it2 = coll.iterator();it2.hasNext();/*迭代器的hasNext取出元素自动向后移动一位*/){ String s = iterator.next(); System.out.println(s); } } }
3.增强for
增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写，是JDK1.5之后出现的
Collection<E>extends Iterable<E>:所有的单列集合都可以使用增强for
public interface Iterable<T>实现这个接口允许对象成为“foreach”语句的目标。
增强for循环：用来遍历集合和数组
格式：
for(集合/数组的数据类型 变量名：集合名/数组名）{
sout(变量名);
}
代码：
public class Demo02_for { public static void main(String[] args) { demo01(); demo02(); } private static void demo01(){ int[] arr = {1,2,3,4,5}; for(int i:arr){ System.out.println(i); } } private static void demo02(){ ArrayList<String> coll = new ArrayList<>(); coll.add("a"); coll.add("b"); coll.add("c"); for(String s:coll){ System.out.println(s); } } }
1.4 泛型
1.概念
泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型，泛型也可以看作是一种变量，可以用来接收数据
ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型
E e:Element 元素
T t:Type 类型
创建集合对象，不适用泛型
2.泛型的定义与使用：
代码：
方法类：
/* 定义一个含有泛型的类,模拟ArrayList集合 泛型是一个未知的数据类型,当我们不确定什么什么数据类型的时候,可以使用泛型 泛型可以接收任意的数据类型,可以使用Integer,String,Student... 创建对象的时候确定泛型的数据类型 */ public class GenericClass<E> { private E name; public E getName() { return name; } public void setName(E name) { this.name = name; } }
实现类：
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); } }
3.好处和弊端
好处：
集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
弊端：
不安全，会引发异常
创建集合对象，使用泛型
好处：
1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
2.把运行期异常（代码运行之后会抛出的异常），提升到了编译期
弊端：
泛型是什么类型，只能存储什么类型的数据
代码：
public class GenericDemo01 { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("a"); list.add(1); Iterator it = list.iterator(); while (it.hasNext()){ Object obj = it.next(); System.out.println(obj); //想要使用String类特有的方法，length获取字符串的长度；不能使用多态，因为obj是 //Object类，不能使用其子类String特有的方法，需向下转型 String s = (String)obj; System.out.println(s.length());//抛出类型转换异常 Integer cannot be cast，所以不使用泛型不安全，容易引发异常 } } }
4.泛型通配符：
当使用泛型或者接口时，传递的数据中，泛型类型不确定，可以使用通配符<?>表示，但是一旦使用泛型的通配符后，只能使用Object类中的
共性方法，集合中元素自身方法无法使用
代码：
/* 泛型的通配符: ?:代表任意的数据类型 使用方式: 不能创建对象使用 只能作为方法的参数使用 */ 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); } } }
通配符的高级使用-------受限泛型（不常用）
代码：
/* 泛型的上限限定: ? extends E 代表使用的泛型只能是E类型的子类/本身 泛型的下限限定: ? super E 代表使用的泛型只能是E类型的父类/本身 */ public class Demo06Generic { 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>(); 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类型或者Number类型的子类 public static void getElement1(Collection<? extends Number> coll){} // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类 public static void getElement2(Collection<? super Number> coll){} }
本章思维导图：
案例：
斗地主关于准备牌/洗牌/发牌/看牌的实现：
代码：
package Java.Collection; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; public class DouDiZhu { public static void main(String[] args) { //1.准备牌 ArrayList<String> poker = new ArrayList(); String[] color = {"♠","♥","♣","♦"}; String[] number = {"1","2","3","4","5","6","7","8","9","10","J","Q","K"}; poker.add("大王"); poker.add("小王"); for(String colour:color){ for(String Number:number){ poker.add(colour+Number); } } //洗牌 Collections.shuffle(poker); //发牌 ArrayList<String> player01 = new ArrayList<>(); ArrayList<String> player02 = new ArrayList<>(); ArrayList<String> player03 = new ArrayList<>(); ArrayList<String> diPai = new ArrayList<>(); for(int i = 0;i<poker.size();i++){ if(i>=51){ String a = poker.get(i); diPai.add(a); }else if(i%3==0){ String a = poker.get(i); player01.add(a); }else if(i%3==1){ String a = poker.get(i); player02.add(a); }else if(i%3==2){ String a = poker.get(i); player03.add(a); } } for(int i = 0;i<diPai.size();i++){ if(i%3==0){ String a = diPai.get(i); player01.add(a); } if(i%3==1){ String a = diPai.get(i); player02.add(a); } if(i%3==2){ String a = diPai.get(i); player03.add(a); } } //看牌 System.out.println("player01："+player01); System.out.println("player02："+player02); System.out.println("player03："+player03); System.out.println("底牌是："+diPai); } } 运行结果： player01：[♠2, ♥6, ♦Q, ♥Q, ♦7, ♦8, ♣8, ♠6, 大王, 小王, ♠8, ♣3, ♣5, ♠K, ♣J, ♠J, ♦3, ♠9] player02：[♥7, ♥8, ♦1, ♥4, ♠3, ♠Q, ♦10, ♣Q, ♣10, ♥K, ♠7, ♣4, ♥1, ♥J, ♥9, ♣7, ♣6, ♦9] player03：[♣9, ♠10, ♣K, ♦2, ♦5, ♦K, ♣2, ♥5, ♦6, ♠1, ♥2, ♠5, ♦4, ♣1, ♠4, ♥3, ♥10, ♦J] 底牌是：[♠9, ♦9, ♦J]
