知识点范围：数组

一、选择题

在Java中，以下程序段能正确为数组赋值的是（ AD ）。（选择2项）

- A：int a[] = {1, 2, 3, 4};
- B：int b[4] = {1, 2, 3, 4};
- C：int c[]; c = {1, 2, 3, 4};
- D：int d[] = new int[] {1, 2, 3, 4};

解析：

A选项：符合定义格式，正确

B选项：在定义数组时，赋值运算符左边的[]内，不允许有任何内容，错误

C选项：c = {1, 2, 3, 4};JVM认为缺失关键字new，应改为int[] c; c = new int[] {1, 2, 3, 4};

D选项：符合定义格式，正确

数组元素的索引可以是（ D ）。（选择1项）

- A：整型常量
- B：整型变量
- C：整型表达式
- D：以上都可以

解析：

A选项：整型常量可以表示，例如is[0]

B选项：整型变量可以表示，例如int i = 0; is[i];

C选项：整型表达式可以表示，例如is[is.length - 1];

D选项：正确

已知表达式int[] m = {0, 1, 2, 3, 4, 5, 6};下面（ B ）表达式的值与数组最大下标数相等。（选择1项）

- A：m.length();
- B：m.length - 1
- C：m.length() + 1
- D：m.length + 1

解析：
数组没有length()方法，只有length属性，且数组的下标从0开始。

在Java中，以下定义数组的语句正确的是（ CD ）。（选择2项）

- A：int t[10] = new int[];
- B：char[] a = ”hello”;
- C：String[] s = new String[10];
- D：double[] d[] = new double [4][];

解析：

A选项：在数组中，赋值运算符左边的[]内不允许有任何内容，错误

B选项：虽然定义了一个char类型数组，但是没有正确接收数组元素，应改为char[] a = {'h', 'e', 'l', 'l', 'o'};

C选项：符合定义的格式，正确

D选项：在二维数组中，赋值运算符右边的第一个[]内必须有内容，第二个[]内可以允许为空，正确

分析下面的Java源程序，编译后的运行结果是（ B ）。（选择1项）

public class Test {
    public static void main(String[] args) {
        int[] numbers = new int[] {1, 2, 3};
        System.out.println(Arrays.binarySearch(numbers, 2));
    }
}

- A：输出0
- B：输出1
- C：输出2
- D：输出3

解析：
java.util.Arrays.binarySearch(int[] a, int key)：用二分查找的方式查询并返回key在a数组中的位置。

以下选项中关于Java中方法的可变参数的说法正确的是（ AC ）。（选择2项）

- A：可变参数是JDK1.5中增加的内容，用来表示方法的形参
- B：一个方法可以没有可变参数，也可以有1个或者多个可变参数
- C：可变参数可以被当作数组参数来处理
- D：可变参数对应的实参的个数可以是1个、2个、多个，但不能是0个，还可以是一个数组

解析：
可变参数最多只能存在一个，且必须放在最右边，可以代表0~N个参数，与数组视为同一类型。

以下选项中能够正确创建一个数组的是（ AD ）。（选择2项）

- A：float[] f[] = new float[6][6];
- B：float f[][] = new float[][];
- C：float[6][] f = new float[6][6];
- D：float[][] f = new float[6][];

解析：
在二维数组中，赋值运算符右边的第一个[]内必须有内容，第二个[]内可以允许为空。

下面的数组定义哪些是正确的？（ CD ）。（选择2项）

- A：int a[][] = new int[3, 3];
- B：int a[3][3] = new int[][];
- C：int a[][] = new int[3][3];
- D：int[] a[] = new int[3][3];

解析：
在二维数组中，赋值运算符右边的第一个[]内必须有内容，第二个[]内可以允许为空。

关于数组作为方法的参数时，向方法传递的是（ A ）。（选择1项）

- A：数组的引用
- B：数组的长度
- C：数组自身
- D：数组的元素

解析：
Java中只有值传递，对于基本数据类型来说传递的是数据的值的副本，对于引用数据类型来说传递的是数据的引用地址的副本。

若一个数组声明为int[][] is = new int[5][6];，则is[2][3]前有多少个元素（ A ）。（选择1项）

- A：15
- B：14
- C：13
- D：12

解析：
int[][] is = new int[5][6];表示一个长度为5的二维数组且内部数组长度为6。

二、简答题

简述数组的特点。
1. 数组是有先后顺序的
2. 数组内元素是可以重复的
3. 数组内元素的内存是连续的
4. 数组的长度是确定的，一旦被创建，大小就不可以改变
5. 数组内元素必须是相同类型
6. 数组内元素可以是任何数据类型，包括基本数据类型和引用类型
简述数组的优缺点。
- 优点：
  1. 按索引查询元素快
  2. 能存储大量数据
  3. 按索引遍历数组方便
- 缺点：
  1. 按内容查找元素慢
  2. 数组的大小一经确定不能改变
  3. 每个数组都只能存储同一种类型的数据
  4. 增删元素慢
数组有哪些初始化方式？
1. 静态创建，如：int[] is = {1, 2, 3};，声明和初始化必须在同一行
2. 动态创建，如：int[] is = new int[3];或int[] is = new int[] {1, 2, 3};，声明和初始化可以不在同一行
数组下标的类型是什么？最小的下标是什么？一维数组的第三个元素如何表示？
数组下标的类型是长整型，最小的下标是0，一维数组的第三个元素表示为is[2]。

三、编码题

数组查找操作：定义一个长度为10的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

代码：

package leif.tests;

import java.util.Scanner;

public class Test {
    private static final String[] STRINGS = {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"};

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        boolean isFound = false;
        String string = scanner.nextLine();

        for (String str : STRINGS) {
            if (str.equals(string)) {
                isFound = true;
                break;
            }
        }

        if (isFound) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }

        scanner.close();
    }
}

结果截图：

image.png

输入某年某月某日，判断这一天是这一年的第几天。

代码：

package leif;

import java.util.Calendar;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Calendar calendar = Calendar.getInstance();
        System.out.print("请输入年份：");
        int year = scanner.nextInt();
        System.out.print("请输入月份：");
        int month = scanner.nextInt();
        System.out.print("请输入日期：");
        int date = scanner.nextInt();
        calendar.set(year, month - 1, date);
        System.out.println(calendar.getTime());
        System.out.println("这一天是这一年的第" + calendar.get(Calendar.DAY_OF_YEAR) + "天");
        scanner.close();
    }
}

结果截图：

image.png

四、程序题

项目结构+README：

image.png
代码：

package test;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Person person = new Person();

        lable: while (true) {
            System.out.println("*****欢迎进入双色球彩票系统*****");
            System.out.println("\t1.购买彩票");
            System.out.println("\t2.查看开奖");
            System.out.println("\t3.退出");
            System.out.println("********************************");
            System.out.print("请选择菜单：");
            int flag = scanner.nextInt();

            switch (flag) {
                case 1:
                    System.out.println("【双色球彩票系统 > 购买彩票】");
                    System.out.println("您需要下多少注？");
                    person.setBet(scanner.nextInt());

                    for (int i = 1; i <= 6; i++) {
                        System.out.println("请输入6个红色球号<数字为1~33>，第【" + i + "】个红色球号为：");
                        int red = scanner.nextInt();

                        if (red < 1 || red > 33) {
                            System.out.println("红色球号范围是1~33！");
                            i--;
                            continue;
                        }

                        if (person.getRedSet().contains(red)) {
                            System.out.println("红色球号不能重复！");
                            i--;
                            continue;
                        }

                        person.addToRedSet(red);
                    }

                    while (true) {
                        System.out.println("请输入1个蓝色球号<数字为1~16>：");
                        int blue = scanner.nextInt();

                        if (blue < 1 || blue > 16) {
                            System.out.println("蓝色球号范围是1~16！");
                            continue;
                        }

                        person.setBlue(blue);
                        break;
                    }

                    System.out.println(person.toString());
                    person.setBuy(true);
                    break;
                case 2:
                    if (person.isBuy()) {
                        DoubleChromosphere doubleChromosphere = new DoubleChromosphere();
                        System.out.println(doubleChromosphere.toString());
                        int redCounter = 0;

                        for (int red : doubleChromosphere.getRedSet()) {
                            if (person.getRedSet().contains(red)) {
                                redCounter++;
                            }
                        }

                        boolean blueBall = false;

                        if (person.getBlue() == doubleChromosphere.getBlue()) {
                            blueBall = true;
                        }

                        if (redCounter == 6 && blueBall) {
                            System.out.println("【一等奖】恭喜你！共下了【" + person.getBet() + "】注，投资【" + (Constant.UNIT_PRICE * person.getBet()) + "】元，获奖【" + (Constant.FIRST_PRIZE * person.getBet()) + "】元！");
                        } else if (redCounter == 6 && !blueBall) {
                            System.out.println("【二等奖】恭喜你！共下了【" + person.getBet() + "】注，投资【" + (Constant.UNIT_PRICE * person.getBet()) + "】元，获奖【" + (Constant.SECOND_PRIZE * person.getBet()) + "】元！");
                        } else if (redCounter == 5 && blueBall) {
                            System.out.println("【三等奖】恭喜你！共下了【" + person.getBet() + "】注，投资【" + (Constant.UNIT_PRICE * person.getBet()) + "】元，获奖【" + (Constant.THIRD_PRIZE * person.getBet()) + "】元！");
                        } else if ((redCounter == 5 && !blueBall) || (redCounter == 4 && blueBall)) {
                            System.out.println("【四等奖】恭喜你！共下了【" + person.getBet() + "】注，投资【" + (Constant.UNIT_PRICE * person.getBet()) + "】元，获奖【" + (Constant.FOURTH_PRIZE * person.getBet()) + "】元！");
                        } else if ((redCounter == 4 && !blueBall) || (redCounter == 3 && blueBall)) {
                            System.out.println("【五等奖】恭喜你！共下了【" + person.getBet() + "】注，投资【" + (Constant.UNIT_PRICE * person.getBet()) + "】元，获奖【" + (Constant.FIFTH_PRIZE * person.getBet()) + "】元！");
                        } else if (redCounter < 3 && blueBall) {
                            System.out.println("【六等奖】恭喜你！共下了【" + person.getBet() + "】注，投资【" + (Constant.UNIT_PRICE * person.getBet()) + "】元，获奖【" + (Constant.SIXTH_PRIZE * person.getBet()) + "】元！");
                        } else {
                            System.out.println("【再接再厉】Sorry！共下了【" + person.getBet() + "】注，投资【" + (Constant.UNIT_PRICE * person.getBet()) + "】元，获奖【" + (Constant.NULL * person.getBet()) + "】元！");
                        }
                    } else {
                        System.out.println("请先购买彩票！");
                    }

                    break;
                case 3:
                    System.out.println("谢谢使用");
                    break lable;
                default:
                    System.out.println("输入错误");
                    continue lable;
            }
        }

        scanner.close();
    }
}

class Person {
    private boolean isBuy;
    private Set<Integer> redSet;
    private int blue;
    private int bet;

    public Person() {
        redSet = new HashSet<Integer>();
    }

    public boolean isBuy() {
        return isBuy;
    }

    public void setBuy(boolean isBuy) {
        this.isBuy = isBuy;
    }

    public Set<Integer> getRedSet() {
        return redSet;
    }

    public void addToRedSet(int red) {
        redSet.add(red);
    }

    public int getBlue() {
        return blue;
    }

    public void setBlue(int blue) {
        this.blue = blue;
    }

    public int getBet() {
        return bet;
    }

    public void setBet(int bet) {
        this.bet = bet;
    }

    @Override
    public String toString() {
        return "您一共买了【" + bet + "】注，共需支付【" + Constant.UNIT_PRICE * bet + "】元，所选号为：" + redSet.toString() + " " + blue;
    }
}

class DoubleChromosphere {
    private Set<Integer> redSet;
    private int blue;

    public DoubleChromosphere() {
        redSet = new HashSet<Integer>();

        for (int i = 1; i <= 6; i++) {
            int red = (int)(Math.random() * 33 + 1);

            if (redSet.contains(red)) {
                i--;
                continue;
            }

            redSet.add(red);
        }

        blue = (int)(Math.random() * 16 + 1);
    }

    public Set<Integer> getRedSet() {
        return redSet;
    }

    public int getBlue() {
        return blue;
    }

    @Override
    public String toString() {
        return "本期双色球为：" + redSet.toString() + " " + blue;
    }
}

class Constant {
    public static final int UNIT_PRICE = 2;
    public static final int FIRST_PRIZE = 500;
    public static final int SECOND_PRIZE = 400;
    public static final int THIRD_PRIZE = 300;
    public static final int FOURTH_PRIZE = 200;
    public static final int FIFTH_PRIZE = 100;
    public static final int SIXTH_PRIZE = 5;
    public static final int NULL = 5;
}

结果截图：

image.png

实操三

实操三

一、选择题

二、简答题

三、编码题

四、程序题

推荐阅读更多精彩内容