几种去重算法的实现

第一种：

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);
	}
 }
}