集合进阶2

最新推荐文章于 2024-03-16 16:37:36 发布

置顶 Zzz丶丶

最新推荐文章于 2024-03-16 16:37:36 发布

阅读量218

点赞数

分类专栏：集合文章标签：集合

本文链接：https://blog.csdn.net/HQZ820844012/article/details/76474006

版权

集合专栏收录该内容

3 篇文章 0 订阅

订阅专栏

HashSet集合

Set接口的特点

A:存入集合的顺序和取出集合的顺序不一致
B:没有索引
C:存入集合的元素没有重复

HashSet使用&唯一性原理

HashSet的使用

 public class HashSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Student> hs = new HashSet<Student>();
        //创建元素对象
        Student s = new Student("zhangsan",18);
        Student s2 = new Student("lisi",19);
        Student s3 = new Student("lisi",19);
        //添加元素对象
        hs.add(s);
        hs.add(s2);
        hs.add(s3);
        //遍历集合对象
        for (Student student : hs) {
            System.out.println(student);
        }
    }    
}

HashSet唯一原理

规则:新添加到HashSet集合的元素都会与集合中已有的元素一一比较
首先比较哈希值(每个元素都会调用hashCode()产生一个哈希值)
如果新添加的元素与集合中已有的元素的哈希值都不同,新添加的元素存入集合
如果新添加的元素与集合中已有的某个元素哈希值相同,此时还需要调用equals(Object obj)比较
如果equals(Object obj)方法返回true,说明新添加的元素与集合中已有的某个元素的属性值相同,那么新添加的元素不存入集合
如果equals(Object obj)方法返回false, 说明新添加的元素与集合中已有的元素的属性值都不同, 那么新添加的元素存入集合

import java.util.HashSet;

public class HashSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Student> hs = new HashSet<Student>();
        //创建元素对象
        Student s = new Student("zhangsan",18);
        Student s2 = new Student("lisi",19);
        Student s3 = new Student("lisi",19);
        //添加元素对象
        hs.add(s);
        hs.add(s2);
        hs.add(s3);
        //遍历集合对象
        for (Student student : hs) {
            System.out.println(student);
        }

    }

}

class Student {
    String name;
    int age;

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public boolean equals(Object obj) {
        //System.out.println("-------------------");
        Student s = (Student)obj;//向下转型，可以获取子类特有成员

        //比较年龄是否相等，如果不等则返回false
        if(this.age != s.age) {
            return false;
        }

        //比较姓名是否相等，如果不等则返回false
        if(!this.name.equals(s.name)) {
            return false;
        }

        //默认返回true，说明两个学生是相等的
        return true;
    }

    @Override
    public int hashCode() {
        return 1;
    }

}

HashCode的方法优化

如果让hashCode()方法返回一个固定值,那么每个新添加的元素都要调用equals(Object obj)方法比较,那么效率较低
只需要让不同属性的值的元素产生不同的哈希值,那么就可以不再调用equals方法比较提高效率


public class Person {
    String name;
    int age;

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }



import java.util.HashSet;

public class HashSetDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Person> hs = new HashSet<Person>();
        //创建元素对象
        Person p = new Person("zhangsan",18);
        Person p2 = new Person("lisi",18);
        Person p3 = new Person("lisi",18); 

        //添加元素对象
        hs.add(p);
        hs.add(p2);
        hs.add(p3);
        //遍历集合对象
        for (Person person : hs) {
            System.out.println(person);
        }
    }
}

Collection中的常用方法


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

/*
 * Collections：
 * 面试题：Collection和Collections有什么区别？
 *      Collection是集合体系的最顶层，包含了集合体系的共性
 *      Collections是一个工具类，方法都是用于操作Collection
 * 
 */
public class CollectionsDemo {
    public static void main(String[] args) {
        //static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(4);
        Collections.swap(list, 0, 1);

        System.out.println(list);

    }

    private static void method6() {
        //static void  sort(List<T> list) :按照列表中元素的自然顺序进行排序
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(4);
        list.add(3);
        list.add(2);

        Collections.sort(list);
        System.out.println(list);
    }

    private static void method5() {
        //static void shuffle(List list):傻否，随机置换  
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Collections.shuffle(list);
        System.out.println(list);
    }

    private static void method4() {
        //static void reverse(List list)  :反转
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        Collections.reverse(list);
        System.out.println(list);
    }

    private static void method3() {
        //static void fill(List list, Object obj) :使用指定的对象填充指定列表的所有元素
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);

        Collections.fill(list, "android");

        System.out.println(list);
    }

    private static void method2() {
        //static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列表
        //注意：目标列表的长度至少等于源列表的长度
        //创建源列表
        List<String> src = new ArrayList<String>();
        src.add("hello");
        src.add("world");
        src.add("java");

        //创建目标列表
        List<String> dest = new ArrayList<String>();
        dest.add("java");
        dest.add("java");
        dest.add("java");
        dest.add("java");
        Collections.copy(dest, src);
        System.out.println(dest);
    }

    private static void method() {
        //static int  binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置 
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        int index = Collections.binarySearch(list, 4);
        System.out.println(index);
    }
}

HashMap集合

Map接口概述

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同。

A:Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储
B:Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
C:Collection中的集合称为单列集合，Map中的集合称为双列集合。
需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

Map常用功能

A:映射功能：
 V put(K key, V value) :以键=值的方式存入Map集合
B:获取功能：
 V get(Object key):根据键获取值
int size():返回Map中键值对的个数
C:判断功能：
boolean containsKey(Object key):判断Map集合中是否包含键为key的键值对
boolean containsValue(Object value):判断Map集合中是否包含值为value键值对
boolean isEmpty():判断Map集合中是否没有任何键值对 
D:删除功能：
void clear():清空Map集合中所有的键值对
V remove(Object key):根据键值删除Map中键值对
E:遍历功能：
Set<Map.Entry<K,V>> entrySet():将每个键值对封装到一个个Entry对象中,再把所有Entry的对象封装到Set集合中返回
Set<K> keySet() :将Map中所有的键装到Set集合中返回
Collection<V> values():返回集合中所有的value的值的集合

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo3 {
    public static void main(String[] args) {
        //创建Map对象
        Map<String,String> map = new HashMap<String,String>();
        //添加映射关系
        map.put("ITCAST001", "张三");
        map.put("ITCAST002", "李四");
        map.put("ITCAST005", "李四");

        //Set<K> keySet() : 以Set的形式获返回所有的key
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key);
        }
        System.out.println("-----------");

        //Collection<V> values() :
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }
    }
}

Map的两种遍历方式

利用keySet()方法遍历


import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
 *  Map的第一种遍历方式：
 *          首先召集所有的丈夫
 *          遍历所有的丈夫
 *          获取每一个丈夫
 *          让每一个丈夫去找他自己的媳妇
 */
public class MapDemo4 {
    public static void main(String[] args) {
        //创建Map对象
        Map<String,String> map = new HashMap<String,String>();
        //添加映射关系
        map.put("谢婷疯", "张箔纸");
        map.put("陈关西", "钟欣桶");
        map.put("李亚碰", "王飞");
        //遍历Map对象

        //首先召集所有的丈夫
        Set<String> keys = map.keySet();
        //遍历所有的丈夫
        for (String key : keys) {
            //让每个丈夫去找他自己的媳妇就可以了
            String value = map.get(key);
            System.out.println("丈夫：" + key + "---" + "媳妇：" + value);
        }

    }
}

利用entrySet()方法遍历

public class MapDemo5 {
    public static void main(String[] args) {
        //创建Map对象
        Map<String,String> map = new HashMap<String,String>();
        //添加映射关系
        map.put("尹志平", "小龙女");
        map.put("令狐冲", "东方菇凉");
        map.put("玄慈", "叶二娘");
        //获取所有的结婚证对象
        Set<Map.Entry<String,String>> entrys = map.entrySet();
        //遍历包含了结婚证对象的集合
        for (Map.Entry<String, String> entry : entrys) {
            //获取每个单独的结婚证对象
            //通过结婚证对象获取丈夫和媳妇
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("丈夫：" + key + "---" + "媳妇:" + value);
        }

    }
}

可变参数

概述
当参数不确定的时候, 类型要明确
Java可以把多个参数直接帮我们转成数组

理解: 可变参数本质就是一个长度可变的数组.

注意
在可变参数之后不可以再追加参数
参数的数量定义, 可以给多个甚至也可以一个都不不给。

Public static int getSum(int…num){
    int sum = 0;
        for(int i = 0; i < num.length; i++){
            sum+=num[i];
}
return sum;
}

Map集合的嵌套

Map中嵌套Map

public class Student {
    private String num;
    private String name;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String num, String name) {
        super();
        this.num = num;
        this.name = name;
    }
    public String getNum() {
        return num;
    }
    public void setNum(String num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student [num=" + num + ", name=" + name + "]";
    }


}


import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest {
    public static void main(String[] args) {

        Map<String,Map<String,String>> itheima = new HashMap<String,Map<String,String>>();
        Map<String,String> base = new HashMap<String,String>();
        base.put("01", "zhangsan");
        base.put("02", "lisi");
        Map<String,String> job = new HashMap<String,String>();
        job.put("01", "wangwu");
        job.put("02", "zhaoliu");
        itheima.put("班级1", base);
        itheima.put("班级2", job);
        Set<String> keys =itheima.keySet();
        for (String key : keys) {
            System.out.println("班级名称：" + key);
            Map<String,String> stus = itheima.get(key);
            Set<String> nums = stus.keySet();
            for (String num : nums) {
                String name = stus.get(num);
                System.out.println("学号：" + num + ",姓名：" + name);
            }
        }

    }
}