java 比较器排序：

最新推荐文章于 2023-09-14 00:06:30 发布

IT萌新@

最新推荐文章于 2023-09-14 00:06:30 发布

阅读量443

点赞数

分类专栏： java基础文章标签： java 数据结构算法

本文链接：https://blog.csdn.net/m0_49102053/article/details/130448394

版权

java基础专栏收录该内容

26 篇文章 0 订阅

订阅专栏

一，比较器排序：

TreeSet是会对元素进行排序去重，有两种实现方案

1，使用空参构造方法创建出来的TreeSet，底层使用自然排序，即元素要实现Comparable接口才能实现排序

2，可以使用有参构造，在创建TreeSet集合时，传入一个Comparator比较器，这样存入的元素就会按照比较器指定的排序方案排序，不再使用默认自然排序

TreeSet(Comparator<? super E> comparator)构造一个新的空 TreeSet，它根据指定比较器进行排序

使用步骤：

自定义类实现Comparator接口

重写Compar(To1,T o2)方法,//o1正在存储的元素，//o2之前存在的元素，返回值与之前的ComparTo的返回值一样

在创建TreeSet集合时,传入一个Comparator比较器,这样存入的元素就会按照该比较器指定的排序方案排序( 不再使用默认的自然排序)

二，Collections:

类似于Arrays，Collections是集合的工具类

static void reverse(List<?> list) 反转反转指定列表中元素的顺序 static void shuffle(List<?> list) 混洗
使用默认随机源对指定列表进行置换。
static void sort(List list) 排序
根据元素的自然顺序对指定列表按升序进行排序

ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(5);
        arrayList.add(2);
        System.out.println(arrayList);
        //原集合反转
        // static void reverse(List<?> list)   反转
        // 反转指定列表中元素的顺序
//        Collections.reverse(arrayList);
//        System.out.println(arrayList);
        //混洗,每次输出结果随机，
        // static void shuffle(List<?> list)    混洗
        // 使用默认随机源对指定列表进行置换
//        Collections.shuffle(arrayList);
//        System.out.println(arrayList);
        //排序，升序，
        // static void sort(List<T> list)    排序
        // 根据元素的自然顺序 对指定列表按升序进行排序
        Collections.sort(arrayList);
        System.out.println(arrayList);

三，Map:

Map是接口，双列集合，一次存储一对键值对(K,V)，代表是键映射到值的对象，一个Map是不能包含重复的键，每个键最多只能映射到一个值，即是可以通过键找到值，但是不能通过值找键，

Map有两个常用的实现类：HashMap,TreeMap;

四，HashMap:

HashMap是Map的实现类，现在JDK8及以后底层由数组+链表+红黑树实现，并允许使用 null值和 null键，除了非同步和允许使用 null之外，HashMap类与 Hashtable大致相同，Hashtable是线程安全的，Map集合，效率低，HashMap是线程不安全的Map集合，效率高，HashMap的扩容和容量，初始值16，加载因子0.75，阈值是 16 * 0.75，达到阈值扩容至原来的两倍

HashMap存储的元素是不保证迭代顺序，存储的键不能重复，值允许重复

1，构造方法：

HashMap()
构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity)
构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity, float loadFactor)
构造一个带指定初始容量和加载因子的空 HashMap。
HashMap(Map<? extends K,? extends V> m)
构造一个映射关系与指定 Map 相同的新 HashMap。

2，方法：

void clear()
从此映射中移除所有映射关系。
Object clone()
返回此 HashMap 实例的浅表副本：并不复制键和值本身。
boolean containsKey(Object key)
如果此映射包含对于指定键的映射关系，则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>> entrySet()
返回此映射所包含的映射关系的 Set 视图。
V get(Object key)
返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
boolean isEmpty()
如果此映射不包含键-值映射关系，则返回 true。
Set keySet()
返回此映射中所包含的键的 Set 视图。
V put(K key, V value)
在此映射中关联指定值与指定键。
void putAll(Map<? extends K,? extends V> m)
将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
V remove(Object key)
从此映射中移除指定键的映射关系（如果存在）。
int size()
返回此映射中的键-值映射关系数。
Collection values()
返回此映射所包含的值的 Collection 视图

3，遍历：

Map接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容

SetKeySet键集，返回一个Set集合，其中只有键

Collectionvalues() 值集,返回一个Collection集合，其中只有值

Set<Map.Entry<K,V>>entrySet()，键值映射集，返回一个Set集合，其中放着key-values对象

3.1键集：

SetKeySet

  HashMap<String,Integer> hashMap = new HashMap<>();
        hashMap.put("a",1);
        hashMap.put("b",2);
        hashMap.put("c",3);
        hashMap.put("d",6);
        //键集，取出键
        //迭代
        Set<String> key = hashMap.keySet();
        Iterator<String> iterator = key.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //foreach
        for (String s : key) {
            System.out.print(s+" ");

        }

3.2值集：

Collectionvalues()

//值集，取出值
//        Collection<Integer> values = hashMap.values();
//        Iterator<Integer> iterator = values.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next()+" ");
//        }
//        for (Integer value : values) {
//            System.out.print(value+" ");
//        }

3.3键值映射集：

Entry是Map接口中的内部接口，代表是一个键值对，即包含键和值，且该Entry接口中提供了关于操作单个键，值的方法

K getKey()
V getValue()

Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
//        Iterator<Map.Entry<String, Integer>> entryIterator = entrySet.iterator();
//        while (entryIterator.hasNext()) {
        //从迭代器取出的是Entry
//            Map.Entry<String, Integer> next = entryIterator.next();
        //通过entry可以单独获得键，值
//            String key = next.getKey();
//            Integer value = next.getValue();
//            System.out.println(key+"=="+value);
//
//        }
//        for (Map.Entry<String, Integer> stringIntegerEntry : entrySet) {
//            String key = stringIntegerEntry.getKey();
//            Integer value =     stringIntegerEntry.getValue();
//            System.out.println(key+ " = "+ value);
//
//        }

4,去重原理：

和HashSet一样

5，HashMap的应用：

有关的映射场景

五，TreeMap:

TreeMap底层是红黑树（平衡二叉树的一种），同样是存储键值对的，键不允许重复还会排序，默认是根据键元素的自然顺序排序或者根据创建TreeMap时指定的Comparator比较器来排序

TreeMap<String,Integer> treeMap = new TreeMap<>();
        treeMap.put("b",2);
        treeMap.put("d",4);
        treeMap.put("c",5);
        treeMap.put("a",1);
        treeMap.put("a",2);
        //按键排序
        System.out.println(treeMap);
        //获得头尾操作的方法，排序后的
        System.out.println(treeMap.firstKey());
        System.out.println(treeMap.lastKey());
        //获得排序后的第一个Entry
        Map.Entry<String, Integer> entry = treeMap.firstEntry();
        System.out.println(entry);