我们这一期的嘉宾是 Java 工程师刘睿。1999 年，在刘睿读初中时，喜欢尝试新东西的父亲花了好几个月工资给家里买了一台电脑，自己探索学习编程，研究各种软件。父亲的学习热情也影响了他对计算机和编程产生兴趣。

在读大学选择专业的时候，刘睿并没有选择当时不热门的计算机专业，但是因为高考分数不够高，被调剂到计算机专业，开始了真正的编程学习之旅，并且自学 Java。

大学时他曾做过社团主席，但是因为没有学位证，在很长一段时间极度不自信，甚至在最初找工作时他只想当个网管。后来，他通过不断摄取知识，重拾自信，在职业发展中逐渐从公司最边缘的开发者成长为上市公司的软件架构师。

刘睿有 15 年 Java 开发经验。在业余时间，他热爱阅读，坚持每天学习，发布了很多关于学习、求职、工作和生活各种主题的视频。同时，他在 freeCodeCamp 社区中写文章、创建视频教程，分享的经验帮助了社区中的很多人。

在这期节目里，他分享了自己的一些鲜为人知的往事，分享他的学习和工作经历，以及如何用程序员的思维指导生活，言谈之间透着哲思。

如果这期节目让你产生一些共鸣，请记得给我们好评，并把节目分享给更多朋友。

欢迎在 https://chinese.freecodecamp.org/ 查看免费的编程学习资源。

更多关于嘉宾的信息

• bilibili 主页
• GitHub 主页

主要话题

• 03:28 初中时独立解决游戏 bug
• 05:42 编程初体验
• 11:30 被调剂到计算机专业
• 13:16 大学选专业时考虑的五个维度
• 16:32 告别颓废，自学 Java
• 18:39 自学编程需要注意加强哪些知识
• 24:17 “源码在手，天下我有”
• 26:41 打破“不自信”的成长障碍
• 28:30 如何保持技术知识的更新
• 29:28 给 Java 学习者的建议
• 31:20 第一次给知名开源项目贡献代码
• 33:05 大厂和小厂招聘的区别
• 34:55 即时反馈是从编程中获得的最大乐趣
• 37:31 优秀程序员的三个特质
• 41:29 程序的本质是什么
• 44:42 是否担心被 AI 取代
• 48:54 大龄程序员如何克服焦虑
• 50:12 开发 iOS 应用督促自己和女儿每天阅读
• 53:18 特别想推荐给刚入门编程的人们的一本书

提到的资源

• 文章《你不知道的 Java》

• 《Java 新手课》视频教程
  • 入门课
  • 通过编写一个 2048 小游戏学习面向对象相关思想
  • 用 Vert.x 开发简易 Web 聊天室

• BookTime - 您的阅读计时伴侣
• 免费试用链接
• Obsidian
• Vert.x
• Quarkus
• 书籍《程序员修炼之道：从小工到专家》

在 Java 中，你可以用不同的方法将变量从一种数据类型转换为另一种。

在这篇文章中，你将学习如何在 Java 中通过以下方式将整数转换成字符串：

• 使用 Integer.toString() 方法
• 使用 String.valueOf() 方法
• 使用 String.format() 方法
• 使用 DecimalFormat 类

如何在 Java 中使用 Integer.toString() 将整数转换成字符串

Integer.toString() 方法接收要转换的整数作为参数，语法如下：

Integer.toString(INTEGER_VARIABLE)

这是一个例子：

class IntToStr {
    public static void main(String[] args) {
        
        int age = 2;
        String AGE_AS_STRING = Integer.toString(age);
        
        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old
    }
}

在上面的例子中，我们创建了一个整数——age——并给它赋值为 2。

为了将 age 变量转换为字符串，我们将其作为参数传递给 Integer.toString() 方法：Integer.toString(age)。

我们将这个新的字符串值存储在一个名为 AGE_AS_STRING 的字符串变量中。

然后我们将新的字符串变量与其他字符串连接起来："The child is " + AGE_AS_STRING + " years old"。

但是，如果我们只是将年龄变量与这些其他字符串连接，而不进行任何形式的转换，是否会出现错误？

class IntToStr {
    public static void main(String[] args) {
        
        int age = 2;
        
        System.out.println("The child is " + age + " years old");
        // The child is 2 years old
    }
}

上面的输出与我们必须将整数转换为字符串的例子相同。

那么，我们如何知道类型转换是否真的成功了呢？

我们可以使用 Java 的 getClass() 对象来检查变量类型，即：

class IntToStr {
    public static void main(String[] args) {
        
        int age = 2;
        
        String AGE_AS_STRING = Integer.toString(age);
        
        
        System.out.println(((Object)age).getClass().getSimpleName());
        // Integer
        
        System.out.println(AGE_AS_STRING.getClass().getSimpleName());
        // String
    }
}

现在我们可以验证，当 age 变量被创建时，它是一个 Integer，经过类型转换，它变成了一个 String。

如何在 Java 中使用 String.valueOf() 将一个整数转换成一个字符串

String.valueOf() 方法也以要转换为字符串的变量为参数。

class IntToStr {
    public static void main(String[] args) {
        
        int age = 2;
        
        String AGE_AS_STRING = String.valueOf(age);
        
        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old
    }
}

上面的代码与上一节的代码类似：

• 我们创建了一个名为 age 的整数。
• 我们把 age 整数作为参数传给 String.valueOf() 方法：String.valueOf(age)。

你也可以使用 getClass() 对象来检查类型转换是否成功：

System.out.println(((Object)age).getClass().getSimpleName());
// Integer
        
System.out.println(AGE_AS_STRING.getClass().getSimpleName());
// String

如何在 Java 中使用 String.format() 将整数转换为字符串

String.format() 方法接收两个参数：一个格式指定器和要格式化的变量。

下面是一个例子：

class IntToStr {
    public static void main(String[] args) {
        
        int age = 2;
        
        String AGE_AS_STRING = String.format("%d", age);
        
        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old
        
    }
}

在上面的例子中，我们向 String.format() 方法传入了两个参数："%d" 和 age。

"%d" 是一个格式指定符，表示要被格式化的变量是一个整数。

age 是第二个参数，将被转换为字符串并存储在 AGE_AS_STRING 变量中。

你也可以检查转换前后的变量类型：

System.out.println(((Object)age).getClass().getSimpleName());
// Integer
        
System.out.println(AGE_AS_STRING.getClass().getSimpleName());
// String

如何在 Java 中使用 DecimalFormat 将整数转换成字符串

DecimalFormat 类用于在 Java 中格式化十进制数字。你可以用不同的方式来使用它，我们将用它来把一个整数转换为一个字符串。

下面是一个例子：

import java.text.DecimalFormat;

class IntToStr {
    public static void main(String[] args) {
        
        int age = 2;
        
        DecimalFormat DFormat = new DecimalFormat("#");
        
        
        String AGE_AS_STRING = DFormat.format(age);
        
        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old
        
        
        System.out.println(((Object)age).getClass().getSimpleName());
        // Integer
        
        System.out.println(AGE_AS_STRING.getClass().getSimpleName());
        // String
        
    }
}

让我们把代码分解一下：

• 为了能够在上面的例子中使用 DecimalFormat 类，我们导入了它：import java.text.DecimalFormat;。
• 我们创建了整数的 age 变量。
• 然后我们创建了一个名为 DFormat 的 DecimalFormat 类的新对象。
• 使用该对象的 format() 方法，我们将 age 转换为字符串：DFormat.format(age);。

小结

在这篇文章中，我们谈到了在 Java 中把整数转换为字符串。

我们看到的例子显示了如何使用三种不同的方法——Integer.toString()、 String.valueOf()、String.format()——和 DecimalFormat 类来将变量从整数转换成字符串。

每个例子都显示了如何在转换前后检查变量的数据类型。

Happy coding!

在使用编程语言时，你可能想把字符串转换为整数。一个例子是使用一个字符串变量的值进行数学运算。

在本文中，你将学习如何使用 Integer 类的两个方法——parseInt() 和 valueOf() 在 Java 中把字符串转换成整数。

如何在 Java 中使用 Integer.parseInt 将字符串转换为整数

parseInt() 方法把要转换为整数的字符串作为参数，即：

Integer.parseInt(string_varaible)

在看它的使用例子之前，让我们看看当你把一个字符串值和一个整数加在一起而不进行任何形式的转换时会发生什么。

class StrToInt {
    public static void main(String[] args) {
        String age = "10";
        
        System.out.println(age + 20);
        // 1020
    }
}

在上面的代码中，我们创建了一个 age 变量，字符串值为 “10”。

当与一个整数值 20 相加时，我们得到的是 1020，而不是 30。

这里有一个使用 parseInt() 方法的快速修复方法：

class StrToInt {
    public static void main(String[] args) {
        String age = "10";
        
        int age_to_int = Integer.parseInt(age);
        
        System.out.println(age_to_int + 20);
        // 30
    }
}

为了将 age 变量转换为整数，我们将其作为参数传递给 parseInt() 方法——Integer.parseInt(age)——并将其存储在一个名为 age_to_int 的变量中。

当与另一个整数相加时，我们得到了一个正确的加法：age_to_int + 20。

如何在 Java 中使用 Integer.valueOf 将一个字符串转换成一个整数

valueOf() 方法的工作原理与 parseInt() 方法相同。它把要转换为整数的字符串作为其参数。

下面是一个例子：

class StrToInt {
    public static void main(String[] args) {
        String age = "10";
        
        int age_to_int = Integer.valueOf(age);
        
        System.out.println(age_to_int + 20);
        // 30
    }
}

上述代码的解释与上一节相同：

• 我们把字符串作为参数传给 valueOf(): Integer.valueOf(age)。它被存储在一个名为 age_to_int 的变量中。
• 然后我们在创建的变量中加入 20：age_to_int + 20。结果值是 30，而不是 1020。

小结

在这篇文章中，我们谈到了在 Java 中把字符串转换为整数。

我们看到了如何使用 Integer 类的两个方法——parseInt() 和 valueOf() 在Java中把字符串转换为整数。

Happy coding!

多维数组只是数组的数组。你可以将其视为存储多个容器的单个容器。

在本文中，我们将讨论 Java 中的二维数组。你将看到创建一个数组的语法，以及如何在二维数组中添加和访问项目。

如何在 Java 中声明一个二维数组

要在 Java 中创建二维数组，你必须指定要存储在数组中的项目的数据类型，后跟两个方括号和数组的名称。

语法如下所示：

data_type[][] array_name;

让我们看一个代码示例。

int[][] oddNumbers = { {1, 3, 5, 7}, {9, 11, 13, 15} };

如果你还没有理解上面发生的事情，请不要担心。在下一节中，你将了解有关二维数组如何工作以及如何访问存储在其中的项目的更多信息。

如何在 Java 中访问二维数组中的项目

我们可以使用两个方括号来访问二维中的项目。

第一个表示我们要从中访问项目的数组，而第二个表示我们要访问的项目的索引。

让我们用一个例子来简化上面的解释：

int[][] oddNumbers = { {1, 3, 5, 7}, {9, 11, 13, 15} };

System.out.println(oddNumbers[0][0]);
// 1

在上面的示例中，oddNumbers 数组中有两个数组——{1, 3, 5, 7} 和 {9, 11, 13, 15}。

第一个数组——{1, 3, 5, 7}——用 0 表示。

第二个数组——{9, 11, 13, 15}——用 1 表示。

第一个数组是 0，第二个是 1，第三个是 2，依此类推。

因此，要访问第一个数组中的项目，我们将 0 分配给第一个方括号。由于我们试图访问数组中的第一项，我们将使用它的索引，即 0：oddNumbers[0][0]。

让我们进一步分解它。

这是访问项目的代码：oddNumbers[?][?]。

我在两个方括号中都加上了问号——我们会随着我们的进展填写它们。

因此，假设我们要访问第二个数组中用 1 表示的项目，我们的代码将如下所示：oddNumbers[1][?]。

现在我们在第二个数组（{9, 11, 13, 15}）中，让我们尝试访问其中的一个项目。就像常规数组一样，每个项目都有一个从零开始的索引。

因此，要访问第三项 13，我们将其索引号传递给第二个方括号：oddNumbers[1][2]。

在下一节中，我们将从一个新示例开始。

如何在 Java 示例中访问二维数组中的项目

int[][] oddNumbers = { {1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23} };

这里的目标是访问第三个数组中的 21。我们的访问代码仍然有问号：oddNumbers[?][?]。

我们将首先给第一个问号一个指向要访问的特定数组的值。

数组 0 => {1, 3, 5, 7}
数组 1 => {9, 11, 13, 15}
数组 2 => {17, 19, 21, 23}

我们要查找的数字在第三个数组中，数组索引为 2。所以我们找到了第一个方括号的值：oddNumbers[2][?]。

第二个方括号的值将指向要访问的实际项目。为此，我们必须指定项目的索引号。以下是该数组中的索引：

17 => 索引 0
19 => 索引 1
21 => 索引 2
23 => 索引 3

21 的索引为 2，因此我们可以继续将其添加到第二个方括号：oddNumbers[2][2]。当你将其打印到控制台时，你将打印出 21。

代码如下所示：

int[][] oddNumbers = { {1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23} };

System.out.println(oddNumbers[2][2]);
// 21

你可以使用嵌套循环遍历二维数组中的所有项目。这是一个例子：

int[][] oddNumbers = { {1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23} };

for(int i = 0; i < oddNumbers.length; i++){
    for(int j = 0; j < oddNumbers[i].length; j++){
        System.out.println(oddNumbers[i][j]);
    }   
}

// 1
// 3
// 5
// 7
// 9
// 11
// 13
// 15
// 17
// 19
// 21
// 23

上面的代码打印出 oddNumbers 数组中的所有项目。

小结

在本文中，我们讨论了 Java 中的二维数组。

我们看到了创建二维数组的语法，还看到了展示如何访问存储在其中的项目的示例。

最后，我们看到了如何循环并打印二维数组中的项目。

祝你编程愉快！

当你学习一门新的编程语言时，你经常会看到第一个程序叫作 “hello world”。它在大多数情况下是初学者需要写的简单程序。

我假设你是作为 Java 编程语言的初学者阅读本文，或者你是为了回忆古老的 hello world 程序。

本文不仅包括 Java 中的 hello world 程序，我们还将讨论一些初学者学习使用 Java 时应该知道的术语。

要继续进行，你需要一个集成开发环境（IDE）。这是你编写和编译代码的地方。你可以在你的 PC 上安装一个，或者如果你不想完成安装过程，则可以使用任何在线 IDE。

Java 中的 Hello World 程序

在本节中，我们将创建一个简单的 hello world 程序。然后，我们将对其进行分解，以便你了解它的工作原理。

代码如下：

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!"); 
        // Hello World!
    }
}

上面示例中的代码将打印 “Hello World！” 到控制台中。这在代码中被注释掉了。我们将很快讨论注释。

让我们分解代码。

Java 中的类

类充当 Java 中整个应用程序的构建块。你可以为不同的功能设置单独的类。

类还可以具有定义类的内容和作用的属性和方法。

一个例子是 Human 类。它可以具有头发颜色、高度等属性。它可以有跑步、吃饭和睡觉等方法。

在我们的 Hello World 程序中有一个名为 HelloWorld 的类。作为惯例，始终将类的名称的首字母大写。

要创建一个类，请使用 class 关键字，后跟类的名称。这是一个使用我们的 Hello World 程序的示例：

class HelloWorld {
    
}

Java 中的 main 方法

每个 Java 程序都必须有一个 main 方法。当 Java 编译器开始执行我们的代码时，它从 main 方法开始。

这是 main 方法的样子：

public static void main(String[] args) {
        
    }

为了使本文保持简单，我们不会讨论上面代码中的其他关键字，例如 public、static 和 void。

System.out.println() 语句

我们使用 System.out.println() 语句将信息打印到控制台。该语句需要一个参数。参数写在括号之间。

这是语法：

System.out.println(Argument) 

在例子中，我们传入了 “Hello World！” 作为参数。你会注意到文本被引号包围。这告诉编译器参数是一个字符串 string。编程中的字符串只是字符的集合——与我们编写常规文本的方式相同，但它们必须用引号引起来。

这是我们的代码的样子：

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!"); 
        // Hello World!
    }
}

当我们运行此代码时，将打印 “Hello World”。

我使用 //Hello World！向你展示代码输出。这部分代码不会被编译器执行，因为它是一个注释。

我们使用两个正斜杠（//）在 Java 中开始单行注释。

小结

在本文中，我们讨论了 Java 中的 Hello World 程序。

我们从创建程序开始，然后将其分解以了解用于创建程序的每一行代码。

我们讨论了 Java 中的类、main 方法、System.out.println() 语句、字符串和注释。

祝你编程愉快！

如果你对学习 Java 感兴趣，我们在 freeCodeCamp 中文 YouTube 频道发布了 Java 新手课第三部分——用 Vert.x 开发简易 Web 聊天室。Vert.x 是一个用于在 JVM 上构建响应式应用程序的工具包。

这个教程的作者是牧云踏歌，他是一位资深的 Java 开发者。在这一个多小时的视频里，他将引导大家理解何谓工程化的 Java 项目开发，以及如何利用已有的 Java 生态，站在巨人的肩膀上完成自己的项目。

教程的内容包括：

• 铺垫
• 使用 gradle 作为构建工具创建项目
• Vert.x 项目开发入门
• 使用 vertx-web 开发 Web 项目
• 聊天室代码具体实现
• 使用 gradle 插件将程序打包

你可以点击这个链接在 bilibili 观看视频。

你也可以在 YouTube 观看视频：

当满足特定条件时，你可以使用 Java 中的 switch 语句来执行特定的代码块。

语法如下所示：

switch(expression) {
  case 1:
    // code block
    break;
  case 2:
    // code block
    break;
    case 3:
    // code block
    break;
  default:
    // code block
}

上面，将 switch 括号中的表达式（expression）与每种情况（case）进行了比较。当 expression 与 case 相同时，执行 case 中对应的代码块。

如果所有 case 都不匹配 expression，则执行在 default 关键字下定义的代码块。

每当满足某个条件时（当 expression 与 case 匹配时），我们使用 break 关键字来终止代码。

让我们看一些代码示例。

如何在 Java 中使用 Switch Case

看看下面的代码：

class CurrentMonth {
    public static void main(String[] args) {
        
        int month = 6;
        
        switch (month) {
          case 1:
            System.out.println("January");
            break;
          case 2:
            System.out.println("February");
            break;
          case 3:
            System.out.println("March");
            break;
          case 4:
            System.out.println("April");
            break;
          case 5:
            System.out.println("May");
            break;
          case 6:
            System.out.println("June");
            break;
          case 7:
            System.out.println("July");
            break;
          case 8:
            System.out.println("August");
            break;
          case 9:
            System.out.println("September");
            break;
          case 10:
            System.out.println("October");
            break;
          case 11:
            System.out.println("November");
            break;
          case 12:
            System.out.println("December");
            break;
            
            // June
        }
    }
}

在上面的代码中，June 被打印出来。不用担心庞大的代码。以下介绍可帮助你理解：

我们创建了一个名为 month 的整数，并为其分配了一个值 6：int month = 6;。

接下来，我们创建了一个 switch 语句，并将 month 变量作为参数传入：switch (month){...}。

作为 switch 语句的表达式，month 的值将与代码中的每个 case 值进行比较。我们有 case 1 到 12。

month 的值是 6，因此它与 case 6 匹配。这就是 case 6 中的代码被执行的原因。其他代码块都被忽略了。

这是另一个简化的例子：

class Username {
    public static void main(String[] args) {
        
        String username = "John";
        
        switch (username) {
          case "Doe":
            System.out.println("Username is Doe");
            break;
          case "John":
            System.out.println("Username is John");
            break;
          case "Jane":
            System.out.println("Username is Jane");
            break;
            // Username is John
        }
    }
}

在上面的示例中，我们创建了一个名为 username 的字符串，其值为 “John”。

在 switch 语句中，username 作为 expression 传入。然后我们创建了三个 case——“Doe”、“John”和“Jane”。

在这三个类中，只有一个匹配 username 的值——“John”。结果，case "John" 的代码块被执行了。

如何在 switch 语句中使用默认关键字

在上一节的示例中，我们的代码被执行是因为一个 case 匹配了一个 expression。

在本节中，你将了解如何使用 default 关键字。在没有任何 case 与 expression 匹配的情况下，你可以将其用作后备。

这是一个例子：

class Username {
    public static void main(String[] args) {
        
        String username = "Ihechikara";
        
        switch (username) {
          case "Doe":
            System.out.println("Username is Doe");
            break;
          case "John":
            System.out.println("Username is John");
            break;
          case "Jane":
            System.out.println("Username is Jane");
            break;
          default:
            System.out.println("Username not found!");
            // Username not found!
        }
    }
}

上例中的 username 变量的值为 “Ihechikara”。

default 关键字的代码块将被执行，因为创建的 case 都不匹配 username 的值。

小结

在本文中，我们了解了如何在 Java 中使用 switch 语句。

我们还讨论了 Java 中 switch 语句的 expression、case 和 default 关键字，以及它们的用例和代码示例。

祝你编程愉快！

在 Java 中，你使用数组将一组变量（具有相同数据类型）存储在单个变量中。

在许多情况下，存储在数组中的值以随机顺序出现。使用 Java 中的 Arrays 类，你可以访问可用于操作数组的各种方法。

我们将从 Arrays 类中使用的方法之一是 sort() 方法，它按升序对数组进行排序。

我们还将看到如何使用 Java 中 Collections 类的 reverseOrder() 方法对数组进行降序排序。

如何使用 Arrays.sort() 在 Java 中按升序对数组进行排序

在本节中，我们将看到一个示例，说明如何使用 sort() 方法对数组进行升序排序。

import java.util.Arrays;

class ArraySort {
    public static void main(String[] args) {
        int[] arr = { 5, 2, 1, 8, 10 };
        Arrays.sort(arr);
        
        for (int values : arr) {
            System.out.print(values + ", ");
            // 1, 2, 5, 8, 10,
        }
    }
}

我们在上面的示例中做的第一件事是导入 Arrays 类：import java.util.Arrays;。这使我们可以访问 Arrays 类的所有方法。

然后我们以随机顺序创建了一个包含数字的数组：int[] arr = { 5, 2, 1, 8, 10 };。

为了按升序对该数组进行排序，我们将数组作为参数传递给 sort() 方法：Arrays.sort(arr);。

请注意，Arrays 类是在使用点符号访问 sort() 方法之前首先编写的。

最后，我们在控制台中循环并打印了数组。结果是一个排序数组：1, 2, 5, 8, 10。

在下一节中，我们将讨论按降序对数组进行排序。

如何在 Java 中使用 Collections.reverseOrder() 对数组进行降序排序

要按降序对数组进行排序，我们使用可以从 Collections 类访问的 reverseOrder()。

我们仍将使用 Arrays.sort();，但在此示例中，它将接受两个参数——要排序的数组和 Collections.reverseOrder()。

这是一个例子：

import java.util.Arrays;
import java.util.Collections;

class ArraySort {
    public static void main(String[] args) {
        Integer[] arr = { 5, 2, 1, 8, 10 };
        Arrays.sort(arr, Collections.reverseOrder());
        
        for (int values : arr) {
            System.out.print(values + ", ");
            // 10, 8, 5, 2, 1,
        }
    }
}

首先，我们导入了 Arrays 和 Collections 类，因为我们将使用这些类提供的方法。

然后我们以随机顺序创建了一个数字数组：Integer[] arr = { 5, 2, 1, 8, 10 };。你会注意到我们使用 Integer[] 而不是 int[]，就像我们在上一个例子中所做的那样——后者会抛出一个错误。

要按降序对数组进行排序，我们这样做：Arrays.sort(arr, Collections.reverseOrder());。

第一个参数是数组 arr ，它将按升序排序。第二个参数 - Collections.reverseOrder() - 然后将反转排序数组的顺序，使其按降序排列。

循环并打印时，数组将如下所示：10, 8, 5, 2, 1。

总结

在本文中，我们讨论了 Java 中的排序数组。数组可以按升序或降序排序。

我们可以使用可以从 Arrays 类的 sort() 方法对数组进行升序排序。sort() 方法接受要排序的数组作为参数。

要按降序对数组进行排序，我们使用了 Collections 类的 reverseOrder() 方法。这作为 sort() 方法中的第二个参数传入，以便可以按降序重新排列排序后的数组。

祝你编码愉快！

1、new BigDecimal(0)、new BigDecimal("0")、new BigDecimal(1)、new BigDecimal("1")、new BigDecimal(10)、new BigDecimal("10")

BigInteger 和 BigDecimal 这两个高精度数字类，对应整数 0、1、10 的值都有对应的常量（BigInteger.ZERO / BigDecimal.ZERO、BigInteger.ONE / BigDecimal.ONE、BigInteger.TEN / BigDecimal.TEN）可供使用。

为了节省创建对象和垃圾回收的开销，我们应该直接使用这些常量。 尤其是 new BigDecimal("0") 这种用法，它不仅会带来创建 BigDecimal 对象的开销，还有把字符串解析成数字的开销。

ZERO、ONE、TEN 这 3 个常量的值是不会变的，因为跟 Integer、Long 这些实现 Number 接口的类一样，BigInteger 和 BigDecimal 也是不可变的（immutable），也就是说调用一个 BigDecimal 对象的任何公共的成员方法都不会改变该 BigDecimal 对象的值。执行如 BigDecimal.TEN.multiply(new BigDecimal(15)) 这样的代码不会改变 BigDecimal.TEN 的值。

2、BigDecimal.ZERO.subtract(bigDecimal)

取一个 BigDecimal 变量的相反数，我们可以直接使用 BigDecimal 类的 negate 方法。

BigDecimal 类的核心其实是3个私有的成员属性：一个 BigInteger 属性 value 表示数字的各个位、一个整数属性 scale 表示小数点的位置、一个整数属性 sign 表示数字的符号（-1 表示负数、0 表示 0、1 表示正数）。一个 BigDecimal 对象的值就是 sign * value / (10 ^ scale)。例如 value 属性的值为 15、scale 属性的值为 0、sign 属性的值为 -1，则该 BigDecimal 对象表示 -15；如果 value 属性的值为 15、scale 属性的值为 1、sign 属性的值为 1，则该BigDecimal对象表示 15 / 10 = 1.5；如果 BigInteger 属性的值为 15、小数点属性的值为 -1、符号属性的值为 1，则该 BigDecimal 对象表示 15 * 10 = 150。

negate 方法是调用 BigDecimal 的私有构造方法，直接创建一个 sign 属性为原 BigDecimal 对象的 sign 的相反数的新的 BigDecimal 对象，不会涉及到减法运算的逻辑。如果我们使用 BigDecimal.ZERO 的 subtract 方法，则会带来高精度小数减法的开销（BigDecimal 的 subtract 方法需要先判断两个 BigDecimal 对象的 scale 属性的大小，调整其中一个 BigDecimal 对象的 scale 属性和 value 属性使两个 BigDecimal 对象的 scale 属性相等）。

3、bigDecimal.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO.subtract(bigDecimal) : bigDecimal

取一个 BigDecimal 变量的绝对值，我们可以直接使用 BigDecimal 类的 abs 方法。

上文已提到，BigDecimal 类的值由 value、scale 和 sign 3个私有成员属性决定。abs 方法是调用 BigDecimal 的私有构造方法，直接创建一个 sign 属性为 1 的新的 BigDecimal 对象，可以为我们省去判断一个 BigDecimal 对象的值是否小于 0 的开销。

4、bigDecimal.multiply(new BigDecimal(100))、bigDecimal.divide(new BigDecimal(100))

要得到一个 BigDecimal 变量乘以 10 的整数次幂，我们可以直接使用 BigDecimal 类的 scaleByPowerOfTen 方法。

bigDecimal.scaleByPowerOfTen(n) 返回一个值为 bigDecimal * 10 ^ n 的新的 BigDecimal 对象。scaleByPowerOfTen 方法是调用 BigDecimal 的私有构造方法，直接创建一个 scale 属性等于原 BigDecimal 对象的 scale - n 的新的 BigDecimal 对象，可以为我们省去高精度小数乘除法的开销。

要全面深入了解 BigDecimal 的用法，可参考 JavaSE 8 的 API 文档和 OpenJDK 8 中 BigDecimal.java 的源码。

根据维基百科上的介绍[1]以及Shaun Abram的一篇博文[2]，一个JavaBean通常是一个有以下3种特点的公共Java类：

1. 有一个无参的构造方法（默认构造方法）；
2. 所有属性都是private的，类外部需要通过public的getter和setter来访问属性；
3. 实现了Serializable接口。

JavaBeans规范[3]中指出，JavaBeans是一种能在开发工具中可视化地编辑的可重用的软件组件，它需要有一系列的属性，可能有一些事件。在JavaBeans规范的第7章中规定了一个JavaBean的属性应该是private的，类外部应该通过pubilc的getter和setter方法来访问属性。在JavaBeans规范的第2章中有规定一个JavaBean需要是可序列化的，以便传输和持久化JavaBean的状态。但是JavaBeans规范中没有规定一个JavaBean必须有一个无参的构造方法。

JavaBeans规范发布于1997年，所以JavaBeans规范其实主要是围绕Java Applet来设计的。Java Applet中的GUI组件会有属性（例如按钮的名称）和事件（例如输入框的输入事件），GUI组件的状态可能需要在服务器端和客户端之间传输，因此JavaBeans的定义中除了属性还包括了事件，而且也规定了JavaBeans需要可序列化。但是现在许多的Java开发是在纯服务器端软件的领域，服务器应用上的如数据库连接这样的对象或者一些实现业务逻辑的对象是不应该在电脑之间传输的，所以我认为这些对象就不适用传统的JavaBeans的定义，至少不适用可序列化这个特性。

EJB

EJB是企业级JavaBeans（Enterprise JavaBeans）的英文缩写。根据EJB规范[4]，一个企业级Bean（Enterprise Bean）有以下特性：

1. 通常包含操作企业数据的业务逻辑；
2. 由容器在运行时管理；
3. 用户需要通过容器访问企业级Bean；
4. 能在部署时根据运行环境定制；
5. 能通过注解或XML在编译或部署时指定其中使用的一些配置信息（可配置）；
6. 只使用了EJB规范中规定的服务的企业级Bean能在任意EJB容器中使用（可移植）；
7. 企业级Bean可以不需要重新编译就被封装在一个企业级应用中。

EJB规范中还指出，一个企业级Bean可以是有状态的，也可以是无状态的；可以实现业务逻辑，也可以代表一个持久化的实体。由此可见，EJB和JavaBeans其实是有挺大区别的，可以说一个EJB并不一定是一个JavaBean。一个EJB也不一定有无参构造方法和实现Serializable接口。

EJB规范中也没有规定一个企业级Bean的属性必须是private的，要通过public的getter和setter来访问。不过我们基于类的封装性和降低类之间的耦合的考虑，通常还是会遵循将属性设为private，为其写public的getter和setter这样的设计。

Spring Bean

根据Spring Framework的官方文档[5]，在Spring中由Spring IoC容器管理的构成应用主干的对象就是bean。（注：IoC是控制反转 Inverse of Control 的英文缩写。）Spring beans都是由Spring IoC容器根据XML配置文件或注解等方式来实例化、组装和管理的。

我认为，Spring beans和EJB比较类似，它们通常都是数据库连接、事务管理器、消息中间件连接、Session管理器、数据访问对象、业务逻辑服务之类的，只是Spring beans是由Spring IoC容器管理的，EJB是由EJB容器管理的。Spring beans同样不一定有无参构造方法和实现Serializable接口。

POJO

POJO是简单的传统的Java对象（Plain Old Java Object）的英文缩写，另有Plain Ordinary Java Object、Pure Old Java Object等说法，最早由Martin Fowler、Rebecca Parsons和Josh MacKenzie提出。[6][7] 结合Spring文档中对POJO的介绍[8]，我们可以知道，POJO是一种尽量不依赖任何第三方库、框架甚至JavaEE规范的实现的Java对象，它应该尽量不继承任何类、不实现任何接口、不包含任何与第三方库或框架相关的注解。

由上述介绍我们可以发现，POJO和JavaBeans、EJB和Spring beans都没有必然的联系。负责GUI组件的继承java.awt.Component的JavaBeans、实现JavaEE规范中的接口的EJB、实现Spring框架中的接口的Spring beans或者使用了Spring框架中的注解的Spring beans都不是POJO。POJO的定义中同样没有规定它有怎样的构造方法和怎样的属性。

因为一个POJO不依赖任何第三方库和框架，它的可维护性和可移植性会更强，开发人员开发与这个POJO相关的功能时，不必考虑它依赖的第三方库或框架的实现，可以更专注于这个POJO本身的业务功能。第三方库或框架升级的时候，不必对POJO进行修改。POJO给了开发人员充分的灵活性，开发人员可以选择将一个POJO应用在任意一个框架中（例如Spring或者Struts、Hibernate或者MyBatis），或者选择不应用在框架中。

BO

BO是业务对象（Business Object）的英文缩写。通常认为，业务对象是用于描述业务逻辑中的对象，但业务对象不依赖具体实现。如果换一种实现方式，例如从关系式数据库迁移到非关系式数据库，或者从单点系统改成一个分布式系统，一个业务对象类需要发生改变的话，那这个业务对象类的设计就是不合理的。

业务对象中的属性应该与业务人员、需求人员、客户理解的一致。例如一个用户信息类中，开发人员可能会在里面设置一个”创建时间“字段，但对于业务人员来说，用户没有“创建时间”，只有“注册时间”，那么用户业务对象中的字段就应该叫做“注册时间”而非“创建时间”。又例如，多数互联网应用，删除一个实体的时候并不会从数据库中物理删除，而是在数据库记录中将该实体的记录的状态字段改为“已删除”，这种“已删除”状态的对象可以是下文说的PO或者DTO，但是一个BO。

又例如，用关系式数据库时，通常会用一个中间表/中间对象来帮助描述多对多关系，我认为这种多对多关系对象（通常是一个PO）就不能算是业务对象。

我觉得，由于业务对象是业务人员，通常业务对象只是在需求或者实现设计中出现，很少人会在代码里写一个纯粹的BO类，即使写BO类，也是作为下文所说的DTO、PO或者VO的基类或组成部分。

DTO

DTO是数据传输对象（Data Transfer Object）的英文缩写。

DTO通常是一个JavaBean（按照有无参构造方法、属性都为private、属性通过public的getter/setter来访问、实现Serializable接口的定义）。DTO也通常是一个POJO，因为要考虑其在交互的系统之间的可移植性。

PO

PO是持久化对象（Persistent Object）的英文缩写。通常我们对PO的理解就跟百度百科[9]中说的一样：一个PO类与一个数据库表对应，一个PO与数据库表中的一行对应。PO通常是也一个JavaBean（按照有无参构造方法、属性都为private、属性通过public的getter/setter来访问、实现Serializable接口的定义）。PO可以是一个POJO，也可能含有JPA规范中定义的一些注解（例如@Entity、@Table、@Column、@Id等）。

虽然在很多架构设计中，DTO和PO等对象没有作区分，都放在model包或者entity包中，我认为一个结构清晰的架构应该对PO与DTO等其他对象作区分，因为存储在数据库中的对象与其他业务对象还是有一些区别的。例如数据库对象通常会有创建时间、创建者的用户ID、最后一次修改时间、最后一次修改者的用户ID、状态、数据库自增ID等字段，但这些信息很多是不需要甚至不应该暴露给用户或者其他系统的，即不应该出现在DTO等其他对象中的。

而在对象关系映射（Object/Relation Mapping，简称ORM）框架Hibernate中，上述含义的PO有三种状态：持久化对象状态（也简称PO）、值对象（Value Object，简称VO）状态、游离（Detached）状态。根据Hibernate的文档[10]，在Hibernate中，与一个Hibernate session绑定的广义PO是一个Hibernate PO，对一个Hibernate PO作修改后，对Hibernate session做flush或close操作时，Hibernate session会将修改后的Hibernate PO的状态持久化到数据库中。开发者手动将Hibernate PO从Hibernate session中解除绑定（detach）之后，该PO就进入游离状态。游离状态的PO可以重新与一个Hibernate session绑定而重新变为持久化对象状态。

VO

VO有两种含义，一种是值对象（Value Object）的英文缩写，另一种是展现层对象（View Object）的英文缩写。

对于值对象，上文有提到在Hibernate中，值对象是广义PO的一种状态。在Hibernate中，除了持久化对象状态和游离状态的广义PO都是值对象。

值对象也有另一种定义，即所有用于存储数据的对象（如PO和DTO）都是值对象。

展现层对象，又可称“视图对象”，是对应一个客户端页面或者组件中数据的对象。展现层对象跟DTO的结构很相似，都有一些private的属性及其public的getter/setter，因为它们本质上都是用来承载传输的数据，DTO通常用于跨应用传输数据，而展现层对象用于业务逻辑层和客户端页面之间传输数据。对于要不要将DTO和展现层对象合并在一起，下文中推荐的博文有详细的讨论，这里不再赘述。

DO

DO有两种含义，一种是数据对象（Data Object）的英文缩写，另一种是领域对象（Domain Object）的英文缩写。

阿里巴巴的《Java开发手册》中的DO用的就是数据对象这个概念，它的含义跟PO的含义是一样的（一个DO类与一个数据库表对应，一个DO与数据库表中的一行对应）。

而领域对象是领域驱动设计（Domain Driven Design）中的一个概念。对领域驱动设计的解释，推荐大家参考一下阿里的盒马技术团队的文章。对领域对象的具体解释，推荐大家参考一下《领域驱动设计系列文章——浅析VO、DTO、DO、PO的概念、区别和用处》《浅析VO、DTO、DO、PO的概念、区别和用处》这两篇博文。

DAO

DAO是数据访问对象（Data Access Object）的英文缩写。DAO是对数据库具体实现细节的封装、对数据库访问方法的抽象。[11] DAO通常需要依赖注入容器为其注入数据库连接对象之类的对象，因此DAO通常是一个EJB或者是Spring bean。

再啰嗦两句

我认为，上文所说的BO、DTO、PO、VO（展现层对象）、DO和DAO，其作用、功能、职责都是有区别的，为了一个软件工程的结构清晰、软件的部件的功能明确，为了最大程度的软件的可拓展性、可移植性和可维护性，应该将这些对象分别放在不同的包（package）中，不要将这些对象混淆或合并在一起使用，虽然这样会使首次开发时的工作量增加。

参考资料

[1] DropDeadGorgias, Fvdham, JimmyShelter, 等．JavaBeans[M/OL]．https://en.wikipedia.org/wiki/JavaBeans, 引用于2018-09-05 10:11

[2] Shaun Abram. JavaBeans vs Spring beans vs POJOs[J/OL]. http://www.shaunabram.com/beans-vs-pojos/, 引用于2018-09-05 10:16

[3] Sun Microsystems, JavaBeans(TM) API specification Version 1.01-4[S/OL], 1997-08-08:9. http://download.oracle.com/otndocs/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/, 引用于2018-09-05 10:53

[4] Sun Microsystems, JSR-000220 Enterprise JavaBeans v.3.0 Final Release[S/OL], 2006-05-08:30-35. http://download.oracle.com/otndocs/jcp/ejb-3_0-fr-eval-oth-JSpec/, 引用于2018-09-05 11:19

[5] Spring Source, Core Technologies[M/OL], 2018-07-26. https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#beans-introduction, 引用于2018-09-05 12:24

[6] Chronist, WikiFan04, Graham87, 等. Plain old Java object[M/OL]. https://en.wikipedia.org/wiki/Plain_old_Java_object, 引用于2018-09-05 12:40

[7] chunchill. 理解POCO[J/OL], 2011-01-08. http://www.cnblogs.com/shineqiujuan/archive/2011/01/08/1930911.html, 引用于2018-09-05 12:47

[8] Spring Source. Understanding POJOs[M/OL]. https://spring.io/understanding/POJO, 引用于2018-09-05 12:54

[9] 匿名. （持久对象 (persistent object)）[M/OL]. https://baike.baidu.com/item/Po/6446468, 引用于2018-09-05 18:27

[10] hibernate.org. Working with objects[M/OL]. http://docs.jboss.org/hibernate/orm/3.3/reference/en/html/objectstate.html, 引用于2018-09-06 15:49

[11] Anonymous. Data access object[M/OL]. https://en.wikipedia.org/wiki/Data_access_object, 引用于2018-09-05 14:34

我们在大多数编程语言中使用运算符来对变量执行操作。

它们分为各种类别，如算术运算符、赋值运算符、比较运算符、逻辑运算符等。

在本文中，我们将讨论按位与 AND 运算符，以及 AND（&&）和 OR（||）逻辑运算符。

如何使用按位与 AND 运算符

符号 & 表示按位与 AND 运算符。它评估给定数字的二进制值。这些数字的二进制结果将转换为十进制返回给我们。

当 & 运算符开始操作时，它将从左侧开始计算两个数字中字符的值。

让我们看一个例子来帮助你更好地理解：

System.out.println(10 & 12);
// returns 8

让我们分解一下。

10 的二进制值是 1010。

12 的二进制值是 1100。

在我们开始操作之前，你应该记住以下几点：

• 1 and 0 => 0
• 0 and 1 => 0
• 1 and 1 => 1
• 0 and 0 => 0

我们来操作一下。

10 的第一个字符是 1，而 12 的第一个字符也是 1，所以：

1 and 1 = 1

我们继续看第二个字符——10 的第二个字符是 0，12 的第二个字符是 1：

1 and 0 = 0

对于第三个字符——10 的第三个字符是 1，12 的第三个字符是 0：

1 and 0 = 0

对于第四个字符——10 的第四个字符是 0，12 的第四个字符是 0：

现在让我们组合所有返回的字符，结果是 1000。

二进制值 1000 在十进制中是 8，这就是我们的操作返回 8 的原因。

如何使用逻辑 AND 运算符

请注意，我们使用逻辑运算符来评估条件。它们根据给定的条件返回 true 或 false。

符号 && 表示 AND 运算符。它评估两个语句/条件，并且仅当两个语句/条件都为 true 时才返回 true。

语法如下所示：

statment1/condition1 && statemnt2/condition2

正如你在上面看到的，有两个语句/条件由运算符分隔。运算符评估两个语句/条件的值并给我们一个结果——true 或 false。

这是一个例子：

System.out.println((10 > 2) && (8 > 4));
//true

该操作将返回 true，因为两个条件都为真——10 大于 2，且 8 大于 4。如果其中任何一个条件的逻辑不正确，那么我们将得到 false。

为了更好地理解 && 运算符，你应该知道两个条件都必须为 true 才能获得结果是 true。

这是另一个返回 false 的示例：

System.out.println((2 > 10) && (8 > 4));
// false

在这里，2 不大于 10，但 8 大于 4——所以我们得到 false。这是因为其中一个条件不成立。

• 如果两个条件都为 true =>true
• 如果两个条件之一为 false => false
• 如果两个条件都为 false => false

如何使用逻辑 OR 运算符

我们使用符号 || 表示 OR 运算符。只有当两个条件都为 false 时，此运算符才会返回 false。这意味着如果两个条件都为 true，将返回 true，如果两个条件之一为 true，也会返回 true。

语法如下：

statment1/condition1 || statemnt2/condition2

让我们看几个例子。

System.out.println((6 < 1) || (4 > 2));  
// true

这将返回 true，因为其中一个条件为 true。

• 如果两个条件都为 true => true
• 如果条件之一为 true => true
• 如果两个条件都为 false => false

总结

在本文中，我们学习了如何在 Java 中使用按位 & 运算符，以及如何执行操作来给我们一个结果。

我们还学习了如何在 Java 中使用 && 和 || 逻辑运算符。我们根据操作中涉及的条件了解了每个操作返回的值。

祝你编程愉快！

如果你对学习 Java 感兴趣，我们在 freeCodeCamp 中文 YouTube 频道发布了包含基础理论和项目实践的《Java 新手课》。

这个教程的作者是牧云踏歌，他是一位资深的 Java 开发者。在这个时长四小时的教程中，他通过有趣的编程例子（比如 2048 小游戏），带领零基础的小伙伴循序渐进入门 Java 开发。

教程的内容包括：

• 课程简介
• 开发环境及第一个程序
• 手动编译代码，理解 JKE 与 JRE
• 与用户交互
• 函数
• 年收入计算器
• 分层思想及面向对象
• 构建棋子与棋盘
• 随机设置棋子及 Gameover 判定
• 实现合并及压缩算法
• 响应用户输入向左合并
• 响应用户所有输入
• 优化得分及游戏结束
• 基于面向接口编程改造为十二生肖版

在这里观看完整视频：

如果你使用过 Java Swing，那么它具有我们用来从 GUI 获取输入的组件，例如 JTextField 和 JTextArea。它将我们的输入作为字符串。

如果我们想使用 Swing 制作一个简单的计算器，我们需要弄清楚如何将字符串转换为整数。这就引出了一个问题——我们如何将字符串转换为整数？

在 Java 中，我们可以使用 Integer.valueOf() 和 Integer.parseInt() 将字符串转换为整数。

使用 Integer.parseInt() 将字符串转换为整数

此方法将字符串作为原始类型 int 返回。如果字符串不包含有效整数，则它将抛出 NumberFormatException。

因此，每次我们将字符串转换为 int 时，都需要通过将代码放在 try-catch 块中来处理此异常。

让我们考虑一个使用 Integer.parseInt() 将字符串转换为 int 的示例：

        String str = "25";
        try{
            int number = Integer.parseInt(str);
            System.out.println(number); // output = 25
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

让我们尝试通过输入一个无效整数来解释这段代码：

     	String str = "25T";
        try{
            int number = Integer.parseInt(str);
            System.out.println(number);
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

正如你在上面的代码中看到的，我们尝试将 25T 转换为整数。这不是有效的输入，因此，它必须抛出 NumberFormatException。

这是上面代码的输出：

java.lang.NumberFormatException: For input string: "25T"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at OOP.StringTest.main(StringTest.java:51)

接下来，我们将考虑如何使用 Integer.valueOf() 方法将字符串转换为整数。

使用 Integer.valueOf() 将字符串转换为整数

此方法将字符串作为整数对象返回。如果你查看 Java 文档，Integer.valueOf() 返回一个整数对象，它等效于 new Integer(Integer.parseInt(s))。

使用此方法时，我们会将代码放在 try-catch 块中。让我们考虑一个使用 Integer.valueOf() 方法的例子：

        String str = "25";
        try{
            Integer number = Integer.valueOf(str);
            System.out.println(number); // output = 25
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

现在，让我们尝试通过输入一个无效的整数来解释上面的代码：

        String str = "25TA";
        try{
            Integer number = Integer.valueOf(str);
            System.out.println(number); 
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

和前面的例子类似，上面的代码会抛出异常。

这是上面代码的输出：

java.lang.NumberFormatException: For input string: "25TA"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.valueOf(Integer.java:766)
	at OOP.StringTest.main(StringTest.java:42)

在使用上述方法之前，我们还可以创建一个方法来检查传入的字符串是否为数字。

我创建了一个简单的方法来检查传入的字符串是否为数字。

public class StringTest {
    public static void main(String[] args) {
        String str = "25";
        String str1 = "25.06";
        System.out.println(isNumeric(str));
        System.out.println(isNumeric(str1));
    }

    private static boolean isNumeric(String str){
        return str != null && str.matches("[0-9.]+");
    }
}

输出是：

true
true

isNumeric() 方法接受一个字符串作为参数。首先它检查字符串是否为空。之后我们使用 matches() 方法检查它是否包含数字 0 到9 和一个句点字符。

这是检查数值的简单方法。你可以在 Google 上编写或搜索更高级的正则表达式，以根据你的用例捕获数字。

在尝试将其转换为整数之前，最好先检查传入的字符串是否为数字。

感谢你阅读本文。

封面图片来自 Unsplash，摄影师 🇸🇮 Janko Ferlič。

你可以在 Medium 联系我。

Happy Coding!

字符串是嵌套在双引号中的字符的集合。indexOf 方法返回指定字符或子串在字符串中的索引位置。

在这篇文章中，我们将看到不同 indexOf 方法的语法。我们还将看一些例子，以帮助你理解并有效地使用它们，在你的 Java 代码中找到一个字符或子串的索引。

indexOf 方法的语法

indexOf 方法有以下几种方法：

public int indexOf(int char)
public int indexOf(int char, int fromIndex)
public int indexOf(String str)
public int indexOf(String str, int fromIndex)

在看到一些例子之前，让我们解释一下这些参数：

• char 表示一个字符串中的单个字符。
• fromIndex 表示搜索一个字符或子串的索引应该从哪个位置开始。当一个字符串中有两个相同值的字符/字符串时，这一点很重要。通过这个参数，你可以告诉 indexOf 方法从哪里开始操作。
• str 代表字符串中的一个子串。

如果你还不明白这一切是如何运作的，不要担心——例子会帮你理解。

如何在 Java 中使用 indexOf 方法

在下面的第一个例子中，我们将找到一个字符串中单个字符的索引。这个例子将帮助我们理解 public int indexOf(int char) 方法。

indexOf(int Char) 方法示例

public class Main {
  public static void main(String[] args) {
    String greetings = "Hello World";
    
    System.out.println(greetings.indexOf("o"));
    
    // 4
  }
}

在上面的代码中，我们得到了字符 “o” 的索引，即 4，我们有两个 “o” 字符，但第一个字符的索引被返回。

在下一个例子中，我们将看到我们如何返回第二个 “o” 的索引。

如果你想知道索引数字是如何得出的，那么你应该注意到，一个字符串中的第一个字符的索引是 0，第二个字符的索引是 1，以此类推。

indexOf(int Char, Int fromIndex) 方法实例

下面是一个解释 int indexOf(int char, int fromIndex) 方法的例子：

public class Main {
  public static void main(String[] args) {
    String greetings = "Hello World";
    
    System.out.println(greetings.indexOf("o", 5));
    
    // 7
  }
}

在上面的例子中，我们告诉 indexOf 方法要从第五个索引开始操作。

H => index 0

e => index 1

l => index 2

l => index 3

0 => index 4

请注意，索引 5 不是 “W” 这个字符，而是 “Hello” 和 “World” 之间的空格。

所以从上面的代码来看，在第 5 个索引之前的其他每个字符都将被忽略。7 被返回为第二个 “o” 字符的索引。

Int indexOf(String Str) 方法实例

在下一个例子中，我们将了解返回子串索引的公共 public int indexOf(String str) 方法是如何工作的。

public class Main {
  public static void main(String[] args) {
    String motivation = "Coding can be difficult but don't give up";
    
    System.out.println(motivation.indexOf("be"));
    
    // 11
  }
}

想知道为什么返回 11 吗？你应该看看上一节，了解索引是如何计算的，子串之间的空格也算作索引。

请注意，当子串被作为参数传入时，返回的索引是子串中第一个字符的索引——11 是 “b” 字符的索引。

indexOf(String Str, Int fromIndex) 方法示例

最后一个方法 public int indexOf(String str, int fromIndex)——与 public int indexOf(int char, int fromIndex) 方法相同，它从一个指定的位置返回一个索引。

下面是一个例子：

public class Main {
  public static void main(String[] args) {
    String motivation = "The for loop is used for the following";
    
    System.out.println(motivation.indexOf("for", 5));
    
    // 21
  }
}

在上面的例子中，我们指定该方法应该从第 5 个索引开始操作，也就是第一个 “for” 子串之后的索引。21 是第二个 “for” 子串的索引。

最后，当我们传入一个在字符串中不存在的字符或子串时，indexOf 方法将返回值 -1。下面是一个例子：

public class Main {
  public static void main(String[] args) {
    String motivation = "The for loop is used for the following";
    
    System.out.println(motivation.indexOf("code"));
    
    // -1
  }
}

总结

在这篇文章中，我们学习了如何使用四个 indexOf 方法，用一个例子解释了每个不同的方法。

我们还看到了这些方法的语法是什么样子的，以及它们如何能够判断要返回的索引。

最后，我们展示了当一个不存在的字符或子串作为参数传入时会发生什么。

祝你编程愉快！

Java 中的 charAt() 方法返回字符串中某个字符在给定或指定索引处的 char 值。

在这篇文章中，我们将看到如何使用 charAt() 方法，首先是它的语法，然后是一些使用示例。

如何使用 Java 的 charAt() 方法

这是 charAt()  方法的语法：

public char charAt(int index)

注意，使用 charAt()  方法从字符串返回的字符具有 char 数据类型。我们将在文章的后面看到这对返回值的连接有何影响。

现在让我们看看一些例子。

public class Main {
  public static void main(String[] args) {
  
    String greetings = "Hello World";
    
    System.out.println(greetings.charAt(0));
    // H
  }
}

在上面的代码中，我们的字符串——存储在一个叫作 greetings 的变量中——写着 “Hello World”。我们使用 charAt() 方法来获取索引为 0 的字符，即 H。

第一个字符的索引总是 0，第二个索引是 1，以此类推。子字符串之间的空格也算作一个索引。

在下一个例子中，我们将看到当我们试图将返回的不同字符连接起来时会发生什么。连接是指将两个或多个值连接在一起（在大多数情况下，这个术语用于连接字符串中的字符或子串）。

public class Main {
  public static void main(String[] args) {
    String greetings = "Hello World";
    
    char ch1 = greetings.charAt(0); // H
    char ch2 = greetings.charAt(4); // o
    char ch3 = greetings.charAt(9); // l
    char ch4 = greetings.charAt(10); // d
    
    System.out.println(ch1 + ch2 + ch3 + ch4);
    // 391
  }
}

使用 charAt() 方法，我们得到了索引为 0、4、9 和 10 的字符，分别是 H、o、l 和 d。

然后我们尝试打印和连接这些字符：System.out.println(ch1 + ch2 + ch3 + ch4);。

但是我们没有得到返回的 Hold，而是得到了 391。这是因为返回的值不再是字符串，而是数据类型为 char。因此，当我们连接它们时，解释器会添加它们的 ASCII 值。

H 的 ASCII 值为 72，o 的值 为111，l 的值为 108，d 的值为 100。当我们把它们加在一起时，我们得到 391，这是在上一个例子中返回的。

StringIndexOutOfBoundsException 错误

当我们传入的索引数超过了字符串中的字符数，我们就会在控制台中得到 StringIndexOutOfBoundsException 错误。

这个错误也适用于使用负数索引，这在 Java 中是不支持的。在像 Python 这样支持负数索引的编程语言中，传入 -1 会给你一个数据集的最后一个字符或值，类似于 0 总是返回第一个字符的情况。

下面是一个例子：

public class Main {
  public static void main(String[] args) {
    String greetings = "Hello World";
    
    char ch1 = greetings.charAt(20); 
    
    System.out.println(ch1);
    
    /* Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 20 
    */
  }
}

在上面的代码中，我们传入了一个 20 的索引：char ch1 = greetings.charAt(20); 这超过了 greetings 变量的字符数——所以我们得到了一个错误。你可以在上面的代码块中看到错误信息的注释。

同样，如果我们像这样传入一个负值：char ch1 = greetings.charAt(-1);，会得到一个类似的错误。

总结

在这篇文章中，我们学习了如何在 Java 中使用 charAt() 方法。我们看到了如何根据索引号返回字符串中的字符，以及当我们把这些字符连接起来时会发生什么。

最后，我们谈到了在 Java 中使用 charAt() 方法时，会得到错误响应的一些情况。

祝你编程愉快！