在Java中从数组中删除项

这里怎么了？我想从数组中删除一个项，但它显示了

错误ArrayIndexOutBound异常

公共类删除{
公共静态void main（字符串[]args）{
int i；
//从数组中删除项
int k[]=新int[]{77,99,44,11,00,55,66,33,10}；
//删除55
int searchkey=55；
int nums=k.长度；
对于（i=0；iOn
k[t]=k[t+1]；
您得到了错误es
k[t+1]
尝试访问索引为9的第10个元素，但您的数组包含9个元素。因此您得到了超出范围的数据。
On
k[t]=k[t+1]；
您得到了错误es
k[t+1]
尝试访问索引为9的第10个元素，但您的数组包含9个元素。因此，您获取的数据超出了范围。
如果您按照Draco所说的那样使用它，它会起作用：

for (int t=i;t<nums-1;t++) {
    k[t]=k[t+1];
}
nums--;

for（int t=i；t如果您像Draco所说的那样使用它，它就会起作用：

for (int t=i;t<nums-1;t++) {
    k[t]=k[t+1];
}
nums--;

for（int t=i；t在下面的循环中

for (int t=i;t<nums;t++)
   k[t]=k[t+1];

for（int t=i；t在下面的循环中

for (int t=i;t<nums;t++)
   k[t]=k[t+1];

对于（int t=i；t以下重写应具有指导意义：

public class Delete {
    static int search(int key, int[] arr) {
        for (int i = 0; i < arr.length; i++)
            if (arr[i] == key) {
                return i;
            }
        return -1;
    }
    static void print(int[] arr, final int L) {
        for (int i = 0; i < L; i++) {
            System.out.println(arr[i]);
            // try this also:
            // System.out.format("%02d ", arr[i]);          
        }
    }
    public static void main(String[] args) {
        int nums[] = { 77, 99, 44, 11, 00, 55, 66, 33, 10 };
        final int N = nums.length;
        int searchKey = 55;

        int pos = search(searchKey, nums);
        for (int t = pos; t < N-1; t++) {
            nums[t] = nums[t + 1];
        }
        print(nums, N-1);
        // prints 77, 99, 44, 11, 0, 66, 33, 10
        System.out.println(010 == 8); // prints "true"
        System.out.println(00000); // prints "0
    }
}

公共类删除{
静态int搜索（int键，int[]arr）{
对于（int i=0；i

以下是一些关键观察结果：


将逻辑分解为辅助方法。这使得逻辑组件更容易测试和重用，并且整体逻辑更容易理解
如果使用
final
局部变量，如
N
来表示
int[]nums
的初始大小，并根据
N
和
N-1
等定义其余逻辑，则代码更容易理解。

非
最终
变量越多，就越难理解它们的值随时间变化时发生了什么

特别是，类名以大写字母开头
一定要小心数组中的
00
。
0
前缀用于八进制文字。也就是说，
010==8
请注意，
00
以简单的方式打印
0
。从数字上看，
00=000=0000=0
。如果需要对其进行零填充，则这是一个格式问题


另见
关于八进制文字




关于零填充


以下重写应具有指导意义：

public class Delete {
    static int search(int key, int[] arr) {
        for (int i = 0; i < arr.length; i++)
            if (arr[i] == key) {
                return i;
            }
        return -1;
    }
    static void print(int[] arr, final int L) {
        for (int i = 0; i < L; i++) {
            System.out.println(arr[i]);
            // try this also:
            // System.out.format("%02d ", arr[i]);          
        }
    }
    public static void main(String[] args) {
        int nums[] = { 77, 99, 44, 11, 00, 55, 66, 33, 10 };
        final int N = nums.length;
        int searchKey = 55;

        int pos = search(searchKey, nums);
        for (int t = pos; t < N-1; t++) {
            nums[t] = nums[t + 1];
        }
        print(nums, N-1);
        // prints 77, 99, 44, 11, 0, 66, 33, 10
        System.out.println(010 == 8); // prints "true"
        System.out.println(00000); // prints "0
    }
}

公共类删除{
静态int搜索（int键，int[]arr）{
对于（int i=0；i

以下是一些关键观察结果：


将逻辑分解为辅助方法。这使得逻辑组件更容易测试和重用，并且整体逻辑更容易理解
如果使用
final
局部变量，如
N
来表示
int[]nums
的初始大小，并根据
N
和
N-1
等定义其余逻辑，则代码更容易理解。

非
最终
变量越多，就越难理解它们的值随时间变化时发生了什么

特别是，类名以大写字母开头
一定要小心数组中的
00
。
0
前缀用于八进制文字。也就是说，
010==8
请注意，
00
以简单的方式打印
0
。从数字上看，
00=000=0000=0
。如果需要对其进行零填充，则这是一个格式问题


另见
关于八进制文字




关于零填充


for（int t=i；t
for（int t=i；t我发现它在以下方面工作得最好：

确保迭代不超过最后第二个元素（array.length-1），以便它可以有一个要比较的元素：

for(int i=elementPosition-1;i<array.length-1;i++){array[i]=array[i+1];}

for（int i=elementPosition-1；i我发现它以以下方式工作得最好：

确保迭代不超过最后第二个元素（array.length-1），以便它可以有一个要比较的元素：

for(int i=elementPosition-1;i<array.length-1;i++){array[i]=array[i+1];}

for（int i=elementPosition-1；i
import java.util.ArrayList；
导入java.util.array；
公共类排序{
公共静态void main（字符串a[]{
国际互换；
整数长度；
int[]未排序={1,2,4,3,6,5,7,8,18,17,65,46,2,4,5,3，
4 };
长度=unso
import java.util.ArrayList;
import java.util.Arrays;

public class Sort {
    public static void main(String a[]) {
        int swap;
        int length;
        int[] unsorted = { 1, 2, 4, 3, 6, 5, 7, 8, 18, 17, 65, 46, 2, 4, 5, 3,
                4 };
        length = unsorted.length;
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j < length; j++) {
                if (unsorted[i] > unsorted[j]) {
                    swap = unsorted[i];
                    unsorted[i] = unsorted[j];
                    unsorted[j] = swap;
                } else if (unsorted[i] == unsorted[j]) {
                    for (int k = j; k < length - 1; k++) {
                        unsorted[k] = unsorted[k + 1];
                    }
                    length -= 1;
                }
            }
        }
        for (int i = 0; i < length; i++) {
            System.out.println(" " + i + "th element " + unsorted[i]);
        }
    }
}