/*
数组去重
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)));
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
