java 高级day2 Collection集合、泛型_2collection-优快云博客

1集合的概念：相较于数组，集合的长度可变，存储的内容只能是对象

2Collection接口：所有单列集合中的共性方法，所有单例集合都可以使用

Collection的共用特性：1boolean add、2voidclear、3boolean remove、4boolean contains

5boolean IsEmpty 、6 int size、7object 【】toArray（）8 addAll

9 shuffle

10 sort<List>（默认升序排序）如果排序的元素是自定义的类，那么需要在类中

重写Comparable接口（先实现该接口然后再重写）接口中的中的

comparaTo方法

举例：public class Person implements Comparable<Person>{//先继承Comparable接口

public int comparaTo(person o){ //将person类作为对象重写comparato方法

return this.getAge - o.getAge}//以年龄升序排序，反过来就是降序

11 sort<List comparator>：和上面方法的区别：使用了匿名内部类，不需要继承和重写

Person类

   public int compare(Person person, Person t1) {//自动生成
                int result= person.getAge()-t1.getAge();//返回结果以age作为判断
                //当age相同时，返回结果以姓名首字母作为判断
                if (result==0){
                    result=person.getName().charAt(0)-t1.getName().charAt(0);
                };
                return result;
            }
        });
        System.out.println(list03);

3Collection集合的两个子类 ：LIst和Set

1 list接口的特性：（Vector、ArrayList、LinkedList）

1是有序的集合（存储和取出顺序相同）2允许存储重复的元素

3有索引，可以使用普通的for循环遍历

2 Set接口特性：TreeSet(无序集合)、HashSet(无序集合）、LinkHashSet(有序集合）

1不允许存储重复元素 2 没有索引

4Irerator接口（迭代器）作用：用于遍历Collecton（List和Set）中的元素。作用流程：判断

Collection中还有没有元素，有的话继续向下取一位（boolean hasNext），返回迭代元素（next）

Iterator的使用：Collection接口中有一个方法，叫做Iterator，这个方法的返回值就是Iterator

的实现类对象，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什

么泛型。Iterator <集合泛型> 名称=集合名称.iterator();也是一个多态

举例注意备注

package com.bed.javahighclass;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Collectiontest {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("b");
        coll.add("e");
        coll.add("d");
        System.out.println(coll);
        //使用迭代器
        Iterator<String> it = coll.iterator();//调用Collection方法建立Iterator迭代器
        while(it.hasNext()){//while循环，判断后面是否还有元素，就执行下一步
            String str=it.next();//拿出元素，指针向后移一位
            System.out.println(str);
        }
        System.out.println("=================");
        for(String s:coll){//使用增强for循环进行遍历
            System.out.println(s);
        }
    }
}

注：其中的while循环也可以使用增强for循环来代替，两者都是集合的遍历方式

增强for循环格式为： for（数据类型（同集合类型）变量名：集合名称）底层使用的也是

迭代器，简化了迭代器的书写。增强for循环的对象时只能是集合或数组

5泛型：public class ArrayList<E> 其中E是elements的意思，当我们不知道集合中是什么类型

可以先使用泛型来接收数据。而当创建对象时，就会确定泛型的数据类型，此时会把确定

数据类型作为参数传递给E。（泛型E有点像一个包装箱的意思。或者百变怪？）

泛型的作用：1避免类型转换的麻烦，存出什么类型，取出就是什么类型

2把运行期异常提升到了编译期

1定义和使用含有泛型的类：当创建对象时，就会确定泛型的数据类型

2定义和使用含有泛型的方法：

格式：修饰符 <泛型> 返回值类型方法名（泛型（泛型参数））{方法体}

在调用方法时确定泛型的数据类型

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

第一种使用方式：在接口中写上泛型<E> 在实现类中指定接口的泛型

第二种使用方式：在接口中写上泛型<E> 在创建对象时指定接口的泛型

4泛型的通配符：定义一个方法参数是？就可以将任意的参数类型传进去执行方法

5泛型的上限限定？extends E ：使用的类型只能是E类型的子类/本身

泛型的下限限定？ super E ：使用的类型只能是E类型的父类/本身

案例斗地主发牌

package com.bed.javahighclass;

import java.util.ArrayList;
import java.util.Collections;

public class DouDiZhu {
    public static void main(String[] args) {
        ArrayList<String> poker=new ArrayList<>();//创建这个扑克牌字符串组合
        String[] huase={"♥","♦","♣","♠"};
        String[] num={"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        poker.add("大王");
        poker.add("小王");

        //将huase与num进行结合组装，用两个增强型for循环进行嵌套
        for (String h : huase) {//拿出一个花色（遍历）
            for (String n : num) {//拿出一个数值（遍历）
                //System.out.println(h+n);
                poker.add(h+n);//组装
            }
        }
        //System.out.println(poker);
        Collections.shuffle(poker);//用Collections里面的shuffle方法，将poker集合随机打乱（洗牌）   细品
        //System.out.println(poker);

        //开始发牌
        ArrayList<String> player1=new ArrayList<>();
        ArrayList<String> player2=new ArrayList<>();
        ArrayList<String> player3=new ArrayList<>();
        ArrayList<String> dipai=new ArrayList<>();

        for(int i=0;i<53;i++){
            String p=poker.get(i);
            if (i>=51){
                dipai.add(p);
            }else if(i%3==1){
                player1.add(p);
            }else if(i%3==0){
                player2.add(p);
            }else if(i%3==2){
                player3.add(p);
            }
        }
        System.out.println("玩家1"+player1);
        System.out.println("玩家2"+player2);
        System.out.println("玩家3"+player3);
        System.out.println("底牌"+dipai);
    }
}

此案例中有三个关键点

1Collection.shuffle的用法：可以对集合进行随机顺序打乱

2当需要对两个集合进行一一对应的组合时，可以使用两个增强for进行循环嵌套，然后相加

3对任意个对象进行按顺序依次的发牌模型时，可使用集合的索引数%总人数，

然后根据模数来对应每个人的分配对策