Java 基础程序结构详解：从输入输出到数组操作

Java 作为一门面向对象的编程语言，其基础程序结构是构建复杂应用的基石。本文将围绕 Java 程序的基本组成部分，从输入输出、控制流程到数组操作等核心内容展开详细介绍，帮助初学者快速掌握 Java 编程的基础知识。

输入与输出操作

在程序开发中，输入输出是与用户交互的重要方式。Java 提供了多种处理输入输出的机制，其中控制台输入输出是最基础也是最常用的方式。

控制台输入

与打印输出到控制台（System.out.println）相比，从控制台读取输入相对复杂一些。Java 中可以通过 Scanner 类来实现控制台输入，步骤如下：

1. 首先需要创建一个 Scanner 对象，并与标准输入流 System.in 关联：

   Scanner in = new Scanner(System.in);

2. 然后使用 Scanner 类的各种方法进行输入操作：

   • nextLine()：读取一整行输入（包含空格）
   • next()：读取一个单词（以空白符为分隔）
   • nextInt()：读取一个整数
   • nextDouble()：读取一个浮点数

示例代码：

import java.util.*;

public class InputTest {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        System.out.print("What is your name? ");
        String name = in.nextLine();
        
        System.out.print("How old are you? ");
        int age = in.nextInt();
        
        System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));
    }
}

 

注意：使用 Scanner 类需要导入 java.util.Scanner，通常我们会使用 import java.util.* 导入整个 java.util 包。

格式化输出

Java SE 5.0 引入了类似 C 语言的 printf 方法，用于格式化输出：

double x = 10000.0 / 3.0;
System.out.printf("%.2f", x); // 保留两位小数，输出 3333.33

printf 方法使用格式说明符来指定输出格式，常用的转换符包括：

• d：十进制整数

  Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");

• f：定点浮点数
• s：字符串
• c：字符
• b：布尔值

还可以使用标志来控制格式化输出，例如：

System.out.printf("%,.2f", 10000.0 / 3.0); // 输出 3,333.33（添加千位分隔符）

文件输入与输出

除了控制台输入输出，Java 也支持文件的读写操作：

• 读取文件：使用 Scanner 结合 Paths.get() 方法

Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");

• 写入文件：使用 PrintWriter 类

PrintWriter out = new PrintWriter("myfile.txt", "UTF-8");

注意：处理文件输入输出时可能会抛出 IOException，需要在方法声明中使用 throws IOException 进行处理。

控制流程语句

控制流程语句用于控制程序的执行顺序，Java 提供了多种控制流程结构，包括条件语句、循环语句和选择语句等。

条件语句

条件语句根据条件判断结果执行不同的代码块，主要有 if 和 if-else 两种形式：

if (condition) {
    // 条件为真时执行
} else {
    // 条件为假时执行
}

多分支条件判断：

if (yourSales >= 2 * target) {
    performance = "Excellent";
} else if (yourSales >= 1.5 * target) {
    performance = "Fine";
} else if (yourSales >= target) {
    performance = "Satisfactory";
} else {
    System.out.println("You're fired");
}

循环语句

循环语句用于重复执行一段代码，Java 提供了三种循环结构：

1. while 循环：先判断条件，再执行循环体

while (condition) {
    // 循环体
}

 2.do-while 循环：先执行循环体，再判断条件（至少执行一次）

do {
    // 循环体
} while (condition);

 3.for 循环：适合已知循环次数的情况

for (initialization; condition; update) {
    // 循环体
}

Java 5.0 引入了增强型 for 循环（for-each 循环），用于遍历数组或集合：

for (variable : collection) {
    // 循环体，variable 依次表示 collection 中的每个元素
}

示例：遍历数组

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}

多重选择：switch 语句

switch 语句用于处理多分支选择，语法如下：

switch (expression) {
    case value1:
        // 代码块
        break;
    case value2:
        // 代码块
        break;
    ...
    default:
        // 默认代码块
}

注意：case 分支后必须使用 break 语句，否则会发生穿透现象，即执行完当前 case 后会继续执行下一个 case。

switch 语句的表达式可以是 char、byte、short、int、枚举类型，从 Java SE 7 开始还可以是字符串类型。

中断控制流程

Java 提供了 break 和 continue 语句用于中断控制流程：

• break：跳出当前循环
• continue：跳过本次循环剩余部分，直接进入下一次循环

Java 还支持带标签的 break 语句，用于跳出多重嵌套循环：

label:
for (...) {
    for (...) {
        if (condition) {
            break label; // 跳出带 label 标签的循环
        }
    }
}

大数值处理

当基本数据类型的精度无法满足需求时，可以使用 java.math 包中的 BigInteger 和 BigDecimal 类，它们支持任意精度的整数和浮点数运算。

使用方法示例：

import java.math.*;

public class BigIntegerTest {
    public static void main(String[] args) {
        BigInteger a = BigInteger.valueOf(100);
        BigInteger b = BigInteger.valueOf(200);
        
        BigInteger c = a.add(b); // 加法
        BigInteger d = a.multiply(b); // 乘法
        BigInteger e = b.subtract(a); // 减法
        BigInteger f = b.divide(a); // 除法
    }
}

注意：BigInteger 和 BigDecimal 类的运算不能使用算术运算符（如 +、* 等），必须使用类中的方法。

数组操作

数组是一种用于存储相同类型元素的容器，Java 提供了丰富的数组操作功能。

数组的声明与初始化

声明数组：

int[] a; // 推荐方式
int a[]; // 兼容 C 语言的方式
//初始化
int[] a = new int[10]; // 创建长度为 10 的数组，元素默认初始化为 0
int[] b = {1, 2, 3, 4, 5}; // 初始化并赋值
int[] c = new int[]{1, 2, 3}; // 匿名数组初始化

数组的使用

访问数组元素：

int[] a = {1, 2, 3};
System.out.println(a[0]); // 访问第一个元素，输出 1
a[1] = 5; // 修改第二个元素的值

获取数组长度：

int length = a.length;

遍历数组：

// 使用 for 循环
for (int i = 0; i < a.length; i++) {
    System.out.println(a[i]);
}

// 使用 for-each 循环
for (int num : a) {
    System.out.println(num);
}

数组工具类 Arrays

java.util.Arrays 类提供了许多静态方法用于操作数组：

• toString()：将数组转换为字符串
• sort()：对数组进行排序
• copyOf()：复制数组
• binarySearch()：二分查找数组元素
• fill()：填充数组元素
• equals()：比较两个数组是否相等

示例：

import java.util.Arrays;

public class ArraysTest {
    public static void main(String[] args) {
        int[] a = {3, 1, 4, 1, 5, 9};
        System.out.println(Arrays.toString(a)); // 输出 [3, 1, 4, 1, 5, 9]
        
        Arrays.sort(a);
        System.out.println(Arrays.toString(a)); // 输出 [1, 1, 3, 4, 5, 9]
        
        int[] b = Arrays.copyOf(a, a.length);
        System.out.println(Arrays.equals(a, b)); // 输出 true
    }
}

多维数组

Java 中的多维数组实际上是数组的数组，可以是规则的，也可以是不规则的：

// 规则二维数组
int[][] matrix = new int[3][4];

// 不规则二维数组
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[2];
jaggedArray[1] = new int[3];
jaggedArray[2] = new int[1];

初始化二维数组：

int[][] magicSquare = {
    {16, 3, 2, 13},
    {5, 10, 11, 8},
    {9, 6, 7, 12},
    {4, 15, 14, 1}
};

遍历二维数组：

for (int[] row : magicSquare) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

总结

本文详细介绍了 Java 基础程序结构的核心内容，包括输入输出操作、控制流程语句、大数值处理和数组操作等。这些基础知识是 Java 编程的基石，掌握它们对于进行更复杂的 Java 开发至关重要。

在实际开发中，这些基础概念会被频繁使用，因此需要深入理解并熟练掌握。随着学习的深入，你会发现这些基础知识在面向对象编程、集合框架、多线程等高级特性中都有广泛的应用。

希望本文能帮助你快速掌握 Java 基础程序结构，为后续的学习打下坚实的基础。