int[]数组和Sting[]数组去重的几种方式

小咪咪 2021-09-15 02:56 487阅读 0赞

（一）int\[ \]类型的：

/*int[]数组去重复 * */ public class TIntDeleteRepeat {
        /* 1.0 测试数组int[] 去重复 ①：无序可以先排序 int[] intArry ={5,4,8,2,1,10 }--->调用Arrays.sort(intArry)方法 ②：再去重 * */ // public static int[] a={1,2,4,3,9,5,6,2}; public static void main(String[] args) {
    
            int[] a = {
      1, 2, 4, 6, 2,7,5,5,8};
            String[] b={
      "a","ad","b","c"};
    // Arrays.sort(a); int[] now=removeRepeat3(a);
            System.out.println(Arrays.toString(now));
    // TIntDeleteRepeat.removeRepeat2(afdd); // System.out.println(c.getClass().getName()); // System.out.println("after "+after.length); // System.out.println(); // // System.out.println(Arrays.toString(after)); // System.out.println(a.getClass().getSuperclass().getName()); }
        /* * （1）int[]数组去重方法一 for循环嵌套： * */ public static int[] removeRepeat1(int[] a){
            int[] tempArr=new int[a.length];
            int t=0;
            for (int i=0;i<a.length;++i){
                boolean isTrue=true;
                for (int j=i+1;j<a.length-1;++j) {
                    if (a[i] == a[j]) {
                        isTrue = false;
                        break;
                    }
                }
                if (isTrue){
                    tempArr[t]=a[i];
                    ++t;
                }
            }
            System.out.println(Arrays.toString(tempArr));
            int[] afterArr=new int[t];
            System.arraycopy(tempArr,0,afterArr,0,t);
            System.out.println(Arrays.toString(afterArr));
            return afterArr;
        }
    
        /* * （2）数组去重 方法二 list--ArrayList集合，contains方法,再放回数组： * */ public static int[] removeRepeat2(int[] arr){
            List<Integer> list=new ArrayList<>();
            for (int i=0;i<arr.length-1;++i){
                if (!list.contains(arr[i])){
                    list.add(arr[i]);
                }
            }
            Integer[] in=(Integer[]) list.toArray(new Integer[list.size()]);
            int[] need=new int[in.length];
            int i=0;
            for (Integer integer:in){
                need[i]=integer;
                ++i;
            }
            return need;
        }
    
    
        /* * （三）方法3[不用自动排序]：利用Set唯一性去重，要排序的化，利用TreeSet； * */ public static int[] removeRepeat3(int[] arr){
            Set<Integer> set=new TreeSet<>();
            for (int i=0;i<arr.length;++i){
                set.add(arr[i]);
            }
            int[] needArr=new int[set.size()];
            int i=0;
            for (Integer integer:set){
                needArr[i]=integer;
                ++i;
            }
            return needArr;
        }
    
    }

（二）String\[ \]数组类型的去重：

/* * String[]数组去重复 * */ public class TStringDeleteRepeat {
        public static void main(String[] args) {
            String[] array = {
      "a", "d", "c", "e", "a", "f"};
            String[] need=TStringDeleteRepeat.removeRepeat3(array);
            System.out.println(Arrays.toString(need));
        }
    
        /*1.0 用两层for循环遍历 * */ public static String[] removeRepeat1(String[] str) {
            String[] temp = new String[str.length];
            int k = 0;
            for (int i = 0; i < str.length; ++i) {
                boolean flag = true;
                for (int j = i + 1; j < str.length-1; ++j) {
                    if (str[i]==str[j]){
                        flag=false;
                        break;
                    }
                }
                if (flag){
                    temp[k]=str[i];
                    ++k;
                }
            }
            String[] need=new String[k];
            System.arraycopy(temp,0,need,0,k);
            return need;
        }
    
        /*（二）方法2：用ArrayList去重,contains()方法去重。 * */ public static String[] removeRepeat2(String[] arr){
            List<String> list=new ArrayList<>(arr.length);
            for (int i=0;i<arr.length;++i){
                if (!list.contains(arr[i])){
                    list.add(arr[i]);
                }
            }
    
            String [] need=new String[list.size()];
            int i=0;
            for (String s:list){
                need[i]=s;
                ++i;
            }
            return need;
        }
    
        /* * （三）方法3：利用Set唯一性，去除重复 * */ public static String[] removeRepeat3(String[] arr){
            Set<String> set=new TreeSet<>();
            for (int i=0;i<arr.length;++i){
             set.add(arr[i]);
            }
            String[] need=new String[set.size()];
            int i=0;
            for (String str:set){
                need[i]=str;
                ++i;
            }
            return need;
        }
    }