Java最高

使用Spring 5和Spring Boot 2开始,通过学习春天课程:

>>查看课程

1.概述

本文将说明如何将排序应用于大批列表地图在Java 7和Java 8中。

2.分类与大批

让我们首先排序整数阵列arrays.sort()方法。

我们将定义以下内容阵列在A.@前jUnit方法:

@Before public void initvariables(){tosort = new int [] {5,1,89,255,7,88,200,123,66};SortedInts = new int [] {1,5,7,66,88,89,123,200,255};sortedRangeInts = new int [] {5,1,89,7,88,200,255,123,66};...}

2.1.排序完成数组

现在让我们使用简单的方法array.sort()API:

@test public voidedIntarray_whenusingsort_thensortedarray(){arrays.sort(tosort);asserttrue(arrays.equals(tosort,sortedints));}

现在完全排序未排序的数组:

[1,5,7,66,88,89,123,200,255]

如官方javadoc中所述Arrays.sort使用双枢轴快速排序原语.它提供O(n log(n))的性能,通常比传统的(单pivot)快速排序实现更快。但是,它使用稳定的、自适应的、迭代的实现归并排序算法大批对象

2.2.数组的一部分排序

Arrays.sort还有一个种类API - 我们将在这里讨论:

Arrays.sort(int[] a, int fromIndex, int toIndex)

这将只对数组的一部分(在两个索引之间)进行排序。

让我们来看一个简单的例子:

@test public voidedIntarray_whenusingrangesort_thenrangesortedarray(){arrays.sort(Tosort,3,7);asserttrue(arrays.equals(tosort,sortedrangeints));}

排序将只对以下子数组元素进行(toIndex将是独家的):

[255,7,88,200]

结果排序的子数组(包含主数组)将是:

[5,1,89,7,88,200,255,123,66]

2.3。Java 8.Arrays.sortvsarrays.parallelsort.

Java 8附带一个新的API -parallelsort.- 与类似的签名arrays.sort()API:

@test public void gentintarray_whenusingparallelsort_thenarraysorted(){arrays.parallelsort(tosort);asserttrue(arrays.equals(tosort,sortedints));}

在幕后parallelSort (),它将数组打入不同的子阵列(根据算法的粒度parallelsort.).每个子数组都用arrays.sort()在不同的线程中这样种类可以以并行方式执行,最后将作为排序阵列合并。

请注意forjoin公共池用于执行这些并行任务,然后合并结果。

结果arrays.parallelsort.等于多少array.sort.当然,这只是一个利用多线程的问题。

最后,API存在类似的变体Arrays.sortarrays.parallelsort.以及

arrays.parallelsort(int [] a,int fromindex,int toindex);

3.整理一个列表

让我们现在使用Collections.sort ()APIjava.utils.Collections.- 排序列表整数:

@test public void给gentlist_whenusingsort_thensortedlist(){list  tosortlist = ints.aslist(tosort);collections.sort(tosortlist);asserttrue(arrays.equals(tosortlist.toarray(),rserutils.toObject(SortedInts)));}

列表Before排序将包含以下元素:

[5,1,89,255,7,88,200,123,66]

自然,在排序后:

[1,5,7,66,88,89,123,200,255]

正如Oracle JavaDoc中提到的集合。排序,它使用修改的合并排序并提供保证n log(n)表现。

4.排序A.

接下来,让我们使用Collections.sort ()解决一个linkedhashset.

我们正在使用linkedhashset.因为它保持插入顺序。

注意如何,为了使用种类API收藏品-我们首先在列表中包装套装

@Test public void givenSet_whenUsingSort_thenSortedSet() {Set integersSet = new LinkedHashSet<>(Ints.asList(toSort));Set descSortedIntegersSet = new LinkedHashSet<>(Arrays。asList(new Integer[] {255, 200, 123, 89, 88, 66, 7, 5, 1});List List = new ArrayList(integersSet);Collections.sort (Comparator.reverseOrder ());integersSet = new LinkedHashSet<>(list);assertTrue(数组。等于( integersSet.toArray(), descSortedIntegersSet.toArray())); }

Comparator.reverseorder()方法反转由自然顺序强加的顺序。

5.排序地图

在本节中,我们将开始看看排序地图 - 键和值均由值。

让我们首先定义将要排序的map:

@Before public void initvariables(){.... hashmap 地图= new hashmap <>();Map.put(55,“John”);Map.put(22,“Apple”);Map.put(66,“Earl”);Map.put(77,“Pearl”);Map.put(12,“乔治”);Map.put(6,“Rocky”);....}

5.1。排序地图通过键

我们现在会提取钥匙价值来自的参赛作品Hashmap.并根据此示例中的键的值对其进行排序:

@test public void给gendmap_whenortingbykeys_thensortedMap(){Integer [] sortedKeys = New Integer [] {6,12,22,55,66,77};列表>条目= new arraylist <>(map.entryset());collections.sort(条目,新比较器<条目>(){@override public int比较(条目<整数,字符串> o1,条目<整数,字符串> o2){return o1.getkey()。Compareto(o2.getkey());}});地图<整数,字符串> sortedmap = new linkedhashmap <>();for(map.entry 条目:条目){sortedmap.put(条目.getKey(),resst.getValue());} iserttrue(arrays.equals(sortedmap.keyset()。toarray(),sortedkeys));}

注意我们是如何使用linkedhashmap.复制已排序的参赛作品基于键(因为hashset.不能保证键的顺序)。

地图排序前:

[key:66,值:bear] [key:22,值:apple] [key:6,值:rocky] [key:55,值:John] [关键:12,价值:乔治] [关键:77,价值:珍珠]

地图排序后按键

[key:6,值:rocky] [key:12,值:george] [key:22,值:apple] [key:55,值:John] [key:66,value:bear] [关键:77,价值:珍珠]

5.2。排序地图按价值观

在这里,我们将比较值Hashmap.基于值的排序条目Hashmap.

@test public void给gendmap_whenortingbyvalues_thensortedmap(){string [] sortedvalues = new string [] {“苹果”,“earl”,“乔治”,“John”,“珍珠”,“珍珠”,“摇滚”};列表>条目= new arraylist <>(map.entryset());collection.sort(条目,新比较器<条目>(){@override public int比较(条目<整数,字符串> o1,条目<整数,字符串> o2){return o.getvalue()。Compareto(o2.getvalue());}});地图<整数,字符串> sortedmap = new linkedhashmap <>();for(map.entry 条目:条目){sortedmap.put(条目.getKey(),resst.getValue());} astertrue(arrays.equals(sortedmap.values()。toarray(),sortedvalues));}

地图排序前:

[key:66,值:bear] [key:22,值:apple] [key:6,值:rocky] [key:55,值:John] [关键:12,价值:乔治] [关键:77,价值:珍珠]

地图排序后按价值观

[key:22,值:Apple] [key:66,值:bear] [key:12,值:george] [key:55,值:John] [key:77,值:珍珠] [关键:6,价值:rocky]

6.排序自定义对象

我们现在使用自定义对象:

公共类员工实现可比{私有字符串名称;私人INT年龄;私人双重薪水;公开雇员(字符串名称,int年龄,双重薪水){...} //标准的getters,setter和toString}

我们将使用以下内容员工用于排序示例的数组:

@Before public void initVariables () {....{new Employee(“John”,23,5000),new Employee(“Steve”,26,6000),new Employee(“Frank”,33,7000),new Employee(“Earl”,43,10000),new Employee(“Jessica”,23,4000),new Employee(“Pearl”,33,6000)};employeesSorted = new Employee[] {new Employee(“Earl”,43,10000),new Employee(“Frank”,33,70000),new Employee(“Jessica”,23,4000),new Employee(“John”,23,5000),new Employee(“Pearl”,33,4000),new Employee(“Steve”,26,6000)};employeesSortedByAge = new Employee[] {new Employee("John", 23, 5000), new Employee("Jessica", 23, 4000), new Employee("Steve", 26, 6000), new Employee("Frank", 33, 70000), new Employee("Pearl", 33, 4000), new Employee("Earl", 43, 10000)};}

我们可以对自定义对象的数组或集合进行排序:

  1. 在自然秩序(使用可比界面)或
  2. 按a比较器界面

6.1。U唱比较

java中的自然顺序表示应在给定的数组或集合中有序排序原始或对象的顺序。

两个都java.util.Arraysjava.util.collections.有一个种类()方法,和强烈建议自然顺序应与语义一致等于

在这个例子中,我们将考虑与相同的员工名称等于:

@test public voidedemparray_sortemparray_thensortedarrayinnaturalOrder(){arrays.sort(员工);asserttrue(arrays.equals(雇员,员工,员工));}

可以通过实现可比接口有相比于()将当前对象和对象传递作为参数的方法。

要清楚地理解,让我们看看一个例子员工班级哪种工具可比界面:

公共类员工实现可比{... @Override公共布尔等于(Object OBJ){return((员工)obj).getname()。等于(getName());@override public int compareto(对象o){员工e =(员工)o;返回getName()。Compareto(e.getName());}}

通常,将写入比较的逻辑相比于.这里我们比较的是员工顺序或名称员工领域。如果他们有同名,两名员工将相等。

现在,当arrays.sort(员工);在上面的代码中被称为,我们现在知道根据年龄根据年龄排序员工的逻辑和顺序是什么:

[(“伯爵”,43,10000),(“弗兰克”,33,70000),(“杰西卡”,23,4000),(“John”,23,5000),(“珍珠”,33,4000),(“史蒂夫”,26,6000)]

我们可以看到阵列按员工的名称排序 - 现在成为自然顺序员工班级。

6.2。使用比较器

现在,让我们使用a对元素进行排序比较器接口实现——在这里,我们动态地将匿名内部类传递给arrays.sort()API:

@Test public void givenIntegerArray_whenUsingSort_thenSortedArray() {Integer [] integers = arrayutil . toobject (toSort);Arrays.sort(integers, new Comparator() { @Override public int compare(Integer a, Integer b) { return Integer.compare(a, b); } }); assertTrue(Arrays.equals(integers, ArrayUtils.toObject(sortedInts))); }

现在让员工排序薪水-并传入另一个比较器实现:

arrays.sort(员工,新比较器(){@override public int比较(员工o1,employee o2){return double.compare(o1.getsalary(),o2.getsalary());}};

基于的分类员工阵列薪水将:

[(杰西卡,23,4000.0),(约翰,23,5000.0),(珍珠,33,6000.0),(史蒂夫,26,6000.0),(Frank,33,7000.0),(伯爵,43,10000.0)]

注意我们可以使用Collections.sort ()以类似的方式排序列表对象的自然或自定义顺序,如上所述的数组。

7.排序和λ

从Java 8开始,我们可以使用Lambdas实现比较器功能界面。

你可以看看Java 8中的Lambdas写作刷在语法上。

让我们替换旧比较器:

比较器<整数> C =新比较器<>(){@override public int比较(整数a,整数b){return integer.compare(a,b);}}

使用等效的实现,使用Lambda表达式:

比较器<整数> c =(a,b) - > integer.compare(a,b);

最后,让我们编写测试:

@test public void给array_whenusingsortwithlambdas_thensortedarray(){integer [] integerstosort = arrayutils.toObject(Tosort);arrays.sort(integerstosort,(a,b) - > {return integer.compare(a,b);});asserttrue(arrays.equals(integerstosort,ressutils.toObject(SortedInts)));}

正如您所看到的,这里有一个更清洁和更简洁的逻辑。

8.使用比赛Comparator.thenComparing

Java 8附带两个用于排序的新API -比较()thencomparing()在里面比较器界面。

类的多个条件的链接非常方便比较器

让我们考虑一个可能需要进行比较的场景员工经过年龄然后通过名称

@Test public void givenArrayObjects_whenUsingComparing_thenSortedArrayObjects() {List employeesList = Arrays.asList(employees);employees.sort (Comparator.comparing(员工::getAge));assertTrue (Arrays.toString (employees.toArray ()) .equals (sortedArrayString));}

在这个例子中,员工::养殖是排序键比较器实现具有比较功能的功能界面的接口。

这是排序后的Employees数组:

[(John,23,5000.0),(杰西卡,23,4000.0),(史蒂夫,26,6000.0),(弗兰克,33,7000.0),(珍珠,33,6000.0),(伯爵,43,10000.0)]

这里员工是根据的年龄

我们可以看到约翰杰西卡在同一年龄 - 这意味着订单逻辑现在应该考虑到他们的名字 - 我们可以实现thencomparing()

... employees.sort(比较器.Comparion.comParing(员工:: Getage).thencomparing(员工:: getName));......

使用上面的代码段排序后,员工阵列中的元素将被排序为:

[(Jessica,23,4000.0),(约翰,23,5000.0),(史蒂夫,26,6000.0),(弗兰克,33,7000.0),(珍珠,33,6000.0),(伯爵,43,10000.0)]

因此比较()thencomparing()肯定会使更复杂的排序方案实现很多清洁器。

9.结论

在本文中,我们看到了我们如何申请排序大批列表, 和地图

我们还简要介绍了Java 8的功能如何有用的简要介绍,在兰姆达斯的雷竞技app官网网站用法中,比较()thencomparing()parallelSort ()

本文中使用的所有示例都是可用的在GitHub

Java底部

使用Spring 5和Spring Boot 2开始,通过学习春天课程:

>>查看课程
对这篇文章的评论关闭!