关于删除数组元素的问题

在这里我说几种方法
第一种利用了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