集合不完全笔记

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/c_yejiajun/article/details/80817637

集合类（Collection）

HashSet

addAll（Collection e）添加所有e集合中的元素

remove（Collection e） 移除所有e集合中的所有元素

retainAll（Collection e）将e集合中没有的元素删除，可以理解成保持跟e集合相同

HashSet

HashSet可以自动去除重复的元素，但是在自定义类中，必须要自己实现equals方法和hashCode方法
在equals方法中，需要将自己定义的关键字进行比较，全部相等则返回一个true
在hashCode方法中，将所有关键字用内置的方法hashCode（表示这个成员变量的哈希值）进行异或，并且将最后的结果返回

如在一个学生类中有下面的成员变量

private String id,name,gender;
    private int age;            
    public Student2(String id,String name,int age,String gender){
        this.id = id; this.name = name; 
        this.age = age; this.gender = gender;
    }

将名字，ID，年龄，性别加入equals方法中进行比较

public boolean equals(Object obj){
        if( obj instanceof Student2){//保证obj是Student或其子类的对象
            Student2 a = (Student2)obj; //可以顺利向下转型为Student类型
            return name.equals(a.name) && this.id.equals(a.id) && 
            this.gender.equals(a.gender) && this.age == a.age;
        }
        return false;
    }

将名字，ID，年龄，性别的哈希值进行异或并返回结果

public int hashCode(){
        //将各个成员变量的哈希码值进行异或得到Student对象的哈希码值
        return id.hashCode()^ name.hashCode() ^ 
        gender.hashCode() ^ (new Integer(age).hashCode());
    }

下面是完整的测试源代码

import java.util.*;
class Student2 {
    private String id,name,gender;
    private int age;            
    public Student2(String id,String name,int age,String gender){
        this.id = id; this.name = name; 
        this.age = age; this.gender = gender;
    }
    //HashSet中需要实现下面两个方法才可以调用，并去除重复值，比较关键字
    public boolean equals(Object obj){
        if( obj instanceof Student2){//保证obj是Student或其子类的对象
            Student2 a = (Student2)obj; //可以顺利向下转型为Student类型
            return name.equals(a.name) && this.id.equals(a.id) && 
            this.gender.equals(a.gender) && this.age == a.age;
        }
        return false;
    }
    public int hashCode(){
        //将各个成员变量的哈希码值进行异或得到Student对象的哈希码值
        return id.hashCode()^ name.hashCode() ^ 
        gender.hashCode() ^ (new Integer(age).hashCode());
    }
    public String toString(){
        return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
    }
}
public class Test3{
    public static void main(String[] args){
        Student2 student1 = new Student2("001","张三",18,"男");
        Student2 student2 = new Student2("001","张三",18,"男");
        Student2 student3 = new Student2("001","李四",19,"男");
        HashSet<Student2> set = new HashSet<Student2>();
        set.add(student1);
        set.add(student2);
        set.add(student3);
        System.out.println("共有" + set.size()+"个元素");
        Iterator<Student2> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next().toString());
        }
    }
}

//运行结果
共有2个元素
id = 001 name = 李四 age = 19 gender = 男
id = 001 name = 张三 age = 18 gender = 男

TreeSet

headSet
方法返回SortedSet，可以理解成返回包含TreeSet中包含第一个元素至当前元素的Set集合

tailSet同理，返回当前元素直至最后一个元素的集合

subSet则返回目标元素的之间的所有元素

注：上面所有的区间都是以[x,y)的形式，即上区间包含，下区间不包含

//测试代码
import java.util.*;
public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<String> c = new TreeSet<String>(); 
        c.add("John");
        c.add("Bob");
        c.add("Alice");
        c.add("Clinton");
        c.add("White");
        c.add("Jack");
        System.out.print("TreeSet集合信息：");
        printSet(c);
        System.out.println("最小的元素："+c.first()+"最大的元素："+c.last());
        System.out.print("c.headSet(\"Clinton\")子集信息：");
        printSet(c.headSet("Clinton"));
        System.out.print("c.tailSet(\"Clinton\")子集信息：");
        printSet(c.tailSet("Clinton"));
        System.out.print("c.subSet(\"Bob,\"\"John\")子集信息：");
        printSet(c.subSet("Bob","John"));
    }
    public static void printSet(Set<String> c){
        System.out.print("元素个数:"+c.size()+",分别是：");
        Iterator<String> iterator = c.iterator();//获得Iterator对象引用
        while(iterator.hasNext())//对集合c的元素进行遍历
            System.out.print(iterator.next()+" ");
        System.out.print("\n"); 
    }   
}

//运行结果
TreeSet集合信息：元素个数:6,分别是：Alice Bob Clinton Jack John White 
最小的元素：Alice最大的元素：White
c.headSet("Clinton")子集信息：元素个数:2,分别是：Alice Bob 
c.tailSet("Clinton")子集信息：元素个数:4,分别是：Clinton Jack John White 
c.subSet("Bob,""John")子集信息：元素个数:3,分别是：Bob Clinton Jack 

在类中，必须自己实现compareTo方法，TreeSet才会自己进行比较

import java.util.*;
class Student3 implements Comparable<Student3> {
    private String id,name,gender;
    private int age;
    public Student3(String id,String name,int age,String gender){
        this.id = id; this.name = name; 
        this.age = age; this.gender = gender;
    }
    public String toString(){
        return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
    }
    public int compareTo(Student3 o) {//实现Comparable接口的抽象方法compareTo
        return this.id.compareTo(o.id);  //比较当前对象与参数对象o的id大小
    }
}
public class Test4{
    public static void main(String[] args){
        Student3 student1 = new Student3("003","张三",18,"男");
        Student3 student2 = new Student3("004","张四",20,"女");
        Student3 student3 = new Student3("002","张二",19,"男");
        Student3 student4 = new Student3("002","赵二",17,"女");//没有插入到集合中
        Student3 student5 = new Student3("001","张一",18,"男");
        Student3 student6 = new Student3("005","张五",20,"男");
        Set<Student3> set = new TreeSet<Student3>();
        set.add(student1);
        set.add(student2);
        set.add(student3);
        set.add(student4);
        set.add(student5);
        set.add(student6);
        System.out.println("按照age排序后的" + set.size()+"个元素");
        Iterator<Student3> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next().toString());
        }
    }
}

//测试结果
按照age排序后的5个元素
id = 001 name = 张一 age = 18 gender = 男
id = 002 name = 张二 age = 19 gender = 男
id = 003 name = 张三 age = 18 gender = 男
id = 004 name = 张四 age = 20 gender = 女
id = 005 name = 张五 age = 20 gender = 男

或者构造一个类实现Comparator接口，在接口中写出compare方法

class StudentComparator implements Comparator<Student5>{//定义比较器类
    public int compare(Student5 o1, Student5 o2) {
        return o1.getId().compareTo(o2.getId());
    }
}

在声明对象TreeSet时,应该将构造的类加入参数

Set<Student5> set = new TreeSet<Student5>(new StudentComparator());

Queue

add()和offer()都可以添加,但是offer的优先级更高

peek()返回头元素

poll()返回头元素并删除

remove()删除头元素

HashMap

与其他集合类似,只是多了key值和value值对应

import java.util.*;
class Student6{
    private String id,name,gender;
    private int age;            
    public Student6(String id,String name,int age,String gender){
        this.id = id; this.name = name; 
        this.age = age; this.gender = gender;
    }
    public String toString(){//如果没有实现投String方法放回对象时则打印地址
        return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
    }
    public String getId(){ return id; }
}
public class MapExample{
    public static void main(String[] args){
        Student6 student1 = new Student6("001","张一",18,"男");
        Student6 student2 = new Student6("002","张二",20,"女");
        Student6 student3 = new Student6("003","张三",19,"男");
        Student6 student4 = new Student6("004","张四",17,"女");
        Map<String,Student6> map = new HashMap<String,Student6>();//创建Map对象
        //以下四行代码添加四个key-value对，key是学号（id），value是学生对象
        map.put(student1.getId(),student1); 
        map.put(student2.getId(),student2);
        map.put(student3.getId(),student3);
        map.put(student4.getId(),student4);
        if(map.containsKey("003")==true){//查找是否有key为003的key-value对
            System.out.println("map中包含key为003的学生对象");
            System.out.println("map中学号003的对象信息是："+
                    map.get("003"));//根据key获得value（根据学号得到学生对象），自动调用toString方法
        }
        //下一行代码功能：查找是否有value为student4的key-value对
        if(map.containsValue(student4) == true) 
            System.out.println("map中包含value为（"+student4+"）的学生对象");

        map.remove("003");//删除学号为003的key-value对
        System.out.println("删除学号为003的学生对象后");
        Set<String> keys = map.keySet(); //获得key的集合
        System.out.print("map的key共有" + keys.size() + "个，它们是：");
        Iterator<String> iterator1 = keys.iterator();
        while(iterator1.hasNext())
            System.out.print(iterator1.next()+"  ");
        Collection<Student6> values = map.values();//获得value的集合
        System.out.println("\nmap的value共有" + values.size() + "个，它们是：");
        Iterator<Student6> iterator2 = values.iterator();
        while(iterator2.hasNext())
            System.out.println(iterator2.next()+"  ");  
    }
}

但是此map没有实现自动排序,自动排序功能在SortedMap中有实现,排序是对key的值进行排序.

同时在本代码中,如果student类没有实现tostring的方法在打印此对象时,则打印对象地址

import java.util.*;
class Student7{
    private String id,name,gender;
    private int age;            
    public Student7(String id,String name,int age,String gender){
        this.id = id; this.name = name; 
        this.age = age; this.gender = gender;
    }
    public String toString(){
        return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
    }
    public String getId(){ return id; }
}
public class SortedMapExample{
    public static void main(String[] args){
        Student7 student1 = new Student7("004","张四",17,"女");
        Student7 student2 = new Student7("001","张一",18,"男");
        Student7 student3 = new Student7("003","张三",19,"男");
        Student7 student4 = new Student7("005","张五",19,"男");
        Student7 student5 = new Student7("002","张二",20,"女");
        SortedMap<String,Student7> map = new TreeMap<String,Student7>();
        map.put(student1.getId(),student1);
        map.put(student2.getId(),student2);
        map.put(student3.getId(),student3);
        map.put(student4.getId(),student4);
        map.put(student5.getId(),student5);
        System.out.println("map的第一个键是：" + map.firstKey());
        System.out.println("map的最后一个键是：" + map.lastKey());
        Set<String> keys = map.keySet();
        System.out.print("map的key共有" + keys.size() + "个，它们是：");
        Iterator<String> iterator1 = keys.iterator();
        while(iterator1.hasNext())
            System.out.print(iterator1.next()+"  ");
        Collection<Student7> values = map.values();
        System.out.println("\nmap的value共有" + values.size() + "个，它们是：");
        Iterator<Student7> iterator2 = values.iterator();
        while(iterator2.hasNext())
            System.out.println(iterator2.next()+"  ");  
        //获取子映射
        map = map.subMap("002","004");//获取键为002、003的子映射
        values = map.values();
        System.out.println("子映射的value共有" + values.size() + "个，它们是：");
        iterator2 = values.iterator();
        while(iterator2.hasNext())
            System.out.println(iterator2.next()+"  ");  
    }
}