修改map和set的排序准则

合集下载

js的set和map用法

js的set和map用法一、set用法1.概述Set是JavaScript中的一个内置对象，主要用于创建集合。

它有两个常用的方法：add()和delete()。

Set对象可以存储不同类型的元素，但需要注意的是，Set中的元素必须是不可变的。

2.常用场景（1）去重：当需要对一个数组进行去重操作时，可以使用Set对象。

（2）存储不同类型的元素：Set对象可以存储不同类型的元素，例如数字、字符串、布尔值等。

（3）数组与Set的转换：可以将数组转换为Set，然后再将Set转换回数组。

3.实例演示```javascriptconst arr = [1, 2, 3, 4, 4, 5, "hello", "world", true];// 创建Set对象const set = new Set(arr);// 输出Set对象console.log(set);// 输出：[1, 2, 3, 4, 5, "hello", "world", true]// 将Set转换为数组const newArr = [...set];// 输出转换后的数组console.log(newArr);// 输出：[1, 2, 3, 4, 5, "hello", "world", true]```二、map用法1.概述Map是JavaScript中的另一个内置对象，主要用于创建映射关系。

Map 对象可以存储键值对，其中键和值可以是任何类型的对象或原始值。

Map对象提供了一系列方法，如set()、get()、has()、delete()等。

2.常用场景（1）存储键值对：当需要存储多个键值对时，可以使用Map对象。

（2）遍历对象：Map对象可以用于遍历对象，将对象的属性名作为键，属性值作为值。

（3）简化数组操作：可以使用Map对象简化数组的操作，如遍历、查找等。

java8集合自定义排序方法

java8集合自定义排序方法Java8集合自定义排序方法：1.Java8集合概述Java8提供了丰富的集合框架，包括List、Set、Map等。

这些集合类为我们处理数据提供了便利。

在此基础上，Java8还引入了Stream API，可以更加高效地操作集合数据。

在本篇文章中，我们将重点讨论如何使用Java8集合对数据进行自定义排序。

2.自定义排序方法在Java8中，可以使用`Comparator`接口对集合进行自定义排序。

`Comparator`接口中有一个`compare`方法，用于比较两个元素的大小。

我们可以实现这个接口，并编写自定义的排序逻辑。

以下是一个自定义排序的示例：```javaimport java.util.ArrayList;import parator;import java.util.List;public class CustomSort {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("apple");list.add("orange");list.add("banana");list.add("kiwi");// 按照字符串长度排序list.sort(new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.length() - o2.length();}});// 输出排序后的列表for (String item : list) {System.out.println(item);}}}```上述代码中，我们创建了一个`ArrayList`存储字符串元素，并使用`sort`方法对列表进行排序。

set与map的区别

set与map的区别MapMap对象保存键值对。

任何值(对象或者原始值) 都可以作为⼀个键或⼀个值。

构造函数Map可以接受⼀个数组作为参数。

Map和Object的区别⼀个Object的键只能是字符串或者Symbols，但⼀个Map的键可以是任意值。

Map中的键值是有序的（FIFO 原则），⽽添加到对象中的键则不是。

Map的键值对个数可以从 size 属性获取，⽽Object的键值对个数只能⼿动计算。

Object都有⾃⼰的原型，原型链上的键名有可能和你⾃⼰在对象上的设置的键名产⽣冲突。

Map对象的属性size：返回Map对象中所包含的键值对个数Map对象的⽅法set(key, val): 向Map中添加新元素get(key): 通过键值查找特定的数值并返回has(key): 判断Map对象中是否有Key所对应的值，有返回true,否则返回falsedelete(key): 通过键值从Map中移除对应的数据clear(): 将这个Map中的所有元素删除遍历⽅法keys()：返回键名的遍历器values()：返回键值的遍历器entries()：返回键值对的遍历器forEach()：使⽤回调函数遍历每个成员const map = new Map([['a', 1], ['b', 2]])for (let key of map.keys()) {console.log(key)}// "a"// "b"for (let value of map.values()) {console.log(value)}// 1// 2for (let item of map.entries()) {console.log(item)}// ["a", 1]// ["b", 2]// 或者for (let [key, value] of map.entries()) {console.log(key, value)}// "a" 1// "b" 2// for...of...遍历map等同于使⽤map.entries()for (let [key, value] of map) {console.log(key, value)}// "a" 1// "b" 2map与其他数据结构的互相转换map转换为数组（使⽤扩展运算符）const arr = [[{'a': 1}, 111], ['b': 222]]const myMap = new Map(arr)[...myMap] // map转数组。

java8集合自定义排序方法

java8集合自定义排序方法Java 8新增了一些功能，使得在集合中进行自定义排序变得更加简单和灵活。

在Java 8中，可以使用lambda表达式和函数式接口来实现自定义排序方法。

在Java 8中，集合类（如List、Set、Map）都新加了一个sort方法，该方法接收一个Comparator接口的实现作为参数，用于定义自定义排序规则。

Comparator接口是一个函数式接口，只有一个抽象方法compare(Object obj1, Object obj2)。

该方法接收两个对象作为参数，返回一个int类型的值，用于比较两个对象的大小。

其中，返回值为负数表示obj1应排在obj2之前，返回值为正数表示obj1应排在obj2之后，返回值为0表示两个对象相等。

下面是一个例子，展示如何使用lambda表达式和Comparator接口来实现自定义排序：List<String> names = Arrays.asList("Bob", "Alice", "Charlie", "David");使用lambda表达式和Comparator接口排序names.sort((String name1, String name2) -> name1pareTo(name2));打印排序后的结果names.forEach(System.out::println);在上面的例子中，首先创建了一个包含四个字符串的List对象names。

然后使用sort方法和lambda表达式来定义自定义排序规则。

在lambda表达式中，调用了String类的compareTo方法来比较两个字符串的大小。

最后使用forEach方法遍历并打印排序后的结果。

除了使用lambda表达式，还可以使用方法引用来实现自定义排序。

方法引用是一种简化lambda表达式的语法。

list、set、map的区别

set －－其中的值不允许重复，无序的数据结构list －－其中的值允许重复，因为其为有序的数据结构map－－成对的数据结构，健值必须具有唯一性（键不能同，否则值替换）List按对象进入的顺序保存对象，不做排序或编辑操作。

Set对每个对象只接受一次，并使用自己内部的排序方法（通常，你只关心某个元素是否属于Set,而不关心它的顺序--否则应该使用List）。

Map同样对每个元素保存一份，但这是基于"键"的，Map也有内置的排序，因而不关心元素添加的顺序。

如果添加元素的顺序对你很重要，应该使用 LinkedHashSet或者LinkedHashMap.List的功能方法实际上有两种List: 一种是基本的ArrayList,其优点在于随机访问元素，另一种是更强大的LinkedList,它并不是为快速随机访问设计的，而是具有一套更通用的方法。

List : 次序是List最重要的特点：它保证维护元素特定的顺序。

List为Collection添加了许多方法，使得能够向List中间插入与移除元素（这只推荐LinkedList使用。

）一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。

ArrayList : 由数组实现的List。

允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。

ListIterator只应该用来由后向前遍历ArrayList,而不是用来插入和移除元素。

因为那比LinkedList开销要大很多。

LinkedList : 对顺序访问进行了优化，向List中间插入与删除的开销并不大。

随机访问则相对较慢。

（使用ArrayList代替。

）还具有下列方法：addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法（没有在任何接口或基类中定义过）使得LinkedList可以当作堆栈、队列和双向队列使用。

treemap重写排序规则

TreeMap排序规则重写1. 简介Treemap是一种数据可视化的图表类型，用于展示层次结构数据的相对比例关系。

它通过矩形的面积来表示不同类别或分支的数据大小，同时通过颜色来表示其它维度的信息。

在Treemap中，矩形的大小和位置决定了数据的比例关系。

在默认情况下，Treemap根据数据的大小来排列矩形，较大的矩形通常位于较小的矩形之上。

然而，在某些情况下，我们可能需要根据自定义规则对Treemap进行排序。

本文将讨论如何重写Treemap排序规则以满足特定需求。

2. Treemap排序原理在了解如何重写Treemap排序规则之前，我们首先需要了解Treemap的基本原理。

Treemap使用递归分割和布局算法来生成矩形布局。

其基本步骤如下：1.将整个可用空间作为一个大矩形。

2.将大矩形按比例分割成若干小矩形，每个小矩形代表一个数据项。

3.对每个小矩形递归地应用步骤1和2，直到所有数据项都被处理完毕。

4.根据数据项的大小确定小矩形的面积，并根据需要添加颜色等其它维度信息。

5.最后，将所有小矩形按照一定的规则排列在大矩形中。

Treemap排序规则决定了最后一步中小矩形的排列顺序。

默认情况下，Treemap使用数据项大小作为排序依据。

3. 重写Treemap排序规则为了重写Treemap排序规则，我们需要修改生成矩形布局时的排序逻辑。

下面是一个示例代码，展示了如何实现自定义排序规则：import parator;public class CustomComparator implements Comparator<DataItem> {@Overridepublic int compare(DataItem item1, DataItem item2) {// 自定义比较逻辑// 返回负数表示item1应该排在item2之前// 返回正数表示item1应该排在item2之后// 返回0表示两个元素相等}}public class DataItem {private String name;private double value;// 省略getter和setter方法}在上述代码中，我们定义了一个CustomComparator类来实现自定义的比较逻辑。

java map排序规则

在Java中，Map 是一个键值对的集合，HashMap 是其中最常用的实现之一。

Java中的Map 并没有提供直接的排序方法，因为它是一个无序的集合。

但是，可以通过一些方式来对Map 进行排序。

以下是一些可能的排序方式：1. 使用TreeMap：TreeMap 是Map 接口的一个实现，它会根据键的自然顺序或自定义的比较器对键进行排序。

通过将HashMap 转换为TreeMap，可以实现对键的排序。

// 使用自然排序Map<Integer, String> unsortedMap = new HashMap<>();// 填充mapTreeMap<Integer, String> sortedMap = new TreeMap<>(unsortedMap);// 或者使用自定义比较器Comparator<Integer> customComparator = (k1, k2) -> pareTo(k2);TreeMap<Integer, String> customSortedMap = new TreeMap<>(customComparator); customSortedMap.putAll(unsortedMap);2. 通过List 排序：将Map 中的键值对转换为List，然后通过Collections.sort() 对List 进行排序。

Map<Integer, String> unsortedMap = new HashMap<>();// 填充mapList<Map.Entry<Integer, String>> entryList = new ArrayList<>(unsortedMap.entrySet()); entryList.sort(paringByKey()); // 或者使用自定义比较器// 将排序后的List 转回MapMap<Integer, String> sortedMap = new LinkedHashMap<>();for (Map.Entry<Integer, String> entry : entryList) {sortedMap.put(entry.getKey(), entry.getValue());}3. Java 8+ 使用流和Lambda 表达式：Map<Integer, String> unsortedMap = new HashMap<>();// 填充mapMap<Integer, String> sortedMap = unsortedMap.entrySet().stream().sorted(paringByKey()) // 或者使用自定义比较器.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,(e1, e2) -> e1, LinkedHashMap::new));在这些例子中，排序是基于键的排序。

map的默认排序和自定义排序

map的默认排序和⾃定义排序STL的容器map为我们处理有序key-value形式数据提供了⾮常⼤的便利，由于内部红⿊树结构的存储，查找的时间复杂度为O(log2N)。

⼀般⽽⾔，使⽤map的时候直接采取map<typename A, typename B>的形式即可，map的内部实现默认使⽤A类型变量的升序来排序map的值。

但是有时我们需要对map的值做特殊的排序(不经其他容器的辅助)，这就需要在定义map变量时做些特殊的处理。

STL中map的定义是：1 template<class _Kty,2class _Ty,3class _Pr = less<_Kty>,4class _Alloc = allocator<pair<const _Kty, _Ty>>>5class map6 : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>>7 {这是⼀个模板类，我们的特殊处理主要改造的就是class _Pr = less<_Kty>，并且从这⾥我们也能看到，⽆论做哪种修改，排序都是针对key ⽽⾔的，要实现value的⾃定义排序，不是修改_Pr类型能完成的。

替换_Pr的也必须是⼀个类型，即⾄少我们要⾃⼰创建⼀个类型，⽤来做key的⽐较。

⾃然，我们需要做的是重载函数调⽤操作符"()"，⼀般的形式为1class T{2public:3bool operator()(const T& lhs, const T& rhs)const4 {5 ...6 }7 };代码需包含头⽂件<algorithm>、<functional>。

下⾯是常见的⼀些⾃定义排序：a.对基本类型的key以降序排列 map默认提供的是less<_Kty>类型的排序⽅式，阅读STL源码1 template<class _Ty = void>2struct less3 { // functor for operator<4 _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty first_argument_type;5 _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty second_argument_type;6 _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef bool result_type;78 constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const9 { // apply operator< to operands10return (_Left < _Right);11 }12 }; 修改上述代码的第10⾏，为修改后的类型起⼀个⾃定义名字很简单，不过STL已经为我们提供了整个类型定义：1 template<class _Ty = void>2struct greater3 { // functor for operator>4 _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty first_argument_type;5 _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty second_argument_type;6 _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef bool result_type;78 constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const9 { // apply operator> to operands10return (_Left > _Right);11 }12 }; 我们直接使⽤就⾏：1 std::map<int, int, std::greater<int>> mi;2for (int i = 0; i < 5; i++)3 {4 mi[i] = i * 2;5 }67 std::for_each(mi.begin(), mi.end(),8 [](const std::map<int, int, std::greater<int>>::value_type& vl) {9 cout << "key:" << vl.first << " value:" << vl.second << '\n';10 }); 对应的输出为：这⾥，我们实现了按key降序排列的⽬的。

treemap重写排序规则

treemap重写排序规则Treemap是一种常用的数据可视化工具，用于将层次化的数据以矩形的形式展示出来。

每个矩形的大小表示数据的重要性，而矩形的颜色则可以表示不同的类别。

然而，在默认情况下，Treemap的排序规则可能无法满足特定需求。

因此，有时候我们需要自定义排序规则来更好地展示数据。

要重写Treemap的排序规则，我们可以采取以下步骤：1. 确定排序依据：首先，我们需要明确基于哪个变量来排序。

例如，如果我们想要依据销售额对产品进行排序，那么我们需要选择该变量作为排序依据。

2. 编写排序函数：接下来，我们可以编写一个排序函数，该函数接受Treemap中的数据作为输入，并按照我们所选的排序依据进行排序。

例如，如果我们选择了销售额作为排序依据，我们可以编写一个函数来根据销售额对数据进行排序。

3. 应用排序规则：在Treemap中，通常有一个sort函数用于应用排序规则。

我们可以使用我们自定义的排序函数作为参数传递给该函数，以按照我们的排序规则对数据进行排序。

4. 更新Treemap：一旦我们应用了新的排序规则，Treemap将会根据我们所选择的排序依据重新排列数据。

这样，我们就能够以我们所期望的方式展示数据了。

通过重写Treemap的排序规则，我们可以更好地展示数据，并突出显示出我们感兴趣的内容。

无论是根据销售额、利润还是其他指标，我们都可以按照自己的需求对数据进行排序，使得Treemap更加灵活和有用。

值得注意的是，重写Treemap的排序规则需要一定的编程技巧，因此可能需要一些编程知识和经验。

然而，一旦我们熟悉了相关的概念和方法，就能够轻松地为Treemap定制排序规则，以满足特定的数据展示需求。

java map排序规则

java map排序规则摘要：1.Java 中的Map 排序规则简介2.Map 排序规则的具体实现3.排序规则的示例与解析4.总结与展望正文：1.Java 中的Map 排序规则简介在Java 编程语言中，Map 接口是一种映射关系，用于存储键值对（key-value pairs）。

由于Map 接口没有实现Comparable 接口，因此它本身不支持排序。

但是，Java 8 引入了新的排序方法，允许我们对Map 中的键或值进行排序。

本篇文章将详细介绍Java 中Map 排序规则的相关知识。

2.Map 排序规则的具体实现在Java 8 中，Map 接口引入了两个新的方法：entrySet() 和forEach()，这使得我们可以遍历Map 中的所有键值对。

同时，Java 8 还引入了一个名为paring() 的静态方法，该方法可以帮助我们创建一个比较器，以便对键或值进行排序。

以下是使用Java 8 对Map 排序的具体步骤：（1）首先，创建一个Map 实例，并添加一些键值对。

（2）接下来，通过调用entrySet() 方法获取Map 的所有键值对。

（3）使用paring() 方法创建一个比较器，指定排序的键或值。

（4）使用Java 8 的Stream API 对键值对进行排序。

可以使用sorted() 方法对键或值进行排序，然后使用collect() 方法将排序后的键值对收集到一个新的Map 中。

（5）最后，输出排序后的Map。

3.排序规则的示例与解析下面是一个具体的示例，演示如何对一个Map 中的键值对按照键进行排序：```javaimport java.util.*;public class Main {public static void main(String[] args) {Map<String, Integer> map = new HashMap<>();map.put("one", 1);map.put("two", 2);map.put("three", 3);map.put("four", 4);// 获取Map 的所有键值对Set<Map.Entry<String, Integer>> entrySet =map.entrySet();// 使用paring() 方法创建一个比较器，指定排序的键Comparator<Map.Entry<String, Integer>> comparator = paring(entry -> entry.getKey());// 使用Java 8 的Stream API 对键值对进行排序List<Map.Entry<String, Integer>> sortedEntryList = entrySet.stream().sorted(comparator).collect(Collectors.toList());// 输出排序后的键值对for (Map.Entry<String, Integer> entry : sortedEntryList) {System.out.println(entry.getKey() + ": " +entry.getValue());}}}```在这个示例中，我们首先创建了一个包含四个键值对的Map 实例。

ES6之Set方法与Map方法

ES6之Set⽅法与Map⽅法 ES6提供了新的数据结构——Set与Map，Set本⾝是⼀个构造函数且成员的值是唯⼀的，没有重复的值！！！Set()是⼀个存储已排序的⽆重复元素的数据⽽Map()是⼀对数据Map()使⽤关键值Key来标识每⼀个成员且Map()的value的值是可以重复的。

var a = new Set([1,1,2,2,3,4,5]);console.log([...a]); //[ 1, 2, 3, 4, 5 ]console.log(a.size); //5 Set⽰例的⽅法有两⼤类：操作⽅法（增删查清）和遍历⽅法，下⾯就分别说下这两⼤类的⽅法第⼀⼤类：Set操作⽅法 1.为Set添加值使⽤add()⽅法，add⽅法可以多次为set添加值但是如果添加两个相同的值则被默认为是⼀个值当然这也符合第⼀句话所说的set本⾝是⼀个构造函数且成员唯⼀，⽆重复的值！！！var a = new Set();a.add(1);a.add(1).add(2);console.log(a); //Set { 1, 2 }console.log(a.size); //2 2.为Set删除某值使⽤delete()⽅法，该⽅法返回的是⼀个布尔值，表⽰是否删除成功。

var a = new Set();a.add(1);a.add(1).add(2);console.log(a); //Set { 1, 2 }console.log(a.size); //2a.delete(1);console.log(a); //Set { 2 }console.log(a.size); //1 3.判断⼀个参数是否为Set参数可以使⽤has()⽅法，该⽅法会返回⼀个布尔值。

var a = new Set();a.add(1);a.add(1).add(2);console.log(a.has(1)); //trueconsole.log(a); //Set { 1, 2 }console.log(a.size); //2a.delete(1);console.log(a.has(1)); //falseconsole.log(a); //Set { 2 }console.log(a.size); //1 4.如果想清除所有Set的值那么使⽤clear()⽅法，该⽅法⽆返回值。

对map集合进行排序

对map集合进⾏排序今天做统计时需要对X轴的地区按照地区代码（areaCode）进⾏排序，由于在构建XMLData使⽤的map来进⾏数据统计的，所以在统计过程中就需要对map进⾏排序。

⼀、简单介绍Map在讲解Map排序之前，我们先来稍微了解下map。

map是键值对的集合接⼝，它的实现类主要包括：HashMap,TreeMap,Hashtable以及LinkedHashMap等。

其中这四者的区别如下（简单介绍）：HashMap：我们最常⽤的Map，它根据key的HashCode 值来存储数据,根据key可以直接获取它的Value，同时它具有很快的访问速度。

HashMap最多只允许⼀条记录的key值为Null(多条会覆盖);允许多条记录的Value为 Null。

⾮同步的。

TreeMap: 能够把它保存的记录根据key排序,默认是按升序排序，也可以指定排序的⽐较器，当⽤Iterator 遍历TreeMap时，得到的记录是排过序的。

TreeMap不允许key的值为null。

⾮同步的。

Hashtable: 与 HashMap类似,不同的是:key和value的值均不允许为null;它⽀持线程的同步，即任⼀时刻只有⼀个线程能写Hashtable,因此也导致了Hashtale在写⼊时会⽐较慢。

LinkedHashMap: 保存了记录的插⼊顺序，在⽤Iterator遍历LinkedHashMap时，先得到的记录肯定是先插⼊的.在遍历的时候会⽐HashMap慢。

key和value均允许为空，⾮同步的。

⼆、Map排序TreeMapTreeMap默认是升序的，如果我们需要改变排序⽅式，则需要使⽤⽐较器：Comparator。

Comparator可以对集合对象或者数组进⾏排序的⽐较器接⼝，实现该接⼝的public compare(T o1,To2)⽅法即可实现排序，该⽅法主要是根据第⼀个参数o1,⼩于、等于或者⼤于o2分别返回负整数、0或者正整数。

对map集合按照value从大到小进行排序

对map集合按照value从⼤到⼩进⾏排序概述：基本特点：该集合存储键值对，⽽且要保证键的惟⼀性⼦类：|--HashTable 底层是哈希数据表结构，不可以使⽤Null作为键或者值；该集合线程是同步的|--hashMap 底层是哈希数据表结构，可以使⽤Null作为键或者值，该集合线程是不同步的|--treemap 底层是⼆叉树结构，线程不同步，可以对Map中的键值可以排序Map集合的两种取出⽅式(原理：将map集合转换成set,再使⽤迭代器)1.传⼊map集合即可public static Map sortByComparator(Map unsortMap){List list = new LinkedList(unsortMap.entrySet());// System.out.println("list:"+list);Collections.sort(list, new Comparator(){public int compare(Object o1, Object o2){return ((Comparable) ((Map.Entry) (o2)).getValue()).compareTo(((Map.Entry) (o1)).getValue());}});Map sortedMap = new LinkedHashMap();for (Iterator it = list.iterator(); it.hasNext();) {Map.Entry entry = (Map.Entry)it.next();sortedMap.put(entry.getKey(), entry.getValue());}return sortedMap;}。

set的排序规则

set的排序规则1. 什么是set？在计算机科学中，set是一种数据结构，用于存储一组无序且唯一的元素。

它是集合的一种实现方式，常用于处理需要快速查找、插入和删除元素的场景。

Set通常被用于解决去重和查找问题。

2. set的特点•set中的元素是无序的，即没有固定的顺序。

•set中的元素是唯一的，不会存在重复的元素。

•set中的元素必须是不可变的，例如数字、字符串等。

3. set的创建和初始化在Python中，可以使用花括号{}或set()函数来创建一个set。

下面是一些示例：# 使用花括号创建sets1 = {1, 2, 3, 4, 5}# 使用set()函数创建sets2 = set([1, 2, 3, 4, 5])# 创建空的sets3 = set()4. set的排序规则由于set是无序的，所以它本身并不支持排序。

但是，我们可以通过一些技巧来实现对set的排序。

4.1 使用sorted()函数进行排序Python中的sorted()函数可以对可迭代对象进行排序，包括set。

它会返回一个新的已排序的列表，而不会改变原始的set。

下面是一个示例：s = {3, 1, 2, 5, 4}sorted_list = sorted(s)print(sorted_list)输出结果为：[1, 2, 3, 4, 5]4.2 使用sorted()函数进行自定义排序如果我们想要按照自定义的排序规则对set进行排序，可以使用sorted()函数的key参数。

key参数接受一个函数，用于指定排序的依据。

下面是一个示例：s = {3, 1, 2, 5, 4}sorted_list = sorted(s, key=lambda x: -x)print(sorted_list)输出结果为：[5, 4, 3, 2, 1]在上面的示例中，我们使用lambda函数指定了排序的依据为元素的相反数，即按照降序进行排序。

4.3 使用sorted()函数进行多重排序如果我们想要对set进行多重排序，可以使用sorted()函数的多个key参数。

JavaScript深入理解-Set、Map、WeakSet和WeakMap

JavaScript深⼊理解-Set、Map、WeakSet和WeakMap SetSet 对象允许储存任何类型的唯⼀值，⽆论是原始值或者是对象引⽤本质：构造函数，⽤来⽣成 Set 数据结构描述Set 对象是值的集合,你可以按照插⼊的顺序迭代它的元素。

Set 中的元素只会出现⼀次，即 Set 元素是唯⼀的。

相当于集合，可以进⾏并集交集运算。

值的相等对于原始数据类型（boolean，number，string，null，undefined），如果储存相同值则只保存⼀个，对于引⽤类型,引⽤地址完全相同则只会存⼀个。

+0 与-0 在存储判断唯⼀性的时候是恒等的，所以不可以重复。

undefined 和 undefined 是恒等的，所以不可以重复。

NaN 与 NaN 是不恒等的，但是在 Set 中只能存⼀个不能重复。

属性⽅法size 属性：返回集合元素个数（类似于数组的长度 length）add(value)⽅法：想集合中添加⼀个元素。

如果添加的元素已存在，则不会进⾏操作。

delete(value)⽅法：从集合中删除元素 valuehas(value)⽅法：判断 value 是否在合集中，返回 true 或者 falseclear()⽅法：清空集合forEach()⽅法：根据集合中元素的插⼊顺序，依次执⾏提供的回调函数应⽤场景数组去重，交集，并集，差集等等//数组去重...new Set([1,1,2,2,3])//并集let arr1 = [1, 2, 3]let arr2 = [2, 3, 4]let newArr = [...new Set([...arr1, ...arr2])]//交集let arr1 = [1, 2, 3]let arr2 = [2, 3, 4]let set1 = new Set(arr1)let set2 = new Set(arr2)let newArr = []set1.forEach(item => {set2.has(item) ? newArr.push(item) : ''})console.log(newArr)//差集let arr1 = [1, 2, 3]let arr2 = [2, 3, 4]let set1 = new Set(arr1)let set2 = new Set(arr2)let newArr = []set1.forEach(item => {set2.has(item) ? '' : newArr.push(item)})set2.forEach(item => {set1.has(item) ? '' : newArr.push(item)})console.log(newArr)MapMap 对象保存键值对，并且能够记住键的原始插⼊顺序，任何值（对象或者原始值）都可以左右⼀个键或者⼀个值描述：⼀个 Map 对象在迭代时会根据对象中元素的插⼊顺序来进⾏，⼀个for of循环在每次迭代后会返回⼀个形式为[key,value]的数组键的相等对于原始数据类型（boolean，number，string，null，undefined），如果储存相同值则只保存⼀个，对于引⽤类型,引⽤地址完全相同则只会存⼀个。

浅析stl序列容器（map和set）的仿函数排序

浅析stl序列容器（map和set）的仿函数排序set是⼀个⾃动有序的集合容器，这是set的⼀个最实惠的性质，从⼩到⼤，只要你插⼊进去，就有序了。

但是，如果你不想要这个顺序呢，是不是可以⼈为控制set容器的元素顺序呢？答案是，可以的，因为stl也是程序员设计的。

⾸先看stl的模板构造函数复制代码代码如下:explicit set ( const Compare& comp = Compare(), const Allocator& = Allocator() );templateset ( InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator() );set ( const set& x );我们完全可以重定义set的构造函数⾥的⽐较函数，完成对set的⾃排序功能。

复制代码代码如下:bool fncomp (int lhs, int rhs) {return lhsstruct classcomp {bool operator() (const int& lhs, const int& rhs) const{return lhs>rhs;} // 控制set逆序};void testset(){// 第⼀种使⽤⽅法bool(*fn_pt)(int,int) = fncomp;set sixth (fn_pt);// 第⼆中使⽤⽅法set s; // class as Compares.insert(4);s.insert(5);set::iterator it;for(it=s.begin();it!=s.end();it++){cout<<*it<<" ";}cout <<endl;};如果set元素是⼀个结构体，你最好要设置你的仿函数，不然set⼀般默认是按第⼀个字段排序的，⽽我们的实际情况是想按序号i排序：复制代码代码如下:struct ST_Message{public:ST_Message(int seq, int64_t time, string strfrom, string strto, string strinfo){this->seq=seq;this->time=time;this->strfrom=strfrom;this->strto=strto;this->strinfo=strinfo;}int seq;int64_t time;string strfrom;string strto;string strinfo;bool operator <(const ST_Message& other) const // 注意是const函数{if (seq != other.seq) // dtime按升序排序{return (seq < other.seq);}else if(time < other.time){return (time < other.time);}else if(strcmp(strfrom.c_str(), other.strfrom.c_str()) != 0){return (strcmp(strfrom.c_str(), other.strfrom.c_str()) < 0);}else if(strcmp(strto.c_str(), other.strto.c_str()) != 0){return (strcmp(strto.c_str(), other.strto.c_str()) < 0);}else{return (strcmp(strinfo.c_str(), other.strinfo.c_str()) < 0);}}};stl中⾃动有序的容器map也和set有相同的应⽤，如果你想快速理解，那么把这篇⽂章中的set改成map就差不多了。

程序设计语言理论

map的有关介绍
• map是单词mapping(映射)的缩写。 • map使用pair(键值对)这种配对的数据，并根据pair中第一个元素的值进行排序，map 的节点是一对数据。 • 一般map是对有关联的食物存储，操作。 • map的形式map<type1, type2> mymap;
• map:使用关键字key来标示每一个成员，相当于字典,把一个值映射成另一个值,如果想创建字典的话，map就是一个很好的选择。 map底层采用的是树型结构,多数使用平衡二叉树实现,查找某一值是常数时间,遍历起来效果也不错, 只是每次插入值的时候,会重新构成底层的平衡二叉树,效率有一定影响。
set的有关介绍
• set的含义是集合，它是一个有序的容器，里面的元素都是排序好的，支持插入，删除，查找等操作，就像一个集合一样。所有的操作的都是严格在logn时间之内完成，效率非常高。 • set是对一个字段进行存储，操作。 • set的形式 set<type> myset;
• • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • •
• • • • • • • • • • • • • • • • • • • •
#include <StdAfx.h> #include <map> #include <iostream> using namespace std; int main( ) { map <int, int> m1, m2, m3; map <int, int>::iterator m1_Iter; m1.insert ( pair <int, int> ( 1, 10 ) ); m1.insert ( pair <int, int> ( 2, 20 ) ); m1.insert ( pair <int, int> ( 3, 30 ) ); m2.insert ( pair <int, int> ( 10, 100 ) ); m2.insert ( pair <int, int> ( 20, 200 ) ); m3.insert ( pair <int, int> ( 30, 300 ) ); cout << "The original map m1 is:"; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << " " << m1_Iter->second; cout << "." << endl; // This is the member function version of swap //m2 is said to be the argument map; m1 the target map m1.swap( m2 );

Set容器的排序规则

2014-04-21 09:20 440人阅读评论(0) 收藏举报
分类：
STL（1） C++（8）
版权声明：本文为博主原创文章，未经博主允许不得转载。

大家都知道，Set容器有其特定的排序准则，缺省情况下以operator<进行比较，也就是默认升序排列，
那么怎么改变容器的排序准则呢，那就是在容器定义的时候，把准则作为第二个template参数传入。

如果想定义成按递减顺序排列，定义成typedef set<int,greater<int> > IntSet; greater<>是一个预先定义的仿函数。

下面是代码实现：
#include "stdafx.h"
#include <set>
using namespace std;
typedef set<int,greater<int> > IntSet;
int _tmain(int argc, _TCHAR* argv[])
{
IntSet coll;
coll.insert(3);
coll.insert(1);
coll.insert(5);
coll.insert(4);
coll.insert(6);
coll.insert(2);
IntSet::const_iterator it = coll.begin(); for( ;it != coll.end();++it)
{
printf("元素值%d\n", *it);
}
return 0;
}
参考《C++标准程序库》。