蓝桥杯java基础

数组的倒序与隔位输出

时间限制：1.000S  空间限制：128MB

题目描述

给定一个整数数组，编写一个程序实现以下功能：

1. 将输入的整数数组倒序输出，每个数之间用空格分隔。

2. 从正序数组中，每隔一个单位（即索引为奇数的元素），输出其值，同样用空格分隔。

输入描述

第一行包含一个整数 n，表示数组的长度。

接下来一行包含 n 个整数，表示数组的元素。

输出描述

首先输出倒序排列的数组元素，然后输出正序数组中每隔一个单位的元素。

输入示例

5
2 3 4 5 6

输出示例

6 5 4 3 2
2 4 6

提示信息

数据范围：

1 <= n <= 1000.

数组

在之前的A+B案例中，我们学习了使用int a = 0;这种形式来表示一个数据，那应该以怎样的形式表示“一组数据”呢？

答案就是数组，Java中的数组是一种用于存储相同数据类型的元素的数据结构。

数据结构的概念理解起来比较抽象，它表示了数据在计算中被组织和存储的形式，而数组呢就是一组按照一定次序排列的数值，数组中的每一个变量被称为元素，比如下图中就是数组的存储形式：

相同数据类型的元素指的是数组中的所有元素都必须是相同的数据类型，也就是说如果创建了一个整型数组，数组里就不能有其他数据类型的存在。

每种数据结构都具有一些特点，我们假设用“班级”这种组织的形式来简单阐述数组的特点：

• 固定大小：数组一旦声明，其大小通常是固定的，不能在运行时动态更改。就好比开设了一个30人的班级，班级大小已经固定，不能再改变班级的规模。
• 相同数据类型： 数组中的所有元素必须具有相同的数据类型，假设这个班都是男生或者都是女生，只能有一种性别存在。
• 连续存储： 数组的元素在内存中是连续存储的，班级里的同学按照顺序就坐，中间没有留空位。
• 下标访问： 数组中的元素通过下标（索引）进行访问，每个人都有一个学号，学号就是自己的座位，这个学号被称为索引，但是数组里的索引是从0开始的，也就是说，第一个元素的索引是0，第二个元素的索引是1，依次类推

  那具体如何在Java中定义和使用数组呢？

  Java中声明数组的方式为dataType[] arrayName或者为dataType arrayName[]

  dataType arrayName[]更符合C++的编程习惯，但在Java中，往往使用dataType[] arrayName这种形式。

  • dataType表示数组元素的类型，比如int、double、char等。
  • arrayName是为数组指定的名称，类似于变量名称。

    int[] nums; // 声明一个整数数组
    double scores[]; // 声明一个浮点数数组
    

    但上面的操作只是声明了一个数组，既没有为数组指定大小，也没有为数组填充数据，也就是说此时数组在计算机中并没有开辟内存空间，想要为数组分配存储空间，必须对其进行初始化。

    Java中的数组可以使用不同的方式进行初始化，包括动态初始化和静态初始化。

    在声明数组后，使用 new 关键字来分配内存并初始化数组元素。

    int[] numbers = new int[3]; // 动态初始化一个包含3个整数的数组
    

    静态初始化：在声明数组时，同时为数组分配内存并指定初始值

    int[] numbers = {1, 2, 3}; // 静态初始化一个包含初始值的整数数组
    

    访问数组中的元素，您可以使用下标操作符 []，请注意，下标从0开始，直到数组长度的前一位。

    int value = arr[2]; // 获取数组 arr 的第三个元素的值，即 3
    

    除了访问元素，还可以通过下标操作符 [] 修改数组中的元素的值。

    arr[0] = 100;  // 修改数组 arr 的第一个元素的值为 100
    

    所有的数组都拥有一个属性 length， 用于获取数组的长度，表示数组中元素的数量。例如：

    int[] nums = {1, 2, 3};
    int length = nums.length; // 获取数组的长度（值为3）
    

    ⚠️ 当数组越界时，Java会抛出运行时错误(异常)

    int[] numbers = {1, 2, 3, 4, 5};
    for (int i = 0; i < numbers.length; i++) {
        System.out.println(numbers[i]);
    }
    

    以上，我们通过一些简短的代码知道了数组的定义、特点、声明方式、访问方式和遍历方式，以及数组使用中容易出错的地方。

    ArrayList

    数组的长度是固定的，但是我们往往并不知道一组数据的大小，这个时候直接使用数组并不太满足需求，可以考虑使用ArrayList。在Java中，ArrayList 是 java.util 包中的一个类，可以在运行时对其动态添加和删除元素以满足我们的操作需要。

    使用前需要在代码中导入 ArrayList 类，如下所示：

    import java.util.ArrayList;
    

    您可以通过以下方式创建一个 ArrayList：

    集合类只能存储对象而不是原始数据类型。

    ArrayList nums = new ArrayList();
    

    想要为 ArrayList 添加元素，需要使用add方法

    nums.add(10);
    nums.add(100);
    nums.add(1000);
    

    想要获取 ArrayList 中的元素，需要使用 get 方法，和[]类似，索引从0开始

    int firstNumber = nums.get(0); // 获取第一个元素 1
    

    使用 remove(index) 方法来删除 ArrayList 中的对应索引的元素。

    nums.remove(1); // 删除第二个元素
    

    不同于数组使用length, ArrayList 使用 size 方法来获取 中的元素数量。

    int size = nums.size(); // 获取 ArrayList 的大小
    

    在数组中，我们通过for循环完成了对数组的遍历，ArrayList 遍历的方式是一样的。

    for (int i = 0; i < nums.size(); i++) {
           System.out.println(nums.get(i));
    }
    

    for (Integer num : nums) {
        System.out.println(num);
    }
    

    以上就是关于ArrayList的一些使用介绍，可能刚开始接触，会觉得对数组和ArrayList的相关操作有点多，看完一遍后只觉得走马观花无法全部记住，但没关系，只需要留个印象，这些内容我们会经常使用，可以在实践中不断增进对这些内容的理解。

    倒序输出数组

    绕了一大圈子，我们终于回归到题目本身了，题目的第一个要求是实现将输入的整数数组倒序输出，每个数之间用空格分隔。

    根据题目要求，我们可以写出基础的代码：

    import java.util.Scanner;
    public class Main {
        public static void main(String[] args) {
            // 定义一个整型ArrayList
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt(); // 输入数组长度
        }
    }
    

    输入n之后，我们可以按照要求定义一个大小为n的整数数组

    int[] nums = new int[n]; // 声明一个大小为 n 的整数数组
    

    对数组进行遍历，输入数组元素

    // 循环输入数组中的数字
    for(int i = 0; i < n; i++) {
        nums[i] = scanner.nextInt();
    }
    

    倒序输出数组，只需要从数组的最后一位倒着遍历即可

    // 倒序输出数组元素，每个数之间用空格分隔
    for (int i = nums.length - 1; i >= 0; i--) {
          System.out.print(nums[i]);
          if (i > 0) {
              System.out.print(" ");
          }
      }
    

    完整的代码如下：

    import java.util.Scanner;
    public class Main {
        public static void main(String[] args) {
            // 定义一个整型ArrayList
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt(); // 输入数组长度
            int[] nums = new int[n];
            // 循环输入数组中的数字
            for(int i = 0; i < n; i++) {
                nums[i] = scanner.nextInt();
            }
            
            // 倒序输出数组元素，每个数之间用空格分隔，使用size()表示ArrayList的大小
            for (int i = nums.length - 1; i >= 0; i--) {
                System.out.print(nums[i]);
                if (i > 0) {
                    System.out.print(" ");
                }
            }
            
            // 关闭Scanner
            scanner.close();
        }
    }
    

    如果使用ArrayList呢，又应该怎么写呢？

    首先先引入ArrayList, 并定义一个ArrayList

    import java.util.ArrayList;
    import java.util.Scanner;
    public class Main {
        public static void main(String[] args) {
            // 定义一个整型ArrayList
            ArrayList nums = new ArrayList();
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt(); // 输入数组长度
          
        }
    }
    

    接着我们使用while循环代替for循环，控制n及n个数据的输入

     // 循环输入数组中的数字
    while (n-- > 0) {
        while (scanner.hasNextInt()) {
            int num = scanner.nextInt();
            // 使用add方法动态添加数组元素
            nums.add(num);
        }
    }
    

    和数组类似，依旧是从ArrayList的最后一个元素开始倒序遍历，不过我们可以使用size()表示长度

    for (int i = nums.size() - 1; i >= 0; i--) {
        System.out.print(nums.get(i));
        if (i > 0) {
            System.out.print(" ");
        }
    }
    

    完整的代码如下：

    import java.util.ArrayList;
    import java.util.Scanner;
    public class Main {
        public static void main(String[] args) {
            // 定义一个整型ArrayList
            ArrayList nums = new ArrayList();
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt(); // 输入数组长度
            // 循环输入数组中的数字
            while (n-- > 0) {
                while (scanner.hasNextInt()) {
                    int num = scanner.nextInt();
                    // 使用add方法动态添加数组元素
                    nums.add(num);
                }
            }
            // 倒序输出数组元素，每个数之间用空格分隔，使用size()表示ArrayList的大小
            for (int i = nums.size() - 1; i >= 0; i--) {
                System.out.print(nums.get(i));
                if (i > 0) {
                    System.out.print(" ");
                }
            }
            System.out.println(); // 换行
            // 关闭Scanner
            scanner.close();
        }
    }
    

    除了普通的for循环遍历，你还可以使用增强型 for 循环或来遍历 ArrayList 中的元素，结构如下，这种方式更为简洁和易读，基本语法如下：

    for (elementType element : collection) {
        // 在此处处理 element
    }
    

    • elementType 是元素的数据类型
    • element 是在每次迭代中表示一个元素的变量
    • collection 是要迭代的数组或其他的对象（比如后面讲到的集合）

      for (String name : names) {
          System.out.println(name);

      java代码实现：

      import java.util.Scanner;
      import java.util.ArrayList;
      public class Main{
            public static void main(String[] args){
                ArrayList nums=new ArrayList();
                Scanner sc=new Scanner(System.in);
                int n=sc.nextInt();
                int a[]=new int[n];
                for(int i=0;i=0;i--){
                   System.out.print(nums.get(i)+" ");
               }
                System.out.println();
               for(int i=0;i