Loading

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]

 


 

posted @ 2021-07-31 16:04  StormArcita  阅读(101)  评论(0编辑  收藏  举报