(1)定义一个int类型的一维数组，内容为{6,2,9,6,1,2,6,7,8}
(2)去除上面定义的数组中的重复元素，打印最终结果{6, 2, 9, 1, 7, 8}
然后我写的是这样的:然后我发现啊,如果数组里面有零的话就输出不了,也不知道怎么改,想了蛮久,还有这个程序太繁杂了,有没有简单点的,求大神指点,我们只学到了面向对象哦,大神不要用后面的编程哦 不然看不懂
class Day05_02 {
        public static void main(String[] args) {
                int[] arr = {0,6,2,9,0,6,1,2,6,7,8,};
                int[] arr2=getNewArr(arr);
                printArr(arr2);
        }
        public static int[] getNewArr(int[] arr){
            int[] arr2 = new int[arr.length];
                int z=0;
                for(int i=0;i<arr.length;i++){
                        boolean b=false;
                        for(int j=0;j<arr.length;j++){
                                if(arr2[j]==arr[i]){
                                        b=true;
                                        break;
                                }
                        }
                        if(!b){
                                arr2[z]=arr[i];
                                z++;
                        }
                }
                int [] arr3 = new int[z];
                for(int i=0;i<z;i++){
                        arr3[i]= arr2[i];
                }
                return arr3;
        }

        public static void printArr(int [] arr){
                for(int i=0;i<arr.length;i++){
                        System.out.print(arr[i]+" ");
                }
        }
}

package com.heima.IO;

import java.io.File;
/*(1)定义一个int类型的一维数组，内容为{6,2,9,6,1,2,6,7,8}
(2)去除上面定义的数组中的重复元素，打印最终结果{6, 2, 9, 1, 7, 8}*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Day1_ClassTest2 {
        public static void main(String[] args) throws IOException {
                int[] a = { 6, 2, 9, 6, 1, 2, 6, 7, 8 };
                int[] a1 = new int[a.length];
                int t = 0;
                A: for (int i = 0; i < a.length; i++) {
                        for (int j = 0; j < i; j++) {
                                if (a[j] == a[i]) {
                                        continue A;
                                }
                        }
                        a1[t++] = a[i];
                }

                int[] a2 = new int[t];

                for (int i = 0; i < t; i++) {
                        a2[i] = a1[i];
                        System.out.println(a2[i]);
                }

        }

}

package com.heima.IO;

import java.io.IOException;
import java.util.ArrayList;

public class Day1_ClassTest2 {
        public static void main(String[] args) throws IOException {
                int[] a = { 6, 2, 9, 6, 1, 2, 6, 7, 8 };
               
                ArrayList<Integer> al = new ArrayList<>();
                for (int i : a) {
                        if(!al.contains(i))
                        al.add(i);
                }
                System.out.println(al);

        }

}

利用Set集合是最方便的了吧

这是我的想法，虽然步骤多一些，但是比较好理解

1. class Test02 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 int[] arr = {6,2,9,6,1,2,6,7,8};
   
5.                 int small = arr[0];
   
6.                 for (int x = 0;x<arr.length ;x++ ) {                        //找出数组中最小的数
   
7.                         if (arr[x]<small) {
   
8.                                 small=arr[x];
   
9.                         }
   
10.                 }
    
11.                 small -=1;                               //将最小数减一，使数组中的数不会影响后面的冒泡排序。
    
12.                
    
13.                 for (int x =0;x<arr.length ;x++ ) {                          //将所有的重复的数赋值为small               
    
14.                         test(arr,x,small);
    
15.                 }
    
16.                 int wei = arr.length;
    
17.                
    
18.                         for (int x =0;x<arr.length ;x++ ) {          //判断结果数组有多少个元素
    
19.                         //System.out.println(arr[x]);
    
20.                         if (arr[x]==small) {
    
21.                                 wei--;
    
22.                         }
    
23.                 }
    
24.                 int temp = arr[0];
    
25.                 for (int z =0;z<arr.length ;z++ ) {                   //冒泡排序，将数组中的small全部排到数组最后。
    
26.                         for (int x=0;x<arr.length ;x++ ) {
    
27.                                 if (arr[x]==small) {
    
28.                                         for (int y =x;y<arr.length-1 ;y++ ) {
    
29.                                                 temp=arr[y+1];
    
30.                                                 arr[y+1]=arr[y];
    
31.                                                 arr[y]=temp;
    
32.                                         }        
    
33.                                 }
    
34.                                 //System.out.print(arr[x]);
    
35.                         }
    
36.                 }
    
37.                 int[] arrTest = new int[wei];                                //定义结果数组
    
38.                 for (int x=0;x<wei ;x++ ) {                                        //遍历得到最终结果
    
39.                         arrTest[x]=arr[x];
    
40.                         System.out.println(arrTest[x]);
    
41.                 }
    
42. 
    
43.         }
    
44.         public static int[] test(int[] arr,int x,int small) {        //定义一个方法，如果数组中有重复的数，则将small赋值给它。
    
45.                 int test = arr[x];
    
46.                 for (int y =x+1;y<arr.length ;y++ ) {
    
47.                         if (arr[y]==test) {
    
48.                                 arr[y]=small;
    
49.                         }
    
50.                 }
    
51.                 return arr;
    
52.         
    
53.         }
    
54. }
    

复制代码

何亚辉 发表于 2016-6-7 13:37
package com.heima.IO;

import java.io.File;

不错，差不多这个意思

何亚辉 发表于 2016-6-7 13:39
package com.heima.IO;

import java.io.IOException;

都说别用集合咯

土菠萝 发表于 2016-6-7 16:22
都说别用集合咯

第一个方法完全没用集合啊

何亚辉 发表于 2016-6-7 19:47
第一个方法完全没用集合啊

对的，所以我赞同你第一个方法

何亚辉 发表于 2016-6-7 13:37
package com.heima.IO;

import java.io.File;

最后新数组的长度应该是t-1吧。因为最后一次循环t又自加了一位

路过，默默顶贴。

haward2015 发表于 2016-6-8 10:37
最后新数组的长度应该是t-1吧。因为最后一次循环t又自加了一位

你没注意到前面的t是索引吗? 索引的最大值加1正好也就是成长度

学习了，还是用ArrayList集合比较好

何亚辉 发表于 2016-6-8 15:24
你没注意到前面的t是索引吗? 索引的最大值加1正好也就是成长度

明白了，受教