java定义一个整型数组，将一个数插在数组元素的末尾形成新的数组。输出新数组

以下是 Java 代码示例：

int[] arr = {1, 2, 3, 4, 5}; // 定义整型数组
int num = 6; // 要插入的数
int[] newArr = new int[arr.length + 1]; // 新建一个长度比原数组多1的数组
for (int i = 0; i < arr.length; i++) {
    newArr[i] = arr[i]; // 将原数组元素复制到新数组中
}
newArr[newArr.length - 1] = num; // 将要插入的数放在新数组的最后一个位置
System.out.println(Arrays.toString(newArr)); // 输出新数组

输出结果为：

[1, 2, 3, 4, 5, 6]

相关问题

java用二维数组写定义一个整型数组，将一个数插在数组元素的末尾形成新的数组。输出新数组

以下是用二维数组实现的代码：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int num = 6;

        int[][] newArr = new int[2][arr.length + 1];
        newArr[0] = arr; // 将原数组复制到新数组的第一行
        newArr[1][0] = num; // 将要插入的数放在新数组的第二行第一列

        System.out.println(Arrays.toString(newArr[0]) + "\n" + Arrays.toString(newArr[1])); // 输出新数组的两行
    }
}

输出：

[1, 2, 3, 4, 5]
[6, 0, 0, 0, 0]

可以看到，新数组的第一行是原数组，第二行是插入了一个数的新数组。

用Java编写一个类TestArray，定义一个一维的整型数组，使用两种循环遍历数组。输出数组中最大值的元素。然后对数组排序，分别在数组头，中间和末尾 位置插入一个元素

好的，首先我们创建一个名为`TestArray`的Java类，并定义一个一维整数数组。接着我们将演示如何使用for循环和while循环遍历数组并找到最大值，以及如何对数组进行排序并在特定位置插入元素。

public class TestArray {
    private int[] array = new int[5]; // 创建一个长度为5的一维整数数组

    public void setUpArray() {
        for (int i = 0; i < array.length; i++) {
            array[i] = (int) (Math.random() * 100); // 随机填充数组
        }
        System.out.println("Original Array: " + Arrays.toString(array));
    }

    // 使用for循环遍历数组寻找最大值
    public int findMaxWithForLoop() {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }

    // 使用while循环遍历数组寻找最大值
    public int findMaxWithWhileLoop(int start) {
        int max = array[start];
        while (start < array.length) {
            if (array[start] > max) {
                max = array[start];
            }
            start++;
        }
        return max;
    }

    // 对数组进行排序
    public void sortArray() {
        Arrays.sort(array);
        System.out.println("Sorted Array: " + Arrays.toString(array));
    }

    // 在数组头部插入元素
    public void insertAtHead(int value) {
        int[] newArray = new int[array.length + 1];
        newArray[0] = value;
        System.arraycopy(array, 0, newArray, 1, array.length);
        array = newArray;
        System.out.println("Array after inserting at head: " + Arrays.toString(array));
    }

    // 在数组中部插入元素
    public void insertAtMiddle(int index, int value) {
        if (index >= 0 && index < array.length) {
            int[] newArray = new int[array.length + 1];
            System.arraycopy(array, 0, newArray, 0, index);
            newArray[index] = value;
            System.arraycopy(array, index, newArray, index + 1, array.length - index);
            array = newArray;
            System.out.println("Array after inserting at middle (" + index + "): " + Arrays.toString(array));
        } else {
            System.out.println("Invalid index.");
        }
    }

    // 在数组尾部插入元素
    public void insertAtEnd(int value) {
        int[] newArray = new int[array.length + 1];
        System.arraycopy(array, 0, newArray, 0, array.length);
        newArray[newArray.length - 1] = value;
        array = newArray;
        System.out.println("Array after inserting at end: " + Arrays.toString(array));
    }

    public static void main(String[] args) {
        TestArray testArray = new TestArray();
        testArray.setUpArray();
        int max = testArray.findMaxWithForLoop();
        System.out.println("Max value: " + max);

        testArray.sortArray();
        testArray.insertAtHead(100);
        testArray.insertAtMiddle(2, 200);
        testArray.insertAtEnd(300);
    }
}