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]