關於刪除數組元素的問題

在這裏我說幾種方法
第一種利用了System.arraycopy method
/*
* 此方法主要即找出要刪除元素的位置，然後再左右複製進目標數組 在jdk保 Long包下面 public static void
* arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
* src - 源數組。
* srcPos - 源數組中的起始位置。
* dest - 目標數組。
* destPos - 目標數據中的起始位置。
* ength - 要複製的數組元素的數量。
*/
刪除元素方法如下:

public static int[] isit(int[] arr,int ele) {//這個方法一次只能刪除一次,如果有多個重複那麼要多次調用即可
        int[] ar = new int[arr.length-1];
        int index = 0;//用作標號
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == ele) {
                index = i;
            }
        }
        /*
         * 此方法主要即找出要刪除元素的位置，然後再左右複製進目標數組 在jdk保 Long包下面 public static void
         * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
         * src - 源數組。
         * srcPos - 源數組中的起始位置。
         * dest - 目標數組。
         * destPos - 目標數據中的起始位置。
         * ength - 要複製的數組元素的數量。
         */
        int[] a1 = new int[index];//前段數組長度
        int[] a2 = new int[ar.length - a1.length];
        System.arraycopy(arr, 0, a1, 0, a1.length);
        System.arraycopy(arr, index+1, a2, 0, a2.length);
        //這注釋的for循環合併就是下面的一個for循環
//      for (int i = 0; i < a1.length; i++) {
//          ar[i] = a1[i];
//      }
//      for (int i = 0; i < a2.length; i++) {
//          ar[i+a1.length] = a2[i];
//      }

        for (int i = 0; i < ar.length; i++) {
            if(i < a1.length) {//把前段數據添加到返回數組中來
                ar[i] = a1[i];
            }
            if(i >= a1.length) {//把後段數據添加到返回數組中來
                ar[i] = a2[i-a1.length];//a2的索引必須從0開始所以要減去前面a1數組的長度
            }
        }
        return ar;
    }

測試

public static void main(String[] args) {
        int[] arr = new int[] {4,6,3,7,10,9,6743,3262,7537,99};
        int ele = 9;
        int [] ar = isit(arr, ele);//如果9只有1個那麼調用一次即可
        /*如果像這樣
        int[] arr = new int[] {4,6,3,7,10,9,9,6743,3262,7537,99};
        有兩個9那麼就調用兩次即可
        int [] ar = isit(isit(arr, ele), ele);
        如果3個那麼就調用3次,當然這也可以寫成一個遞歸遞歸我這沒有加
        */
        System.out.println("源:"+Arrays.toString(arr));
        System.out.println("刪:"+Arrays.toString(ar));
    }

console:

源:[4, 6, 3, 7, 10, 9, 6743, 3262, 7537, 9, 99]
刪:[4, 6, 3, 7, 10, 6743, 3262, 7537, 99]

///然後在說一種，這種方法挺蠢的
思路也是找到要刪除的索引，然後在把刪除的元素修改爲最大的，然後就再次用一個返回數組來接收
源代碼如下

public class DeleteElement {

    public static int[] isArr(int[] arr,int ele) {
        int[] ar = new int[arr.length-1];

        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == ele) {
                arr[i] = Integer.MAX_VALUE;
            }
        }
        //排序  歸併排序
        for (int i = 0; i < arr.length; i++) {
            for (int j = i +1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {//找出值,並修改爲最大值
                    arr[i] = arr[i] + arr[j];
                    arr[j] = arr[i] - arr[j];
                    arr[i] = arr[i] - arr[j];
                }
            }
        }
        //
        for (int i = 0; i < ar.length; i++) {
            ar[i] = arr[i];
        }
        return ar;
    }
    public static long[] isArr(long[] arr,long ele) {
        long[] ar = new long[arr.length-1];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == ele) {
                arr[i] = Long.MAX_VALUE;
            }
        }
        //排序  歸併排序
        for (int i = 0; i < arr.length; i++) {
            for (int j = i +1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {//找出值,並修改爲最大值
                    arr[i] = arr[i] + arr[j];
                    arr[j] = arr[i] - arr[j];
                    arr[i] = arr[i] - arr[j];
                }
            }
        }
      //----------------------
        for (int i = 0; i < ar.length; i++) {
            ar[i] = arr[i];
        }
        return ar;
    }
    public static double[] isArr(double[] arr,double ele) {
        double[] ar = new double[arr.length-1];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == ele) {//找出值,並修改爲最大值
                arr[i] = Double.MAX_VALUE;
            }
        }
        //排序  歸併排序
        for (int i = 0; i < arr.length; i++) {
            for (int j = i +1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    arr[i] = arr[i] + arr[j];
                    arr[j] = arr[i] - arr[j];
                    arr[i] = arr[i] - arr[j];
                }
            }
        }
      //----------------------
        for (int i = 0; i < ar.length; i++) {
            ar[i] = arr[i];
        }
        return ar;
    }
    public static float[] isArr(float[] arr,float ele) {
        float[] ar = new float[arr.length-1];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == ele) {//找出值,並修改爲最大值
                arr[i] = Float.MAX_VALUE;
            }
        }
        //排序  歸併排序
        for (int i = 0; i < arr.length; i++) {
            for (int j = i +1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    arr[i] = arr[i] + arr[j];
                    arr[j] = arr[i] - arr[j];
                    arr[i] = arr[i] - arr[j];
                }
            }
        }
      //----------------------
        for (int i = 0; i < ar.length; i++) {
            ar[i] = arr[i];
        }
        return ar;
    }
    public static short[] isArr(short[] arr,short ele) {
        short[] ar = new short[arr.length-1];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == ele) {//找出值,並修改爲最大值
                arr[i] = Short.MAX_VALUE;
            }
        }
        //排序  歸併排序
        for (int i = 0; i < arr.length; i++) {
            for (int j = i +1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    arr[i] = (short) (arr[i] + arr[j]);
                    arr[j] = (short) (arr[i] - arr[j]);
                    arr[i] = (short) (arr[i] - arr[j]);
                }
            }
        }
      //----------------------
        for (int i = 0; i < ar.length; i++) {
            ar[i] = arr[i];
        }
        return ar;
    }
    public static byte[] isArr(byte[] arr,byte ele) {
        byte[] ar = new byte[arr.length-1];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == ele) {//找出值,並修改爲最大值
                arr[i] = Byte.MAX_VALUE;
            }
        }
        //排序  歸併排序
        for (int i = 0; i < arr.length; i++) {
            for (int j = i +1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    arr[i] = (byte) (arr[i] + arr[j]);
                    arr[j] = (byte) (arr[i] - arr[j]);
                    arr[i] = (byte) (arr[i] - arr[j]);
                }
            }
        }
      //----------------------
        for (int i = 0; i < ar.length; i++) {
            ar[i] = arr[i];
        }
        return ar;
    }
}

這個方法沒有寫測試方法，但是在我的機器上倒是測試過了，可以運行的

另一種方法就是利用for循環的遍歷來刪除元素
//方法

public static int[] deleteD(int[] arr, int ele) {//整形
        int[] ax = new int[arr.length - 1];
        int i = 0;// 用作目標數組的指針索引
        for (int a : arr) {
            if (!(a == ele)) {// 取 找到指定數字的相反
                ax[i] = a;// 把遍歷出來且不等於待刪除元素的元素添加到目標數組(返回數組)
                i++;
            }
        }
        return ax;
    }

    public static String[] deleteD(String[] strings, String string) {//字符串型
        String[] str = new String[strings.length - 1];
        int i = 0;// 用作目標數組的指針索引
        for (String s : strings) {
            if (!string.equals(s)) {// 取 找到指定字符串 的相反
                str[i] = s;// 把遍歷出來且不等於待刪除元素的元素添加到目標數組(返回數組)
                i++;
            }
        }
        return str;
    }

測試

public static void main(String[] args) {
        String[] strings = new String[] { "6", "hdh", "67", "x5", "0", "fg" };// 源數組
        int[] arr = new int[] { 4, 3, 7, 234, 626, 8, 73, 1, 0, 9 };// 源數組
        int ele = 1;// 待刪除元素
        String string = "x5";// 待刪除元素

        System.out.println("待刪除元素:" + string + " " + ele);
        System.out.println(Arrays.toString(deleteD(arr, ele)) + "-int \n");
        System.out.println(Arrays.toString(deleteD(strings, string)) + "-String \n");
    }

console:

待刪除元素:x5 1
[4, 3, 7, 234, 626, 8, 73, 0, 9]-int 

[6, hdh, 67, 0, fg]-String