Java实现的数组去重与排序操作详解

本文实例讲述了Java实现的数组去重与排序操作。分享给大家供大家参考,具体如下:

这里演示Java实现数组去重、排序操作

文中的示例源码编写基于Jdk1.6+、junit4.8.2

java.util.Arrays.sort()

支持对int[],long[],short[],char[],byte[],float[],double[],Object[]进行排序

参考示例代码片段如下

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

Junit 测试类源码:

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

控制台输出

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方法实现对象的比较

示例代码片段如下

/**
* 使用 Collections.sort(list, Comparator(){});
* 对List数组排序 推荐使用方法
*/
public void collectionsSortElement1(List list) {
Collections.sort(list, new Comparator() {
@Override
public int compare(String o1, String o2) {
// 根据实际排序需要调整compareTo对象顺序
return (o2).compareTo(o1);
}
});
}

Java实现对List去重

方式一,使用for循环遍历去除List中的重复元素

代码片段如下

List tempList = new ArrayList();
// 去除原始List中的重复元素
for (String string : originalList) {
if (!tempList.contains(string)) {
tempList.add(string);
}
}

方式二,使用Set去重

代码片段如下

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

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

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

Java实现对List去重后排序

Junit 测试List去重及排序源码

package com.gjnote.test.array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import org.junit.Before;
import org.junit.Test;
/**
* Test Class
*
List 数组去重 元素排序
*
* @version 1.0
* @author www.gjnote.com
*
*/
public class TestListArraySort {
private ListoriginalList = null;
@Before
public void setUp() throws Exception {
originalList = new ArrayList();
for (int i = 10000; i > 0; i--) {
originalList.add("element" + i);
// add repeat element
if(i % 2 == 0) {
originalList.add("element" + i);
}
}
}
/**
* 输出List 元素
* @param list
*/
private void outputList(List list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
/**
* 使用 Collections.sort(list, Comparator(){});
* 排序 推荐方法
*/
private void collectionsSortElement(List list) {
long start = System.currentTimeMillis();
Collections.sort(list, new Comparator() {
@Override
public int compare(String o1, String o2) {
// 根据实际排序需要调整compareTo对象顺序
return o2.compareTo(o1);
}
});
//outputList(tempList);
System.out.println("Collections.sort:"
+ (System.currentTimeMillis() - start) + "ms");
}
/**
* 测试 使用for循环遍历去除重复元素
* Collections.sort排序
*/
@Test
public void testForLoopRemoveRepeatElement() {
System.out.println("testForLoopRemoveRepeatElement");
long start = System.currentTimeMillis();
List tempList = new ArrayList();
// 去除重复元素
for (String string : originalList) {
if (!tempList.contains(string)) {
tempList.add(string);
}
}
// 排序
collectionsSortElement(tempList);
//outputList(tempList);
System.out.println("使用for循环遍历List,去除重复元素: "
+ (System.currentTimeMillis() - start) + "ms");
}
/**
* 测试 使用Set去重;
* 使用Collections.sort(list, Comparator(){});排序
*
*/
@Test
public void testSetRemoveRepeatElement() {
System.out.println("testSetRemoveRepeatElement");
long start = System.currentTimeMillis();
// 先排序 (理论值:先排序后去重会比后排序效率更高)
collectionsSortElement(originalList);
// Set 利用Set元素唯一性,去重
Set set = new HashSet(originalList);
List tempList = new ArrayList(set);
// 后排序 可以注释先排序,开启后排序试试运行时间
//collectionsSortElement(tempList);
//outputList(tempList);
System.out.println("Collections.sort排序,使用Set去重:"
+ (System.currentTimeMillis() - start) + "ms");
}
/**
* 测试 使用 TreeSet去除重复元素
* 默认排序或Collections.reverse翻转排序
*/
@Test
public void testTreeSetRemoveRepeatElement() {
System.out.println("testTreeSetRemoveRepeatElement");
long start = System.currentTimeMillis();
TreeSettreeSet = new TreeSet(originalList);
ListtempList = new ArrayList();
tempList.addAll(treeSet);
// treeSet 默认的排序为升序,根据实际情况添加是否需要反排序
Collections.reverse(tempList);
//outputList(tempList);
System.out.println("使用 TreeSet排序,去除重复元素:"
+ (System.currentTimeMillis() - start) + "ms");
}
@Test
public void testMethods() {
//outputList(originalList);
// List 去重 推荐方法
testSetRemoveRepeatElement();// 14ms
testTreeSetRemoveRepeatElement();// 20ms
//testForLoopRemoveRepeatElement();// 2525ms
}
}

运行testSetRemoveRepeatElement()控制台输出结果

testSetRemoveRepeatElement
Collections.sort:8ms
Collections.sort排序,使用Set去重:14ms

运行testTreeSetRemoveRepeatElement()控制台输出结果

testTreeSetRemoveRepeatElement
使用 TreeSet排序,去除重复元素:20ms

运行testForLoopRemoveRepeatElement()控制台输出结果

testForLoopRemoveRepeatElement
Collections.sort:7ms
使用for循环遍历List,去除重复元素: 2525ms

PS:这里再为大家提供几款相关工具供大家参考使用:

在线去除重复项工具:
http://tools.jb51.net/code/quchong

在线文本去重复工具:
http://tools.jb51.net/aideddesign/txt_quchong

在线动画演示插入/选择/冒泡/归并/希尔/快速排序算法过程工具:
http://tools.jb51.net/aideddesign/paixu_ys

更多关于java算法相关内容感兴趣的读者可查看本站专题:《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。

(0)

相关推荐

  • java正则表达式实现提取需要的字符并放入数组【ArrayList数组去重复功能】

    本文实例讲述了java正则表达式实现提取需要的字符并放入数组.分享给大家供大家参考,具体如下: 这里演示Java正则表达式提取需要的字符并放入数组,即ArrayList数组去重复功能. 具体代码如下: package com.test.tool; import java.util.ArrayList; import java.util.HashSet; import java.util.regex.*; public class MatchTest { public static void ma

  • java数组排序示例(冒泡排序、快速排序、希尔排序、选择排序)

    快速排序法主要是运用了Arrays中的一个方法Arrays.sort()实现. 冒泡法是运用遍历数组进行比较,通过不断的比较将最小值或者最大值一个一个的遍历出来. 选择排序法是将数组的第一个数据作为最大或者最小的值,然后通过比较循环,输出有序的数组. 插入排序是选择一个数组中的数据,通过不断的插入比较最后进行排序. 复制代码 代码如下: package com.firewolf.sort; public class MySort { /**  * @param args  */ public s

  • java排序去重示例分享

    复制代码 代码如下: package action;import java.util.Arrays;import java.util.TreeSet;public class test { /**  * @param args  */ public static void main(String[] args) {  String strs = "ZZZ BBB AAA OOO ZZZ AAA ZZZ BBB AAA ZZZ AAA VVV OOO CCC DDD CCC CCC KKK BBB

  • Java中的数组排序方式(快速排序、冒泡排序、选择排序)

    1.使用JavaApi文档中的Arrays类中的sort()进行快速排序 复制代码 代码如下: import java.util.Arrays; public class TestOne{ public static void main(String [] args){ int [] array={2,0,1,4,5,8}; Arrays.sort(array);//调用Arrays的静态方法Sort进行排序,升序排列 for(int show:array){ System.out.printl

  • Java编程实现中英混合字符串数组按首字母排序的方法

    本文实例讲述了Java编程实现中英混合字符串数组按首字母排序的方法.分享给大家供大家参考,具体如下: 在Java中对于字符串数组的排序,我们可以使用Arrays.sort(String[])方法很便捷的进行排序.例如: String[] arrays = new String[] { "gyu", "sdf", "zf", "大同", "收到", "地方", "三等分"

  • java利用冒泡排序对数组进行排序

    本文实例讲述了java利用冒泡排序对数组进行排序的方法.分享给大家供大家参考.具体如下: 一.冒泡排序: 利用冒泡排序对数组进行排序 二.基本概念: 依次比较相邻的两个数,将小数放在前面,大数放在后面.即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后.然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后.至此第一趟结束,将最大的数放到了最后.在第二趟:仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数

  • java中List对象列表实现去重或取出及排序的方法

    前言 因为在面试的时候碰到几次list的去重和排序,觉着有必要给大家总结一下具体的方法,分享出来供大家学习参考,话不多说了,来一起看看下面介绍的一种做法: 一.list去重 1.1 实体类Student List<Student>容量10k以上,要求去重复.这里Student的重复标准是属性相同,因此需要重写equals和hashcode方法,不知道有几个可以手写出来. student的equals方法: public void equals(Object o){ if(this == o)

  • java去除已排序数组中的重复元素

    题目描述 给定一个已排序的数组,去除数组中的重复元素,只保留一个重复的元素,并且返回新的数组长度. 要求: 不要给数组分配额外的空间,你必须使用常量的内存大小进行原地操作. 例如: 给出数组A=[1,1,2],你的函数调用之后必须返回长度length=2,并且A现在变成[1,2]. 输入 一个已排序的数组,例如[1,1,2]. 输出 返回数组新的长度,例如length=2. 快慢指针法 设置fast指针遍历数组,slow指针指向不重复元素的下一位. public static int remov

  • Java使用选择排序法对数组排序实现代码

    编写程序,实现将输入的字符串转换为一维数组,并使用选择排序法对数组进行排序. 思路如下: 点击"生成随机数"按钮,创建Random随机数对象:使用JTextArea的setText()方法清空文本域:创建一个整型一维数组,分配长度为10的空间:初始化数组元素,使用Random类的nextInt()方法生成50以内的随机数,使用JTextArea类的append()方法把数组元素显示在文本域控件中:点击"排序"按钮,使用JTextArea类的setText()方法清空

  • Java中集合和数组的排序方式小结

    根据约定,在使用java编程的时候应尽可能的使用现有的类库,当然你也可以自己编写一个排序的方法,或者框架,但是有几个人能写得比JDK里的还要好呢?使用现有的类的另一个好处是代码易于阅读和维护,这篇文章主要讲的是如何使用现有的类库对数组和各种Collection容器进行排序,(文章中的一 部分例子来自<Java Developers Almanac 1.4>) 首先要知道两个类:java.util.Arrays和java.util.Collections(注意和Collection的区 别)Co

随机推荐