java之LinkedHashSet单列集合，TreeSet单列集合，HashMap双列集合和集合的去重，以及双列集合的与元素打印

最新推荐文章于 2024-07-02 14:36:44 发布

时光仍在

最新推荐文章于 2024-07-02 14:36:44 发布

阅读量757

点赞数

分类专栏： java 文章标签： HashMap双列集合和他的两种遍历方法 LinkedHashSet集合 TreeSet集合及其重写去重方法 hashMap去重 entry对象遍历HashMap双列集合

本文链接：https://blog.csdn.net/KongLingLei_08225/article/details/82502647

版权

java 专栏收录该内容

38 篇文章 1 订阅

订阅专栏

一. LinkedHashSet单列集合

1.LinkedHashSet 特点：去重，无下标。
inked ：有链接表结构，有序。
有序:指的是，怎么存的顺序，打印出来的就是什么顺序。
代码例子：

public class Kll {
    public static void main(String[] args) {
    //创建LinkedHashSet集合，泛型是字符串类型，存入字符串
        LinkedHashSet<String> set = new LinkedHashSet<>();
        set.add("g");
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("a");
        System.out.println(set);
        //获取迭代器
        Iterator<String> iterator = set.iterator();

        while (iterator.hasNext()) {
            String string = (String) iterator.next();
            System.out.println(string);
        }
    }

输出结果：
这里写图片描述
2.代码案例：
利用set集合，去除ArrayList集合中的重复元素(操作原ArrayList)，ArrayList 保存a a, b b, c c, d d

public class Kll {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("d");
        list.add("d");
        //创建set集合 去重
        LinkedHashSet<String> set = new LinkedHashSet<>();
        set.addAll(list);
        //打印set集合
        System.out.println(set);
        //清空原list
        list.clear();
        //去重好的set元素再装回list集合中
        list.addAll(set);
        //打印list集合
        System.out.println(list);
    }
}

打印结果：
这里写图片描述

二.TreeSet单列集合

1.TreeSet集合：无序，无下标，不重复。
功能:排序按升序。
代码案例：

public class Kll {
    public static void main(String[] args) {
    //创建TreeSet 存四个数字 查看打印结果
        TreeSet<Integer> integers = new TreeSet<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(1);
        integers.add(-1);
        System.out.println(integers);
    }
}

输出结果：【-1， 1， 2， 3】

2.案例需求：保存四个人，查看打印结果，人类：姓名和年龄。
首先创建人这个类，
因为TreeSet集合在添加元素，是要实现comparable接口，而我们自己写的类没有，所以要手动添加，并重写compareTo方法。
以下是对compareTo方法的解读：

实现comparable接口
泛型:填写 比较对象。
   compareTo方法：
     1.返回0 只有一个元素
     2.返回正数 按存入的正序输出
     3.返回负数 按输入的倒序输出
   TreeSet ：二叉树排序
     存的规则:
     1.比我存的数,放左边(返回负数时的效果)
     2.比我存的数,放右边(返回正数时的效果)
     取的规则:
    从小到大 ,升序输出

    会根据compareTo的返回值进行存储:
    为0 只存一个数,其他的不存;为负,放左边;为正,放在右边

    TreeSet排序步骤
       1.实现(comparable)接口
       2.实现接口中的方法(compareTo)
       3.编写 排序规则

人类：实现Comparable接口，并重写compareTo方法

package kll;

//实现comparable接口
// 泛型:填 比较对象
public class Person implements Comparable<Person> {
    private String name;
    private int age;
    //构造方法
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    //set/get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //重写tostring方法
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    //重写比较方法
    @Override
    public int compareTo(Person o) {
        //按年龄排序
        /*int num = o.getAge() - this.age;
        return num;*/

        //按名字排序
        /*int num1 = this.name.compareTo(o.getName());
        return num1;*/

        //主要按年龄,次要按名字
        int rel = o.getAge() - this.age == 0 ? this.name.compareTo(o.getName()) : o.getAge() - this.age;
        return rel;

    }
}

public class Kll {
    public static void main(String[] args) {
        TreeSet<Person> set = new TreeSet<>();
        set.add(new Person("K1", 22));
        set.add(new Person("K2", 12));
        set.add(new Person("K3", 21));
        set.add(new Person("K4", 12));
        set.add(new Person("K4", 12));
        System.out.println(set);
    }
}

输出结果：这里写图片描述

3.案例需求：TreeSet集合，保存四个字符串，按字符串长度排序且不去重（因为字符串是系统类，但是又没有实现需求的方法，所以我们需要自己写类实现接口）
需要用到 Comparator 比较器接口，编写规则，将比较规则，直接传入到 TreeSet的构造方法中。

重写类实现Comparator接口代码如下：

class CompareLength implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        int rel = o1.length() - o2.length() == 0 ? 1 : o1.length() - o2.length() ;
        return rel;
    }
}

public class Kll {
    public static void main(String[] args) {
    //将比较规则 直接传入到 TreeSet的构造方法中
        TreeSet<String> set = new TreeSet<>(new CompareLengths());
        set.add("konglinglei");
        set.add("wangshijirt");
        set.add("wuha");
        set.add("jiujiu");
        System.out.println(set);
    }
}

运行结果：这里写图片描述

三.HashMap双列集合

1.双列集合


 * Map(双列集合的父接口)
 *  1.以键值对形式来存储数据
 *     key ---- value
 *  2.键值唯一(键值不能重复)
 *  
 *  HashSet 和 HashMap 有什么关系?
 *   依赖关系
 *   HashSet依赖HashMap
 *   实际上向HashSet中添加元素 相当于向map中的key列添加元素
 *   
 *   HashMap:去重的功能(该功能属于的 key列)
 *   TreeMap:排序功能(该功能属于的 key列)

简单集合元素添加和创建代码案例：

public class Kll {
    public static void main(String[] args) {
        //key 名字 value 年龄
        HashMap<String, Integer> map = new HashMap<>();
        //添加 键值对元素
        // put方法返回值是该键被覆盖的值
        Integer v1 = map.put("孔令蕾", 23);
        //map.put("孔令蕾", 26);
        Integer v2 = map.put("集合", 23);
        Integer v3 = map.put("更换", 22);
        Integer v4 = map.put("大幅度", 12);
        Integer v5 = map.put("儿童", 5);
        System.out.println(map);
        System.out.println(v1);
        System.out.println(v2);
        System.out.println(v3);
        System.out.println(v4);
        System.out.println(v5);
    }
}

输出结果：这里写图片描述

2.以下是

* map 方法
    * 包含 key            containsKey()
    * 包含 value          containsValue()
    * 获取所有key的Set集合  keySet()
    * 获取所有value集合     values()
    * 通过key删除整个键值对  remove()
    * 清空map              clear()

的应用例子：

public class Kll {
    public static void main(String[] args) {
    //创建HashMap集合 添加元素
        HashMap<String, Integer> map = new HashMap<>();
        map.put("姐姐", 23);
        map.put("看看", 21);
        map.put("哈哈", 24);
        map.put("柳柳", 22);
        //判断包含key
        boolean b1 = map.containsKey("看看");
        System.out.println(b1);
        //判断包含value
        boolean b2 = map.containsValue(24);
        System.out.println(b2);
        //取出所有的key的Set集合(核心方法)
        Set<String> keySet = map.keySet();
        System.out.println(keySet);
        //获取所有value的集合
        Collection<Integer> values = map.values();
        System.out.println(values);
        //通过key删除整个键值对  remove()
        Integer remove = map.remove("柳柳");
        System.out.println(remove);
        System.out.println(map);
        //清空
        map.clear();
        System.out.println(map);
    }
}

3.HashMap去重
hashMap 去重，也是重写equals和hashCode方法

public class Kll {
    public static void main(String[] args) {
        HashMap<Person, String> map = new HashMap<>();
        map.put(new Person("分隔符", 22), "上海");
        map.put(new Person("发过火", 24), "北京");
        map.put(new Person("erect", 21), "湖北");
        map.put(new Person("额外若多所", 13), "上海");
        map.put(new Person("分隔符", 22), "上海");
        System.out.println(map);
    }
}

Person类代码：

package com.lanou3g;
//实现comparable接口
// 泛型:填 比较对象
public class Person implements Comparable<Person> {
    private String name;
    private int age;
    //构造方法
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    //set/get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    //重写tostring方法
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    //重写compareTo方法
    @Override
    public int compareTo(Person o) {
        //按年龄排序
        /*int num = o.getAge() - this.age;
        return num;*/

        //按名字排序
        /*int num1 = this.name.compareTo(o.getName());
        return num1;*/

        //主要按年龄,次要按名字
        int rel = o.getAge() - this.age == 0 ? this.name.compareTo(o.getName()) : o.getAge() - this.age;
        return rel;

    }

    @Override//重写hashCode方法
    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//重写equals方法
    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;
    }

}

运行结果图：这里写图片描述

四.双列集合的元素打印的两种方式

1.第一种：取出key值集合，然后输出对应的value

public class Kll {
    public static void main(String[] args) {
        map.put(new Person("分隔符", 22), "上海");
        map.put(new Person("发过火", 24), "北京");
        map.put(new Person("erect", 21), "湖北");
        map.put(new Person("额外若多所", 13), "上海");
        map.put(new Person("分隔符", 22), "上海");
        System.out.println(map);
        //取出key的集合
        Set<Person> keySet = map.keySet();
        // 取出集合的 迭代器
        Iterator<Person> iterator = keySet.iterator();
        //遍历所有的key
        while (iterator.hasNext()) {
            //取出集合中的key值
            Person person = (Person) iterator.next();
            //取出key对应的value值
            String string = map.get(person);
            //打印 
            System.out.println("key = " + person + "  value = " + string);
        }
    }
}

运行结果图：这里写图片描述

2.第二种：利用Entry对象遍历Map。Entry对象中，封装了一个键值对对象。
然后利用里面的getValue和getKey取出key和对应的value。

public class Kll {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("姐姐", 23);
        map.put("看看", 21);
        map.put("哈哈", 24);
        //利用Entry对象遍历Map
        //Entry对象中 封装了一个键值对 对象

        //获取所有Entry对象的Set集合
        Set<Entry<String, Integer>> entry = map.entrySet();
        //取迭代器
        Iterator<Entry<String, Integer>> iterator = entry.iterator();
        //遍历
        while (iterator.hasNext()) {
            //取出 集合中的 每个entry对象
            Entry<java.lang.String,java.lang.Integer> entry2 = (Entry<String,Integer>) iterator.next();
            // 打印entry对象
            System.out.println(entry2);
            //打印 key 和 对应的value 值
            System.out.println(entry2.getKey() + "---" + entry2.getValue());

        }
    }
}

运行结果图：这里写图片描述

时光仍在

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java之LinkedHashSet单列集合，TreeSet单列集合，HashMap双列集合和集合的去重，以及双列集合的与元素打印

一. LinkedHashSet单列集合1.LinkedHashSet 特点：去重，无下标。 inked ：有链接表结构，有序。有序:指的是，怎么存的顺序，打印出来的就是什么顺序。代码例子：public class Kll { public static void main(String[] args) { //创建LinkedHashSet集合，...
复制链接

扫一扫

专栏目录