（1-6-1）Java 集合

最新推荐文章于 2025-05-28 23:38:48 发布

isyangli_blog

最新推荐文章于 2025-05-28 23:38:48 发布

阅读量936

点赞数 10

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_43457850/article/details/148104045

版权

（3）Set集合的唯一性（hashCode() -> equals()）

0.知识概述：

1.集合

1.1 集合继承关系类图

1.2 集合遍历的三种方式

/*  遍历集合的三种方式：
    01 -> for 循环遍历
    02 -> forEach  方法遍历
    03 -> Iterator  迭代器遍历
 */

代码实现：

System.out.println(dmList);     //[斗罗, 沧源图, 仙逆, 凡人, 斗破, 吞噬星空]

        /*  遍历集合的三种方式：
            01 -> for 循环遍历
            02 -> forEach  方法遍历
            03 -> Iterator  迭代器遍历
         */

        // 法1：
        for(String dm: dmList){
            System.out.print(dm+" ");
        }                                 //斗罗 沧源图 仙逆 凡人 斗破 吞噬星空
        System.out.println();

        // 法2：
        dmList.forEach(dm->{
            System.out.print(dm + " ");   //斗罗 沧源图 仙逆 凡人 斗破 吞噬星空
        });
        System.out.println();

        // 法3：
        Iterator<String> itr = dmList.iterator();
        while(itr.hasNext()){
            String dm = itr.next();   // 提取下一个元素， 同时指针向后移动
            System.out.print(dm);
        }                             // 斗罗沧源图仙逆凡人斗破吞噬星空
        System.out.println();

1.3 集合排序

1.3.1 Collections实现

方式1： Collections.sort(list);

方式2： 创建一个内部类继承Comparator, 实现其compare

code:

public class ListSorter {
    // 方式1： Collections.sort(list);
    public static List<Integer> sort1(List<Integer> list){
        Collections.sort(list);
        System.out.println(list);         //[18, 25, 45, 49]
        return list;
    }


    // 方式2： 创建一个内部类继承Comparator, 实现其compare
    class CompareDemo implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    }
    public  List<Integer> sort2(List<Integer> list){
        Collections.sort(list, new CompareDemo());
        System.out.println(list);              // [49, 45, 25, 18]
        return list;
    }



    public static void main(String[] args) {
        List<Integer> alist = new ArrayList<>();

        alist.add(25);
        alist.add(45);
        alist.add(49);
        alist.add(18);

        System.out.println(alist);            //[25, 45, 49, 18]
        System.out.println(alist.toString()); //[25, 45, 49, 18]

        System.out.println(ListSorter.sort1(alist));  //[18, 25, 45, 49]
        ListSorter ls = new ListSorter();
        System.out.println(ls.sort2(alist));  //[49, 45, 25, 18]
    }
}

1.3.2 自定义排序类

public class TestSort {
    class CarSortDemo implements Comparator<Car> {
        // 01 比较car 对象
//        @Override
//        public int compare(Car o1, Car o2) {
//            return o1.equals(o2) ? 0 : 1;
//        }

        // 02 比较car 对象的  sn属性值
//        @Override
//        public int compare(Car o1, Car o2) {
//            return o1.getSn().compareTo(o2.getSn());
//        }

        // 03 比较car 对象的  brand 属性值
        public int compare(Car o1, Car o2){
            return o2.getModel().compareTo(o1.getModel());
        }
    }

    public List<Car> sort(List<Car> list){
        Collections.sort(list, new CarSortDemo());
        return list;
    }

    public static void main(String[] args) {
        List<Car> carsList = new ArrayList<>();

        carsList.add(new Car("217893","baoma"));
        carsList.add(new Car("689326","su7"));
        carsList.add(new Car("859032","aodi"));
        carsList.add(new Car("785932","benchi"));
        carsList.add(new Car("238979","biyadi"));

        System.out.println(carsList);
//[Car{sn='217893', model='baoma'}, Car{sn='689326', model='su7'}, Car{sn='859032', model='aodi'}, Car{sn='785932', model='benchi'}, Car{sn='238979', model='biyadi'}]

        System.out.println(new TestSort().sort(carsList));
        // 01 比较car 对象
//[Car{sn='217893', model='baoma'}, Car{sn='689326', model='su7'}, Car{sn='859032', model='aodi'}, Car{sn='785932', model='benchi'}, Car{sn='238979', model='biyadi'}]
        // 02 比较car 对象的  sn属性值
//[Car{sn='217893', model='baoma'}, Car{sn='238979', model='biyadi'}, Car{sn='689326', model='su7'}, Car{sn='785932', model='benchi'}, Car{sn='859032', model='aodi'}]
        // 03 比较car 对象的  brand 属性值
//[Car{sn='689326', model='su7'}, Car{sn='238979', model='biyadi'}, Car{sn='785932', model='benchi'}, Car{sn='217893', model='baoma'}, Car{sn='859032', model='aodi'}]
    }
}

2 List 集合概述

有关List的相关继承关系：

2.1 ArrayList

（1）特点

（2）常用方法

/**
 * ArrayList   ->
 * 01. ArrayList<String> nickList = new ArrayList<String>();
 * 02. nickList.add("phdvb");
 *     nickList.add(1,"pxq");
 *     nickList.get(2)
 * 03. nickList.set(2, "drl");
 * 04. nickList.remove("phdvc");
 *     remove(listSize-1);
 *     nickList.size();
 */

public class ArrayListDemo {
    public static void main(String[] args) {
        /**
         * ArrayList   ->
         * 01. ArrayList<String> nickList = new ArrayList<String>();
         * 02. nickList.add("phdvb");
         *     nickList.add(1,"pxq");
         *     nickList.get(2)
         * 03. nickList.set(2, "drl");
         * 04. nickList.remove("phdvc");
         *     remove(listSize-1);
         *     nickList.size();
         */
        //01 创建ArrayList对象
        ArrayList<String> nickList = new ArrayList<String>();

        //02 往ArrayList中添加数据
        nickList.add("phdvb");
        nickList.add("phdva");
        boolean isChange = nickList.add("phdvb");
        System.out.println("ArrayList是否发生变化？"+ isChange); //ArrayList是否发生变化？true
        System.out.println(nickList);   //[phdvb, phdva, phdvb]
        System.out.println(nickList.get(2));  //phdvb
        nickList.add(1,"pxq");
        System.out.println(nickList);   //[phdvb, pxq, phdva, phdvb]
        nickList.add("phdvb");
        nickList.add("phdvc");
        nickList.add("phdvc");
        nickList.add("phdvd");

        //03 更新ArrayList中的元素
        String beforeNick = nickList.set(2, "drl");
        System.out.println(beforeNick); //phdva
        System.out.println(nickList);   //[phdvb, pxq, drl, phdvb, phdvb, phdvb, phdvc, phdvd]

        //04 删除ArrayList中的元素
        boolean isRemove = nickList.remove("phdvc");
        System.out.println(isRemove);   //true
        System.out.println(nickList);   //仅删除了一个元素，[phdvb, pxq, drl, phdvb, phdvb, phdvc, phdvd]
        int listSize = nickList.size();
        System.out.println(listSize);   //7
        nickList.remove(listSize-1);
        System.out.println(nickList);   //[phdvb, pxq, drl, phdvb, phdvb, phdvc]
        nickList.set(nickList.size()-2, "vb");
        System.out.println(nickList);   //[phdvb, pxq, drl, phdvb, vb, phdvc]
    }
}

2.2 LinkedList

代码实现：

public class LinkedListDemo {

    public static void main(String[] args) {
        LinkedList<String> dmList = new LinkedList<String>();

        dmList.add("仙逆");
        dmList.add("凡人");
        dmList.add("斗破");

        System.out.println(dmList);     //[仙逆, 凡人, 斗破]

        dmList.add(0, "沧源图");

        System.out.println(dmList);     //[沧源图, 仙逆, 凡人, 斗破]


        // 实现的是 Deque接口 中的方法
        dmList.addFirst("斗罗");
        dmList.addLast("吞噬星空");

        System.out.println(dmList);     //[斗罗, 沧源图, 仙逆, 凡人, 斗破, 吞噬星空]
    }
}

3. Set集合

3.1 概述

（1）特点

Set集合接口间的实现关系：

（2）重要方法

代码实现：

public class HashSetDemo {
    public static void main(String[] args) {
        // 实例化一个 Set集合
        Set<String> gameSet = new HashSet<String>();
        gameSet.add("夏洛特");
        gameSet.add("貂蝉");
        gameSet.add("戈雅");
        gameSet.add("不知火舞");

        System.out.println(gameSet);       //[不知火舞, 戈雅, 夏洛特, 貂蝉]

        // add()返回值代表是否真正在集合中插入元素
        boolean isChanged = gameSet.add("米莱迪");
        System.out.println(gameSet);       //[不知火舞, 戈雅, 夏洛特, 貂蝉, 米莱迪]
        System.out.println(isChanged);     //true

        isChanged = gameSet.add("貂蝉");
        System.out.println(gameSet);       // [不知火舞, 戈雅, 夏洛特, 貂蝉, 米莱迪]
        System.out.println(isChanged);     // false

        // Set 可以 使用所有 Collection 接口定义方法
        int size = gameSet.size();
        System.out.println(size);          // 5
        boolean isContain = gameSet.contains("夏洛特");
        System.out.println(isContain);     // true
    }
}

（3）Set集合的唯一性（hashCode() -> equals()）

/**
 * Q1 : Set集合如何确保数据的  唯一性
 */

/**
 * A1 : Set集合在新增数据时， 先会判断hashCode() 是否已存在
 *      若新增的hashCode() 在Set集合中存在， 在调用equals () 进行 值比较；
 *      新增的hashCode() 与 equals() 都存在的情况下
 *      Set集合认为数据已存在，不予新增
 */

/**
 * Q2: 直接使用equals()判断不行吗？
 */

/**
 * A2: 出于执行效率老驴
 *     hashCode() 返回的整数结果  决定了其将Set集合中的存放位置
 *     由于相比于Equals()方法hashCode()计算速度会很快，  但是有可能发生哈希碰撞
 *     所以equals再次会发生哈希碰撞的值进行比较
 */

School类（重写了hashCode()、equals()、toString()）

public class School {
    private String name;
    private String addr;

    public School(String name, String addr) {
        setAddr(addr);
        setName(name);
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 重写Object类的 toString()方法
    @Override
    public String toString() {
        return this.hashCode() + "= School{" +
                "name='" + name + '\'' +
                "addr='" + addr + '\'' +
                "}";
    }

    @Override
    public int hashCode() {
//        return super.hashCode();

        return this.name.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
//        return super.equals(obj);

        if(obj instanceof School){
            School school = (School)obj;
            if(this.name.equals(((School)obj).getName())){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }

}

Test类

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

        String sa = "西交大";
        String sb = "西工大";

        System.out.println("sa.hashCode():" + sa.hashCode() +
                ",sa.hashCode():" + sb.hashCode());
        //  sa.hashCode():34473154,sa.hashCode():34594209

        HashSet<School> schoolHashSet = new HashSet<School>();
        schoolHashSet.add(new School(sa,"西安"));
        schoolHashSet.add(new School(sb,"西安"));
        schoolHashSet.add(new School("克职","克拉玛依"));
        schoolHashSet.add(new School("克职","克拉玛依"));

        System.out.println(schoolHashSet);
        //[1956725890= School{name='克职'addr='克拉玛依'},
        // 1163157884= School{name='西工大'addr='西安'},
        // 460141958= School{name='西交大'addr='西安'}]

    }
}

3.2 HashSet

数据存放实例：

3.3 LinkedHashSet

数据存放示例：

代码演示：

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        Set<String> langSet= new LinkedHashSet<String>();

        langSet.add("Java");
        langSet.add("Python");
        langSet.add("C#");
        langSet.add("C++");
        System.out.println(langSet);    //[Java, Python, C#, C++]

    }
}

3.4 TreeSet

code01:

public class TreeSetDemo {
    public static void main(String[] args) {
        Set<Integer> tSet = new TreeSet<Integer>();
        tSet.add(108);
        tSet.add(139);
        tSet.add(75);
        tSet.add(64);
        tSet.add(225);

        System.out.println(tSet);   //[64, 75, 108, 139, 225]

        TreeSetDemo td = new TreeSetDemo();
        td.sort();                  //[226, 140, 109, 76, 65]
    }
    
    // 重写Comparator接口中的compare方法，  实现自定义比较逻辑
    class IntegerComparator implements Comparator<Integer> {
        public int compare(Integer o1, Integer o2) {
            return o2 -o1;
        }
    }

    public void sort(){
        Set<Integer> tSet = new TreeSet<Integer>(new IntegerComparator());
        tSet.add(109);
        tSet.add(140);
        tSet.add(76);
        tSet.add(65);
        tSet.add(226);

        System.out.println(tSet);       //[226, 140, 109, 76, 65]
    }
}

4.Map

4.1 概述

4.1.1 特点 & 继承关系

4.1.2 遍历集合的三种方式

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class LoopMapThreeWays {
    // 遍历集合

    //方式1： 增强for循环
    public void doForLoop(Map map){
        Set<String> keys = map.keySet();

        for(String key : keys){
            System.out.println(key + ":" + map.get(key));
        }
    }

    // 方式2： lambda 表达式
    public void doForLoop2(Map map){
        map.forEach((key, value) ->{
            System.out.println(key + ":" + value);
        });
    }

    // 方式3： 使用迭代器
    public void doForLoop3(Map map){
        Iterator<Map.Entry<String, Object>> itr = map.entrySet().iterator();
        while(itr.hasNext()){
            Map.Entry<String, Object> entry = itr.next();
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }



    public static void main(String[] args) {
        Map<String, Object> xlt = new LinkedHashMap<>();
        xlt.put("name", "夏洛特");
        xlt.put("nick", "玫瑰剑士");
        xlt.put("技能", "七星光芒剑");
        xlt.put("技能", "七星光芒斩");
        xlt.put("皮肤1", "浮生王");
        xlt.put("皮肤2", "金色皮");
        System.out.println(xlt);
//{name=夏洛特, nick=玫瑰剑士, 技能=七星光芒斩, 皮肤1=浮生王, 皮肤2=金色皮}

        LoopMapThreeWays lm = new LoopMapThreeWays();
        lm.doForLoop(xlt);
        System.out.println("——————————————————————————————————————————");
        lm.doForLoop2(xlt);
        System.out.println("——————————————————————————————————————————");
        lm.doForLoop3(xlt);
        /*
            name:夏洛特
            nick:玫瑰剑士
            技能:七星光芒斩
            皮肤1:浮生王
            皮肤2:金色皮
         */
    }
}

4.2 HashMap

code:

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

public class HashMapDemo {
    public static void main(String[] args) {
        Map<String, Object> xlt = new HashMap<String, Object>();

        xlt.put("name", "夏洛特");
        xlt.put("nick", "玫瑰剑士");
        xlt.put("技能", "七星光芒剑");
        xlt.put("技能", "七星光芒斩");

        System.out.println(xlt);        //{nick=玫瑰剑士, 技能=七星光芒斩, name=夏洛特}

        String heroNick = (String) xlt.get("nick");
        System.out.println(heroNick);   //玫瑰剑士

        System.out.println(xlt.containsKey("技能"));    //true
        System.out.println(xlt.containsKey("皮肤"));    //false


        xlt.put("皮肤1", "浮生王");

        int count = xlt.size();
        System.out.println(count);         //4

        xlt.put("皮肤2", "金色皮");
        System.out.println(xlt);           //{nick=玫瑰剑士, 技能=七星光芒斩, 皮肤2=金色皮, 皮肤1=浮生王, name=夏洛特}

        String removeValur = (String)xlt.remove("皮肤2");
        System.out.println(removeValur);   //金色皮
    }
}

4.3 LinkedHashMap

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        Map<String, Object> xlt = new LinkedHashMap<>();

        xlt.put("name", "夏洛特");
        xlt.put("nick", "玫瑰剑士");
        xlt.put("技能", "七星光芒剑");
        xlt.put("技能", "七星光芒斩");
        xlt.put("皮肤1", "浮生王");

        xlt.put("皮肤2", "金色皮");
        System.out.println(xlt);
//{name=夏洛特, nick=玫瑰剑士, 技能=七星光芒斩, 皮肤1=浮生王, 皮肤2=金色皮}
    }
}

4.4 TreeMap


import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        /*
           正常需求测试1：
         */
        Map<Object, Object> tMap = new TreeMap<Object, Object>();
        tMap.put("a2", 589);
        tMap.put("a1", "vb");

        tMap.put("b4", "运还是重要的");
        tMap.put("b5", "自信也重要");

        tMap.put("b2", 3.5);
        System.out.println(tMap);
//{a1=vb, a2=589, b2=3.5, b4=运还是重要的, b5=自信也重要}

        /*
            比较方法重写测试2：
         */
        TreeMapDemo td = new TreeMapDemo();
        td.sort();   //{b5=自信也重要, b4=运还是重要的, b2=3.5, a2=589, a1=vb}

    }

    class tMapComparator implements Comparator<String> {

        @Override
        public int compare(String o1, String o2) {
            return o2.compareTo(o1);
        }
    }

    public void sort(){
        Map<String, Object> t2Map = new TreeMap<>(new tMapComparator());
        t2Map.put("a2", 589);
        t2Map.put("a1", "vb");

        t2Map.put("b4", "运还是重要的");
        t2Map.put("b5", "自信也重要");

        t2Map.put("b2", 3.5);
        System.out.println(t2Map);
    }
}