java高级篇3——Collection集合、Iterator迭代器、泛型

于 2020-04-04 17:56:22 发布
阅读量173 收藏
点赞数
分类专栏： java高级篇 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Saltyyy/article/details/105311562
版权

1.Collection集合

  • 集合是java中提供的一种容器，可以用来存储多个数据。
  • 集合和数组既然都是容器，它们的区别；
    • 数组的长度是固定的。集合的长度是可变的。
    • 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
集合框架
  • JAVASE提供了满足各种需求的API，在使用这些API前，先了解其继承与接口操作架构，才能了解何时采用哪个类，以及类之间如何彼此合作，从而达到灵活应用。
    集合框架
Collection 常用方法
  • java.util.Collection是所有单列集合的父接口，所以Collection中定义了单列集合（List和set）通用的一些方法，可用于操作所有的单列集合。
  • 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(): 把集合中的元素，存储到数组中。
import java.util.ArrayList;
import java.util.Collection;

public class Demo1Collection {
    public static void main(String[] args) {
    	// 使用多态形式创建集合对象
    	Collection<String> coll = new ArrayList<String>();
    	// 使用方法
    	// 添加功能  boolean  add(String s)
    	coll.add("小李广");
    	coll.add("扫地僧");
    	coll.add("石破天");
    	System.out.println(coll);

    	// boolean contains(E e) 判断o是否在集合中存在
    	System.out.println("判断  扫地僧 是否在集合中"+coll.contains("扫地僧"));

    	//boolean remove(E e) 删除在集合中的o元素
    	System.out.println("删除石破天："+coll.remove("石破天"));
    	System.out.println("操作之后集合中元素:"+coll);
    	
    	// size() 集合中有几个元素
		System.out.println("集合中有"+coll.size()+"个元素");

		// Object[] toArray()转换成一个Object数组
    	Object[] objects = coll.toArray();
    	// 遍历数组
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}

		// void  clear() 清空集合
		coll.clear();
		System.out.println("集合中内容为："+coll);
		// boolean  isEmpty()  判断是否为空
		System.out.println(coll.isEmpty());  	
	}
}

2、Iterator迭代器

Iterator接口
  • java.util.Iterator接口即迭代器，对集合/数组进行遍历。
  • 迭代：即Collection集合元素的通用获取方法在取元素前先判断集合中有没有元素，如果有则将元素取出，继续再判断，如果有再取出，直到全部取出，这种取出方式就叫迭代。
  • 常用方法
    • public E next():返回迭代的下一个元素。
    • public boolean hasNext():如果仍有元素可以迭代，则返回 true。
  • Iterator迭代器是一个接口，无法直接使用，需用Iterator接口的实现类对象获取实现类的方式。Collection接口有一个方法叫 iterator() 这个方法返回的是迭代器的实现类对象。
  • Iterator<E> iterator()：返回在此Collection的元素上进行迭代的迭代器。
  • 迭代器使用步骤：
    • 1、使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态写法）；
    • 2、使用Iterator接口中的hasNext方法判断还有没有下一个元素；
    • 3、使用Iterator接口中的next方法取出集合中的下一个元素。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();  //多态写法创建一个集合
        coll.add("XX1");
        coll.add("XX2");
        coll.add("XX3");

        Iterator<String> it = coll.iterator();  //1、使用Collection的方法iterator()创建Iterator接口的实现类对象
        while(it.hasNext()){  //2、先判断是否有下一个元素
            String s = it.next();  //3、若有，再取出元素
            System.out.println(s);
        }
    }
}
迭代器的实现原理

迭代器的实现原理

增强for循环
  • 增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
  • Collection<E> extends Iterator<E>：所有单列集合都可以使用增强for。
  • public iterface Iterable<T>：实现这个接口允许对象成为“foreach”语句的目标。
  • 格式：
    for(元素的数据类型 变量 : Collection集合or数组){ //写操作代码 }
import java.util.ArrayList;

public class ForeachDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("XX1");
        list.add("XX2");
        list.add("XX3");

        for(String s :list){  //增强for循环遍历集合
            System.out.println(s);
        }

        int[] arr = {1,2,3};
        for(int i : arr){  //增强for循环遍历数组
            System.out.println(i);
        }
    }
}
结果：
XX1
XX2
XX3
1
2
3

3、泛型

  • 泛型是一种未知的数据类型，当不知道使用什么数据类型时，可以使用泛型，泛型也可以看成是一个变量，用来接收数据类型。
    泛型
  • 使用泛型的好处：
  1. 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
  2. 把运行期异常（代码运行之后抛出异常）提升到了编译期异常（写代码的时候会报错）。
  • 弊端：泛型是什么类型，只能存储什么类型的数据。
public class GenericDemo {
	public static void main(String[] args) {
		Collection coll = new ArrayList(); //无泛型
		coll.add("abc");
		coll.add("itcast");
		coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
		Iterator it = coll.iterator();
		while(it.hasNext()){
			//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
			String str = (String) it.next();
			System.out.println(str.length());
		}
		//程序在运行时发生了问题java.lang.ClassCastException。   
	}
}

public class GenericDemo2 {
	public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>(); //使用泛型
        list.add("abc");
        list.add("itcast");
        // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
        // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
            System.out.println(str.length());
        }
	}
}
定义和使用含有泛型的类
  • 定义一个含有泛型的类，模拟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 DemoGenericClass {   
    public static void main(String[] args) {
        GenericClass gc = new GenericClass();  //不写泛型，默认为Object类型
        gc.setName("XX");    //String类型可以自动转化为Object类型
        Object obj = gc.getName();
        System.out.println(obj);  //XX

        GenericClass<Integer> gc2 = new GenericClass<>();  //泛型为Integer
        gc2.setName(1);      //只能传入Integer类型的参数
        Integer name = gc2.getName();
        System.out.println(name);  //1
    }
}
定义和使用含有泛型的方法
  • 定义含有泛型的方法：泛型定义在方法的修饰符和返回值之间。
  • 格式：
    修饰符 <泛型> 返回值类型 方法名（参数列表（使用泛型））{ 方法体； }
  • 含有泛型的方法在调用方法的时候确定泛型的数据类型，传递什么类型的参数，泛型就是什么类型。
//定义一个含有泛型的方法
public class GenericMethod {
    public <M> void method(M m){  
        System.out.println(m);
    }
    public static <S> void method02(S s){  //定义一个含有泛型的静态方法
        System.out.println(s);
    }
}

//使用含有泛型的方法
public class DemoGenericMethod {  
    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.method(10);  //10    参数是整数，则泛型为Integer
        gm.method("XX");  //XX    String
        gm.method(true);  //true   Boolean

        GenericMethod.method02("静态方法");  //静态方法   类名.静态方法
        GenericMethod.method02(1); //1
    }
}
定义和使用含有泛型的接口
  • 含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型。 如：
    public interface Iterator<E>{E next();}
    public final class Scanner implements Iterator<String>{ public String next(){}}
    Scanner类实现了Iterator接口，并指定了接口的泛型为String，所以重写的next方法泛型默认为String。
  • 含有泛型的接口，第二种使用方式：接口是什么泛型，实现类就用什么泛型，类跟着接口走，就相当于定义了一个含有泛型的类，创建对象时确定泛型类型。如：
    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 interface GenericInterface<I> {
    public abstract void method(I i);  //抽象方法
}

//使用第一种方式定义实现类
public class GenericInterfaceImpl01 implements GenericInterface<String>{ //实现类指定泛型
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

//使用第二种方式定义实现类
public class GenericInterfaceImpl02<I> implements GenericInterface<I> {  //实现类不指定泛型
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

//使用含有泛型的接口
public class DemoGenericInterface {
    public static void main(String[] args) {
        //第一种方式
        GenericInterfaceImpl01 gi1 = new GenericInterfaceImpl01(); //以及在实现类指定泛型
        gi1.method("只能是字符串");  //只能是字符串

        //第二种方式
        GenericInterfaceImpl02<String> gi2 = new GenericInterfaceImpl02<>(); //创建实现类对象时才指定泛型
        gi2.method("XX");  //XX

        GenericInterfaceImpl02<Integer> gi3 = new GenericInterfaceImpl02<>();
        gi3.method(10);  //10

        GenericInterfaceImpl02<Double> gi4 = new GenericInterfaceImpl02<>();
        gi4.method(3.3);  //3.3
    }
}
泛型的通配符
  • 当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?> 表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
  • 使用方式：不能创建对象使用，只能作为方法的参数使用。
public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型
通配符高级使用----受限泛型

  • 之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

  • 泛型的上限：

    • 格式： 类型名称 <? extends 类 > 对象名称
    • 意义： 只能接收该类型及其子类

  • 泛型的下限：

    • 格式： 类型名称 <? super 类 > 对象名称
    • 意义： 只能接收该类型及其父类型
// 比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类
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>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

4、集合的综合案例

  • 按照斗地主的规则，完成洗牌发牌的动作。
    具体规则：使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
  • 案例分析：
    案例分析
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<>(); //存54张牌
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers ={"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        poker.add("大王");
        poker.add("小王");
        for(String color : colors){   //循环嵌套组装52张牌
            for(String number : numbers){
                poker.add(color+number);
            }
        }

        //2、洗牌
        Collections.shuffle(poker);

        //3、发牌
        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++) {
            String p = poker.get(i);
            if (i >= 51) {   //先判断底牌（i>=51)，否则牌就没了
                diPai.add(p);
            } else if (i % 3 == 0) {
                player01.add(p);
            } else if (i % 3 == 1) {
                player02.add(p);
            } else if (i % 3 == 2) {
                player03.add(p);
            }
        }

        //4、看牌
        System.out.println("玩家1的牌：" + player01);
        System.out.println("玩家2的牌：" + player02);
        System.out.println("玩家3的牌：" + player03);
        System.out.println("底牌：" + diPai);
    }
}
结果：
玩家1的牌：[♣3, ♣5, ♣K, 大王, ♣Q, ♥7, ♦2, ♣7, ♦8, ♠2, ♥2, ♦A, ♦6, 小王, ♦K, ♠9, ♣J]
玩家2的牌：[♥4, ♣4, ♥10, ♥Q, ♥A, ♥5, ♣2, ♠J, ♣A, ♦3, ♠5, ♠3, ♦7, ♠8, ♣9, ♣10, ♥9]
玩家3的牌：[♠4, ♦4, ♠Q, ♦9, ♦10, ♥J, ♣8, ♥K, ♥6, ♣6, ♠6, ♠K, ♦Q, ♥3, ♦J, ♥8, ♠A]
底牌：[♠10, ♦5, ♠7]
Saltyyy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值