目前有数组” int[] arr =  {11,2, 4, 2, 10, 11}，定义一个函数清除该数组的重复元素，返回的数组不准浪费长度。

思路：1、排序。2、计数器找出重复值个数，计算得出目标数组长度。3、冒泡思想遍历数组，将不等于前一个元素的值记录入目标数组。目标数组第一个元素与原数组第一个元素相同。
import java.util.*;
class Demo9
{
        public static void main(String[] args)
        {
                int[] arr =  {11,2, 4, 2, 10, 11};
                System.out.println(Arrays.toString(clear(arr)));
        }

        public static int[] clear(int[] arr){       
                for(int i=0;i<arr.length-1;i++){
                        for(int j=0;j<arr.length-1-i;j++){
                                if(arr[j]>arr[j+1]){
                                        int temp=arr[j];
                                        arr[j]=arr[j+1];
                                        arr[j+1]=temp;
                                }
                        }
                }
                int index=0;
                for(int i=0;i<arr.length-1;i++){
                        if(arr[i]==arr[i+1]){
                                index++;
                        }
                }
                index=arr.length-index;
                int[] arr1=new int[index];
                for(int i=0,j=1;i<arr.length-1;i++){
                        if(arr[i]!=arr[i+1]){
                                arr1[j]=arr[i+1];
                                j++;
                        }
                }
                arr1[0]=arr[0];
                return arr1;
        }
}


请问还有其他思路吗？

这是我以前做的
import java.util.*;

class Demo9{
        public static void main(String[] args){
                int[] arr={1,2,2,4,1,2,8,2,2,9};
                System.out.println(Arrays.toString(new Count().getArray(arr)));
        }
}

class Count{
        /*
        1.找出不重复的数组元素个数，
        2.创建数组用于保存不重复的数组元素
        3.找出不重复的数组元素（把数组的元素都与那个数组元素前面的元素逐一对比，如果是有相同则不是不重复数，数组对比时从下标1开始）
        */
        public int[] getArray(int[] arr){

                //找出不重复的数组元素个数
                int count=1;
        outer:for(int j=1;j<arr.length;j++){
                        for(int i=0;i<j;i++){
                                if(arr[j]==arr){
                                        continue outer;
                                }
                        }
                        count++;
                }
               
                int[] returnArr=new int[count];
                returnArr[0]=arr[0];        //第一数组元素是不会重复的

                int count1=1;
                //找出不重复的数组元素
                outer:for(int j=1;j<arr.length;j++){
                        for(int i=0;i<j;i++){
                                if(arr[j]==arr){
                                        continue outer;
                                }
                        }
                        returnArr[count1]=arr[j];
                        count1++;
                }
                return returnArr;
        }
}

放到set集合里再弄回来

放到List中，利用其中的contains方法判断，然后再转成数组

1. import java.util.ArrayList;
   
2. 
   
3. 
   
4. public class ContainDemo {
   
5.         public static void sop(Object obj)
   
6.         {
   
7.                 System.out.print(obj);
   
8.         }
   
9.         public static void main(String[] args)
   
10.         {
    
11.                 int[] a={1,11,11,23,23,67,67};
    
12.                 ArrayList<Integer> b=quchong(a);
    
13.                 int[] bb=new int[a.length];
    
14.                 for(int i=0;i<b.size();i++)
    
15.                 {
    
16.                         bb[i]=b.get(i);
    
17.                         sop(bb[i]);
    
18.                         sop(" ");
    
19.                 }
    
20.                
    
21.         }
    
22.         public static ArrayList<Integer> quchong(int[] a)
    
23.         {
    
24.                 ArrayList<Integer> al=new ArrayList<Integer>();
    
25.                 for(int i=0;i<a.length;i++)
    
26.                 {
    
27.                         if(!al.contains(a[i]))
    
28.                         {
    
29.                                 al.add(a[i]);
    
30.                         }
    
31.                 }
    
32.                 return al;       
    
33.         }
    
34. 
    
35. }
    

复制代码

用 Set 集合吧。它的特点是 元素无重复，无序！

可以在遍历中判断。