怎么把数组中重复的元素去掉，打印剩下的元素。

这个问题看到很多遍了，思路就是把数组的元素一个一个取出来存到另一个数组里。只要在存的时候判断是否存在即可！

使用set集合！！！

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.HashSet;
   
5. 
   
6. /*
   
7. * 第七题：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
8. */
   
9. public class Test7 {
   
10.         public static void main(String[] args) {
    
11.                 // 原始数组
    
12.                 int[] array = new int[] { 4, 2, 4, 6, 1, 2, 4, 7, 8 };
    
13.                
    
14.                
    
15.                 HashSet<Integer> set = new HashSet<>(); // 保存出现过的原素
    
16.                 ArrayList<Integer> result = new ArrayList<>(); // 保存去重后的结果
    
17. 
    
18.                 for (int i = 0; i < array.length; ++i) {
    
19.                         // 如果array[i]没有出现过，就添加到set并保存到结果中
    
20.                         if (!set.contains(array[i])) {
    
21.                                 result.add(array[i]);
    
22.                                 set.add(array[i]);
    
23.                         }
    
24.                 }
    
25.                
    
26.                 // 打印结果
    
27.                 System.out.println(result);
    
28. 
    
29.         }
    
30. }
    

复制代码

YC匪帮 发表于 2015-9-19 10:29
使用set集合！！！

还没看到这一块，有基础的点方法吗？

orgcheng 发表于 2015-9-19 10:34

我才看到面向对象这一块，有没有比你这低级一点的方法。。。。。。

我也刚看，java不知道有没有去重方法啊

    如果还没学到集合的话可以使用另外一个数组，然后将原数组的中的元素存过去，在每一次存的过程中，都与新数组里面的每一个元素进行比较，如果不相同就存进去。但是长度不好确定。
    StringBuilder如果学到了的话也可以使用StringBuilder，然后使用indexOf 的方法，如果返回-1就存进去，但每存一次都要再存一个,(逗号)，到最后一个就不用存逗号了，接着使用toString方法返回里面的内容字符串，利用String类里面的split方法返回一个String类型的数组，接着就看需求了，如果是int型就用Integer.parseInt()再转呗。
     但这些都不太好用，还是集合好用一些。使用LinkedHashSet，会自动过滤掉相同元素，并且会按存入顺序返回。

pengwei1989 发表于 2015-9-19 11:30
我才看到面向对象这一块，有没有比你这低级一点的方法。。。。。。

如果让你去打仗，AK47和小米加步枪你会选择那种武器？
当然是AK47，不会用就学呗，不学啥时候都不会用。

Java提供集合类库，就是为了方便实现编码的。

set存储的元素是不重复的 直接放到set里就行了
import java.util.HashSet;


public class quChong {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                int[] a = {3,4,6,7,8,8,2,3,4};
                HashSet<Integer> hs = new HashSet<Integer>();
               
                for(int i=0;i<a.length;i++){
                       
                        hs.add(a[i]);
                       
                       
                }
                System.out.println(hs);
        }

}

还没看到集合，表示，看不懂啊

我顶......

哥们飘过，呵呵

我觉的这个方法你应该能理解

1. class Temp {
   
2.         public static void main(String[] args) {
   
3.                 // 旧数组
   
4.                 int[] arrOld = { 1, 2, 4, 5, 6, 2, 3, 2 };
   
5.                 // 新建一个数组用于装不重复的元素
   
6.                 int[] arrNew = new int[arrOld.length];
   
7.                 int j = 0;
   
8.                 // 逐个复制元素到新数组，如果元素已经存在则不复制
   
9.                 for (int i = 0; i < arrOld.length; i++) {
   
10.                         if (isContain(arrOld[i], arrNew)) {// 判断是否已经有次元素
    
11.                                 continue;
    
12.                         }
    
13.                         arrNew[j] = arrOld[i];
    
14.                         j++;//同时记录数组中不重复的个数
    
15.                 }
    
16.                 printArr(arrOld);
    
17.                 System.out.println("去重后的数组：");
    
18.                 for(int i = 0; i < j ; i++)
    
19.                         System.out.print(arrNew[i]+" ");
    
20.         }
    
21. 
    
22.         private static void printArr(int[] arr) {// 打印数组
    
23.                 for (int i : arr) {
    
24.                         System.out.print(i + " ");
    
25.                 }
    
26.                 System.out.println();
    
27.         }
    
28. 
    
29.         private static boolean isContain(int i, int[] arrNew) {
    
30.                 //遍历数组看是否已经含有此元素
    
31.                 for (int j = 0; j < arrNew.length; j++) {
    
32.                         if(i == arrNew[j]){
    
33.                                 return true;
    
34.                         }
    
35.                 }
    
36.                 return false;
    
37.         }
    
38. }[code]运行结果
    
39. 1 2 4 5 6 2 3 2
    
40. 去重后的数组：
    
41. 1 2 4 5 6 3

复制代码

[/code]

数组中可以有重复的元素啊?我都不知道,基础太不牢了.