（一）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;
    }
}