1. package itheima;
   
2. 
   
3. /**
   
4. *
   
5. * 数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
6. *
   
7. * @author sman@mnxnm.com
   
8. *
   
9. */
   
10. public class Test5 {
    
11.         public static void main(String[] args) {
    
12.         // 数组去重复后,元素顺序没有改变,所以不能排序不能用冒泡法
    
13. 
    
14.         int[] a = { 4, 2, 4, 6, 1, 2, 4, 7, 8 };
    
15.         if (a.length > 1) { // 如果元素个数不足2个,直接打印结果
    
16. 
    
17.             // 依次取出元素与并与右面的元素比较
    
18.             for (int i = 0; i < (a.length - 1); i++) {
    
19.                 for (int j = (i + 1); j < a.length;) {
    
20.                     if ( a[i] == a[j]) {
    
21. 
    
22.                         // 去除右面与左面重复的元素,并重新定义数组长度和元素内容
    
23.                        int[] b = new int[a.length - 1];
    
24.                        System.arraycopy(a, 0, b, 0, j);
    
25.                        System.arraycopy(a, j + 1, b, j, b.length - j);
    
26.                        a = b;
    
27.                        
    
28.                     } else {
    
29.                         j++; // 数组重新定以后,下标不变,元素变成新的;当新元素与左面不重复时,才比较下一个元素
    
30.                     }
    
31.                 }
    
32.             }
    
33.         }
    
34.                     //打印新数组
    
35.                    System.out.println(Arrays.toString(a));
    
36.         }
    
37.     }
    
38. }

复制代码

这么做,有没有问题

感觉是没问题      
不过我感觉把数组放到set里面（set的值不会重复）就可以去重了   这样 会简单点   关于set端口怎么用可以在网上搜搜

你的代码中有个小错误    if (a== a[j])

那个a怎么保存之后就变a了     你的代码是对的
                    
              

可能是我能力问题，我看你的代码好吃力，下面是我的实现代码，自我感觉良好，你看看如何。

1. package com.heima;
   
2. 
   
3. import java.util.Arrays;
   
4. 
   
5. /**
   
6. * 5、 数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
7. * @author czm
   
8. *
   
9. */
   
10. public class ClearElemnt {
    
11.         public static void main(String[] args) {
    
12.                 int[] arr = {4,2,4,6,1,2,4,7,8};
    
13.                
    
14.                 //获取数组中元素的重复个数
    
15.                 int repickNum = getRepickNum(arr);
    
16.                
    
17.                 int[] newArr = new int[arr.length-repickNum];
    
18.                
    
19.                 //对新数组进行赋值，如果新元素中没有这个元素则添加进去，如果已经存在，则不添加
    
20.                 copyArr(arr, newArr);
    
21.                
    
22.                 //打印新数组
    
23.                 System.out.println(Arrays.toString(newArr));
    
24.                
    
25.         }
    
26. 
    
27.         private static void copyArr(int[] arr, int[] newArr) {
    
28.                 // TODO Auto-generated method stub
    
29.                 //定义新数组的下标，用于自增
    
30.                 int index = 0;
    
31.                 for (int i = 0; i < arr.length; i++) {
    
32.                         //用于判断新数组中是否已经存在这个元素，默认是不存在的。
    
33.                         boolean flag = false;
    
34.                         for (int j = 0; j < newArr.length; j++) {
    
35.                                 if (arr[i]==newArr[j]) {
    
36.                                         flag = true;
    
37.                                         break;
    
38.                                 }
    
39.                         }
    
40.                         if (!flag) {
    
41.                                 newArr[index] = arr[i];
    
42.                                 index++;
    
43.                         }
    
44.                 }
    
45.         }
    
46. 
    
47.         private static int getRepickNum(int[] arr) {
    
48.                 int repickNum = 0;
    
49.                 //简单的排序算法
    
50.                 for (int i = 0; i < arr.length-1; i++) {
    
51.                         for (int j = i+1; j < arr.length; j++) {
    
52.                                 //如果在比较中，发现有相同的元素则repickNum＋1，继续执行下一次循环。
    
53.                                 if (arr[i]==arr[j]) {
    
54.                                         repickNum++;
    
55.                                         break;
    
56.                                 }
    
57.                         }
    
58.                 }
    
59.                 return repickNum;
    
60.         }
    
61. 
    
62. }
    

复制代码

直接新建一个list集合，对原数组中的元素依次判断，如果不包含则添加，言外之意就是重复元素不会添加进去

1. class Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[]  oldArr =  {1,4,9,4,1,1,7};
   
6.                 int[] newArr = clearRepeat(oldArr);
   
7.                 System.out.println("清除重复元素的数组："+ Arrays.toString(newArr));
   
8.         }
   
9. 
   
10. 
    
11.         public static int[] clearRepeat(int[] oldArr){
    
12.                 int count = 0 ; //count变量 是用于记录重复元素的个数
    
13. 
    
14.                 //计算出重复元素的个数
    
15.                 for(int i  = 0 ; i<oldArr.length -1  ; i++ ){
    
16.                         for(int j = i+1 ; j<oldArr.length ; j++){
    
17.                                 if(oldArr[i]==oldArr[j]){
    
18.                                         count++;
    
19.                                         break;
    
20.                                 }
    
21.                         }
    
22.                 }
    
23.                
    
24.                 //创建一个新的数组
    
25.                 int[] newArr = new int[oldArr.length-count];
    
26.                
    
27.                
    
28.                 int index = 0;        //新数组使用的索引值。
    
29. 
    
30.                 //遍历旧数组
    
31.                 for(int i = 0 ; i<oldArr.length ; i++){
    
32.                         boolean flag = false; //该标识是用于标识取出的元素是否存在新数组中。 false默认情况是不存在 的。
    
33. 
    
34.                         int temp = oldArr[i];        //从旧数组 中取出遍历的元素
    
35.                         //遍历新的数组是否存在该数据
    
36.                         for(int j = 0 ; j<newArr.length ; j++){
    
37.                                 if(newArr[j]==temp){
    
38.                                         flag = true;
    
39.                                         break;
    
40.                                 }       
    
41.                         }
    
42. 
    
43.                         //该元素不存在新数组中，这时候应该存储起来
    
44.                         if(flag==false){
    
45.                                 newArr[index++] = temp;
    
46.                         }
    
47.                 }
    
48. 
    
49.                 return newArr;
    
50.         }
    
51. }
    

复制代码

天涯111 发表于 2015-5-29 11:31
那个a怎么保存之后就变a了     你的代码是对的
                    
              

嗯,是的,我是以纯文字发表的,点击"代码"后,在代码框里提交就好了

视频里面我记得有   是搞了一个方法   该方法传入一个ArrayList  然后在方法里面在建立一个ArrayList   对传入的进行遍历 同时判断 新建的集合中是否包含遍历出来的元素 包含就pass  不包含就添加 最后输出新的集合   这是视频上的去除重复方法  额  受限 数组变集合  最后集合变数组~~~~

天涯111 发表于 2015-5-29 11:14
感觉是没问题      
不过我感觉把数组放到set里面（set的值不会重复）就可以去重了   这样 会简单点   关于 ...

set是乱序的,用set去重后,元素的顺序会发生改变,所以没用set

yogkin 发表于 2015-5-29 15:20
可能是我能力问题，我看你的代码好吃力，下面是我的实现代码，自我感觉良好，你看看如何。

嗯,你的方法不错,
我们两个的思路刚好相反,
我的是逐个剔除重复元素
你的是逐个增加新元素,已经存在的就不添加
:lol

志行 发表于 2015-5-29 17:42
视频里面我记得有   是搞了一个方法   该方法传入一个ArrayList  然后在方法里面在建立一个ArrayList   对 ...

是的,大多数人都是这么做的,引入了list集合,
集合变数组,数组变集合
我这个就是两个for循环,没有引入第三种对象进来

edithe 发表于 2015-5-29 17:25

你和"地板"那一楼的,你们两个一样滴:lol

我用的是集合,因为数组定长不确定重复的有多少个所以感觉还是集合好

我用的集合做的

新人报道，正在努力

真心受教了

人多力量大啊，讨论中学到的东西更多。大家多发表一下个人思路  分享一下。

mnxnm 发表于 2015-5-29 17:42
set是乱序的,用set去重后,元素的顺序会发生改变,所以没用set

哦，大家想的不同   我想的就是简单点   能实现题目要求就行:)