比如数组里有{1，2，3，4，5，6，3，4，5，6}  怎样才能得出{1，2，3，4，5，6}  希望大神们能提供思路以及用什么样的方法更快捷 占用资源更少？

放进LinkedHashSet里面，再拿出来，哈哈，简单吧

根据你的需求，我用数组的知识写了个代码，思路和注释都在里面（ps：可能有些低效，求优化），楼主可参考一下，希望能有所帮助！

1. /*
   
2. 需求：去除数组中的重复元素，
   
3.           比如数组里有{1，2，3，4，5，6，3，4，5，6}  怎样才能得出{1，2，3，4，5，6}
   
4. 
   
5. 思路：1，定义一个新数组，用于接收老数组中取出的元素
   
6.           2，遍历老数组，并取出其中元素，存入新数组
   
7.           3，在存入之前，先和新数组中的已有元素比较一下
   
8.           4，如果新数组中已有此元素，则不存入，继续取一个元素
   
9.           5，最后返回新数组，即是去除了重复元素的数组。
   
10. */
    
11. 
    
12. class TestArr
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 int [] arr = {1,2,3,4,5,6,3,4,5,6};
    
17. 
    
18.                 arr = quChongFu(arr);
    
19. 
    
20.                 for (int x=0;x<arr.length ;x++ )//遍历数组，打印看结果
    
21.                 {
    
22.                         System.out.println(arr[x]);
    
23.                 }
    
24.         }
    
25.         public static int[] quChongFu(int[] arr)
    
26.         {
    
27.                 int [] tempArr = new int[arr.length];//定义一个新数组，长度为老数组的长度
    
28.                 int count=0;//定义一个变量自增，用于作为新数组的角标
    
29. 
    
30.                 st:for (int x=0;x<arr.length ;x++ )//遍历老数组，并给for循环标号
    
31.                 {
    
32.                         for (int y=0;y<x ;y++ )//遍历0——x之间角标的数，用于和x角标的数做比较
    
33.                         {
    
34.                                 if (arr[x]==arr[y])//如果x角标之前的数，有和x角标的数重复的，则跳过存入语句，继续取出下一元素
    
35.                                         continue st;
    
36.                         }
    
37.                         tempArr[count++]=arr[x];//否则的话就把此数存入新数组
    
38.                 }
    
39. 
    
40.                 int[] tempArr2 = new int[count];//再定义一个临时数组，用于存储长度刚刚好的去除重复元素的数组
    
41.                 for (int x=0;x<count ;x++ )
    
42.                 {
    
43.                         tempArr2[x]=tempArr[x];
    
44.                 }
    
45. 
    
46.                 return tempArr2;//返回的即是去除重复元素的数组
    
47.         }
    
48. 
    
49. }
    

复制代码

我这是些的简便方法，直接用java中ArrayList类中的 contain方法，至于你说的效率问题，我也不知道contain方法底层的算法是怎么去完成判断的，你有时间可以去看看。

1. public static void moveSame(int[] arr){
   
2.                 int[] newarr = null;
   
3.                 ArrayList list = new ArrayList();
   
4.                 for(int i : arr){
   
5.                         if(!list.contains(i)){
   
6.                                 list.add(i);
   
7.                         }
   
8.                 }
   
9.         }
   
10.         /**

复制代码

yanghu 发表于 2014-6-7 16:52
我这是些的简便方法，直接用java中ArrayList类中的 contain方法，至于你说的效率问题，我也不知道contain方 ...

厉害这个方法就是ArraList没有包含这个数就加进去    我怎么给忘了:L    谢谢哈

用set最简单

import java.util.Arrays;
public class DeleteElem {
        /*
         * 思想： 首先将数组排序 创建一个新数组用于存放不重复的元素。
         * 由于新数组中的每一个元素都是不重复的，取出新数组中角标最大的元素和原数组中的当前角标的右边元素比较，如果相等则重复不存储，反之则存储
         */
        public static void main(String[] args) {
                int[] arr = new int[] { 1, 1, 2, 3, 4, 5, 6, 3, 4, 5, 6, 6, 7 };
                System.out.println(Arrays.toString(DeleteDuplicate(arr)));
        }

        private static int[] DeleteDuplicate(int[] arr) {
                 // 如果重复元素过多浪费存储空间，可以使用集合容器
                int[] newArr = new int[arr.length];
                // 先将数组排序
                Arrays.sort(arr);
                // 打印之前的数组
                System.out.println(Arrays.toString(arr));
                // 控制新数组角标
                int newArrIndex = 0;
                // 讲数组的第一个值给新数组，数组中的值依次和右边的元素相比较，若不想等则不存
                newArr[newArrIndex] = arr[0];
                for (int x = 1; x < arr.length; x++) {
                        if (newArr[newArrIndex] != arr[x]) {
                                // 如果新数组中的当前元素和数组中角标为X的元素不相等则表示新数组的当前元素没有重复，此时新数组角标加1，准备存放下一个元素
                                newArrIndex++;
                                newArr[newArrIndex] = arr[x];
                        }
                }
                return newArr;
        }
}

我认为用集合最简单，最快捷:

public static void main(String[] args) {

         int[] Nums = {1，2，3，4，5，6，3，4，5，6};
         Integer [] aa =  getDistinct(Nums);
         
         for(int i : aa){
          System.out.println(i);
         }
     }

     static Integer[] getDistinct(int num[]) {
         List<Integer> list = new java.util.ArrayList<Integer>();
         for (int i = 0; i < num.length; i++) {
             if (!list.contains(num[i])) {//如果list数组不包括num[i]中的值的话，就返回true。
                 list.add(num[i]); //在list数组中加入num[i]的值。已经过滤过。
             }
         }
         return list.toArray(new Integer[0]);  
/*toArray（数组）方法返回数组。并要指定Integer类型。
new integer[o]的空间大小不用考虑。
因为如果list中的长度大于0（你integer的长度），
toArray方法会分配一个具有指定数组的运行时类型和此列表大小的新数组。*/
     }

基础测试题，我当时还没学集合，那时候刚开始学Java才接触，因为以前学c语言所以一开始思路和一楼是一样的，但是想了很久希望找一种可以避免重新开辟一个数组空间的方法始终没想出来最后也是用一楼的方法提交了

想飞的鱼 发表于 2014-6-7 15:25
根据你的需求，我用数组的知识写了个代码，思路和注释都在里面（ps：可能有些低效，求优化），楼主可参考一 ...

挺好  使用了 标记这个知识点  ，如果是在实践当中可以使用集合效率更快

看着好复杂啊？是不是我太笨了，搞不明白呢！

数组转换集合，在便利判断存入新集合，再转成数组

http://bbs.itheima.com/forum.php?mod=viewthread&tid=155357

非常给力，谢谢！

赶紧来学学。。

想飞的鱼 发表于 2014-6-7 15:25
根据你的需求，我用数组的知识写了个代码，思路和注释都在里面（ps：可能有些低效，求优化），楼主可参考一 ...

这种思想很牛逼，喜欢。