java数组去除重复数据 java 数组去重复

/*
数组去重
1:遍历数组，将元素依次添加进结果集中，如果结果集中已经存在，则不再添加，O(n*n)
2:如果知道元素范围，比如是字母，或者数字在固定范围内，可以采用辅助数组，辅助数组下标是去重数组的元素，辅助数组元素时去重数组元素的个数，O(n)
3:先将原数组排序，在与相邻的进行比较，如果不同则存入新数组
4:利用HashSet集合无序不可重复的特性进行元素过滤
5:TreeSet不仅可以使元素不重复，而且可以实现排序等功能的集合
6:只需要创建一个集合，然后遍历数组逐一放入集合，只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了

*/ 

 import java.util.ArrayList; 

 import java.util.Arrays; 

 import java.util.HashSet; 

 import java.util.Set; 

 import java.util.TreeSet; 



 class Deduplicate  

 { 

//O(n*n) 

public static int[] deduplicate1(int[] array) 

{ 

if (array==null||array.length==0) 

{ 

return null; 

} 

ArrayList<Integer> al=new ArrayList<Integer>(); 

out:for (int i=0; i<array.length; i++) 

{ 

for (int j=0; j<al.size(); j++) 

{ 

if (array[i]==al.get(j)) 

{ 

continue out; 

} 

} 

al.add(array[i]); 

} 



//Integer[] arrayResult =(Integer[])al.toArray(new Integer[al.size()]); 

int[] arrayResult = al.stream().mapToInt(i->i).toArray(); 

/*

既不想用循环，又想要得到int[]，那就只能在jdk8中使用IntStream
这是Java8 的新特性，它都做了什么：
1. 首先从Integer数组中获取一个Stream 流 
2. 将流中的每一个元素拆箱； 
3. 调用toArray将拆箱之后的流转换为数组 

*/ 

return arrayResult; 

} 



//假设元素范围是0-100,既可以去重，又可以排序 

public static int[] deduplicate2(int[] array) 

{ 

if (array==null||array.length==0) 

{ 

return null; 

} 



int[] temp=new int[101]; 



for (int i=0; i<array.length; i++) 

{ 

temp[array[i]]++; 

} 



ArrayList<Integer> al=new ArrayList<Integer>(); 
  

for (int i=0; i<temp.length; i++) 

{ 

if (temp[i]!=0) 

{ 

al.add(i); 

} 

} 



return al.stream().mapToInt(i->i).toArray(); 

} 



//先排序，然后相邻的元素去重 

public static int[] deduplicate3(int[] array) 

{ 

if (array==null||array.length==0) 

{ 

return null; 

} 

 

Arrays.sort(array); 



ArrayList<Integer> al=new ArrayList<Integer>(); 
  

al.add(array[0]); 



for (int i=1; i<array.length; i++) 

{ 

if (array[i]!=array[i-1]) 

{ 

al.add(array[i]); 

} 

} 



return al.stream().mapToInt(i->i).toArray(); 

} 



//HashSet进行去重 

public static int[] deduplicate4(int[] array) 

{ 

if (array==null||array.length==0) 

{ 

return null; 

} 



Set<Integer> set=new HashSet<Integer>(); 

for (int i=0; i<array.length; i++) 

{ 

set.add(array[i]); 

} 



return set.stream().mapToInt(i->i).toArray(); 

} 



//HashSet进行去重和排序 

public static int[] deduplicate5(int[] array) 

{ 

if (array==null||array.length==0) 

{ 

return null; 

} 



Set<Integer> set=new TreeSet<Integer>(); 

for (int i=0; i<array.length; i++) 

{ 

set.add(array[i]); 

} 



return set.stream().mapToInt(i->i).toArray(); 

} 



public static int[] deduplicate6(int[] array) 

{ 

if (array==null||array.length==0) 

{ 

return null; 

} 

ArrayList<Integer> al=new ArrayList<Integer>(); 



for (int i=0; i<array.length; i++) 

{ 

if (!al.contains(array[i])) 

{ 

al.add(array[i]); 

} 

} 



return al.stream().mapToInt(i->i).toArray(); 

} 



public static void main(String[] args)  

{ 

int[] array={1,4,3,2,5,3,6,100,2}; 

System.out.println(Arrays.toString(deduplicate6(array))); 

} 

 }