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

我这个写的不好。你参考一下吧

1. 
   
2. import java.util.*;
   
3. 
   
4. public class Test1 {
   
5.         public static void main(String[] args) {
   
6.                 // 原数组
   
7.                 int[] arr = { 4,2,4,6,1,2,4,7,8 };
   
8.                 // 定义一个list集合
   
9.                 List al = new ArrayList();
   
10.                 // 对数组进行遍历
    
11.                 for (Integer a : arr) {
    
12.                         // 添加到list集合中
    
13.                         al.add(a);
    
14.                 }
    
15.                 // 打印没有去重的list集合
    
16.                 sop("al=" + al);
    
17.                 // 打印去重后的list集合
    
18.                 List list = quchong(al);
    
19.                 sop("newAl=" + list);
    
20.                 // 对list集合进行迭代
    
21.                 Iterator it = list.iterator();
    
22.                 System.out.print("去重后的数组=" + "{");
    
23.                 for (int i = 0; i < list.size(); i++) {
    
24.                         if (i != list.size() - 1)
    
25.                                 System.out.print(it.next() + ",");
    
26.                         else
    
27.                                 System.out.println(it.next() + "}");
    
28.                 }
    
29.         }
    
30. 
    
31.         public static List quchong(List al) {
    
32.                 // 定义一个临时的list集合，存储去重后的list集合
    
33.                 List newAl = new ArrayList();
    
34.                 // 迭代
    
35.                 Iterator it = al.iterator();
    
36.                 while (it.hasNext()) {
    
37.                         Object obj = it.next();
    
38.                         if (!newAl.contains(obj))
    
39.                                 newAl.add(obj);
    
40.                 }
    
41.                 return newAl;
    
42.         }
    
43. 
    
44.         public static void sop(Object obj) {
    
45.                 System.out.println(obj);
    
46.         }
    
47. }
    

复制代码

我会告诉你我基础测试也有这题吗？

1. package com.itheima;
   
2. 
   
3. public class Test5 {
   
4. 
   
5.         /**
   
6.          * 5、 数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
7.          * @author QWY
   
8.          */
   
9.         /*
   
10.                  思路：
    
11.                          定义一个新的数组，每添加一个元素前先判断是否存在
    
12.          */
    
13.         public static void main(String[] args) {
    
14.                 // 定义两个整型数组，src为原数组，res为消去重复后的数组
    
15.                 int[] src = {4,2,4,6,1,2,4,7,8}, res;
    
16.                 // len为原数组的长度，count为消去重复后的数组的长度
    
17.                 int len = src.length, i = 0, j = 0, count = 1;
    
18.                 res = new int[len];
    
19.                 // 将原数组第一个元素放到res中
    
20.                 res[0] = src[0];
    
21.                 for(i = 1;i < len;i++){
    
22.                         // 定义一个标志，用来判断当前元素是否已存在
    
23.                         boolean flag = true;
    
24.                         for(j = 0;j < count;j++){
    
25.                                 // 若当前元素存在则置flag为false并跳出本次循环
    
26.                                 if(src[i] == src[j]){
    
27.                                         flag = false;
    
28.                                         break;
    
29.                                 }
    
30.                         }
    
31.                         // 如果当前元素不存在则加入到res中
    
32.                         if(flag)
    
33.                                 res[count++] = src[i];
    
34.                 }
    
35.                 // 打印出消除重复元素后的数组
    
36.                 for(i = 0;i < count;i++)
    
37.                         System.out.print(" "+res[i]);
    
38.         }
    
39. 
    
40. }
    

复制代码

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class Test1 {
        public static void main(String[] args) {
                /**
                 * 5、 数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
                 *
                 * @author QWY
                 */
                int[] arr = { 4, 2, 4, 6, 1, 2, 4, 7, 8 };
                List<Integer> list = new ArrayList<Integer>();
                for (int i : arr) {
                        list.add(i);
                }
                Set<Integer> set = new LinkedHashSet<Integer>(list);
                int[] sort = new int[set.size()];
                int j = 0;
                for (int i : set) {
                        sort[j] = i;
                        j++;
                }
                for (int y = 0; y < sort.length; y++) {
                        if (y == 0)
                                sop("{" + sort[y] + ",");
                        else if (y == sort.length - 1)
                                sop(sort[y] + "}");
                        else
                                sop(sort[y] + ",");
                }
        }

        public static void sop(Object o) {
                System.out.print(o);
        }
}
我是这样解决的 利用list集合可存在重复元素 set集合不允许存在重复元素 用list跟set集合间的转换来排除重复元素

毅心缘 发表于 2014-7-6 22:15
我这个写的不好。你参考一下吧

太感谢了  辛苦了     

1. public class quchong {
   
2.         public static void main(String[] args) {
   
3.                 int arr[]={4,2,4,6,1,2,4,7,8};
   
4.                 Set set =new HashSet();
   
5.                 for(int i=0;i<arr.length;i++){
   
6.                         if(!set.contains(arr[i])){
   
7.                                 set.add(arr[i]);
   
8.                         }
   
9.                 }
   
10.                 System.out.println(set);
    
11.         }
    
12. }

复制代码

打印结果：[1, 2, 4, 6, 7, 8]