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