数组去重
例如:
原始数组是{4,2,4,6,1,2,4,7,8}
得到结果{4,2,6,1,7,8}

    //去除数组中重复的记录  
    public static String[] array_unique(String[] a) {         
        List<String> list = new LinkedList<String>();  
        for(int i = 0; i < a.length; i++) {  
            if(!list.contains(a[i])) {  
                list.add(a[i]);  
            }  
        }  
        return (String[])list.toArray(new String[list.size()]);  
    }  

完整代码：

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class Diary2 {
   
7. 
   
8.         /**
   
9.          * @author M.change(http://wanyan1991.blog.163.com/我的博客  请关注   嘿嘿（云行水边））
   
10.          * @param args
    
11.          */
    
12.         public static void main(String[] args) {
    
13. 
    
14.                 int [] data = {4,2,4,6,1,2,4,7,8};  
    
15.         for (int elementA:data ) {  
    
16.             System.out.print(elementA + " ");  
    
17.         }  
    
18.         List list = new ArrayList();  
    
19.         for (int i=0; i<data.length; i++) {  
    
20.             if(!list.contains(data[i])) {  
    
21.                 list.add(data[i]);  
    
22.             }  
    
23.         }
    
24.                 System.out.println();  
    
25.                 //list.toArray();
    
26.                 for (Object elementB:list.toArray() ) {  
    
27.            System.out.print(elementB + " ");  
    
28.         }  
    
29.         System.out.println();
    
30.         }
    
31. 
    
32. }

复制代码

结果

1. 4 2 4 6 1 2 4 7 8
   
2. 4 2 6 1 7 8
   

复制代码

解题思路是：
定义两个数组，一个装原数组，一个装重组后的数组，后边这个数组都默认为0
然后两个for循环，把数组中出现的数赋给第二个数组，然后输出第二个数组就行了

他们的都是使用集合，集合的比较简单了。我写了一个数组版的，你可以参阅下：

1. package itheima.test;
   
2. /*数组去重！数组版！
   
3. *
   
4. * 原始数组是{4,2,4,6,1,2,4,7,8}
   
5. 得到结果{4,2,6,1,7,8}*/
   
6. public class ArrayToHeavy {
   
7.         public static void main(String[] args){
   
8.                 int[] oldarray = new int[]{4,2,4,6,1,2,4,7,8};
   
9.                 int[] newarray = new int[oldarray.length];
   
10.                 System.out.println("旧数组：{4,2,4,6,1,2,4,7,8}");
    
11.                 int index = 0;boolean flag = true;
    
12.                 for(int i=0;i<oldarray.length;i++){
    
13.                         for(int j=0;j<index+1;j++){
    
14.                                 if(oldarray[i]==newarray[j]){
    
15.                                         flag = false;
    
16.                                 }
    
17.                         }if(flag){
    
18.                                 newarray[index]=oldarray[i];
    
19.                                 index++;
    
20.                         }flag=true;
    
21.                 }
    
22.                 System.out.print("新数组：{");               
    
23.                 for(int i=0;i<index;i++){
    
24.                         System.out.print(newarray[i]+",");
    
25.                 }System.out.print("}");
    
26.         }
    
27. }
    

复制代码

来学习。。。。。。。。。

这个很简单的，使用集合判断即可。

代码如下（为了结果好看，里面有很多废话）：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class JiShuFen15 {
/**
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  
  int[] arr={4,2,4,6,1,2,4,7,8};
  System.out.print("原数组："+"\r\n"+"{");
  for(int i=0;i<arr.length;i++){
   if(i==arr.length-1){
    System.out.print(arr[i]);
   }
   else{   
    System.out.print(arr[i]+",");
   }
  }
  System.out.print("}");
  
  
  List l=new ArrayList();
  for(int j=0;j<arr.length;j++){
   if(!l.contains(arr[j])){
    l.add(arr[j]);
   }
  }
  
  System.out.println("\r\n"+"去重之后的数组:");  
  Object[] obj=l.toArray();
  System.out.print("{");
  for(int n=0;n<obj.length;n++){
   if(n==obj.length-1){
    System.out.print(obj[n]);
   }
   else{
    System.out.print(obj[n]+",");
   }
  }
  System.out.print("}");
}
}

1. import java.util.ArrayList;
   
2. import java.util.Arrays;
   
3. import java.util.List;
   
4. 
   
5. public class newArr {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                
   
9.                 Object[] arr={4,2,4,6,1,2,4,7,8};
   
10.                 List<Object> al=Arrays.asList(arr);
    
11.                 getSimply(al);
    
12.                
    
13.                
    
14.                
    
15.                
    
16. 
    
17.         }
    
18.         public static<T> void getSimply(List<T> al)
    
19.         {
    
20.                 List<T> list=new ArrayList<T>();//定义一个新的数组
    
21.                 for(T t:al)
    
22.                 {
    
23.                         if(!list.contains(t))//判断新的集合中是否已经有了该元素
    
24.                                 list.add(t);//有就加
    
25.                 }
    
26.                 Object[] arr=list.toArray();//这步可要可不要，也可以直接迭代集合
    
27.                 for(int x=0;x<arr.length;x++)
    
28.                 {
    
29.                         System.out.println(arr[x]);
    
30.                 }
    
31.                
    
32.                
    
33.         }
    
34. }

复制代码