无论您是开发游戏、实用工具还是复杂应用程序，相关的问题是：Python是否比Java更好？Java 是否比 Python 更容易？应该学习哪种编程语言呢？

看看您是否能自己决定，并且是否同意我们的结论，该结论是基于一些相关分析得出的。

Java vs. Python：竞争开始

在这个比较中，您可以考虑以下要点：

• 学习：学习Java是否比学习Python更容易？还是反之？
• 运行代码：哪种编程语言更容易编译和运行您的代码？
• 游戏开发：Java是否比Python更适合游戏开发？
• 衡量需求：哪种编程语言能够战胜竞争，赢得市场？
• Web应用程序：Python是否比Java更擅长构建动态网站和应用程序？
• 数据科学：哪种编程语言是每个数据科学家最喜欢的？

Python vs. Java：学习细节

Python对于初学者来说非常简单：所见即所得。它的语法简单，是一种很好的通用语言。Python持续吸引那些刚开始编程、希望尽可能轻松入门的人。

尽管有着广泛且有力的社区支持，但Java更适合具有多年编程经验的高级用户。简单来说，尽管该语言拥有众多用户，但不适合心志薄弱者。

Java vs. Python：解释代码

这两种语言继续吸引人们的注意，因为它们用途广泛。每种语言都使用不同的语法，都旨在易于阅读，因此您会发现相似之处和不同之处。

Python 配备了一个交互式 Shell，也称为REPL（Read-Eval-Print-Loop），它允许您尝试使用该语言。您可以使用它来运行代码片段，并直接从命令行中了解Python语法是如何工作的。

例如，您可以输入以下命令：

a = 9
b = 3
a + b

并可以即时看到效果：

Python 交互式 Shell 显示基本加法的示例

Java不提供命令行解释器，因为它是一种编译语言。您需要编写代码、编译它，然后运行它才能看到其效果，这可能是一个耗时的过程。

而且，即使是最简单的Java程序也需要大量样板代码：

public class linuxmi {
    public static void main(String[] args) {
        System.out.println("9+3=" + (Integer.toString(9 + 3)));
    }
}

输出如下：

Python vs. Java：游戏开发导引

Python是一种高级语言，易于使用，但它不能生成运行速度最快的代码。游戏开发需要快速的处理和高速的图形处理。

Python可以通过使用第三方库的包装和绑定来克服这种延迟。然而，这是实现游戏速度的一种困难方式，从长远来看并不用户友好。

如果您仍然热衷于使用Python进行游戏开发，可以考虑使用Arcade库作为动画游戏对象的适当选择。

在此轮比较中，Java获胜，因为它提供了多线程，而Python则没有。Java还具有出色的网络支持，提供了在创建多人游戏时非常方便的套接字。在Java中，JMonkeyEngine和OpenGL仍然是受欢迎的开源游戏引擎，尽管它们无法与C和C++等一些其他更快的语言竞争。

最终，无论哪种语言都不是最适合游戏开发的。尽管Java是更好的选择，但市场上有更适合游戏开发的编程语言。

Python vs. Java：哪个更受欢迎？

Python的编程需求在后疫情时代急剧上升，这个备受喜爱的语言已经不可逆转。在2023年，它在TIOBE的编程社区指数中获得了第一名，这充分说明了它在编程领域的重要性。

Python是否比Java更受欢迎？答案是”是”，因为尽管出现了更新的替代品，但这种语言仍然具有合适的市场份额。

Java的多功能性和开发选项使其保持在Stack Overflow最受欢迎的编程语言之列，尽管这可能会在未来几年内下降。尽管地位逐渐下降，但在2023年，它仍然是一种值得学习的编程语言。

Python vs. Java：拥抱Web开发的框架

Python的Web开发框架包括Django和Flask，它们提供了基本的功能，而没有太多的路由请求和过多的开销。

另一方面，Java的Spring是最知名的后端框架之一，主导着Web应用程序开发。Java的开发生态系统庞大，具备社区支持，使开发过程更加简便和实用。

无论如何，Java和Python之间的竞争是激烈的，因为这两种语言都提供了许多竞争性的选项，为优秀的Web应用程序构建铺平了道路。

Python vs. Java：数据科学适用性

在数据科学领域，支持的编程语言不胜枚举。当比较Python和Java时，前者仍然居于优势地位。您可以使用Java进行数据科学编程，因为它支持大数据处理。然而，Python的数据科学工具在数据科学家中非常流行。

Python为数据科学提供了许多有用的功能，无论是在其标准库中还是通过第三方库。Pandas和NumPy库非常广为人知和使用。

另一方面，Java更倾向于支持Web开发和通用编程，没有太多专注于数据科学的特点。

Java vs. Python：未来哪个更适合

考虑到上面列出的所有排名因素，毫无疑问，Python 是我们在 2023 年的首选语言。如果您想深入研究一种定制、易于学习且能够带来良好回报的语言，那么您应该选择 Python。

该语言的多功能性、可定制选项和简单的语法将使其成为您现有的编程技能库中的绝佳补充。

相关：

探索 Python 3.12：让你的调试技能翻倍提升！  https://www.linuxmi.com/python-3-12-debugging.html

10 个 Python Itertools，让你的代码如虎添翼  https://www.linuxmi.com/python-itertools.html

15 个强大的日常使用的 Python 单行代码  https://www.linuxmi.com/python-one-line-code.html

了解 Java 21 的最新增强功能  https://www.linuxmi.com/java-21.html

Java 中的 Hello World 示例程序  https://www.linuxmi.com/java-hello-world.html

The post Python vs. Java: 2023 年最佳编程语言 first appeared on Linux迷.

Java 21 带来了一系列令人振奋的增强功能，革新了并发性、集合操作以及记录处理方式。

引入虚拟线程

扩展服务器应用程序一直是一个挑战，线程往往成为瓶颈。有限的线程数量，加上频繁等待事件或锁的解除阻塞，制约了整体性能。

过去，解决这个问题需要使用 CompletableFuture 或响应式框架等构建，导致代码变得复杂，难以理解和维护。

幸运的是，Java 19 引入了虚拟线程作为预览功能，而 Java 21 通过 JDK Enhancement Proposal 444 进一步完善和巩固了这一功能。

虚拟线程提供了一种非常有希望的解决方案，让您更有效地应对可扩展性挑战，从而提高服务器应用程序的性能和响应能力。

序列化集合更易用

传统上，在 Java 编程中使用链表需要编写冗长的代码。例如，要获取最后一个元素，必须使用下面这种繁琐的方法：

var last = list.get(list.size() - 1);

然而，Java 21 引入了一种简洁而优雅的替代方法：

var last = list.getLast();

类似地，要访问 LinkedHashSet 的第一个元素，以前需要绕个弯子：

var first = linkedHashSet.iterator().next();

但是在 Java 21 中，这个任务变得简单得多：

var first = linkedHashSet.getFirst();

你还可以使用新的 getLast 方法访问 LinkedHashSet 的最后一个元素，而无需遍历整个集合。

这些对序列化集合的改进不仅提高了代码的可读性，还简化了元素的检索过程，使 Java 编程更高效、更友好。

记录模式（Record Patterns）

记录模式在 Java 19 中作为预览功能引入，为在 Java 中访问记录（Record）的字段提供了一种便捷的机制，无需显式的强制类型转换或访问方法。

它们与 instanceof 模式匹配（Pattern Matching for instanceof）和 switch 模式匹配（Pattern Matching for switch）相辅相成，极大地简化了代码，提升了整体可读性。

下面是一个示例，以一个名为 Position 的简单记录为例：

public record Position(int x, int y) {}

以前，基于对象的类执行不同操作需要使用 instanceof 模式匹配，如以下代码片段所示：

public void print(Object o) {
    if (o instanceof Position p) {
        System.out.printf("o is a position: %d/%d%n", p.x(), p.y());
    } else if (o instanceof String s) {
        System.out.printf("o is a string: %s%n", s);
    } else {
        System.out.printf("o is something else: %s%n", o);
    }
}

使用记录模式，现在可以直接匹配记录模式，如 Position (int x, int y)，而无需使用 Position p 模式。这使您可以在代码中直接访问变量 x 和 y，无需使用 p.x() 和 p.y()：

public void print(Object o) {
    if (o instanceof Position(int x, int y)) {
        System.out.printf("o is a position: %d/%d%n", x, y);
    } else if (o instanceof String s) {
        System.out.printf("o is a string: %s%n", s);
    } else {
        System.out.printf("o is something else: %s%n", o);
    }
}

此外，您可以与 switch 模式匹配结合使用记录模式，进一步简化代码：

public void print(Object o) {
    switch (o) {
        case Position(int x, int y) - > System.out.printf("o is a position: %d/%d%n", x, y);
        case String s - > System.out.printf("o is a string: %s%n", s);
        default - > System.out.printf("o is something else: %s%n", o);
    }
}

嵌套记录模式允许匹配字段本身就是记录的记录。例如，考虑一个名为 Path 的记录，包含了一个 from 和 to 位置：

public record Path(Position from, Position to) {}

通过使用记录模式，打印 Path 对象变得更简洁：

public void print(Object o) {
    switch (o) {
        case Path(Position from, Position to) - > System.out.printf("o is a path: %d/%d -> %d/%d%n", from.x(), from.y(), to.x(), to.y());
       // other cases
    }
}

借助记录模式，处理包含不同类型字段的记录变得更加清晰和可读。假设您有修改过的记录 Position2D 和 Position3D，其中 Position 是一个 Java 接口，两者都实现了它：

public sealed interface Position permits Position2D, Position3D {}
public record Position2D(int x, int y) implements Position {}
public record Position3D(int x, int y, int z) implements Position {}
public record Path < P extends Position > (P from, P to) {}

为了区分打印 2D 和 3D 路径的行为，您可以使用记录模式：

public void print(Object o) {
    switch (o) {
        case Path(Position2D from, Position2D to) - > System.out.printf("o is a 2D path: %d/%d -> %d/%d%n", from.x(), from.y(), to.x(), to.y());
        case Path(Position3D from, Position3D to) - > System.out.printf("o is a 3D path: %d/%d/%d -> %d/%d/%d%n", from.x(), from.y(), from.z(), to.x(), to.y(), to.z());
       // other cases 
    }
}

记录模式大大减少了冗长的代码，提高了处理包含不同类型字段的记录时的可读性。

Java 21 开启新的可能性

Java 21 引入了许多强大的功能，增强了 Java 编程语言的能力。通过采用这些增强功能，您可以简化开发过程，为应用程序开启新的可能性。

及时了解最新的语言特性和 Java 框架，可以使您的代码更高效和可维护，确保您始终处于 Java 编程的前沿。

The post 了解 Java 21 的最新增强功能 first appeared on Linux迷.

Java 是一种广泛使用的面向对象编程语言和软件平台。它在数十亿台设备上运行，包括笔记本电脑、移动设备、游戏机和许多其他设备。

拥有这样的能力是有代价的。Java 语法冗长复杂。它是静态类型的，这可能不太方便。虽然它是独立于平台的，但云计算平台的崛起让独立变得不那么成功了。

这些只是 Java 可能失宠的几个原因。

1. Java 越来越不流行了

首先，Java 的受欢迎程度似乎正在慢慢下滑。多年来，它一直是最值得学习的编程语言之一，但现在它不再流行了。这意味着，随着时间的推移，开发人员用 Java 编写的新应用程序将越来越少。

这种趋势意味着 Java 可能最终将会消失。世界各地的企业将继续雇佣 Java 程序员来维护遗留代码库，但这种情况不会永远持续下去。

不过，如果您希望将职业重点放在构建新事物上，而不是维护现有的程序，那么 Java 可能不是您的最佳选择。

2. Java 并不简单

Java 可能很容易学，但它并不简单。这种语言很容易学习，因为 Java 代码很容易编写、组织和编译。但这并不简单，因为用 Java 编写的代码往往更冗长、更繁琐。

您还必须编译它，这使得 Java 远不如 Python 等语言方便。因此，如果您是第一次学习编码的新手，Java 不是一个好的开始语言。

如果你是一个专业人士，想要大量编写简单、优雅的代码并快速部署，那么Java也不是理想的选择。

3.Getter 和 Setter

getter 和 setter 几乎是编程语言使用的必需品，许多框架都鼓励使用它们。不过，Java 里面充斥着冗长的 getter 和 setter。

管理用 Java getter和setter装饰的代码是非常复杂的。缺乏一个有意义的解决方法来解决 getter 和 setter 的问题。

如果您是一名专业人员，希望大量编写简单、优雅的代码并快速部署，那么 Java 也不是理想的选择。

4. 没有语法糖

您正在操作一个集合。你要第一件。你在做什么?当然，您调用该方法而不是使用通用的[]操作符。这都是因为运算符不能过载。

对于几乎每一个操作，都必须使用冗长的方法名，即使可以使用单个字符的操作符。

Java 支持这个概念;例如，该语言允许您使用+操作符连接字符串。它只是不让你，程序员，做同样的事情。

5. 声明一个方法可能抛出的异常

Java 要求您声明方法可能抛出的异常。看起来很有用，不是吗?通过使用给定的方法，您知道将会发生什么。

问题是，代码是一个活的有机体，而且您正在使用的方法碰巧开始抛出更多的异常。那么会发生什么呢?你的代码停止编译了。

您必须处理这种情况或向抛出列表中添加异常。让我们假设您使用的 API 没有改变。Java 中有一个类似 RuntimeException 的东西。如果您的方法可以抛出此异常或其子异常，则需要声明它。

Java 的异常会带来许多代码维护问题。

6. 复杂的 IDE

Java 程序员经常使用像 Eclipse 或 IntelliJ 这样的 IDE。这些 IDE 功能强大，但与它们交互非常复杂，特别是对于初学者或中级开发人员。您需要投入大量精力从内到外地学习 IDE，以便提高它的效率，减少它给您带来的痛苦。

7. 在2022年，平台独立性不那么重要

Java非常平台独立的事实可以说在今天已经不像 10 或 20 年前那么重要了。

原因是我们生活在一个软件定义的世界里。如今，虚拟机、容器和云服务使得您可以轻松地在任何想要的地方运行应用程序，而不必担心底层环境。

换句话说，你不需要改变你的代码来让你的应用在你需要它工作的地方工作。您可以更改宿主环境。

这并不是说应用程序的可移植性不再重要。它只是不像以前那么重要了，这使得 Java 在扩展方面变得不那么重要了。

8. 静态类型

Java在编译时执行类型检查。这意味着您必须在编译时声明每个变量的类型。这与 C 和 C++ 等语言是一样的，但其他语言，如 Scala 和 Haskell，提供了某种形式的类型推断。

对于静态类型，变量通常不允许更改类型。这使得 Java 语法有点复杂，特别是在为大型项目编写代码时。

许多程序员喜欢在运行时进行类型检查的动态编程。这意味着变量的类型可以在其生命周期中改变。

学习新的编程语言

这并不是说 Java 什么都不好，而是它的语法很笨拙，不利于阅读代码。Java的依赖管理允许滥用，并导致难以检测的错误。

技术一直在变化，作为开发人员，及时了解新兴编程语言总是很有用的。今天流行的东西可能很快就会成为过去的新闻。

The post 为什么说在 2022 年 Java 可能失宠了 first appeared on Linux迷.

现在我们需要一个环境来运行我们的程序。此后，JRE代表“Java 运行时环境”，也可以写成“Java RTE”。Java 运行时环境提供了执行 Java 应用程序的最低要求；它由Java 虚拟机 (JVM)、核心类和支持文件组成。

现在让我们讨论一下JVM，它代表了 java 虚拟机。如下：

• 指定 Java 虚拟机工作的规范。但实现提供者独立选择算法。它的实现由 Sun 和其他公司提供。
• 实现是满足 JVM 规范要求的计算机程序。
• 运行时实例每当您在命令提示符下编写 java 命令以运行 java 类时，就会创建一个 JVM 实例。

在继续讨论 JDK、JRE 和 JVM 之间的区别之前，让我们先简要讨论它们，并将它们与下面提出的图像相互关联。

不用感到困惑，因为我们将一一讨论它们。

1. JDK（Java Development Kit）是一个提供开发和执行（运行） Java程序环境的工具包。JDK 是一个工具包（或包），包括两个东西

• 开发工具（提供开发Java程序的环境）
• JRE（执行您的 java 程序）。

2. JRE（Java Runtime Environment）是一个安装包，它提供了一个环境，只在你的机器上运行（而不是开发） java程序（或应用程序）。JRE 仅供那些只想运行作为系统最终用户的 Java 程序的人使用。

3. JVM（Java 虚拟机） 是 JDK 和 JRE 中非常重要的一部分，因为它包含或内置在两者中。无论你使用 JRE 还是 JDK 运行的 Java 程序都会进入 JVM，而 JVM 负责逐行执行 Java 程序，因此它也被称为解释器。

现在让我们讨论 JRE 的组件，以了解它的重要性并了解它的实际工作原理。为此，让我们讨论组件。

JRE的组件如下：

1. 部署技术，包括部署、Java Web Start 和 Java 插件。
2. 用户界面工具包，包括抽象窗口工具包 (AWT)、Swing、Java 2D、可访问性、图像 I/O、打印服务、声音、拖放( DnD)和输入法。
3. 集成库，包括接口定义语言 (IDL)、Java 数据库连接 (JDBC)、Java 命名和目录接口 (JNDI)、远程方法调用 (RMI)、基于 Internet Inter-Orb 协议的远程方法调用 (RMI-IIOP)和脚本。
4. 其他基础库，包括国际支持、输入/输出 (I/O)、扩展机制、Beans、Java 管理扩展 (JMX)、Java 本机接口 (JNI)、数学、网络、覆盖机制、安全性、序列化和Java XML 处理 (XML JAXP)。
5. Lang 和 util 基础库，包括lang 和 util、管理、版本控制、zip、仪器、反射、集合、并发实用程序、Java 存档 (JAR)、日志记录、首选项 API、参考对象和正则表达式。
6. Java 虚拟机 (JVM)，包括Java HotSpot 客户端和服务器虚拟机。

在对组件有足够的了解之后，现在让我们讨论一下 JRE 的工作原理。为了理解 JRE 是如何工作的，让我们考虑下面的一个例子：

考虑一个保存为 ‘ Example.java’的 java 源文件。该文件被编译成一组字节码，存储在“ .class ”文件中。这里将是“ Example.class ”。

注意：从上面可以解释编译时的媒体操作计算。

以下操作在运行时发生，如下所示：

• 类加载器
• 字节码验证器
• 口译员
  • 执行字节码
  • 对底层硬件进行适当的调用

现在让我们简要讨论一下 JVM 是如何工作的。如下：

JVM 在 Java 程序运行时成为 JRE 的一个实例。它被广泛称为运行时解释器。JVM 在很大程度上有助于从使用 JDK 程序库的程序员抽象内部实现。

它主要负责三项活动。 

• Loading
• Linking
• Initialization

同样，现在让我们讨论一下 JRE 的工作原理，如下所示：

• JVM（Java 虚拟机）充当运行 Java 应用程序的运行时引擎。JVM 是实际调用java 代码中存在的main方法的那个。JVM 是 JRE（Java 运行时环境）的一部分。
• Java 应用程序称为 WORA（一次编写，随处运行）。这意味着程序员可以在一个系统上开发 Java 代码，并且可以期望它在任何其他支持 Java 的系统上运行而无需任何调整。由于 JVM，这一切皆有可能。
• 当我们编译文件时*.java，Java 编译器会生成与*.java文件中存在的相同类名的*.class文件（包含字节码） 。当我们运行这个*.class文件时，它会进入各个步骤。这些步骤一起描述了整个 JVM。

结语

如果您发现任何不正确的地方，或者如果您想分享有关信息，欢迎在评论区留言。

The post JDK、JRE 和 JVM 的区别 first appeared on Linux迷.

在处理不需要更改的值时，通常会使用enum，比如一周中的天数、一年中的季节、颜色等等。

在本文中，我们将看到如何创建一个枚举enum以及如何将其值赋给其他变量。我们还将看到如何在switch语句中使用 enum 或循环遍历它的值。

如何在 Java 中创建枚举

要创建enum，我们使用enum关键字，类似于使用 class 关键字创建类的方式。

以下是一个例子：

enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}

在上面的代码中，我们创建了一个名为 Colors 的枚举。您可能会注意到这个枚举的值都是大写的—这只是一个通用的约定。如果值是小写的，您将不会收到错误。

枚举中的每个值用逗号分隔。

接下来，我们将创建一个新变量，并将枚举的一个值赋给它。

enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}

public class Main { 
  public static void main(String[] args) { 
  
    Colors red = Colors.RED; 
    
    System.out.println(red); 
    // RED
  } 
}

这类似于初始化任何其他变量。在上面的代码中，我们初始化了一个 Colors 变量，并将枚举的一个值赋给它：Colors red = Colors.RED;。

请注意，我们可以在Main类内部创建枚举，代码仍然可以工作。那就是:

public class Main { 
  enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}
  public static void main(String[] args) { 
  
    Colors red = Colors.RED; 
    
    System.out.println(red); 
  } 
}

如果我们想获得任何值的索引号，我们就必须使用ordinal()方法。下面是一个例子：

enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}

public class Main { 
  public static void main(String[] args) { 
  
    Colors red = Colors.RED; 
    
    System.out.println(red.ordinal()); 
    // 0
  } 
}

上面代码中的 red.ordinal()  返回0。

如何在 switch 语句中使用枚举

在本节中，我们将演示如何在switch语句中使用 enum。

下面是一个例子:

  public class Main { 
      enum Colors {
      RED,
      BLUE,
      YELLOW,
      GREEN
  }
  public static void main(String[] args) { 
    
    Colors myColor = Colors.YELLOW;

    switch(myColor) {
      case RED:
        System.out.println("The color is red");
        break;
      case BLUE:
         System.out.println("The color is blue");
        break;
      case YELLOW:
        System.out.println("The color is yellow");
        break;
      case GREEN:
        System.out.println("The color is green");
        break;
    }
  } 
}

这是一个在 switch 语句中使用 enum 的非常基本的例子。我们将在控制台中打印“The color is yellow”，因为这是唯一符合switch语句条件的情况。

如何循环遍历枚举的值

enum在 Java 中有一个values()方法，它返回枚举值的数组。我们将使用 for-each 循环遍历并打印枚举的值。

我们可以这样做:

enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}

public class Main { 
  public static void main(String[] args) { 
      
      for (Colors allColors : Colors.values()) {
      System.out.println(allColors);
      
      /* 
      RED
      BLUE
      YELLOW
      GREEN
      */
    }
    
  } 
}

结论

在本文中，我们了解了 Java 中的 enum 是什么，如何创建它，以及如何将它的值赋给其他变量。

我们还学习了如何在 switch语句中使用 enum 类型，以及如何循环遍历 enum 的值。

跟 Linux迷 www.linuxmi.com 一起开始快乐编码吧！

The post Java Enum – Java 枚举示例讲解 first appeared on Linux迷.

我假定您是作为 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!Linux迷 www.linuxmi.com"); 
        // Hello World!
    }
}

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

现在让我们先分解代码。

Java 中的类

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

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

在我们的 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！Linux迷 www.linuxmi.com” 作为参数。您会注意到文本被引号包围。这告诉编译器参数是一个字符串。在编程中，字符串只是字符的集合—与我们编写常规文本的方式相同，但它们必须用引号引起来

下面是我们的代码:

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

当我们运行此代码时，将打印“Hello World!Linux迷 www.linuxmi.com”。

它不会打印在上面的代码块中。我使用// Hello World!向您展示代码输出的一种方式。这部分代码不会被编译器执行，因为它是一个注释。

在 Java 中，我们使用两个正斜杠 ( //) 来开始单行注释。

结论

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

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

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

跟 Linux迷 www.linuxmi.com 一起开始快乐编码吧！

The post Java 中的 Hello World 示例程序 first appeared on Linux迷.

1. 1. Arrays.toString() 方法
   2. Arrays.deepToString() 方法
   3. 循环
   4. for-each 循环
   5. Arrays.asList() 方法

让我们一一讨论上述方法，包括示例。

1.Java Arrays.toString() 方法

该Arrays.toString()方法是 Java 编程中最简单且最常用的打印数组的方法。

import java.util.Arrays;

public class ArrayLinuxmi1 {

    public static void main(String[] args) {
        // 初始化数组
        String[] array = {"apple","orange","banana","grapes","mango"};

        // 打印数组元素
        System.out.println(Arrays.toString(array));
    }
}

将上述 Java 程序保存在ArrayLinuxmi1.java文件中，编译运行。您将看到如下输出：

[apple, orange, banana, grapes, mango]

2. 使用 Arrays.deepToString() 方法

Java Arrays.deepToString() 方法用于从数组中获取深层内容。这里的深层内容代表多维数组。

import java.util.Arrays;

public class ArrayLinuxmi2 {

    public static void main(String[] args) {
        //多维数组的声明和初始化
        int[][] array = {{1,2,3}, {4, 5}, {6, 7, 8}};

        // 打印数组元素
        System.out.println(Arrays.deepToString(array));
    }
}

将上述 Java 程序保存在ArrayLinuxmi2.java文件中，编译运行。您将看到以下输出：

[[1, 2, 3], [4, 5], [6, 7, 8]]

3.使用for循环

for 循环是用于集成的常用方法。我们可以通过数组索引号浏览所有数组元素。以下示例将使用 Java 中的 for 循环打印数组元素。

public class ArrayLinuxmi3 {

    public static void main(String[] args) {
        //数组的声明和初始化
        String[] array = {"apple","orange","banana","grapes","mango"};

        // 打印数组元素
        for(int i=0;i<array.length;i++)
            System.out.println(array[i]);  
    }
}

将上述 Java 程序保存在ArrayLinuxmi3.java文件中，编译运行。您将看到以下输出：

apple
orange
banana
grapes
mango

4. 使用 for-each 循环

For-each 是遍历数组的另一种方式，而不是 for 循环。这是一个使用 for-each 获取数组元素并打印它们的快速示例。

public class ArrayLinuxmi4 {
 
    public static void main(String[] args) {
        //数组的声明和初始化
        String[] array = {"apple","orange","banana","grapes","mango"};
 
        // 打印数组元素
        for (String element: array) {
            System.out.println(element);
        }
    }
}

将程序保存在名为 ArrayLinuxmi4.java 的文件中。然后编译程序并运行它。您将看到以下输出：

apple
orange
banana
grapes
mango

5. 使用 Arrays.asList() 方法

asList() 是另一个 java 函数，它返回指定数组的固定大小列表。

import java.util.Arrays;  
public class ArrayLinuxmi5
{ 
    public static void main(String [] args)  
    { 
        //数组的声明和初始化
        String[] array = {"apple","orange","banana","grapes","mango"};

        // 打印数组元素
        System.out.println(Arrays.asList(array));
    }
}

将 Java 程序保存到名为 ArrayLinuxmi5.java 的文件中，然后编译并运行它。您将看到以下输出：

[apple, orange, banana, grapes, mango]

总结

在本教程中，您学习了 5 种用于打印数组的 Java 方法，包括示例。

The post 在 Java 中打印数组的 5 种方法 first appeared on Linux迷.