AI编程网

2024-08-08发表2024-08-10更新编程 / Java小白5 分钟读完 (大约710个字)

关系运算符

关系运算符是用于比较两个值之间关系的运算符。在 Java 中，关系运算符的主要作用是返回布尔值（true 或 false），通常用于控制程序的执行流程，比如条件语句和循环。本文将详细介绍 Java 中的关系运算符及其用法。

1. 关系运算符列表

Java 中的关系运算符包括：

== : 等于
!= : 不等于
> : 大于
< : 小于
>= : 大于等于
<= : 小于等于

2. 运算符详解

2.1 等于运算符 `==`

== 运算符用于判断两个值是否相等。如果相等，则返回 true；否则返回 false。

示例代码：

1
2
3

int a = 5;
int b = 5;
boolean result = (a == b); // result 将为 true

2.2 不等于运算符 `!=`

!= 运算符用于判断两个值是否不相等。如果不相等，则返回 true；否则返回 false。

示例代码：

1
2
3

int a = 5;
int b = 3;
boolean result = (a != b); // result 将为 true

2.3 大于运算符 `>`

> 运算符用于判断左边的值是否大于右边的值。如果是，则返回 true；否则返回 false。

示例代码：

1
2
3

int a = 7;
int b = 3;
boolean result = (a > b); // result 将为 true

2.4 小于运算符 `<`

< 运算符用于判断左边的值是否小于右边的值。如果是，则返回 true；否则返回 false。

示例代码：

1
2
3

int a = 5;
int b = 10;
boolean result = (a < b); // result 将为 true

2.5 大于等于运算符 `>=`

>= 运算符用于判断左边的值是否大于或等于右边的值。如果是，则返回 true；否则返回 false。

示例代码：

1
2
3

int a = 5;
int b = 5;
boolean result = (a >= b); // result 将为 true

2.6 小于等于运算符 `<=`

<= 运算符用于判断左边的值是否小于或等于右边的值。如果是，则返回 true；否则返回 false。

示例代码：

1
2
3

int a = 3;
int b = 5;
boolean result = (a <= b); // result 将为 true

3. 复合使用示例

关系运算符可以结合逻辑运算符一起使用，以构造复杂的条件表达式。

示例代码：

int age = 20;
boolean isAdult = (age >= 18); // 用于检测是否成年人
boolean isSenior = (age > 65);  // 用于检测是否老年人

if (isAdult && !isSenior) {
    System.out.println("这是成年人，但不是老年人。");
} else if (isSenior) {
    System.out.println("这是老年人。");
} else {
    System.out.println("这是未成年人。");
}

4. 小结

关系运算符在 Java 编程中非常重要，能够帮助我们进行条件判断。掌握这些运算符的用法，是学习 Java 的基础。通过上面的示例，可以看到如何使用不同的关系运算符来比较变量并做出相应的判断。希望这些内容能帮助你更好地理解和运用 Java 中的关系运算符。

2024-08-08发表2024-08-10更新编程 / Java进阶5 分钟读完 (大约824个字)

使用 Stream API 处理集合

Stream API 是 Java 8 引入的重要特性，它提供了对集合进行函数式编程的能力，能够更简洁、更易读地处理数据。本文将详细介绍如何使用 Stream API 处理集合。

1. 引言

Stream API 可以用于对 Collection 接口的实现类（如 List、Set 等）进行操作。使用 Stream 的最大优势是可以通过链式调用进行复杂数据处理，而没有需要额外的中间变量。

2. 创建 Stream

2.1 从集合创建

Stream 可以从集合直接创建，例如：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Apple", "Banana", "Orange");
        Stream<String> stream = list.stream();
    }
}

2.2 从数组创建

可以使用 Arrays.stream() 方法将数组转换为 Stream：

1 2	String[] array = {"A", "B", "C"}; Stream<String> streamFromArray = Arrays.stream(array);

3. 常用操作

Stream API 提供了多种常用操作，可以分为以下几类：

3.1 中间操作

中间操作会返回一个新的 Stream，典型的中间操作有 filter()、map()、sorted()、distinct() 等。

3.1.1 `filter()`

用于筛选出符合条件的元素：

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry", "Date");

List<String> filteredFruits = fruits.stream()
    .filter(fruit -> fruit.startsWith("A")) // 只保留以"A"开头的水果
    .collect(Collectors.toList());

System.out.println(filteredFruits); // [Apple]

3.1.2 `map()`

用于将每个元素转换成另一种形式：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<Integer> nameLengths = names.stream()
    .map(String::length) // 计算每个名字的长度
    .collect(Collectors.toList());

System.out.println(nameLengths); // [5, 3, 7]

3.1.3 `sorted()`

用于对流中的元素进行排序：

List<String> unsorted = Arrays.asList("Banana", "Apple", "Cherry");

List<String> sortedFruits = unsorted.stream()
    .sorted() // 默认按照自然顺序排序
    .collect(Collectors.toList());

System.out.println(sortedFruits); // [Apple, Banana, Cherry]

3.2 终端操作

终端操作会结束 Stream 的处理，并生成一个结果或有副作用的操作。常见的终端操作有 collect()、forEach()、count()、reduce() 等。

3.2.1 `collect()`

用于将流的结果收集到集合中：

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");

Set<String> fruitSet = fruits.stream()
    .collect(Collectors.toSet()); // 收集到一个 Set 中

System.out.println(fruitSet); // [Apple, Banana, Cherry]

3.2.2 `forEach()`

用于遍历流中的每个元素：

1
2
3

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");

fruits.stream().forEach(fruit -> System.out.println(fruit)); // 打印每个水果

3.2.3 `count()`

用于计算流中的元素数量：

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");

long count = fruits.stream().count(); // 计算元素个数
System.out.println(count); // 3

3.2.4 `reduce()`

用于对流中的元素进行聚合操作，返回一个累加结果：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()
    .reduce(0, Integer::sum); // 计算总和

System.out.println(sum); // 15

4. 组合操作示例

Stream API 允许我们将多种操作组合在一起，以实现复杂的数据处理需求。例如，筛选出以特定字母开头的水果并将其转换为大写，然后排序：

List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry", "Apricot");

List<String> result = fruits.stream()
    .filter(fruit -> fruit.startsWith("A")) // 筛选以"A"开头的水果
    .map(String::toUpperCase) // 转换为大写
    .sorted() // 排序
    .collect(Collectors.toList()); // 收集结果

System.out.println(result); // [ALMOND, APPLE, APRICOT]

5. 结论

Java 的 Stream API 是操作集合的强大工具，通过提供一系列的中间操作和终端操作，使得数据处理可以更简洁、更灵活。掌握 Stream API 的使用，将大大提高你的 Java 编程能力和效率。

2024-08-08发表2024-08-10更新编程 / Java小白7 分钟读完 (大约978个字)

逻辑运算符

在 Java 编程中，逻辑运算符用于组合布尔表达式，常用于条件判断和控制程序流程。Java 中的主要逻辑运算符包括：

&&（逻辑与）
||（逻辑或）
!（逻辑非）

1. 逻辑与（`&&`）

逻辑与运算符 &&用于连接两个布尔表达式，当且仅当两个表达式都为 true 时，结果为 true。

示例

boolean a = true;
boolean b = false;

boolean result = a && b; // result 为 false

在上面的代码中，由于 b 为 false，因此 result 的值也是 false。

逻辑与的使用场景

逻辑与通常用于需要多个条件同时满足的场景，例如：

int age = 25;
boolean hasLicense = true;

if (age >= 18 && hasLicense) {
    System.out.println("可以合法驾驶。");
} else {
    System.out.println("无法合法驾驶。");
}

在这个例子中，只有当 age >= 18 且 hasLicense 为 true 时，才能输出“可以合法驾驶”。

2. 逻辑或（`||`）

逻辑或运算符 || 用于连接两个布尔表达式，只要其中一个表达式为 true，结果就是 true。

示例

boolean x = true;
boolean y = false;

boolean result = x || y; // result 为 true

在这个示例中，尽管 y 为 false，但由于 x 为 true，因此 result 的值为 true。

逻辑或的使用场景

逻辑或常在需要满足任一条件的情况下使用，例如：

boolean isWeekend = true;
boolean hasWork = false;

if (isWeekend || hasWork) {
    System.out.println("可以放松一下。");
} else {
    System.out.println("需要工作。");
}

在这个例子中，只要 isWeekend 为 true 或 hasWork 为 true，则输出“可以放松一下”。

3. 逻辑非（`!`）

逻辑非运算符 ! 用于反转布尔值。如果布尔表达式为 true，应用逻辑非后将变为 false，反之亦然。

示例

1
2
3

boolean condition = true;

boolean result = !condition; // result 为 false

在这个例子中，condition 为 true，因此经过逻辑非操作后，result 变为 false。

逻辑非的使用场景

逻辑非可用于简化条件判断，例如：

boolean isRaining = false;

if (!isRaining) {
    System.out.println("今天不下雨，可以出去玩！");
} else {
    System.out.println("今天下雨，呆在家里吧。");
}

在这个例子中，我们判断 isRaining 的相反情况。

4. 结合使用逻辑运算符

在实际应用中，逻辑运算符通常被结合使用，形成复杂的条件表达式。例如：

int temperature = 30;
boolean isSunny = true;

if ((temperature > 25 && temperature < 35) || isSunny) {
    System.out.println("适合去海滩。");
} else {
    System.out.println("不适合去海滩。");
}

这里我们同时检查了温度和天气条件，只要温度在 25 到 35 度之间，或者天气晴朗，就适合去海滩。

5. 逻辑运算符的优先级

在 Java 中，逻辑运算符的优先级如下（从高到低）：

!（逻辑非）
&&（逻辑与）
||（逻辑或）

这意味着在没有使用括号的情况下，代码会先计算逻辑非，然后是逻辑与，最后是逻辑或。如果你希望改变默认的优先级，可以使用括号来明确表达式的计算顺序。

示例

boolean a = true;
boolean b = false;
boolean c = true;

// 先计算 a && b，然后和 c 进行或运算
boolean result = a && b || c; // result 为 true

// 使用括号改变优先级
boolean resultWithParentheses = a && (b || c); // resultWithParentheses 为 true

在这个例子中，我们展示了不同优先级下的结果。

小结

逻辑运算符在 Java 中是构建复杂条件语句的基本工具。掌握 &&、|| 和 ! 的用法以及它们的优先级，可以帮助你更好地控制程序逻辑和流向。通过练习和实际应用，你会逐渐熟悉这些运算符，并能够灵活利用它们来解决不同的问题。

1. 关系运算符列表

2. 运算符详解

2.1 等于运算符 ==

2.2 不等于运算符 !=

2.3 大于运算符 >

2.4 小于运算符 <

2.5 大于等于运算符 >=

2.6 小于等于运算符 <=

3. 复合使用示例

4. 小结

1. 引言

2. 创建 Stream

2.1 从集合创建

2.2 从数组创建

3. 常用操作

3.1 中间操作

3.1.1 filter()

3.1.2 map()

3.1.3 sorted()

3.2 终端操作

3.2.1 collect()

3.2.2 forEach()

3.2.3 count()

3.2.4 reduce()

4. 组合操作示例

5. 结论

1. 逻辑与（&&）

示例

逻辑与的使用场景

2. 逻辑或（||）

示例

逻辑或的使用场景

3. 逻辑非（!）

示例

逻辑非的使用场景

4. 结合使用逻辑运算符

5. 逻辑运算符的优先级

示例

小结

链接

分类

最新文章

标签

2.1 等于运算符 `==`

2.2 不等于运算符 `!=`

2.3 大于运算符 `>`

2.4 小于运算符 `<`

2.5 大于等于运算符 `>=`

2.6 小于等于运算符 `<=`

3.1.1 `filter()`

3.1.2 `map()`

3.1.3 `sorted()`

3.2.1 `collect()`

3.2.2 `forEach()`

3.2.3 `count()`

3.2.4 `reduce()`

1. 逻辑与（`&&`）

2. 逻辑或（`||`）

3. 逻辑非（`!`）