第一种:
package Demo1;
import java.util.TreeSet;
//实现功能:去重
/* 利用Set接口的实现类,实现类不能添加重复元素的特性,
同时TreeSet实现类中添加元素是按照顺序排列的特点解决查重和排序问题
*
* 使用Set接口中三个实现类无法存入相同的元素特性,
* 和TreeSet存储顺序为升序存储引用的特性来实现排序
* sortArray 待排序数组
*/
public class Demo1 {
public static void main(String[] args) {
int[] sortArray ={2,1,3,4,4,2,7,5,8,9};
treeSetSort(sortArray);
}
public static void treeSetSort(int[] sortArray){
if(sortArray.length==0){ //待排序数组的判空
int[] len ={0};
System.out.println(len);
}
TreeSet<Integer> myTreeSet = new TreeSet<Integer>();
for(int i=0;i<sortArray.length;i++){ //如果非空,就可进行排序
myTreeSet.add(sortArray[i]); //将待排序的数组添加到TreeSet中
}
int[] desArray = new int[myTreeSet.size()]; //定义一个新数组,长度和myTreeSet一样
int count =0; //计数
for(Integer xInteger:myTreeSet){ //增强for循环进行遍历
desArray[count++]=xInteger;
System.out.println(xInteger); //得到的myTreeSet是去重和排序好的数组
}
}
}
第二种:
package Demo2;
import java.util.HashSet;
import java.util.Set;
/*
* 该方法根据集合类中的set接口,使用HashSet的实现类的特性来完成,即重复元素无法加到集合中。
* 程序的时间复杂度为n,空间复杂度为HashSet占用的空间
* 输出结果可以实现去重,但会出现乱序排列
*/
public class Demo2 {
public static void main(String[] args) {
int[] nums ={2,1,3,4,4,2,7,5,8,9}; //待排序数组
hashSetReduce(nums);
}
public static void hashSetReduce(int[]nums){
if(nums.length==0){ //判空
int[] len={0};
System.out.println(len);
}
Set<Integer> mySet = new HashSet<Integer>(); //新建HashSet
int pos = 0;
for(int i=0;i<nums.length;i++){
if(mySet.add(nums[i])){
//将nums装入到mySet中,此时可完成去重,但顺序在输出的时候会出现乱序
nums[pos] =nums[i];
pos++;
}
}
int[] desArray = new int[pos]; //新建desArray数组
for(int i=0;i<desArray.length;i++){
desArray[i]=nums[i];
System.out.println(desArray[i]); //输出结果是乱序的
}
}
}
第三种:
package Demo3;
import java.util.Arrays;
/*
* 使用Array类中的sort方法实现排序,然后用后面的值与前面的一个比较,不相同则加入到新数组中。
* 注意:该方法返回的是一个有序的数组
*/
public class Demo3 {
public static void main(String[] args) {
int[] sourArray={2,1,3,4,4,2,7,5,8,9}; //待排序数组
sortToReduce(sourArray);
}
public static void sortToReduce(int[] sourArray) {
if(sourArray.length==0){
int[] len ={0};
System.out.println(len);
}
Arrays.sort(sourArray);
int index = 1;
for(int i=1;i<sourArray.length;i++){
if(sourArray[i]!=sourArray[i-1]){
sourArray[index] = sourArray[i];
index++;
}
}
int[] desArray = new int[index];
for (int i = 0; i < desArray.length; i++) {
desArray[i] =sourArray[i];
System.out.println(desArray[i]);
}
}
}
第四种:
package Demo4;
/*
* 采用break关键字中断跳出本层循环,
* 即有多层嵌套循环那么只跳出这一层循环,并不是跳出所有的循环
* 该方法使用插入排序的思想来处理
* int[] sourArray={2,1,3,4,4,2,7,5,8,9}; //待去重数组
*/
public class Demo4 {
public static void main(String[] args) {
int[] sourArray={2,1,3,4,4,2,7,4,4,5,8,9}; //待去重数组
insertSort(sourArray);
}
public static void insertSort(int[] sourArray) {
if(sourArray.length==0){ //判空
int[] len ={0};
System.out.println(len);
}
int index = 1; //索引角标的值设置为1
for(int i=1;i<sourArray.length;i++){ //注意思想:一个在前,一个在后,就可以实现排序
int j=0;
for(;j<index;j++){
//由于排序是总是要将后面的元素与前面所有不重复的进行比较,所以必须进行这样的过程,虽然增加,但j却总是
//从0开始的,因为判重需要逐一比较。
if(sourArray[j]==sourArray[i]){
break;
//break只会爆破当前的循环,假如当前循环为内层循环,那么值跳出当前的这层内循环
}
}
if(index==j){ //如果index等于j时,说明比较的值不重复,因此就需要进行赋值
sourArray[index]=sourArray[i];
index++;
}
}
//将索引赋值给新数组,从而可以进行遍历,从而得到去重的数组
int[] desArray = new int[index];
for(int k=0;k<desArray.length;k++){
desArray[k] = sourArray[k];
System.out.println(desArray[k]);
}
}
}
第五种:
package Demo5;
/*
* 新建一个相同大小的数组,然后依次从老数组中拿出元素与新数组中元素比较,
* 如果不相同则不处理,如果相同则立刻用break中断该层的循环函数
* 时间复杂度O(n*n)
*/
public class Demo5 {
public static void main(String[] args) {
int[] sourArray={2,1,3,4,4,2,7,5,8,9}; //待去重数组
doubleReduce(sourArray);
}
public static void doubleReduce(int[] sourArray) {
if(sourArray.length==0){
int[] len={0};
System.out.println(len);
}
int[] newArray = new int[sourArray.length];
newArray[0]=sourArray[0];
int index =1;
for(int i=1;i<newArray.length;i++){
int j=0;
for(;j<index;j++){
if(newArray[j]==sourArray[i]){
break;
}
}
if(j==index){
newArray[index]=sourArray[i];
index++;
}
}
int[] desArray = new int[index];
for(int i=0;i<desArray.length;i++){
desArray[i]=newArray[i];
System.out.println(desArray[i]);
}
}
}
第六种:
package Demo6;
import java.util.ArrayList;
public class Demo6 {
public static void main(String[] args) {
int[] sourArray={2,1,3,4,4,2,7,5,8,9}; //待去重数组
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < sourArray.length; i++) {
list.add(sourArray[i]);
}
sortedarray(list);
}
public static void sortedarray(ArrayList<Integer> list) {
for(int i=0;i<list.size();i++){
for(int j=i+1;j<list.size();j++){
if(list.get(i)==list.get(j)){
list.remove(j);
j--;
}
}
}
for(int i:list){
System.out.println(i);
}
}
}