0Pricing
Java Academy · 课时

按索引插入、删除与移动

将元素插入新数组，按索引删除元素并向左移动后续元素，同时练习安全的边界检查。

按索引插入、删除与移动 是 CoddyKit 上的免费 Java Academy 课时。 这是第 3 节课，共 3 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 3 节课。

插入概览

向普通数组中插入元素，通常需要创建一个多出一个位置的新数组。复制位置之前的元素，放入新值，然后将其余元素向后移动一位并复制。

插入到新数组

将元素插入新数组的索引 i 处：

public class Main {
  // Method to insert a value at a given index
  static int[] insertAt(int[] a, int i, int val) {
    // Create a new array, one element larger
    int[] b = new int[a.length + 1];

    // Copy elements before the insertion index
    for (int p = 0; p < i; p = p + 1) {
      b[p] = a[p];
    }

    // Insert the new value at position i
    b[i] = val;

    // Copy the rest of the elements after position i
    for (int p = i; p < a.length; p = p + 1) {
      b[p + 1] = a[p];
    }

    return b;
  }

  public static void main(String[] args) {
    // Example array
    int[] a = {5, 8, 9, 12};

    // Insert 99 at index 2 (between 8 and 9)
    int[] b = insertAt(a, 2, 99);

    // Print new array
    System.out.print("Array after insertion: ");
    for (int x : b) {
      System.out.print(x + " ");
    }
  }
}

删除与移动

通过向左移动元素并清空最后一个单元格，按索引删除元素：

public class Main {
  // Method to delete an element at index k
  static void deleteAt(int[] a, int k) {
    // Shift elements to the left, starting from index k
    for (int i = k; i < a.length - 1; i = i + 1) {
      a[i] = a[i + 1];
    }

    // Clear the last element (since it's now duplicated)
    a[a.length - 1] = 0; 
  }

  public static void main(String[] args) {
    // Example array
    int[] a = {5, 8, 9, 12, 15};

    // Delete element at index 2 (value = 9)
    deleteAt(a, 2);

    // Print updated array
    System.out.print("Array after deletion: ");
    for (int x : a) {
      System.out.print(x + " ");
    }
  }
}

边界检查

边界检查有助于避免运行时错误。包含 n 个元素时，有效索引为 0..n-1。插入时，有效的 i 为 0..n。

public class Main {
  // Insert a value at a given index
  static int[] insertAt(int[] a, int i, int val) {
    // Validate index (0 ≤ i ≤ a.length is allowed for insert)
    if (i < 0 || i > a.length) {
      throw new IllegalArgumentException("bad index");
    }

    int[] b = new int[a.length + 1];
    for (int p = 0; p < i; p++) b[p] = a[p];
    b[i] = val;
    for (int p = i; p < a.length; p++) b[p + 1] = a[p];
    return b;
  }

  // Delete a value at a given index
  static void deleteAt(int[] a, int k) {
    // Validate index (0 ≤ k < a.length is required for delete)
    if (k < 0 || k >= a.length) {
      throw new IllegalArgumentException("bad index");
    }

    for (int i = k; i < a.length - 1; i++) {
      a[i] = a[i + 1];
    }
    a[a.length - 1] = 0; // clear the last slot
  }

  public static void main(String[] args) {
    int[] a = {5, 8, 9, 12};

    // Test insert
    int[] b = insertAt(a, 2, 99);
    System.out.print("After insert: ");
    for (int x : b) System.out.print(x + " ");

    System.out.println();

    // Test delete
    deleteAt(b, 3);
    System.out.print("After delete: ");
    for (int x : b) System.out.print(x + " ");
  }
}

删除并创建新数组

创建一个跳过索引 k 的更小副本：

public class Main {
  // Method to create a new array without the element at index k
  static int[] without(int[] a, int k) {
    // Validate index
    if (k < 0 || k >= a.length) {
      throw new IllegalArgumentException("bad index");
    }

    // New array has one fewer element
    int[] b = new int[a.length - 1];

    // Copy elements before k
    for (int p = 0; p < k; p = p + 1) {
      b[p] = a[p];
    }

    // Copy elements after k (shift left by one)
    for (int p = k + 1; p < a.length; p = p + 1) {
      b[p - 1] = a[p];
    }

    return b;
  }

  public static void main(String[] args) {
    int[] a = {5, 8, 9, 12, 15};

    // Remove element at index 2 (value = 9)
    int[] b = without(a, 2);

    // Print original
    System.out.print("Original array: ");
    for (int x : a) System.out.print(x + " ");
    System.out.println();

    // Print new array
    System.out.print("Array without index 2: ");
    for (int x : b) System.out.print(x + " ");
  }
}

插入/删除演示

运行它：查看插入到新数组、通过向左移动原地删除，以及通过复制删除。

public class Main {
  static int[] insertAt(int[] a, int i, int val) {
    if (i < 0 || i > a.length) throw new IllegalArgumentException("bad index");
    int[] b = new int[a.length + 1];
    for (int p = 0; p < i; p = p + 1) b[p] = a[p];
    b[i] = val;
    for (int p = i; p < a.length; p = p + 1) b[p + 1] = a[p];
    return b;
  }

  static void deleteAtShift(int[] a, int k) {
    if (k < 0 || k >= a.length) throw new IllegalArgumentException("bad index");
    for (int i = k; i < a.length - 1; i = i + 1) {
      a[i] = a[i + 1];
    }
    a[a.length - 1] = 0;
  }

  static int[] without(int[] a, int k) {
    if (k < 0 || k >= a.length) throw new IllegalArgumentException("bad index");
    int[] b = new int[a.length - 1];
    for (int p = 0; p < k; p = p + 1) b[p] = a[p];
    for (int p = k + 1; p < a.length; p = p + 1) b[p - 1] = a[p];
    return b;
  }

  static String join(int[] a) {
    String s = "";
    for (int i = 0; i < a.length; i = i + 1) {
      s = s + a[i] + (i + 1 < a.length ? " " : "");
    }
    return s;
  }

  public static void main(String[] args) {
    int[] a = {10, 20, 30, 40};
    System.out.println("a           = " + join(a));

    int[] b = insertAt(a, 2, 99);
    System.out.println("insertAt(2) = " + join(b));

    deleteAtShift(a, 1);
    System.out.println("deleteAt(1) = " + join(a));

    int[] c = without(b, 3);
    System.out.println("without(3)  = " + join(c));
  }
}

删除与移动检查

快速检查：哪个代码片段会通过向左移动删除索引 k 处的元素，并清空最后一个位置？

回顾与下一步

回顾：您使用新数组完成了插入，通过向左移动完成了删除，并创建了更小的副本。请始终检查边界。

下一步：继续学习对象数组，以及统计频率等简单算法。

常见问题解答

「按索引插入、删除与移动」课时是免费的吗？

是的 — 「按索引插入、删除与移动」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 3 节课。

「按索引插入、删除与移动」这节课中我会学到什么？

将元素插入新数组，按索引删除元素并向左移动后续元素，同时练习安全的边界检查。 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 3 节。

「按索引插入、删除与移动」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 数组基础与遍历
  2. 搜索、最小值/最大值与反转
  3. 按索引插入、删除与移动
← 返回 Java Academy