Java实现数组去重、排序操作

Java实现数组去重、排序操作
本文中的示例源码编写基于Jdk1.6+、junit4.8.2

java.util.Arrays.sort()
支持对int[],long[],short[],char[],byte[],float[],double[],Object[]进行排序

参考示例代码片段如下

1 // 声明int 数组，并初始化
2 int[] intArry = {5,4,7,8,2,0,1,9,3,6,10};
3 // 对int数组进行排序
4 Arrays.sort(intArry);

Junit 测试类源码：

1 package com.gjnote.test.array;
2
3 import java.util.Arrays;
4 import org.junit.Test;
5
6 public class TestArraysSort {
7
8 // 声明int 数组，并初始化
9 int[] intArry = {5,4,7,8,2,0,1,9,3,6,10};
10
11 @Test
12 public void test() {
13 // 对int数组进行排序
14 Arrays.sort(intArry);
15 for (int i = 0; i < intArry.length; i++) {
16 System.out.println(intArry[i]);
17 }
18
19 System.out.println(Arrays.toString(intArry));
20 }
21 }

控制台输出
0
1
2
3
4
5
6
7
8
9
10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

java.util.Collections.sort()
通过实现内部compare方法实现对象的比较
示例代码片段如下

1 /**
2 * 使用 Collections.sort(list, Comparator(){});
3 * 对List数组排序 推荐使用方法
4 */
5 public void collectionsSortElement1(List list) {
6 Collections.sort(list, new Comparator() {
7
8 @Override
9 public int compare(String o1, String o2) {
10 // 根据实际排序需要调整compareTo对象顺序
11 return (o2).compareTo(o1);
12 }
13
14 });
15 }

Java实现对List去重
方式一，使用for循环遍历去除List中的重复元素
代码片段如下

1 List tempList = new ArrayList();
2
3 // 去除原始List中的重复元素
4 for (String string : originalList) {
5 if (!tempList.contains(string)) {
6 tempList.add(string);
7 }
8 }

方式二，使用Set去重
代码片段如下

1 // Set 利用Set元素唯一性，去重
2 Set set = new HashSet(originalList);
3 List tempList = new ArrayList(set);

方式三，使用 TreeSet去除重复元素

1 TreeSet treeSet = new TreeSet(originalList);
2
3 ListtempList = new ArrayList();
4 tempList.addAll(treeSet);
5
6 // treeSet 默认的排序为升序，根据实际情况添加是否需要反排序
7 Collections.reverse(tempList);

Java实现对List去重后排序
Junit 测试List去重及排序源码

1 package com.gjnote.test.array;
2
3 import java.util.ArrayList;
4 import java.util.Collections;
5 import java.util.Comparator;
6 import java.util.HashSet;
7 import java.util.List;
8 import java.util.Set;
9 import java.util.TreeSet;
10
11 import org.junit.Before;
12 import org.junit.Test;
13
14 /**
15 * Test Class
16 *
17
18 List 数组去重 元素排序
19
20 *
21 * @since 2015-10-21
22 * @version 1.0
23 * @author www.gjnote.com
24 *
25 */
26 public class TestListArraySort {
27
28 private ListoriginalList = null;
29
30 @Before
31 public void setUp() throws Exception {
32 originalList = new ArrayList();
33 for (int i = 10000; i > 0; i--) {
34 originalList.add("element" + i);
35
36 // add repeat element
37 if(i % 2 == 0) {
38 originalList.add("element" + i);
39 }
40 }
41 }
42
43 /**
44 * 输出List 元素
45 * @param list
46 */
47 private void outputList(List list) {
48 for (int i = 0; i < list.size(); i++) {
49 System.out.println(list.get(i));
50 }
51 }
52
53 /**
54 * 使用 Collections.sort(list, Comparator(){});
55 * 排序 推荐方法
56 */
57 private void collectionsSortElement(List list) {
58 long start = System.currentTimeMillis();
59 Collections.sort(list, new Comparator() {
60
61 @Override
62 public int compare(String o1, String o2) {
63 // 根据实际排序需要调整compareTo对象顺序
64 return o2.compareTo(o1);
65 }
66
67 });
68
69 //outputList(tempList);
70
71 System.out.println("Collections.sort："
72 + (System.currentTimeMillis() - start) + "ms");
73
74 }
75
76 /**
77 * 测试 使用for循环遍历去除重复元素
78 * Collections.sort排序
79 */
80 @Test
81 public void testForLoopRemoveRepeatElement() {
82 System.out.println("testForLoopRemoveRepeatElement");
83 long start = System.currentTimeMillis();
84 List tempList = new ArrayList();
85
86 // 去除重复元素
87 for (String string : originalList) {
88 if (!tempList.contains(string)) {
89 tempList.add(string);
90 }
91 }
92
93 // 排序
94 collectionsSortElement(tempList);
95
96 //outputList(tempList);
97
98 System.out.println("使用for循环遍历List，去除重复元素: "
99 + (System.currentTimeMillis() - start) + "ms");
100 }
101
102 /**
103 * 测试 使用Set去重；
104 * 使用Collections.sort(list, Comparator(){});排序
105 *
106 */
107 @Test
108 public void testSetRemoveRepeatElement() {
109 System.out.println("testSetRemoveRepeatElement");
110 long start = System.currentTimeMillis();
111
112 // 先排序 (理论值：先排序后去重会比后排序效率更高)
113 collectionsSortElement(originalList);
114
115 // Set 利用Set元素唯一性，去重
116 Set set = new HashSet(originalList);
117 List tempList = new ArrayList(set);
118
119 // 后排序 可以注释先排序，开启后排序试试运行时间
120 //collectionsSortElement(tempList);
121
122 //outputList(tempList);
123
124 System.out.println("Collections.sort排序，使用Set去重："
125 + (System.currentTimeMillis() - start) + "ms");
126
127 }
128
129 /**
130 * 测试 使用 TreeSet去除重复元素
131 * 默认排序或Collections.reverse翻转排序
132 */
133 @Test
134 public void testTreeSetRemoveRepeatElement() {
135 System.out.println("testTreeSetRemoveRepeatElement");
136 long start = System.currentTimeMillis();
137
138 TreeSettreeSet = new TreeSet(originalList);
139
140 ListtempList = new ArrayList();
141 tempList.addAll(treeSet);
142
143 // treeSet 默认的排序为升序，根据实际情况添加是否需要反排序
144 Collections.reverse(tempList);