StudyTonight-Java-中文教程-三-

StudyTonight Java 中文教程（三）

原文：StudyTonight

协议：CC BY-NC-SA 4.0

Java 程序：打印斐波那契数列

原文：https://www.studytonight.com/java-programs/java-program-to-print-fibonacci-series

在本教程中，我们将学习如何打印斐波那契数列。斐波那契数列是下一个数是前两个数之和的数列。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入数字:10

输出:斐波那契数列为:

0 1 1 2 3 5 8 13 21 34

上述问题可以通过以下方式解决:

方法 1:使用 for 循环

方法 2:使用 while 循环

方法 3:打印给定数量的系列

方法 4:使用递归函数。

让我们分别看看这些方法。

程序 1:打印斐波那契数列

在这个程序中，我们将看到如何使用 for 循环在 Java 中打印斐波那契数列。在这里，首先，我们将要求用户输入项数，然后我们将找到斐波那契数列。

算法:

1. 开始
2. 为术语总数声明一个变量。
3. 要求用户初始化术语的数量。
4. 打印系列的第一个和第二个数字。
5. 使用 for 循环打印多达该数量项的斐波那契数列。
6. 在每次迭代中更新系列术语。
7. 打印斐波那契数列。
8. 停止

让我们看看下面的例子，以更好地理解上述算法。

//Java Program to print Fibonacci series
import java.util.*;
public class Main
{
    public static void main(String[] args) 
    {
        //Take input from the user
        //Create instance of the Scanner class
        Scanner sc=new Scanner(System.in);
        int t1 = 0, t2 = 1;
        System.out.print("Enter the number of terms: ");
        int n=sc.nextInt();   //Declare and Initialize the number of terms
        System.out.println("First " + n + " terms of fibonnaci series: ");
        //Print the fibonacci series
        for (int i = 1; i <= n; ++i)
        {
            System.out.print(t1 + " ");
            int sum = t1 + t2;
            t1 = t2;
            t2 = sum;
        }
    }
}

输入项数:10
斐波那契数列的前 10 项:
0 1 2 3 5 8 13 21 34

程序 2:打印斐波那契数列

在这个程序中，我们将看到如何使用 while 循环在 Java 中打印斐波那契数列。在这里，首先，我们将要求用户输入项数，然后我们将找到斐波那契数列。

算法:

1. 开始
2. 为术语总数声明一个变量。
3. 要求用户初始化术语的数量。
4. 打印系列的第一个和第二个数字。
5. 使用 while 循环打印斐波那契数列，直到达到该项数。
6. 在每次迭代中更新系列术语。
7. 打印斐波那契数列。
8. 停止

让我们看看下面的例子，以更好地理解上述算法。

//Java Program to print the Fibonacci series
import java.util.*;
public class Main
{
    public static void main(String[] args) 
    {
        //Take input from the user
        //Create instance of the Scanner class
        Scanner sc=new Scanner(System.in);
        int t1 = 0, t2 = 1;
        System.out.print("Enter the number of terms: ");
        int n=sc.nextInt();   //Declare and Initialize the number of terms
        System.out.println("First " + n + " terms of fibonnaci series: ");
        //Print the fibonacci series
        int i = 1; 
        while (i <= n)
        {
            System.out.print(t1 + " ");
            int sum = t1 + t2;
            t1 = t2;
            t2 = sum;
            i++;
        }
    }
}

输入项数:10
斐波那契数列的前 10 项:
0 1 2 3 5 8 13 21 34

程序 3:打印斐波那契数列

在这个程序中，我们将看到如何在 Java 中打印给定数字的斐波那契数列。在这里，首先，我们将要求用户输入项数，然后我们将找到斐波那契数列，直到那个特定的数字。

算法:

1. 开始
2. 声明一个变量。
3. 要求用户初始化数字。
4. 打印系列的第一个和第二个数字。
5. 使用 while 循环打印斐波那契数列到那个数字。
6. 在每次迭代中更新系列术语。
7. 打印斐波那契数列。
8. 停止

让我们看看下面的例子，以更好地理解上述算法。

//Java Program to print the Fibonacci series
import java.util.*;
public class Main
{
    public static void main(String[] args) 
    {
        //Take input from the user
        //Create instance of the Scanner class
        Scanner sc=new Scanner(System.in);
        int t1 = 0, t2 = 1;
        System.out.print("Enter the number: ");
        int n=sc.nextInt();   //Declare and Initialize the number
        System.out.println("Fibonnaci series upto "+n+": ");
        //Print the fibonacci series
        while (t1 <= n)
        {
            System.out.print(t1 + " ");
            int sum = t1 + t2;
            t1 = t2;
            t2 = sum;
        }
    }
}

输入数字:30
Fibonnaci 系列到 30:
0 1 2 3 5 8 13 21

程序 4:打印斐波那契数列

在这个程序中，我们将看到如何使用递归在 Java 中打印斐波那契数列。在这里，首先，我们将要求用户输入项数，然后我们将找到斐波那契数列。

算法:

1. 开始
2. 为术语总数声明一个变量。
3. 要求用户初始化术语的数量。
4. 打印系列的第一个和第二个数字。
5. 调用一个递归函数来打印斐波那契数列的项数。
6. 递归更新系列术语。
7. 打印斐波那契数列。
8. 停止

让我们看看下面的例子，以更好地理解上述算法。

//Java Program to print Fibonacci series
import java.util.*;
public class Main
{  
   static int n1=0,n2=1,n3=0;   
   //Prints Fibonacci Series using Recursion 
   static void printFibonacci(int n)
   {    
        if(n>0)
        {    
            n3 = n1 + n2;    
            System.out.print(" "+n3);   
            n1 = n2;    
            n2 = n3;    
            printFibonacci(n-1);   
        }    
   }    
    public static void main(String args[])
    {    
        //Take input from the user
        //Create instance of the Scanner class
        Scanner sc=new Scanner(System.in);
        System.out.print("Enter the number of terms: ");
        int n=sc.nextInt();   //Declare and Initialize the number of terms
        System.out.print("Fibonacci Series up to "+n+" terms: ");
        System.out.print(n1+" "+n2);//printing 0 and 1    
        printFibonacci(n-2);
    }  
} 

输入项数:12
斐波那契数列最多 12 项:
0 1 2 3 5 8 13 21 34 55 89

---

---

Java 程序：while循环

原文：https://www.studytonight.com/java-programs/java-while-loop-program

在本教程中，我们将学习如何在不同的场景中实现 while 循环。但是在继续之前，如果你不熟悉 while loop 的概念，那么一定要查看一下 Java 中Loops的文章。

循环时的语法

while(condition)
{
   //Code to be executed
}

Java 程序：程序 1:实现 While 循环

在这个程序中，我们将看到如何在 java 中实现 while 循环程序。在这里，我们将考虑一个场景，我们将找到一个特定数字的乘法表。我们将对相同的元素使用 while 循环，而不是为每个元素编写乘法表。我们将编写一次语句，并多次实现。

算法

1. 开始

2. 创建 Scanner 类的实例。

3. 宣布一个数字

4. 要求用户初始化数字。

5. 使用 while 循环打印该数字的乘法表。

6. 显示结果。

7. 停下来。

下面是 while 循环的 Java 代码。

//Java Program to see the implementation while loop program
import java.util.*;

public class Main
{
     public static void main(String []args)
     {
        //Take input from the user
        //Create instance of the Scanner Class
        Scanner sc=new Scanner(System.in); 
        System.out.println("Enter the number: ");
        int n=sc.nextInt();      //Declare and initialize the number
        int i=1;
        System.out.println("The multiplication table of "+n+" is: ");
        //Infinite Loop Example      
        while(i<=10)
        {
           System.out.println(n+" * "+i+" = "+ (n*i));
            i++;
        }  
     }
}

输入数字:3
3 的乘法表为:
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
3 * 10 = 30

Java 程序：程序 2:实现 While 循环

在这个程序中，如何使用 while 循环找到所有输入的正数的和。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量。

4. 要求用户初始化变量。

5. 声明另一个变量来存储所有正数的和。

6. 将其初始化为 0。

7. 使用 while 循环检查输入的数字是否为正数。

8. 每次输入正数时增加总和。

9. 如果输入了任何负数，请中断循环。

10. 显示总和。

11. 停下来。

下面是 while 循环的 Java 代码。

//Java Program to calculate the sum of entered positive numbers using a while loop
import java.util.*;

public class Main
{
     public static void main(String []args)
     {
        //Take input from the user
        //Create instance of the Scanner Class
        Scanner sc=new Scanner(System.in); 
        System.out.println("Enter the number: ");
        int n=sc.nextInt();      //Declare and initialize the number
        int sum=0;
        //While loop will take values only if the numbers are positive
        while (n >= 0) 
        {
            // add only positive numbers
            sum += n;
            System.out.println("Enter the number:");
            n = sc.nextInt();
        }
        System.out.println("Sum of the entered positive numbers = " + sum);

     }
} 

输入数字:3
输入数字:4
输入数字:3
输入数字:2
输入数字:1
输入数字:-9
输入正数之和= 13

Java 程序：程序 3:实现 While 循环

在这个程序中，我们将看到如何使用 while 循环无限次地执行某个任务。为此，我们将在 while 循环的条件语句中传递 true。这样做会使它成为一个不定式 while 循环。这里需要注意的一点是，为了退出无限循环，您需要按 ctrl+c。

算法:

1. 开始

2. 声明一个变量。

3. 将其初始化为 1。

4. 在 while 循环的条件下传递 true。

5. 执行该语句，直到条件为假。

6. 在每次迭代中增加变量。

7. 显示结果。

8. 停下来。

下面是 while 循环的 Java 代码。

//Java Program for the implementation of a while loop
public class Main
{
     public static void main(String []args)
     {
        int i=1;
        //If true is passed in a while loop, then it will be infinitive while loop.
        while (true) 
        {
            System.out.println(i + " Hello World!");
           i++;
        }  
     }
} 

1 你好世界！
2 你好世界！
3 你好世界！
4 你好世界！
5 你好世界！
6 你好世界！
7 你好世界！
ctrl+c

---

---

Java 程序：检查闰年

原文：https://www.studytonight.com/java-programs/java-program-to-check-leap-year

闰年是有 366 天的一年。如果满足以下条件，则称一年为闰年:

• 年份是 400 的倍数。
• 年份是 4 的倍数，但不是 100。

在这里，给我们一年，我们的任务是检查给定的一年是否是闰年。例如，

输入: 2019

产量:不是闰年

程序 1:检查闰年

在这个方法中，我们会在主方法本身中直接检查一年是否是闰年。

算法

1. 开始
2. 声明一个变量，比如一年。
3. 初始化它。
4. 检查条件。
5. 如果条件满足，那就是闰年，否则就不是。
6. 显示结果。
7. 停下来。

下面是相同的代码。

在下面的程序中，我们在主方法本身中检查给定的年份是否是闰年。

//Java Program to check whether the given year is a leap year or not
import java.util.Scanner;

public class CheckYear
{
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int year;   //Year Declaration
        System.out.println("Enter the year");
        year=sc.nextInt();   //Year Initialization

       //Check for leap year
        if(((year % 4 == 0) && (year % 100 != 0)) ||
            (year % 400 == 0))
        System.out.println(year+" is a leap year");
        else
        System.out.println(year+" is not a leap year");
     } 
}

进入 1998 年
1998 年不是闰年

程序 2:检查闰年

在这个方法中，我们将使用条件运算符检查给定的年份是否是闰年。

算法:

1. 开始
2. 声明一个变量，比如一年。
3. 初始化它。
4. 使用三元运算符检查给定的年份是否是闰年。
5. 在三进制运算符的条件部分调用一个方法进行检查。
6. 如果年份是 400 的倍数，则返回 true。
7. 否则，如果年份是 100 的倍数，则返回 false。
8. 否则，如果年是 4 的倍数，那么它是闰年，返回真。否则返回 false。
9. 停下来。

下面是相同的代码。

下面的例子演示了如何使用三元运算符来检查闰年。

//Java Program to check whether the given year is a leap year or not
import java.util.Scanner;

public class CheckYear
{
static boolean checkLeapYear(int year)
    {
        // If a year is multiple of 400, then it is a leap year
        if (year % 400 == 0)
            return true;

        // Else If a year is multiple of 100, then it is not a leap year
        if (year % 100 == 0)
            return false;

        // Else If a year is multiple of 4, then it is a leap year
        if (year % 4 == 0)
            return true;
        return false;
    }

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int year;   //Year Declaration
        System.out.println("Enter the year");
        year=sc.nextInt();   //Year Initialization

        //Ternary Operator to check
        System.out.println( checkLeapYear(2000)? "Leap Year" :
                           "Not a Leap Year" );    
     }

}

进入 2012 年
闰年

程序 3:检查闰年

在这个方法中，我们将使用函数检查给定的年份是否是闰年。

算法:

1. 开始
2. 声明一个变量，比如说年份。
3. 初始化它。
4. 调用函数进行检查。
5. 如果年份是 400 的倍数，则返回 true。
6. 否则，如果年份是 100 的倍数，则返回 false。
7. 否则，如果年份是 4 的倍数，那么它就是闰年，并返回 true。
8. 使用 if-else 条件显示结果。
9. 停下来。

下面是相同的代码。

下面的例子演示了如何使用函数来检查闰年。

//Java Program to check whether the given year is a leap year or not using Functions
import java.util.Scanner;

public class CheckYear
{
static boolean checkLeapYear(int year)
    {
        // If a year is multiple of 400, 
        // then it is a leap year
        if (year % 400 == 0)
            return true;

        // Else If a year is multiple of 100,
        // then it is not a leap year
        if (year % 100 == 0)
            return false;

        // Else If a year is multiple of 4,
        // then it is a leap year
        if (year % 4 == 0)
            return true;
        return false;
    }

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int year;   //Year Declaration
        System.out.println("Enter the year");
        year=sc.nextInt();   //Year Initialization
         boolean check=checkLeapYear(year);
         if(check)
         {
             System.out.println(year+" is a leap year");
         }
         else
         {
            System.out.println(year+" is not a leap year");
         }
     }

}

进入 2018 年
2018 年不是闰年

---

---

Java 程序：检查一个数字是正数还是负数

原文：https://www.studytonight.com/java-programs/java-program-to-check-whether-a-number-is-positive-or-negative

如果一个数大于 0，则认为它是正的，如果小于 0，则认为它是负的。这里需要注意的一点是，0 既不是正的，也不是负的。

这里，给我们一个数字，我们的任务是找出给定的数字是正数还是负数。

输入:输入数字:56

输出:为正数。

程序 1:检查一个数字是正数还是负数

在这个方法中，我们将使用关系运算符来检查给定的数字是正数还是负数。使用关系运算符背后的主要逻辑是

• 如果数字大于 0，则为正数。
• 如果数字小于 0，则为负数。
• 如果一个数=0，那么它既不是正的也不是负的。

算法

1. 开始
2. 声明一个变量。
3. 初始化变量。
4. 使用关系运算符检查是正数还是负数。
5. 显示结果。
6. 停下来。

下面是相同的代码。

下面的程序演示了如何使用关系运算符来检查给定的数字是正数还是负数。

//Java Program to check whether the given number is positive or negative
import java.util.Scanner;

public class CheckNumber
{
    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int num ;     //Number declaration
        System.out.println("Enter the number");
        num=sc.nextInt();    //Number Initialization

        if(num>0)
        System.out.println("It is a positive number");
        else if(num<0)
        System.out.println("It is a negative number");
        else
        System.out.println("Neither positive nor negative");
     } 
}

输入数字 45
是正数

程序 2:检查一个数字是正数还是负数

这里，我们将使用 Integer.signum()方法来检查数字是正数还是负数。signum()是一个接受Integer类型参数的内置函数。它用于检查一个数字是正数还是负数。使用 Integer.signum()方法背后的逻辑是，

• 如果参数为 0，则返回 0。
• 如果参数大于 0，则返回 1。
• 如果参数小于 0，则返回-1。

算法

1. 开始
2. 声明一个变量。
3. 初始化变量。
4. 调用函数检查数字是正数还是负数。
5. 使用 Integer.signum()方法检查结果。
6. 返回结果。
7. 显示结果。
8. 停下来。

下面是相同的代码。

下面的程序演示了如何使用 Integer.signum()方法来检查给定的数字是正数还是负数。

//Java Program to check whether the given number is positive or not
import java.util.Scanner;

public class CheckNumber
{
    //Function Definitin
    static int checkNum(int x)
    { 
        // inbuilt signum function 
        int ans = Integer.signum(x); 
        return ans; 
    } 

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int num ;     //Number declaration
        System.out.println("Enter the number");
         num=sc.nextInt();    //Number Initialization

        int res=checkNum(num);    //Function Call
        if(res==0)
        System.out.print(num + " is Zero");
        else if (res == 1) 
            System.out.print(num + " is Positive"); 
        else
            System.out.print(num + " is Negative");

     }
}

输入数字-12
-12 为负数

程序 3:检查一个数字是正数还是整数

这里，我们将使用移位运算符来检查一个数字是正数还是负数。移位运算符(Val>>31)将最高位复制到每隔一位。我们知道任何负数的最高位是 1，任何其他数字的最高位是 0。因此，在(Val>>31)之后，我们可以使用&运算符来检查一个数字是正数还是负数。

• 如果((Val>>31) & 1)为 1，则该数字将为负数。
• 如果((Val>>31) & 1)为 0，则该数字将为正数。

算法

1. 开始
2. 声明一个变量。
3. 初始化变量。
4. 调用函数检查数字是正数还是负数。
5. 使用移位运算符检查结果。
6. 返回结果。
7. 显示结果。
8. 停下来。

下面是相同的代码。

下面的程序演示了如何使用移位运算符来检查给定的数字是正数还是负数。

//Java Program to check whether the given number is positive or not
import java.util.Scanner;

public class CheckNumber
{
    //Function Definition
    static String checkPosNeg(int val) 
    { 

        String[] result = { "Positive", "Negative" }; 

        // checks if the number is positive or negative 
        return result[(val >> 31) & 1]; 
    } 

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int num ;     //Number declaration
        System.out.println("Enter the number");
        num=sc.nextInt();    //Number Initialization

        System.out.println(num + " is " + checkPosNeg(num));   //Function Call
     }     
}

输入数字 867
867 为正

---

---

Java 程序：检查字符是否是字母

原文：https://www.studytonight.com/java-programs/java-program-to-check-whether-a-character-is-alphabet-or-not

所有字符变量都有一个 ASCII 值供计算机使用。该值可用于检查字符是否是字母。

这里，在这个程序中，我们被赋予一个字符，我们的任务是检查给定的字符是否是字母表。

输入:输入元素:R

输出:是字母表。

上述问题可以通过以下方式解决:

方法 1:使用 if-else 语句

方法 2:使用三元运算符

方法 3:使用 ASCII 值

方法 4:使用 isAlphabetic()方法

让我们分别看一下这些方法。

程序 1:检查字符是否是字母

在这个方法中，我们将使用 if-else 语句来检查给定的字符是否是字母表。

算法:

1. 开始吧。
2. 声明一个变量。
3. 初始化它。
4. 使用 if-else 语句检查给定字符是否是字母表。
5. 显示结果。
6. 停下来。

下面是相同的代码。

下面的程序演示了如何使用 if-else 语句来检查给定的字符是否是字母表。

//Java Program to check whether the given character is an alphabet or not
import java.util.Scanner;

public class CheckAlphabet
{

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        char ch;     //Declare a character
        System.out.println("Enter the character ");
        ch=sc.next().charAt(0);   //Initialize the character

        //check whether alphabet or not using if-else statement

        if((ch>='A' && ch<='Z')||(ch>='a' && ch<='z'))
        {
             System.out.print(ch+" is an Alphabet ");
        }
        else
        {
             System.out.print(ch+" is not an Alphabet ");
        }
     }   
}

输入字符 B
B 是一个字母表

程序 2:检查字符是否是字母

在这个方法中，我们将使用三元运算符来检查给定的字符是否是字母表。

算法:

1. 开始吧。
2. 声明一个变量。
3. 初始化它。
4. 使用三元运算符检查给定字符是否是字母表。
5. 显示结果。
6. 停下来。

下面是相同的代码。

下面的程序演示了如何使用三元运算符来检查给定的字符是否是字母

//Java Program to check whether the given character is an alphabet or not
import java.util.Scanner;

public class CheckAlphabet
{

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        char ch;     //Declare a character
        System.out.println("Enter the character ");
        ch=sc.next().charAt(0);   //Initialize the character

        //check whether alphabet or not using if-else statement

        String res = (ch>= 'a' && ch<= 'z') || (ch>= 'A' && ch<= 'Z')
                ? ch+ " is an alphabet."
                : ch+ " is not an alphabet.";

        System.out.println(res);
     }

}

输入字符 d
d 是一个字母表。

程序 3:检查字符是否是字母

在这个方法中，我们将使用 ASCII 值来检查给定的字符是否是字母表。ASCII 值由 0 到 127 之间的整数值表示。小写字母的 ASCII 值从 97 到 122，大写字母的 ASCII 值从 65 到 90

算法:

1. 开始吧。
2. 声明一个变量。
3. 初始化它。
4. 检查输入字符的 ASCII 值。
5. 如果它位于 97 - 122 或 65 - 90 之间，那么它就是一个字母表。
6. 显示结果。
7. 停下来。

下面是相同的代码。

下面的程序演示了如何使用 ASCII 值来检查给定的字符是否是字母表。首先，字符被初始化。然后，将其值与所需条件进行比较。如果条件满足，那么它就是字母表，否则就不是。

//Java Program to check whether the given character is an alphabet or not
import java.util.Scanner;

public class CheckAlphabet
{

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        char ch;     //Declare a character
        System.out.println("Enter the character ");
        ch=sc.next().charAt(0);   //Initialize the character

        //check whether alphabet or not using if-else statement

       if((ch>=97 && ch<=122)||(ch>=65 && ch<=90))
       {
           System.out.print(ch+" is an Alphabet");
       }
       else
       {
          System.out.print(ch+" is not an Alphabet");
       }
     }

}

输入字符 9
9 不是字母表

程序 4:检查字符是否是字母

在这个方法中，我们将使用 isAlphabetic()方法来检查给定的字符是否是字母表。

算法:

1. 开始吧。
2. 声明一个变量。
3. 初始化它。
4. 使用 isAlphabetic()方法检查给定的字符是否是字母表。
5. 显示结果。
6. 停下来。

下面是相同的代码。

下面的程序演示了如何使用 isAlphabetic()方法来检查给定的字符是否是字母

//Java Program to check whether the given character is an alphabet or not
import java.util.Scanner;

public class CheckAlphabet
{

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        char ch;     //Declare a character
        System.out.println("Enter the character ");
        ch=sc.next().charAt(0);   //Initialize the character

        //check whether alphabet or not using if-else statement

        if (Character.isAlphabetic(ch)) 
        {
             System.out.println(ch + " is an alphabet.");
        }
        else 
       {
             System.out.println(ch + " is not an alphabet.");
       }

     }  
}

输入字符 89
89 不是字母表。

---

---

Java 程序：计算自然数总和

原文：https://www.studytonight.com/java-programs/java-program-to-calculate-the-sum-of-natural-numbers

从 1 到 n 的所有正数，即 1，2，3，....，n 被称为一个自然数。所有这些数字的总和给了我们自然数的总和。

这里，给我们一个数，我们的任务是计算所有自然数的和。

输入:输入数字:1 2 3 4 5

输出:所有数字之和:15

程序 1:自然数的和

在这个方法中，我们将使用 for 循环来计算自然数的和。

算法

1. 开始
2. 声明数字。
3. 初始化数字。
4. 使用 for 循环计算总和。
5. 声明一个 sum 变量并将其初始化为 0。
6. 在每次迭代中更新该变量的值。
7. 打印最终值。
8. 停下来。

下面是相同的代码。

下面的程序演示了如何使用 for 循环来计算自然数的和。

//Java Program to calculate the sum of natural numbers
import java.util.Scanner;

public class CalculateSum
{

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int num; //Declare the number
        System.out.println("Enter the number");
        num=sc.nextInt();    //Initialize the number

        int sum=0;   //Variable to calculate the sum
        for(int i=1; i<=num;i++)
        {
            sum=sum+i;
        }
        System.out.println("The sum of natural numbers is "+sum);
     }
}

输入数字 5
自然数之和为 15

程序 2:自然数的和

在这个方法中，我们将使用 while 循环来计算自然数的和。

算法

1. 开始
2. 声明数字。
3. 初始化数字。
4. 使用 while 循环计算总和。
5. 声明一个 sum 变量并将其初始化为 0。
6. 在每次迭代中更新该变量的值。
7. 打印最终值。
8. 停下来。

下面是相同的代码。

下面的程序演示了如何使用 while 循环来计算自然数的总和。

//Java Program to calculate the sum of natural numbers
import java.util.Scanner;

public class CalculateSum
{

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int num; //Declare the number
        System.out.println("Enter the number");
        num=sc.nextInt();    //Initialize the number
        int i=1;
        int sum=0;   //Variable to calculate the sum
        while(i <= num)
        {
            sum += i;
            i++;
        }
        System.out.println("The sum of natural numbers is "+sum);
     }
}

输入数字 10
自然数之和为 55

程序 3:自然数的和

在这种方法中，我们将使用数学公式来计算自然数的和。

算法

1. 开始
2. 声明数字。
3. 初始化数字。
4. 使用公式计算总和。
5. 声明一个将存储最终总和的总和变量。
6. 使用公式 sum= num*(num+1)/2
7. 打印最终值。
8. 停下来。

下面是相同的代码。

下面的程序演示了如何使用公式计算自然数的总和。

//Java Program to calculate the sum of natural numbers
import java.util.Scanner;

public class CalculateSum
{

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int num; //Declare the number
        System.out.println("Enter the number");
        num=sc.nextInt();    //Initialize the number

        //formula to calculate the sum of natural numbers     
        int sum= num *( num +1) / 2;

        System.out.println("The sum of natural numbers is "+sum);
     }
}

输入数字 18
自然数之和为 171

程序 4:自然数的和

在这个方法中，我们将使用函数来计算自然数的和。

算法

1. 开始
2. 声明数字。
3. 初始化数字。
4. 调用一个计算自然数总和的函数。
5. 声明一个将存储最终总和的总和变量。
6. 使用公式 sum= num*(num+1)/2 并返回总和。
7. 打印最终值。
8. 停下来。

下面是相同的代码。

下面的程序演示了如何使用函数来计算自然数的总和。

//Java Program to calculate the sum of natural numbers
import java.util.Scanner;

public class CalculateSum
{
     static int sumOfNaturalNumbers(int n)   
     {   
          //formula to calculate the sum of natural numbers      
          return n * (n + 1) / 2;   
     }  

    // Driver method
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int num; //Declare the number
        System.out.println("Enter the number");
        num=sc.nextInt();    //Initialize the number

        int sum=sumOfNaturalNumbers(num);

        System.out.println("The sum of natural numbers is "+sum);
     }
}

输入数字 12
自然数之和为 78

---

---

Java 程序：接受学生分数并计算总分数和百分比

原文：https://www.studytonight.com/java-programs/java-program-to-accept-the-marks-of-a-student-and-find-the-total-marks-and-percentage

在本教程中，我们将学习如何将学生的分数接受到一维数组中，并找到总分数和百分比。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。

输入:

马克= 40 50 80 90 60 70

输出:

总分= 390

总百分比= 65%

程序 1:找出学生的总分数和百分比

在这种方法中，我们将使用迭代方法来计算学生获得的总分数和百分比。

算法

1. 开始
2. 声明一个数组。
3. 要求用户初始化数组。
4. 调用一个方法来计算数组中所有元素(标记)的总和和百分比。
5. 在那里声明一个 sum 变量，并将其初始化为 0。
6. 在每次迭代中更新总和。
7. 打印总和。
8. 计算百分比。
9. 打印安全百分比。
10. 停下来。

下面是相同的代码。

下面的程序演示了如何接受一个学生的分数到一个数组中，并使用迭代法找到总分数和百分比。

/* Java Program to accept the marks of a student into a 1-D array and find the total marks and percentage. */
import java.util.*;   
public class Main 
{ 
    // Main driver method 
    public static void main(String args[]) 
    {   
        // Taking input from user 
        Scanner sc = new Scanner(System.in); 
        int n;     //Declaring Variables

        //Ask the user to enter the Array Size
        System.out.println("Enter the total subjects ");
        n=sc.nextInt();

        //Declare the array
        int arr[] = new int[n]; 
        System.out.println("Enter the marks secured in each subject ");
        for(int i=0;i<n;i++)   //Initialize the array
        {
            arr[i]=sc.nextInt();
        }

        int total=0;
        //Calculate the total marks
        for(int i=0;i<n;i++)
        {
            total=total+arr[i];
        }
        //Display the total marks
        System.out.println("The total marks obtained is "+total);

        //Calculate the percentage
        float percentage; 
        percentage = (total / (float)n); 

        //Display the total percentage
        System.out.println( "Total Percentage : " + percentage + "%");                         
    }   
}

输入总科目 6
输入每个科目的安全分数 78 98 67 90 34 23
获得的总分数为 390
总百分比:65.0%

程序 2:找出学生的总分数和百分比

在这种方法中，我们将使用递归方法来计算学生获得的总分数和总百分比。

算法

1. 开始
2. 声明一个数组。
3. 要求用户初始化数组。
4. 调用一种方法来计算学生获得的总分数和总百分比。
5. 使用递归函数计算数组中所有元素的总和和百分比。
6. 返回数组中所有元素的百分比和总和。
7. 打印数组中所有元素的百分比和总和。
8. 停止

下面的程序演示了如何接受一个学生的分数到一个数组中，并使用递归方法找到总分数和百分比。

/* Java Program to accept the marks of a student into a 1-D array and find the total marks and percentage. */
import java.util.*; 
public class Main 
{ 
    // Recursively computes average of a[]
    static double findTotal(int a[], int i, int n)
    {
        // Last element
        if (i == n-1)
            return a[i];    
        // When index is 0, divide sum computed so
        // far by n.
        if (i == 0)
            return ((a[i] + findTotal(a, i+1, n))/n);    
        // Compute sum
        return (a[i] + findTotal(a, i+1, n));
    }    
    // Function that returns the average of an array.
    static double findPercentage(int a[], int n)
    {
         return findTotal(a, 0, n);
    }    
    // Main driver method 
    public static void main(String args[]) 
    {   
        // Taking input from user 
        Scanner sc = new Scanner(System.in); 
        int n;     //Declaring Variables

        //Ask the user to enter the Array Size
        System.out.println("Enter the total subjects ");
        n=sc.nextInt();

        //Declare the array
        int arr[] = new int[n]; 
        System.out.println("Enter the marks secured in each subject ");
        for(int i=0;i<n;i++)   //Initialize the array
        {
            arr[i]=sc.nextInt();
        }        
        //Print the sum and percentage
         double avg=findPercentage(arr, n);  
         double sum=avg*n;
        System.out.println("The total marks is "+sum);
        System.out.println("The total percentage is "+avg+" % ");     
    }   
}

输入总科目 6
输入每个科目的安全分数 87 56 34 24 45 99
总分数为 345.0
总百分比为 57.5 %

---

---

Java 程序：If Else

原文：https://www.studytonight.com/java-programs/java-if-else-program

在这个程序中，我们将使用 java 中的 if-else 语句执行各种程序。但是在继续之前，如果你不熟悉 java 中 if 语句的概念，那么一定要查看主题为Java 中条件语句的文章。

语法

if(condition){  
//code if condition is true  
}else{  
//code if condition is false  
} 

在本教程中，我们将看到三种 if 语句的程序:

1. if 语句

2. if-else 语句

3. 如果-否则-如果梯子

让我们分别看看这些程序。

程序 1:如果用 Java 编程

在这个程序中，我们将看到 if 语句在 java 中的实现。在这里，我们将根据一个人的年龄来决定他/她是否有资格投票。

算法:

1. 开始吧。

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储人的年龄。

4. 要求用户初始化变量。

5. 使用 if 语句检查此人是否有资格投票。

6. 如果输入的年龄大于等于 18 岁，则他有资格投票。

7. 显示结果。

8. 停下来。

下面是 if 条件程序的 Java 代码。

//Java Program for implementation of if statement
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
         //Take input from the user
         //Create an instance of the Scanner class
         Scanner sc=new Scanner(System.in);
         System.out.println("Enter the age: ");
         int age=sc.nextInt();
         //Determine whether the person is eligible to vote or not
          if(age>=18)
          {  
                System.out.println("The person is eligible to vote");  
          }     
     }
}

输入年龄:21
此人有资格投票

程序 2: Java If-Else 程序

在这个程序中，我们将看到 if-else 语句在 java 中的实现。这里，我们将使用 if-else 语句来确定输入的数字是正数还是负数。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储数字。

4. 要求用户初始化数字。

5. 使用 if-else 语句检查输入的数字是正数还是负数。

6. 如果输入的数字大于 0，则将其打印为正数。

7. 否则，如果输入的数字小于 0，则将其打印为负数。

8. 显示结果。

9. 停下来。

下面是 if-else 条件程序的 Java 代码。

//Java Program for implementation of if-else statement
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
         //Take input from the user
         //Create an instance of the Scanner class
         Scanner sc=new Scanner(System.in);
         System.out.println("Enter a number: ");
         int num=sc.nextInt();
         if(num>0)
         {
             System.out.println("The entered number "+num+" is positive.");
         }
         else
         {
             System.out.println("The entered number "+num+" is negative.");
         }
     }
}

输入数字:-9
输入的数字-9 为负数。

程序 3: Java If-else-if 程序

在这个程序中，我们将看到 if-else-if 阶梯在 java 中的实现。在这里，我们将根据一个学生获得的分数来确定他的分数。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储获得的标记。

4. 要求用户初始化变量。

5. 使用 if-else-if 语句来确定从输入的分数中获得的分数。

6. 如果标记小于 50，打印为失败。

7. 否则，如果标记在 50 到 60 之间，打印为 D 级。

8. 否则，如果标记在 60 到 70 之间，打印为 C 级。

9. 否则，如果标记在 70 到 80 之间，打印为 B 级。

10. 否则，如果分数在 80 到 90 之间，打印为 A 级。

11. 否则，如果分数在 90 到 100 之间，打印为 A+级。

12. 否则打印为无效。

13. 显示结果。

14. 停下来。

下面是 if-else 条件程序的 Java 代码。

//Java Program for implementation of if-else-if statement
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
         //Take input from the user
         //Create an instance of the Scanner class
         Scanner sc=new Scanner(System.in);
         System.out.println("Enter the marks obtained: ");
         int num=sc.nextInt();
         //Determine the grades from the marks obtained
          if(num<50)
          {  
                System.out.println("fail");  
          }  
          else if(num>=50 && num<60)
          {  
                System.out.println("D grade");  
          }  
          else if(num>=60 && num<70)
          {  
               System.out.println("C grade");  
          }  
          else if(num>=70 && num<80)
          {  
               System.out.println("B grade");  
          }  
          else if(num>=80 && num<90)
          {  
              System.out.println("A grade");  
          }
          else if(num>=90 && num<100)
          {  
              System.out.println("A+ grade");  
          }
          else
          {  
             System.out.println("Invalid!");  
          }  
     }
}

输入获得的分数:78
B 级

---

---

Java 程序：嵌套If

原文：https://www.studytonight.com/java-programs/java-nested-if-program

在这个程序中，我们将使用 java 中的嵌套 if 语句执行各种程序。当在另一个 if 语句中有一个 if 语句时，它被称为嵌套 if 语句。有时，我们在另一个条件中测试一个条件，如果条件满足就返回一个值，如果条件不满足就返回另一个值。计算多个条件，并根据使用 if 语句嵌套的条件返回多个值。但是在继续之前，如果您不熟悉 java 中嵌套 if 语句的概念，那么一定要查看主题为【Java 中的 T0】条件语句的文章。

句法

if(condition_1) {
   Statement1(s);

   if(condition_2) {
      Statement2(s);
   }
}

程序 1: Java 嵌套 if 程序

在这个程序中，我们将看到嵌套 if 语句在 java 中的实现。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储数字。

4. 要求用户初始化数字。

5. 使用第一个 if 语句检查数字是否小于 100。

6. 使用内部 if 语句检查该数字是否大于 50。

7. 如果数字大于 50 小于 100，则打印输入的数字大于 50 小于 100 的消息。

8. 如果数字不大于 50 但小于 100，则打印输入的数字小于 100 的消息。

9. 如果数字大于 100，则打印输入的数字大于 100 的消息。

10. 停下来。

下面是嵌套 if-else 的 Java 代码示例。

//Java nested if Program
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
        //Take input from the user
        //Create an instance of the Scanner class
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter a number: ");
        int num=sc.nextInt();
        if( num < 100 )
        { 
           System.out.println("The entered number is less than 100"); 
           if(num > 50)
           {
	          System.out.println("The entered number is greater than 50");
	       }
	    }
	    else
	    {
	        System.out.println("The entered number is greater than 100");
	    }
     }
}

输入数字:67
输入的数字小于 100
输入的数字大于 50

程序 2: Java 嵌套 if-else 程序

在这个程序中，我们将看到 java 程序中嵌套 if-else 语句的实现。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明两个变量来存储一个人的年龄和体重。

4. 要求用户初始化年龄和体重。

5. 使用第一个 if 语句检查该人是否超过 18 岁。

6. 如果此人超过 18 岁，则使用另一个 If 语句检查此人的体重是否超过 50。

7. 如果这个人的年龄在 18 岁以上，体重也在 50 以上，那么，打印这个人有资格献血的信息。

8. 如果此人超过 18 岁，但他/她的体重低于 50，则打印此人没有资格献血的信息。

9. 如果此人未满 18 岁，则打印年龄必须大于 18 岁的信息。

10. 显示结果。

11. 停止

下面是嵌套 if-else 的 Java 代码示例。

//Java nested if-else Program
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
        //Take input from the user
        //Create an instance of the Scanner class
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the age: ");
        int age=sc.nextInt();
        System.out.println("Enter the weight: ");
        int weight=sc.nextInt();
        if(age>=18)
        {      
           if(weight>50)
           {    
              System.out.println("The person is eligible to donate blood");    
           }
           else
           {  
              System.out.println("The person is not eligible to donate blood");    
           }  
        }
        else
        {  
            System.out.println("Age must be greater than 18");  
        }  
     }
}

输入年龄:24
输入体重:49
此人无献血资格

程序 3: Java 嵌套 if-else 梯形程序

在这个程序中，我们将看到 java 程序中嵌套 if-else 语句的实现。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储部门名称。

4. 要求用户初始化年份。

5. 使用第一个 if 语句检查学生的系。

6. 使用内部 if 语句检查学生在哪一年。

7. 显示结果。

8. 停止

下面是嵌套 if-else 的 Java 代码示例。

//Java nested if Program
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
        //Take input from the user
        //Create an instance of the Scanner class
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the dept: ");
        String dept=sc.nextLine();
        int year;
        if(dept.equals("CSE"))
        { 
             System.out.println("Enter a year: ");
             year=sc.nextInt();
           System.out.println("The student is in the Computer Science department"); 
           if(year == 1)
           {
	          System.out.println("The student is in 1st year");
	       }
	       else if(year == 2)
	       {
	        System.out.println("The student is in 2nd year");
	       }
	       else if(year == 3)
	       {
	        System.out.println("The student is in 3rd year");
	       }
	       else if(year == 4)
	       {
	        System.out.println("The student is in 4th year");
	       }
	    }
	    else if(dept.equals("EEE"))
        { 
             System.out.println("Enter a year: ");
             year=sc.nextInt();
           System.out.println("The student is in the Electrical and Electronics department"); 
           if(year == 1)
           {
	          System.out.println("The student is in 1st year");
	       }
	       else if(year == 2)
	       {
	        System.out.println("The student is in 2nd year");
	       }
	       else if(year == 3)
	       {
	        System.out.println("The student is in 3rd year");
	       }
	       else if(year == 4)
	       {
	        System.out.println("The student is in 4th year");
	       }
	    }
	    else if(dept.equals("ME"))
        { 
             System.out.println("Enter a year: ");
             year=sc.nextInt();
           System.out.println("The student is in the Mechanical department"); 
           if(year == 1)
           {
	          System.out.println("The student is in 1st year");
	       }
	       else if(year == 2)
	       {
	        System.out.println("The student is in 2nd year");
	       }
	       else if(year == 3)
	       {
	        System.out.println("The student is in 3rd year");
	       }
	       else if(year == 4)
	       {
	        System.out.println("The student is in 4th year");
	       }
	    }
	    else
	    {
	        System.out.println("Enter a valid department");
	    }
     }
} 

进入院系:CSE
进入一年:2
学生在计算机系
学生在二年级

---

---

Java 程序：寻找最大和最小出现字符

原文：https://www.studytonight.com/java-programs/java-program-to-find-maximum-and-minimum-occurring-character

在本教程中，我们将学习如何找到最小和最大出现字符。这里，我们将首先遍历字符串，然后计算每个元素的频率。最后，我们将打印频率最高和最低的字符。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:苹果

输出:最大出现次数:p

最小出现次数:A

程序 1:找到最小和最大出现字符

在这个程序中，我们将看到当字符串是用户定义的时，如何计算字符串中出现的最小和最大字符。在这里，我们将要求用户初始化数组，然后我们将找出最小和最大出现字符

算法:

1. 开始

2. 声明字符串

3. 请用户初始化它。

4. 声明一个数组来存储元素的频率。

5. 为最小和最大出现字符声明变量，并将它们赋给 0。

6. 将字符串转换为字符数组。

7. 对同一个循环使用两个。

8. 使用第一个 for 循环遍历字符串中的每个字符。

9. 选择字符，并在频率数组中将它们对应的频率初始化为 1。

10. 使用第二个 for 循环将所选字符与字符串中的其余字符进行比较。

11. 再次使用两个 for 循环迭代频率数组。

12. 使用最小和最大变量存储字符串中出现的最小和最大字符数。

13. 迭代循环，比较 freq 中存储的每个字符的计数与最小值和最大值。

14. 如果存储在 freq 中的计数小于 min 的值，则将该计数存储在 min 中，并将相应的字符存储在 minChar 中。

15. 如果存储在 freq 中的计数大于 max 的值，则将该计数存储在 max 中，并将相应的字符存储在 maxChar 中。

16. 现在，最小字符将存储最小出现字符，最大字符将存储最大出现字符。

17. 打印最少和最多出现的字符。

18. 停止

下面的例子说明了上述算法的实现。

//Java Program to find the maximum and minimum occurring character in a string
import java.util.*;
public class Main  
{
   public static void main(String[] args) 
   {    
       //Take input from the user 
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the string: ");
        String str=sc.nextLine();
      int[] freq = new int[str.length()];    
      char minChar = str.charAt(0), maxChar = str.charAt(0);    
      int i, j, min, max;            
      char string[] = str.toCharArray();    
      for(i = 0; i < string.length; i++) 
	  {    
          freq[i] = 1;    
          for(j = i+1; j < string.length; j++) 
		  {    
              if(string[i] == string[j] && string[i] != ' ' && string[i] != '0') 
			  {    
                  freq[i]++;    

                  string[j] = '0';    
              }    
          }    
      }    
      min = max = freq[0];    
      for(i = 0; i <freq.length; i++) 
	  {    
          if(min > freq[i] && freq[i] != '0') 
		  {    
              min = freq[i];    
              minChar = string[i];    
          }    
          if(max < freq[i]) 
		  {    
              max = freq[i];    
              maxChar = string[i];    
          }    
      }             
      System.out.println("Minimum occurring character: " + minChar);    
      System.out.println("Maximum occurring character: " + maxChar);    
  }  
}

输入字符串:查找最小和最大出现字符
最小出现字符:F
最大出现字符:m

程序 2:找到最小和最大出现字符

在这个程序中，我们将看到当字符串在程序中被预定义时，如何计算字符串中出现的最小和最大字符。

算法:

1. 开始

2. 声明字符串

3. 初始化它。

4. 声明一个数组来存储元素的频率。

5. 为最小和最大出现字符声明变量，并将它们赋给 0。

6. 将字符串转换为字符数组。

7. 对同一个循环使用两个。

8. 使用第一个 for 循环遍历字符串中的每个字符。

9. 选择字符，并在频率数组中将它们对应的频率初始化为 1。

10. 使用第二个 for 循环将所选字符与字符串中的其余字符进行比较。

11. 再次使用两个 for 循环迭代频率数组。

12. 使用 min 和 max 变量存储字符串中出现的最小和最大字符数。

13. 迭代循环，比较 freq 中存储的每个字符的计数与最小值和最大值。

14. 如果存储在 freq 中的计数小于 min 的值，则将该计数存储在 min 中，并将相应的字符存储在 minChar 中。

15. 如果存储在 freq 中的计数大于 max 的值，则将该计数存储在 max 中，并将相应的字符存储在 maxChar 中。

16. 现在，最小字符将存储最小出现字符，最大字符将存储最大出现字符。

17. 打印最少和最多出现的字符。

18. 停止

下面的例子说明了上述算法的实现。

//Java Program to find the maximum and minimum occurring character in a string

public class Main  
{
   public static void main(String[] args) 
   {  
        String str = "Example of minimum and maximum Character";  
        System.out.println("The entered string is: "+str);
        int[] freq = new int[str.length()];  
        char minChar = str.charAt(0), maxChar = str.charAt(0);  
        int i, j, min, max;          
        //Converts given string into character array  
        char string[] = str.toCharArray();  
        //Count each word in given string and store in array freq  
        for(i = 0; i < string.length; i++) 
        {  
            freq[i] = 1;  
            for(j = i+1; j < string.length; j++) 
            {  
                if(string[i] == string[j] && string[i] != ' ' && string[i] != '0') 
                {  
                    freq[i]++;  

                    //Set string[j] to 0 to avoid printing visited character  
                    string[j] = '0';  
                }  
            }  
        }  
        //Determine minimum and maximum occurring characters  
        min = max = freq[0];  
        for(i = 0; i <freq.length; i++) 
        {  
            if(min > freq[i] && freq[i] != '0') 
            {  
                min = freq[i];  
                minChar = string[i];  
            }  

            if(max < freq[i]) 
            {  
                max = freq[i];  
                maxChar = string[i];  
            }  
        }  
        //Print the minimum and maximum occurring characters  
        System.out.println("Minimum occurring character: " + minChar);  
        System.out.println("Maximum occurring character: " + maxChar);  
    }  
} 

输入的字符串为:最小和最大字符示例
最小出现字符:E
最大出现字符:m

---

---

Java 程序：计算复利

原文：https://www.studytonight.com/java-programs/java-program-to-calculate-compound-interest

在本教程中，我们将学习如何在给定本金、利率、时间段和复利次数的情况下找到复利。但是在继续之前，如果你不熟悉 java 中算术运算符的概念，那么一定要查看关于 Java 中运算符的文章。

输入:输入本金金额:6200.0

输入汇率:11.0

输入时间段:2.0

输出:

复利:886600.0

2 年期末金额:892800.0

上述问题可以通过以下方式解决:

方法 1:当值由用户定义时

方法 2:当值被预定义时

让我们分别看看这些方法。

程序 1:计算复利

在这个程序中，我们将看到当值是用户定义的时，如何使用公式找到复利。这意味着，首先我们将要求用户初始化变量，然后我们将使用公式找到复利。

算法:

1. 开始
2. 创建 Scanner 类的实例，从用户处获取输入。
3. 声明本金金额、利率、时间段和复利次数的变量。
4. 要求用户初始化这些变量。
5. 使用公式计算复利。
6. 打印复利的价值。
7. 打印复利后的金额。
8. 停止

下面是相同的代码。

//Java Program to calculate the compound interest
import java.util.*;
public class Main
{
    public static void main(String args[]) 
    {
        //Take input from the user
        //Create an instance of the Scanner class
    	Scanner sc = new Scanner(System.in);
        //Declare variables
        float p, r, t, n;
        System.out.println("Enter the Principal : ");
        p = sc.nextFloat();     //Initialize the variables
        System.out.println("Enter the Rate of interest : ");
        r = sc.nextFloat();     //Initialize the variables
        System.out.println("Enter the Time period : ");
        t = sc.nextFloat();     //Initialize the variables
        System.out.println("Enter the number of times that interest is compounded per unit t");
        n=sc.nextFloat();      //Initialize the variables
        sc.close();

        //Calculate the compound interest
    	double amount = p * Math.pow(1 + (r / n), n * t);
        double cinterest = amount - p;
        System.out.println("Compound Interest after " + t + " years: "+cinterest);
        System.out.println("Amount after " + t + " years: "+amount);
    }
}

输入本金金额:5200
输入利率:12
输入时间段:3
输入单位 t 复利次数:2
3.0 年后复利:6.117696 E8
3.0 年后金额:6.117748E8

程序 2:计算复利

在这个程序中，我们将看到当值在程序中预先定义时，如何使用公式找到复利。

算法:

1. 开始
2. 创建 Scanner 类的实例，从用户处获取输入。
3. 声明本金金额、利率、时间段和复利次数的变量。
4. 初始化这些变量。
5. 使用公式计算复利。
6. 打印复利的价值。
7. 打印复利后的金额。
8. 停止

下面是相同的代码。

//Java Program to calculate the compound interest
public class Main
{
    public static void main(String args[]) 
    {
        //Declare and initialize the variables 
        float p = 4500, r = 10, t = 2 , n=1; 
        //Print the variables and their corresponding values
        System.out.println("The entered principle amount is = " + p);
        System.out.println("The entered rate is = " + r);
        System.out.println("The entered time period is " + t);
        System.out.println("The entered number of times the interest is compounded is " + n);

        //Calculate the compound interest and the amount
    	double amount = p * Math.pow(1 + (r / n), n * t);
        double cinterest = amount - p;
        System.out.println("Compound Interest after " + t + " years: "+cinterest);
        System.out.println("Amount after " + t + " years: "+amount);
    }
}

录入本金金额为= 4500.0
录入利率为= 10.0
录入时间段为 2.0
录入复利次数为 1.0
2.0 年后复利:540000.0
2.0 年后金额:544500.0

程序 3:寻找复利

在这个程序中，我们将看到当值是用户定义的时，如何使用公式找到复利。这意味着，首先我们将首先要求用户初始化变量，然后用用户定义的方法计算复利。

算法:

1. 开始
2. 创建 Scanner 类的实例，从用户处获取输入。
3. 声明本金金额、利率、时间段和复利次数的变量。
4. 要求用户初始化这些变量。
5. 调用一个方法来计算复利。
6. 使用公式计算复利。
7. 打印复利的价值。
8. 打印复利后的金额。
9. 停止

下面是相同的代码。

//Java Program to calculate the compound interest
public class Main
{
    public static void main(String args[]) 
    {
        //Declare and initialize the variables 
        float p = 2900, r = 18, t = 2 , n=1; 
        //Print the variables and their corresponding values
        System.out.println("The entered principle amount is = " + p);
        System.out.println("The entered rate is = " + r);
        System.out.println("The entered time period is " + t);
        System.out.println("The entered number of times the interest is compounded is " + n);
        findCi(p,r,t,n);
    }
    public static void findCi(float p, float r, float t, float n)
    {
        //Calculate the compound interest and the amount
    	double amount = p * Math.pow(1 + (r / n), n * t);
        double cinterest = amount - p;
        System.out.println("Compound Interest after " + t + " years: "+cinterest);
        System.out.println("Amount after " + t + " years: "+amount);
    }
}

录入本金金额为= 2900.0
录入利率为= 18.0
录入时间段为 2.0
录入复利次数为 1.0
2.0 年后复利:1044000.0
2.0 年后金额:1046900.0

---

---

Java 程序：计算二次方程所有根

原文：https://www.studytonight.com/java-programs/java-programs-to-find-all-roots-of-a-quadritic-equation

如果一个方程的形式是 ax2+bx+c=0 ，其中 a、b、c 是实数，a 不等于 0，那么这个方程被称为二次方程。方程的标准形式和计算公式如下:

一个二次方程有两个根，这两个根取决于判别式。在上式中，sqrt((bb)-(4a*c))被称为判别式。

• 如果判别式是正的，那么根是实的，不相等的。
• 如果判别式为 0，那么根是实的且相等的。
• 如果判别式是负的，那么根是不相等的，是虚的。

在这里，我们得到一个二次方程，我们的任务是找到这个方程的根。例如，

输入: 1 -2 1

输出: 1 1

程序 1:求二次方程

在这个程序中，二次方程的根是在主方法本身中找到的。

算法:

1. 开始
2. 声明变量 a，b，c。
3. 初始化变量 a，b，c。
4. 用主方法本身计算二次方程的根。
5. 使用条件 a==0 检查根是否可能。
6. 计算判别式为判别式= sqrt((bb)-(4a*c))。
7. 如果判别式。> 0，那么根是真实的，不相等的。
8. 求根为(-b+判别式)/(2 *a)和(-b -判别式)/(2 *a)。
9. 如果判别式=0，那么根是实的和相等的。
10. 求根为(-b +判别式)/( 2*a)。
11. 如果判别式> 0，那么根是复杂且不同的。
12. 将根计算为(-b/(2a)) + iD 和(-b/(2a)) - iD。
13. 显示根。
14. 停止

下面是相同的代码。

在这个例子中，我们将直接找到二次方程的根。首先，二次方程的系数被声明和初始化。然后我们直接在主方法本身找到二次方程的根。

//Java Program to find the roots of the quadratic equation
import java.util.Scanner;
public class QuadraticEquation
{

     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        double a,b,c;      //Quadratic Variables declaration
        System.out.println("Enter the value of a..");
        a=sc.nextDouble();   //Quadratic Variables Initialization
        System.out.println("Enter the value of b..");
        b=sc.nextDouble();    //Quadratic Variables Initialization
        System.out.println("Enter the value of c..");
        c=sc.nextDouble();   //Quadratic Variables Initialization

        double d=(b*b)-(4*a*c);    //Find the determinant
        double D= Math.sqrt(d);
        double r=2*a;

        //Check for Roots
        if(D>0)
        {
            System.out.println("Roots are real and unequal");
            double root1=(D-b)/r;
            double root2=(-D-b)/r;
            System.out.println("Roots are..");
            System.out.println(root1);
            System.out.println(root2);
        }
        else if(D==0)
        {
            System.out.println("The roots of the quadratic equation are real and equal.");
            double root=(-b)/r;
            System.out.println("Root is "+root);
        }
        else
        {
            System.out.println("The roots of the quadratic equation are complex and different");
            System.out.println("Roots are ");
            System.out.println((-b/r)+" +i" + D);
            System.out.println((-b/r)+" -i" + D);
        }
     }
}

输入的值..15
输入 b 的值..68
输入 c 的值..3
根真实不平等
根真实不平等..
-0.044555558333472335
-4。58865 . 88888888666

程序 2:求二次方程

在这种方法中，用函数求出二次方程的根。

算法

1. 开始
2. 声明变量 a，b，c。
3. 初始化变量 a，b，c。
4. 调用一个函数来计算二次方程的根。
5. 使用条件 a==0 检查根是否可能。
6. 计算判别式为判别式= sqrt((bb)-(4a*c))
7. 如果判别式。> 0，那么根是真实的，不相等的。
8. 求根为(-b+判别式)/(2 *a)和(-b -判别式)/(2 *a)。
9. 如果判别式=0，那么根是实的和相等的。
10. 求根为(-b +判别式)/( 2*a)
11. 如果判别式> 0，那么根是复杂且不同的。
12. 将根计算为(-b/(2a)) + iD 和(-b/(2a)) - iD
13. 显示根。
14. 停止

下面是相同的代码。

在这个例子中，我们将使用方法来寻找二次方程的根。首先，二次方程的系数被声明和初始化。然后调用一个函数来求二次方程的根。

//Java Program to find the roots of quadratic equation using Functions
import java.util.Scanner;
import static java.lang.Math.*;

public class QuadraticEquation
{
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        int a,b,c;    //Quadratic Variables Declaration
        System.out.println("Enter the value of a..");
        a=sc.nextInt();   //Quadratic Variables Initialization
        System.out.println("Enter the value of b..");
        b=sc.nextInt();    //Quadratic Variables Initialization
        System.out.println("Enter the value of c..");
        c=sc.nextInt();;   //Quadratic Variables Initialization
         quadraticRoots(a,b,c);   //Function Call

     }

     static void quadraticRoots(int a,int b,int c)
     {
        //Check whether roots are possible or not
        if (a == 0)   
        {  
           System.out.println("The value of a cannot be 0.");  
           return;  
        }  
       //calculating discriminant (d)  
       int d = b * b - 4 * a * c;  
       double D = sqrt(abs(d));  
       if (d > 0)   
       {  
          System.out.println("The roots of the equation are real and different. \n");  
          System.out.println((double)(-b + D) / (2 * a) + "\n"+ (double)(-b - D) / (2 * a));  
       }  
       else if (d == 0)   
       {  
          System.out.println("The roots of the equation are real and same. \n");  
          System.out.println(-(double)b / (2 * a) + "\n"+ -(double)b / (2 * a));  
       }  
       // executes if d < 0  
       else   
       {  
          System.out.println("The roots of the equation are complex and different. \n");  
          System.out.println(-(double)b / (2 * a) + " + i"+ D + "\n"+ -(double)b / (2 * a)+ " - i" + D);  
        }   
     }
}

输入的值..7
输入 b 的值..7
输入 c 的值..7
方程的根复杂且不同。

-0.5+i12.12435565298214
-0.5-i12 . 53961 . 53963943106

---

---

Java 程序：计算平行四边形面积

原文：https://www.studytonight.com/java-programs/java-program-to-find-the-area-of-a-parallelogram

在本教程中，我们将学习如何用 java 计算平行四边形的面积。平行四边形是有两对平行边的简单四边形。平行四边形的相对边或相对边长度相等，平行四边形的相对角大小相等。平行四边形的面积是二维平面中被平行四边形覆盖的区域。

让我们看看下面的例子。

输入:输入基数:7

输入高度:8

输出:平行四边形的面积:56

下面是同样的图示。

上述问题可以通过以下方式解决:

程序 1:求平行四边形的面积

在这个程序中，我们将学习如何使用底部和高度公式来寻找平行四边形的面积。

算法

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储平行四边形的底和高的值。
4. 要求用户初始化变量。
5. 声明另一个变量来存储平行四边形的面积。
6. 使用底部和高度公式计算面积。
7. 显示结果。
8. 停下来。

下面是 Java 语言的代码示例。

//Java Program to Calculate the Area of a Parallelogram
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
        //Take input from the user 
        //Create an instance of the Scanner Class
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the base of the parallelogram: ");
        int base=sc.nextInt();
        System.out.println("Enter the height of the parallelogram: ");
        int height=sc.nextInt();
        int area=base*height;

        // display the area of a parallelogram
        System.out.println("Area of the parallelogram = " + area);
     }
}

输入平行四边形的底边:10
输入平行四边形的高度:20
平行四边形的面积= 200

程序 2:在 Java 中找到平行四边形的面积

在这个节目中，我们将学习如何使用三角学来寻找平行四边形的面积。

算法

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储平行四边形边的值。
4. 要求用户初始化变量。
5. 声明另一个变量来存储平行四边形边之间的角度。
6. 将其转换为弧度。
7. 计算角度的正弦值。
8. 用三角公式计算平行四边形的面积，
9. 打印平行四边形的面积值。
10. 停下来。

下面是 Java 语言的代码示例。

//Java Program to Calculate the Area of a Parallelogram
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
        //Take input from the user 
        //Create an instance of the Scanner Class
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the sides of the parallelogram: ");
        double a1=sc.nextDouble();
        System.out.println("Enter the sides of the parallelogram: ");
        double b1=sc.nextDouble();
        System.out.println("Enter the angle between the sides of the parallelogram: ");
        double a = sc.nextDouble();
        // converting values to radians
        double b = Math.toRadians(a);
        double area=a1*b1*(Math.sin(b));
        // display the area of parallelogram
        System.out.println("Area of the parallelogram = " + area);
     }
}
?

输入平行四边形的边:3
输入平行四边形的边:4
输入平行四边形的边之间的角度:90
平行四边形的面积= 12.0

Java 程序：程序 3: Java 中求平行四边形面积

在这个程序中，我们将学习如何使用对角线来寻找平行四边形的面积。

算法

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储平行四边形对角线的值。
4. 要求用户初始化这些变量。
5. 声明另一个变量来存储平行四边形任意两条对角线之间的角度。
6. 要求用户初始化变量。
7. 将其转换为弧度。
8. 计算角度的正弦值。
9. 用对角线公式计算平行四边形的面积，
10. 打印平行四边形的面积值。
11. 停下来。

下面是 Java 语言的代码示例。

//Java Program to Calculate the Area of a Parallelogram
import java.util.Scanner;
public class Main
{
     public static void main(String []args)
     {
        //Take input from the user 
        //Create an instance of the Scanner Class
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the first diagonal of the parallelogram: ");
        double d1=sc.nextDouble();
        System.out.println("Enter the second diagonal of the parallelogram: ");
        double d2=sc.nextDouble();
        System.out.println("Enter the angle between the diagonals of the parallelogram: ");
        double a = sc.nextDouble();
        // converting values to radians
        double b = Math.toRadians(a);
        double area=(d1*d2*(Math.sin(b)))/2;
        // display the area of parallelogram
        System.out.println("Area of the parallelogram = " + area);
     }
}

输入平行四边形的第一条对角线:30
输入平行四边形的第二条对角线:40
输入平行四边形对角线之间的角度:30
平行四边形的面积= 299 . 999999999994

---

---

Java 程序：执行位运算

原文：https://www.studytonight.com/java-programs/java-program-to-perform-bitwise-operations

在本教程中，我们将学习如何通过从用户处获取输入来执行按位运算。按位运算符是用于操作数字的各个位的运算符。这些在对二进制索引树执行更新和查询操作时非常有用。它适用于Integer类型，长整型、整型、短整型、字符型和字节型。但是在继续之前，如果您不熟悉 java 中按位运算符的概念，那么一定要查看关于 Java 中运算符的文章。

输入: ( 5 & 4)

( 5 | 4 )

( 5 ^ 4 )

( 5 << 4 )

( 5 >> 4 )

输出:

four

five

one

Eighty

Zero

上述问题出现了两种情况:

情况 1:当值由用户定义时

情况 2:当值被预定义时

让我们分别看看这些案例。

程序 1:执行位操作

在这个程序中，我们将看到当值是用户定义的时，如何在 java 中执行位操作。这里，我们首先要求用户输入值，然后执行按位运算。

算法:

1. 开始
2. 这里，我们将使用 switch case 从不同的按位运算符中进行选择，如&、|、^、~、<>。
3. 为相同的声明一个变量。
4. 请用户初始化它。
5. 根据选择的操作，声明两个变量。
6. 要求用户初始化变量。
7. 执行按位运算后显示结果。
8. 停下来。

让我们看看下面的例子，以便更好地理解。

//Java Program to perform the bitwise operation
import java.util.Scanner;
public class Main
{
   public static void main(String args[])
   {   
       //Take input from the user
       //Create instance of the Scanner class
        Scanner s = new Scanner(System.in);
        while(true)
        {
            System.out.println("");

            System.out.println("Choose the operation you want to perform ");
            System.out.println("Choose 1 for & ");
            System.out.println("Choose 2 for | ");
            System.out.println("Choose 3 for ^ ");
            System.out.println("Choose 4 for ~");
            System.out.println("Choose 5 for <<");
            System.out.println("Choose 6 for >>");
            System.out.println("Choose 7 for EXIT");
            int n = s.nextInt();
            switch(n)
            {
                case 1:
                    System.out.println("Enter the two numbers to perform operations ");
                    System.out.print("Enter the first number : ");
                    int x = s.nextInt();
                    System.out.print("Enter the second number : ");
                    int y = s.nextInt();
                    System.out.println("Result of "+x+"&"+y+" = " + (x&y));
                    break;

                case 2:
                    System.out.println("Enter the two numbers to perform operations ");
                    System.out.print("Enter the first number : ");
                    int p = s.nextInt();
                    System.out.print("Enter the second number : ");
                    int q = s.nextInt();
                    System.out.println("Result of "+p+"|"+q+" = " + (p |q ));
                    break;

                case 3:
                    System.out.println("Enter the two numbers to perform operations ");
                    System.out.print("Enter the first number : ");
                    int a = s.nextInt();
                    System.out.print("Enter the second number : ");
                    int b = s.nextInt();
                    System.out.println("Result of "+a+"^"+b+" = " + (a ^ b));
                    break;

                case 4:
                    System.out.print("Enter the number : ");
                    int c = s.nextInt();
                    System.out.print("The result of ~"+c+ " is "+(~c));
                    break;

                case 5:
                    System.out.println("Enter the two numbers to perform operations ");
                    System.out.print("Enter the first number : ");
                    int e = s.nextInt();
                    System.out.print("Enter the second number : ");
                    int f = s.nextInt();
                    System.out.println("Result of "+e+"<<"+f+" = " + (e<<f));
                    break;

                case 6:
                    System.out.println("Enter the two numbers to perform operations ");
                    System.out.print("Enter the first number : ");
                    int g = s.nextInt();
                    System.out.print("Enter the second number : ");
                    int h = s.nextInt();
                    System.out.println("Result of "+g+">>"+h+" = " + (g>>h));
                    break;
                case 7:
                    System.exit(0);
            }
        }
    }
}

选择要执行的操作
选择 1 为&
选择 2 为|
选择 3 为^
选择 4 为~
选择 5 为< <
选择 6 为> >
选择 7 为退出
1
输入两个数字执行操作
输入第一个数字:2
输入第二个数字:3
结果为 2 & 3 = 2

选择要执行的操作
选择 1 为&
选择 3 为^
选择 4 为~
选择 5 为< <
选择 6 为> >
选择 7 为退出
2
输入两个数字执行操作
输入第一个数字:4
输入第二个数字:5
结果为 4|5 = 5

选择要执行的操作
选择 1 为&
选择 3 为^
选择 4 为~
选择 5 为< <
选择 6 为> >
选择 7 为退出
3
输入两个数执行操作
输入第一个数:5
输入第二个数:6
结果 5^6 = 3

选择要执行的操作
选择 1 为&
选择 2 为
选择 3 为^
选择 4 为~
选择 5 为< <
选择 6 为> >
选择 7 为退出
4
输入数字:结果~7 为-8
选择要执行的操作
选择 1 为&
选择 2 为|
选择 3 为^
选择 4 为~
选择 5 为< <
选择 6 为> >
选择 7 为退出
5
输入两个数进行运算
输入第一个数:8
输入第二个数:9
结果为 8 < < 9 = 4096

选择 3 为^
选择 4 为~
选择 5 为< <
选择 6 为> >
选择 7 为退出
6
输入两个数进行运算
输入第一个数:1
输入第二个数:2
结果为 1>>2 = 0
t80
选择 3 为^
选择 4 为~
选择 5 为< <选择 6 为> >选择 7 为退出
7

程序 2:执行位操作

在这个程序中，我们将在程序中预定义值时执行按位运算。

算法:

1. 开始
2. 这里，我们将使用 switch case 从不同的按位运算符中进行选择，如&、|、^、~、<>。
3. 声明两个变量。
4. 初始化它。
5. 执行所有按位运算符，如&、|、^、~、<>。
6. 显示每个按位运算的结果。
7. 停下来。

让我们看看下面的例子，以便更好地理解。

//Java Program to perform bitwise operation
public class Main 
{
    public static void main(String[] args)
    {
        // Declare and initialize the variables
        int a = 3;
        int b = 2;
        // bitwise and
        System.out.println("Result of "+a+"&"+b+" = " + (a & b));
        // bitwise or
        System.out.println("Result of "+a+"|"+b+" = " + (a | b));
        // bitwise xor
        System.out.println("Result of "+a+"^"+b+" = " + (a ^ b));
        System.out.println("Result of ~"+a+" = " + ~a);
        System.out.println("Result of "+a+" << "+b+" = " + (a << b));
        System.out.println("Result of "+a+" >> "+b+" = " + (a >> b));
        // When combined with assignment operator 
        a &= b;
        System.out.println("Result after a&=b is a= " + a);
    }
}

3&2 = 2
的结果 3|2 = 3
的结果 3^2 = 1
的结果~3 = -4
的结果 3 <的结果 T9】 2 = 12
的结果 3 > > 2 = 0
的结果 a &之后=b 为 a= 2

---

---

Java 程序：计算C(n, r)

原文：https://www.studytonight.com/java-programs/java-program-to-perform-ncr

在本教程中，我们将学习如何找到 C(n, r) 的价值。C(n, r) 值给出了从 n 个对象中选择 r 个对象的方法，不考虑顺序；更正式地说，n 元素集的 r 元素子集(或 r 元素组合)的数量。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

以下公式用于计算 C(n, r) 值。

C(n, r) = (n！)/((n-r)！ r！)*

输入:输入 n: 5 的值

输入 r: 2 的值

输出: 5C2 = 10

上述问题出现了两种情况:

情况 1:当值由用户定义时

情况 2:当值被预定义时

让我们分别看看这些案例。

程序 1:在 Java 中找到 C(n, r) 值

在这个程序中，当值是用户定义的时，我们将找到 C(n, r) 值。这意味着，首先我们将要求用户输入 n 和 r 值，然后我们将使用公式计算 C(n, r) 值。这里，我们将使用 for 循环来计算阶乘。

算法:

1. 开始

2. 声明变量。

3. 要求用户初始化变量。

4. 检查是否有可能找到 C(n, r) 值。

5. 如果可能，那么调用一个方法来计算 C(n, r)。

6. 使用 for 循环计算一个数的阶乘。

7. 使用公式求出 C(n, r) 值。

8. 请输入 C(n, r) 值。

9. 如果无法计算 C(n, r) 值，则输入 n 和 r 的值，使 n>=r。

10. 停止

下面的例子说明了上述算法的实现。

//Java Program to find the `C(n, r)`
import java.util.*;  
public class Main 
{   
    //Method to calculate the `C(n, r)` value
    static int `C(n, r)`(int n, int r)   
    {   
          return fact(n) / (fact(r) * fact(n - r));   
    }   
    //Method to calculate the factorial of the number
    static int fact(int n)   
    {   
          int res = 1;   
          for (int i = 2; i <= n; i++)   
          res = res * i;   
          return res;   
    }   
   public static void main(String[] args)   
   {   
       //Take input from the variables
       //Create instance of the Scanner Class
       Scanner sc = new Scanner(System.in);  
       int n,r;  //Declare variables
       System.out.println("Enter the value of n :");  
       n = sc.nextInt();  //Initialize the variables
       System.out.println("Enter the value of r :");
       r = sc.nextInt();  //Initialize the variables
       if(n>=r)
	   {
	       //Print the `C(n, r)` value
            System.out.println("Value of "+ n+"C"+r+"= "+`C(n, r)`(n, r)); 
	   }
		else
		  System.out.println("n value should be greater than or equals to r value");
   }   
} 

输入 n: 5 的值
输入 r: 2 的值
的值 5C2= 10

程序 2:在 Java 中找到 C(n, r) 值

在这个程序中，当数值在程序中被预定义时，我们将找到 C(n, r) 值。

算法:

1. 开始

2. 声明并初始化变量。

3. 检查是否有可能找到 C(n, r) 值。

4. 如果可能，那么调用一个方法来计算 C(n, r)。

5. 计算数字的阶乘。

6. 使用公式求出 C(n, r) 值。

7. 请输入 C(n, r) 值。

8. 如果无法计算 C(n, r) 值，则输入 n 和 r 的值，使 n>=r。

9. 停止

下面的例子说明了上述算法的实现。

//Java Program to find the `C(n, r)`
public class Main 
{   
    //Method to calculate the `C(n, r)` value
    static int `C(n, r)`(int n, int r)   
    {   
          return fact(n) / (fact(r) * fact(n - r));   
    }   
    //Method to calculate the factorial of the number
    static int fact(int n)   
    {   
          int res = 1;   
          for (int i = 2; i <= n; i++)   
          res = res * i;   
          return res;   
    }   
   public static void main(String[] args)   
   {   
       int n=7,r=2;  //Declare and initialize the variables
       System.out.println("The entered value of n is :"+ n);  
       System.out.println("The entered value of r is :"+ r);
        if(n>=r)
	   {
	       //Print the `C(n, r)` value
            System.out.println("Value of "+ n+"C"+r+"= "+`C(n, r)`(n, r)); 
	   }
		else
		  System.out.println("n value should be greater than or equals to r value");

   }   
} 

输入的 n 值为:7
输入的 r 值为:2
值为 7C2= 21

程序 3:在 Java 中找到 C(n, r) 值

在这个程序中，当值是用户定义的时，我们将找到 C(n, r) 值。这意味着，首先我们将要求用户输入 n 和 r 值，然后我们将使用公式计算 C(n, r) 值。这里，我们将使用 while 循环来计算阶乘。

算法:

1. 开始

2. 声明变量。

3. 要求用户初始化变量。

4. 检查是否有可能找到 C(n, r) 值。

5. 如果可能，那么调用一个方法来计算 C(n, r)。

6. 使用 while 循环计算一个数的阶乘。

7. 使用公式求出 C(n, r) 值。

8. 打印 C(n, r) 值。

9. 如果无法计算 C(n, r) 值，则输入 n 和 r 的值，使 n>=r。

10. 停止

下面的例子说明了上述算法的实现。

//Java Program to find `C(n, r)`
import  java.util.*;
public class Main
{
    //Calculate factorial of the number
	static double fact(double n)
	{
	    int i=1;
        double fact=1;
	    while(i<=n)
	    {
	   	   fact=fact*i;
		   i++;
 	    }
  	    return fact;
	}
    //Calculate the combination value
	static double combination(int n,int r)
	{
		double com=fact(n)/(fact(n-r)*fact(r));
		return com;
	}
	//Driver Code
	public static void main(String arg[])	
	{
		//Take input from the user
		//Create an instance of the Scanner class
		Scanner sc=new Scanner(System.in);
		System.out.println("Enter the value of n : ");
        int n=sc.nextInt();
		System.out.println("Enter the value of r : ");
        int r=sc.nextInt();
        //Check whether it is possible to find the `C(n, r)` value.
		if(n>=r)
		{
		   System.out.println("The value of "+n+"c"+r+" is : "
		     +combination(n,r));
		}
		else
		  System.out.println("n value should be greater than or equals to r value");

	}	
} 

输入 n: 8 的值
输入 r: 3 的值
8 C3 的值为:56.0

---

---

Java 程序：do-while

原文：https://www.studytonight.com/java-programs/java-do-while-programs

在本教程中，我们将学习如何在不同的场景中实现 do-while 循环。但是在继续之前，如果你不熟悉 do-while 循环的概念，那么一定要查看 Java 中Loops的文章。

语法:

do
{  
//code to be executed  
}while(condition); 

Java 程序：程序 1:实现边做边循环

在这个程序中，如何使用 do-while 循环找到所有输入正数的和。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明一个变量。
4. 要求用户初始化变量。
5. 声明另一个变量来存储所有正数的和。
6. 将其初始化为 0。
7. 使用边做边循环检查输入的数字是否为正数。
8. 每次输入正数时增加总和。
9. 如果输入了任何负数，请中断循环。
10. 显示总和。
11. 停下来。

下面是相同的代码。

// Java program to find the sum of positive numbers using do-while loop
import java.util.Scanner;

public class Main 
{
  public static void main(String[] args) 
  {
    // Take input from the user
    // create an object of Scanner class
    Scanner sc = new Scanner(System.in);

    int sum = 0;
    int num = 0;

    // do...while loop continues 
    // until entered number is positive
    do {
      // add only positive numbers
      sum += num;
      System.out.println("Enter a number");
      num = sc.nextInt();
    } 
    while(num >= 0); 

    System.out.println("The sum of entered positive numbers is " + sum);
    sc.close();
  }
}

输入数字:4
输入数字:6
输入数字:2
输入数字:8
输入数字:5
输入数字:1
输入数字:3
输入数字:-9
输入的正数之和为 29

Java 程序：程序 2:实现边做边循环

在这个程序中，我们将看到如何在 java 中实现 do-while 循环程序。在这里，我们将考虑一个场景，我们将找到一个特定数字的乘法表。我们将对相同的元素使用 do-while 循环，而不是为每个元素编写乘法表。我们将编写一次语句，并多次实现。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 宣布一个数字
4. 要求用户初始化数字。
5. 使用 do-while 循环打印该数字的乘法表。
6. 显示结果。
7. 停下来。

下面是相同的代码。

//Java Program to see the multiplication table using a do-while loop program
import java.util.*;

public class Main
{
     public static void main(String []args)
     {
        //Take input from the user
        //Create instance of the Scanner Class
        Scanner sc=new Scanner(System.in); 
        System.out.println("Enter the number: ");
        int n=sc.nextInt();      //Declare and initialize the number
        int i=1;
        System.out.println("The multiplication table of "+n+" is: ");
        //Infinite Loop Example      
        do
        {
           System.out.println(n+" * "+i+" = "+ (n*i));
            i++;
        }
        while(i<=10);
     }
}

输入数字:4
4 的乘法表为:
4 * 1 = 4
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20
4 * 6 = 24
4 * 7 = 28
4 * 8 = 32
4 * 9 = 36
4 * 10 = 40

Java 程序：程序 3:实现边做边循环

在这个程序中，我们将看到如何使用 do-while 循环无限次地执行某个任务。为此，我们将在 while 循环的条件语句中传递 true。这样做将使它成为一个不定式 do-while 循环。这里需要注意的一点是，为了退出无限循环，您需要按 ctrl+c。

算法:

1. 开始
2. 声明一个变量。
3. 将其初始化为 1。
4. 使用边做边循环打印消息。
5. 在 while 循环的条件下传递 true。
6. 执行该语句，直到条件为假。
7. 在每次迭代中增加变量。
8. 显示结果。
9. 停下来。

下面是相同的代码。

//Java Program to see the implementation of an infinite do-while loop program

public class Main
{
     public static void main(String []args)
     {
        int i=1;
        System.out.println("Example of Infinite do while loop: ");
        //Infinite Loop Example      
        do
        {
           System.out.println(i+" Hello World!");
            i++;
        }
        while(true);
     }
}

无限边做边循环示例:
1 Hello World！
2 你好世界！
3 你好世界！
4 你好世界！
5 你好世界！
6 你好世界！
7 你好世界！
ctrl+c

---

---

Java 程序：for-each循环

原文：https://www.studytonight.com/java-programs/java-for-each-loop-programs

在本教程中，我们将学习如何在不同的场景中实现 for-each 循环。但是在继续之前，如果你不熟悉 for-each 循环的概念，那么一定要查看一下 Java 中Loops的文章。

语法:

for(data_type variable : array | collection)
{  
//body of for-each loop  
} 

程序 1:Java For-每个循环程序

在这个程序中，我们将看到如何使用带有预定义值的 for 循环来打印数组元素。

算法:

1. 开始
2. 声明一个数组。
3. 初始化数组。
4. 通过对每个循环使用遍历数组。
5. 打印数组元素。
6. 停止

下面是相同的代码

//Java Program to see the implementation of the for-each loop in Arrays
public class Main
{
     public static void main(String []args)
     {
        int arr[]={1,3,4,7,8,5,4};  
        System.out.println("The Array elements are ");
        //traversing the array with for-each loop  
        for(int i:arr)
        {  
           System.out.println(i);  
        }  
     }
} 

阵元为
1
3
4
7
8
5
4

程序 2:Java For-每个循环程序

在本程序中，我们将看到如何使用预定义值的每个循环打印集合元素。

算法:

1. 开始
2. 声明String类型的ArrayList。
3. 向ArrayList中添加元素。
4. 每个循环使用一个遍历ArrayList。
5. 打印ArrayList元素。
6. 停止

下面是相同的代码。

//Java Program to see the implementation of the for-each loop in Collections
import java. util.*;  
public class Main
{  
  public static void main(String args[])
  {  
   //Creating a list of elements  
   ArrayList<String> list=new ArrayList<String>();  
   list.add("Cat");  
   list.add("Dog");  
   list.add("Cow"); 
   list.add("Tiger"); 
   list.add("Lion"); 
   //traversing the list of elements using for-each loop 
   System.out.println("The elements in the list are: ");  
   for(String str:list)
   {  
     System.out.println(str);  
   }  

 }   
} 

列表中的元素有:
猫
狗
牛
虎
狮

Java For 循环和 For 每个循环的区别

在这里，我们将看到 for-each 循环与 for 循环有何不同。for 循环和每个循环之间的主要区别在于，for 循环为我们提供了控制循环过程的机会。

Java 程序：程序 3:每个循环

在这个程序中，我们将看到在用户定义的程序中每个循环的实现。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明一个数组。
4. 要求用户为每个循环使用初始化数组。
5. 对每个循环使用相同的打印数组元素。
6. 停下来。

下面是相同的代码。

//Java Program to see the implementation of for-each loop
import java.util.*;  
public class Main
{  
  public static void main(String args[])
  {  
     //Take input from the user
     //Creates an instance of the Scanner Class
    Scanner sc=new Scanner(System.in);
    int arr[]=new int[5];     //Declare an array
    System.out.println("The elements in the array: ");
    for (int i : arr) 
    {
        i=sc.nextInt();      //Initialize the array elements
        System.out.println(i);   //Print the array elements
    }
 }   
} 

阵中元素:
4
5
3
2
1

程序 4: Java For 循环程序

在这个程序中，我们将看到在用户定义的程序中 for 循环的实现。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明一个数组。
4. 要求用户使用 for 循环初始化数组。
5. 使用相同的 for 循环打印数组元素。
6. 停下来。

下面是相同的代码。

//Java Program to see the implementation of for loop
import java.util.*;  
public class Main
{  
  public static void main(String args[])
  {  
     //Take input from the user
     //Creates an instance of the Scanner Class
    Scanner sc=new Scanner(System.in);
    int arr[]=new int[5];     //Declare an array 
    //Initialize the array elements
    System.out.println("Initializing the elements in the array: ");
    for (int i=0; i< arr.length;i++) 
    {
        arr[i]=sc.nextInt();
    }
    //Print the array elements
    System.out.println("The elements in the array: ");
    for (int i=0; i<arr.length;i++) 
    {
        System.out.println(arr[i]);
    }
 }   
} 

初始化数组中的元素:4 5 3 2 1
数组中的元素:
4
5
3
2
1

---

---

Java 程序：break语句

原文：https://www.studytonight.com/java-programs/java-break-statement-programs

在本教程中，我们将学习如何在不同的场景中使用 break 语句。但是在继续之前，如果你不熟悉 break 语句的概念，那么一定要查看 Java 中 Break 语句的文章。

语法:

jump-statement;    
break; 

程序 1:在 While 循环中的 Java Break 语句

在这个程序中，我们将看到如何在 while 循环中使用 break 语句，同时计算所有正数的和。

算法:

1. 开始
2. 为数字和总和声明变量。
3. 将总和初始化为 0。
4. 创建 Scanner 类的实例。
5. 使用 while 循环输入数字。
6. 检查数字是否为正数。
7. 在每次迭代中增加总和。
8. 如果输入了任何负数，请中断循环。
9. 显示总和。
10. 停下来。

下面是相同的代码。

//Java Program to see the implementation of break statement
import java.util.Scanner;

public class Main 
{
    public static void main(String[] args) 
    {
        //Declare variables
        int num, sum = 0;
        //Take input from the user
        // create an object of Scanner
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("Enter a number: ");
            // initialize the elements
            num = sc.nextInt();
            // if number is negative then the loop terminates
            if (num < 0) 
            {
                break;
            }
           sum += num;
        }
        System.out.println("The sum of all positive numbers is = " + sum);
    }
}

输入数字:2
输入数字:3
输入数字:5
输入数字:4
输入数字:-9
所有正数之和= 14

程序 2:边做边循环中的 Java Break 语句

在这个程序中，我们将看到如何在 do-while 循环中使用 break 语句，同时计算所有正数的总和。

算法:

1. 开始
2. 为数字和总和声明变量。
3. 将总和初始化为 0。
4. 创建 Scanner 类的实例。
5. 使用边做边循环输入数字。
6. 检查数字是否为正数。
7. 在每次迭代中增加总和。
8. 如果输入了任何负数，请中断循环。
9. 显示总和。
10. 停下来。

下面是相同的代码。

//Java Program to see the implementation of break statement
import java.util.Scanner;

public class Main 
{
    public static void main(String[] args) 
    {
        //Declare variables
        int num, sum = 0;
        //Take input from the user
        // create an object of Scanner
        Scanner sc = new Scanner(System.in);

        do 
        {
            System.out.println("Enter a number: ");
            // initialize the elements
            num = sc.nextInt();
            // if number is negative then the loop terminates
            if (num < 0) 
            {
                break;
            }
           sum += num;
        }while (true);
        System.out.println("The sum of all positive numbers is = " + sum);
    }
}

输入数字:6
输入数字:7
输入数字:8
输入数字:5
输入数字:4
输入数字:-2
所有正数之和= 30

程序 3:For 循环中的 Java break语句

在这个程序中，我们将看到如何在 for 循环中使用 break 语句。

算法:

1. 开始
2. 使用从 1 到 10 迭代的 for 循环。
3. 如果遇到 6，打破循环。
4. 在 break 语句执行之前打印所有元素。
5. 停下来。

下面是相同的代码。

//Java Program to see the implementation of break statement
import java.util.Scanner;

public class Main 
{
    public static void main(String[] args) 
    {
       System.out.println("The elements are: ");
       for(int i=1;i<10;i++)
       {
           if(i==6)
           {
               break;
           }
           System.out.println(i);
       }
    }
}

元素为:
1
2
3
4
5

---

---

Java 程序：continue语句

原文：https://www.studytonight.com/java-programs/java-continue-statement-programs

在本教程中，我们将学习如何在不同的场景中使用 continue 语句。但是在继续之前，如果你不熟悉 break 语句的概念，那么一定要查看 Java 中 Continue 语句的文章。

语法:

jump-statement;    
continue; 

程序 1: Java continue语句程序

在这个程序中，我们将在 for 循环中看到 continue 语句的实现。

算法:

1. 开始
2. 使用 for 循环打印从 1 到 10 的元素。
3. 如果遇到 6，则跳过该元素。
4. 打印剩余的元素。
5. 停下来。

下面是相同的代码。

//Java Program to see the implementation of continue statement
import java.util.Scanner;

public class Main 
{
    public static void main(String[] args) 
    {
        System.out.println("The elements are: ");
       for(int i=1;i<=10;i++)
       {
           if(i==6)
           {
               continue;
           }
           System.out.println(i);
       }
    }
}

元素为:
1
2
3
4
5
7
8
9
10

程序 2: Java continue语句程序

在这个程序中，我们将在一个内部循环中看到 continue 语句的实现。

算法:

1. 开始
2. 循环使用两个。
3. 从 1 到 3 运行两个循环。
4. 如果 for 循环的索引都匹配，则使用 continue 语句。
5. 打印元素。
6. 停下来。

下面是相同的代码。

//Java Program to see the implementation of continue statement
public class Main 
{  
    public static void main(String[] args) 
    {  
            //outer loop  
            for(int i=1;i<=3;i++)
            {    
                    //inner loop  
                    for(int j=1;j<=3;j++)
                    {    
                        if(i==j)
                        {    
                            //using continue statement inside inner loop  
                            continue;    
                        }    
                        //Print the elements
                        System.out.println(i+" "+j);    
                    }    
            }    
    }  
} 

1 2
1 3
2 1
2 3
3 1
3 2

程序 3: Java continue语句程序

在这个程序中，我们将在 do-while 循环中看到 continue 语句的实现。

算法:

1. 开始
2. 使用边做边循环打印小于 10 的元素。
3. 从 0 到 10 运行循环。
4. 如果元素是 5，则使用 continue 语句。
5. 打印元素。
6. 在每次迭代中增加循环变量的值。
7. 停下来。

下面是相同的代码。

//Java Program to see the implementation of continue statement
import java.util.*;
public class Main 
{  
    public static void main(String[] args) 
    {  
	    int j=0;
        do
	    {
	       if (j==5)
	       {
		      j++;
		      continue;
	       }
	       System.out.print(j+ " ");
	       j++;
           }while(j<10);
    }  
} 

0 1 2 3 4 6 7 8 9

程序 4: Java continue语句程序

在这个程序中，我们将看到如何打印所有正输入数字的总和。

算法:

1. 开始
2. 为数字和总和声明变量。
3. 将总和初始化为 0。
4. 创建 Scanner 类的实例。
5. 使用 for 循环输入数字。
6. 检查数字是否为正数。
7. 如果输入了任何负数，请使用 continue 语句。
8. 在每次迭代中增加总和。
9. 显示总和。
10. 停下来。

下面是相同的代码。

//Java Program to implement the continue statement  
import java.util.Scanner;

public class Main 
{
  public static void main(String[] args) 
  {
    int num, sum = 0;
    // create an object of Scanner
    Scanner sc = new Scanner(System.in);

    for (int i = 1; i < 10; ++i) 
    {
      System.out.println("Enter number " + i + " : ");
      // takes input from the user
      num = sc.nextInt();

      // if number is negative
      // continue statement is executed
      if (num <= 0) {
        continue;
      }

      sum += num;
    }
    System.out.println("The sum of all the numbers  = " + sum);
    sc.close();
  }
}

输入 1: 7
输入 2: 6
输入 3: 5
输入 4: 4
输入 5: 8
输入 6: -9
输入 7: 1
输入 8: 2
输入 9 : 3
所有数字之和= 36

---

---

Java 程序：检查回文数字

原文：https://www.studytonight.com/java-programs/java-program-to-check-palindrome-number

在本教程中，我们将学习如何检查输入的数字是否是回文。回文数字是向后写时保持不变的数字或字符串。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章

输入:输入数字:87876

输出:输入的数字 87876 不是回文数字。

程序 1:用 Java 检查回文

在下面的程序中，我们将看到如何检查输入的数字是否是回文。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个字符串变量。

4. 要求用户初始化变量。

5. 声明一个变量来存储反向数。

6. 将其初始化为空字符串。

7. 对相同的使用 for 循环。

8. 检查反转的数字/字符串是否与原始数字/字符串相同。

9. 如果相同，则将其打印为回文号。

10. 如果不一样，那就把它打印成不是回文号。

11. 显示结果。

12. 停下来。

下面是查找回文数字的 Java 代码。

// Java program to find palindrome number
import java.util.*;
public class Main 
{  
   public static void main(String[] args) 
   {  
       //Take input from the user
       //Create instance of the Scanner class
       Scanner sc = new Scanner(System.in);  
       System.out.println("Enter the number: ");  
       String reverse = ""; 
       String num = sc.nextLine(); 
       int length = num.length();   
      for ( int i = length - 1; i >= 0; i-- )  
         reverse = reverse + num.charAt(i);  
      if (num.equals(reverse))  
         System.out.println("The entered string " +num +" is a palindrome.");  
      else  
         System.out.println("The entered string " +num +"  isn't a palindrome.");     
  }
} 

输入数字:212
输入的字符串 212 是回文。

程序 2:用 Java 检查回文数字

在下面的程序中，我们将看到如何检查输入的数字是否是回文。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量。

4. 要求用户初始化变量。

5. 声明一个变量来存储反向数。

6. 将其初始化为 0。

7. 使用 while 循环进行同样的操作。

8. 检查反转数字是否与原数字相同。

9. 如果相同，则将其打印为回文号。

10. 如果不一样，那就把它打印成不是回文号。

11. 显示结果。

12. 停下来。

下面是查找回文数字的 Java 代码。

// Java program to find palindrome number
import java.util.*;
public class Main 
{  
   public static void main(String[] args) 
   {  
       //Take input from the user
       //Create instance of the Scanner class
       Scanner sc = new Scanner(System.in);  
       System.out.println("Enter the number: ");  
       int num=sc.nextInt();
       int r,sum=0;
       int temp=num;    
       while(num>0)
       {    
       r=num%10;    
       sum=(sum*10)+r;    
       num=num/10;    
       }    
        if(temp==sum)    
        System.out.println("The entered number "+temp+" is a palindrome number ");    
        else    
        System.out.println("The entered number "+temp+" is not a palindrome");    
  }  
} 

输入数字:8338
输入的数字 8338 是回文数字

程序 3:用 Java 检查回文数字

在下面的程序中，我们将看到如何检查输入的数字是否是回文。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个范围。

4. 要求用户初始化范围。

5. 调用一个检查是否回文的方法。

6. 声明一个变量来存储反向数。

7. 将其初始化为 0。

8. 使用 while 循环进行同样的操作。

9. 检查反转数字是否与原数字相同。

10. 如果一样，那就还真。

11. 如果不相同，则返回 false。

12. 显示结果。

13. 停下来。

下面是查找回文数字的 Java 代码。

// Java program to find palindrome number
import java.util.*;
public class Main 
{  
   public static void main(String[] args) 
   {  
       //Take input from the user
       //Create instance of the Scanner class
       Scanner sc = new Scanner(System.in);  
       System.out.println("Enter the number: ");  
       int num1=sc.nextInt();
       System.out.println("Enter the number: ");  
       int num2=sc.nextInt();
       for(int i=num1;i<=num2;i++)
       {
           boolean temp=checkPalindrome(i);
           if(checkPalindrome(i))
           System.out.print(i+" ");
       }

  }
  public static boolean checkPalindrome(int num)
  {
      int r,sum=0;
       int temp=num;    
       while(num>0)
       {    
       r=num%10;    
       sum=(sum*10)+r;    
       num=num/10;    
       }    
        if(temp==sum)    
        return true;  
        else    
        return false;
  } 
} 

输入数字:10
输入数字:500
11 22 33 44 55 66 77 88 99 101 111 121 131 141 151 161 171 181 191 202 212 222 232 242 252 262 272 282 292 303 313 323 333 343 353 363 373 383

---

---

Java 程序：寻找质数

原文：https://www.studytonight.com/java-programs/java-program-to-find-prime-number

如果一个数只能被它自己和一整除，它就叫做质数。这意味着质数只有两个因素一和它本身。

一个数如果有两个以上的因子，就叫做合成数。

这里需要注意的一点是，1 既不是素数，也不是合数。

一个数是质数的条件:

1. 它应该大于 1。

2. 应该不会超过 2 个因素。

这些是第一批素数:{2，3，5，7，11，....}.

在本教程中，我们将学习如何在 java 中找到素数。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章

输入:输入数字:34

输出: 34 不是素数。

程序 1:在 Java 中寻找质数

在这个程序中，我们将使用一个从 2 到这个数的平方根的 for 循环来检查输入的数是否是质数。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量。

4. 要求用户初始化变量。

5. 调用一个方法来检查输入的数字是否是质数。

6. 如果数字是 0 或 1，打印它不是质数。

7. 如果数字不是 0 和 1，则运行从 2 到该数字平方根的 for 循环。

8. 如果这个数可以被那个循环中的任何一个数整除，那么就把它打印成不是质数。

9. 如果这个数不能被循环中的任何一个数整除，那么就把它打印成质数。

10. 停下来。

下面是查找质数的 Java 代码。

// Program to find prime number in Java
import java.util.Scanner;
public class Main 
{  
   public static void main(String[] args) 
   {  
       Scanner sc = new Scanner(System.in);  
       System.out.println("Enter a number : ");  
       int num = sc.nextInt();  
       if (checkPrime(num)) {  
           System.out.println(num + " is a prime number");  
       }
       else 
       {  
           System.out.println(num + " is not a prime number");  
       }  
   }  
   public static boolean checkPrime(int num) 
   {  
       if (num <= 1) 
       {  
           return false;  
       }  
       for (int i = 2; i < Math.sqrt(num); i++) 
       {  
           if (num % i == 0) 
           {  
               return false;  
           }  
       }  
       return true;  
   }  
} 

输入一个数字:245
245 不是质数

程序 2:在 Java 中寻找质数

在这个程序中，我们将使用从 2 到数字/2 的 for 循环来检查输入的数字是否是质数。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量。

4. 要求用户初始化变量。

5. 如果数字是 0 或 1，打印它不是质数。

6. 如果数字不是 0 和 1，则运行从 2 到数字/2 的 for 循环。

7. 如果这个数可以被那个循环中的任何一个数整除，那么就把它打印成不是质数。

8. 如果这个数不能被循环中的任何一个数整除，那么就把它打印成质数。

9. 停下来。

下面是查找质数的 Java 代码。

// Program to find prime number in Java
import java.util.Scanner;
public class Main 
{  
   public static void main(String[] args) 
   {  
       //Take input from the user
       //Create instance of the Scanner class
       Scanner sc = new Scanner(System.in);  
       System.out.println("Enter a number : ");  
       int num = sc.nextInt();  
       int flag=0; 
       int i, temp=num/2;      
       if(num==0||num==1)
       {  
          System.out.println(num+" is not prime number");      
       }
       else
       {  
         for(i=2;i<=temp;i++)
         {      
           if(num%i==0)
           {      
               System.out.println(num+" is not a prime number");      
               flag=1;      
               break;      
           }      
         }      
         if(flag==0)  
         { 
             System.out.println(num+" is a prime number");  
         }  
        }//end of else  
   }   
} 

输入数字:29
29 是质数

Java 程序：程序 3:寻找质数

在这个程序中，我们将使用递归来检查一个数是否是质数。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量。

4. 要求用户初始化变量。

5. 使用递归函数检查数字是否为质数。

6. 递归调用该函数来检查该数是否可被任何其他数整除。

7. 如果这个数不能被除 1 和它本身之外的任何其他数整除，那么就把它打印成质数。

8. 否则打印输入的数字不是质数。

9. 停下来。

下面是查找质数的 Java 代码。

// Program to find prime number in Java using recursion
import java.util.Scanner;
public class Main 
{  
    static int i=2;
   public static void main(String[] args) 
   {  
       //Take input from the user
       //Create instance of the Scanner class
       Scanner sc = new Scanner(System.in);  
       System.out.println("Enter the number: ");  
       int num = sc.nextInt();  

       if (checkPrime(num)) 
        {  
               System.out.print(num+" is a prime number ");  
        }
        else
        {
            System.out.println(num+" is not a prime number "); 
        }

   }  
    static boolean checkPrime(int num)
    {
       // Corner cases
       if (num == 0 || num == 1) 
       {
          return false;
       }
       // Checking Prime
       if (num == i)
           return true;
        // Base cases
       if (num % i == 0) 
       {
          return false; 

       }
       i++;
       return checkPrime(num);
    }    
} 

输入数字:57
57 不是质数

---

---

Java 程序：计算两个数的 GCD

原文：https://www.studytonight.com/java-programs/java-program-to-calculate-gcd-of-two-numbers

在本教程中，我们将学习如何在 java 中找到两个数字的最大公约数(GCD)。两个或两个以上数字的最高公因数( HCF )或最大公约数( GCD )被定义为精确划分它们的最大数字。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入第一个数字:3

输入第二个数字:5

输出:3 和 5 两个数的 HCF 为 1

Java 程序：程序 1:计算两个数的 GCD

在这个程序中，我们将看到如何使用 for 循环在 java 中计算两个数字的 GCD。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明两个变量。
4. 要求用户初始化这些变量。
5. 声明一个变量来存储 HCF，并将其初始化为 0。
6. 使用 for 循环计算 GCD。
7. 如果这两个数字都可以被循环变量整除，那么将这个数字设置为 GCD。
8. 继续这个过程，直到找到最大的数，这个数除以两个数而没有余数。
9. 打印结果。
10. 停下来。

//Java Program to Calculate the GCD of two numbers
import java.util.Scanner;  
public class Main   
{  
    public static void main(String[] args)    
    {
        //Take input from the user
        //Create an instance of the Scanner class
        Scanner sc = new Scanner(System.in); 
        System.out.println("Enter the first number: ");  
        int num1 = sc.nextInt();  
        System.out.println("Enter the second number: ");  
        int num2 = sc.nextInt();  
        int hcf=0;
        for(int i = 1; i <= num1 || i <= num2; i++) 
        {
         if( num1%i == 0 && num2%i == 0 )
         hcf = i;
      }
      System.out.println("HCF of given two numbers is :"+hcf);
   }  
} 

输入第一个数字:2
输入第二个数字:6
给定两个数字的 HCF 为:2

Java 程序：程序 2:计算两个数的 GCD

在这个程序中，我们将看到如何使用 while 循环在 java 中计算两个数字的 GCD。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明两个变量。
4. 要求用户初始化这些变量。
5. 使用 while 循环计算 GCD。
6. 从较大的整数中减去较小的整数，并将结果赋给持有较大整数的变量
7. 继续这个过程，直到两个数字相等。
8. 打印结果。
9. 停下来。

//Java Program to Calculate the GCD of two numbers
import java.util.Scanner;  
public class Main   
{  
    public static void main(String[] args)    
    {
        //Take input from the user
        //Create an instance of the Scanner class
        Scanner sc = new Scanner(System.in); 
        System.out.println("Enter the first number: ");  
        int num1 = sc.nextInt();  
        System.out.println("Enter the second number: ");  
        int num2 = sc.nextInt();  
        while(num1 != num2) 
        {
          if(num1 > num2) 
          {
            num1 -= num2;
          }
          else 
          {
            num2 -= num1;
          }
        }
      System.out.println("HCF of given two numbers is :"+num1);
   }  
} 

输入第一个数字:2
输入第二个数字:7
给定两个数字的 HCF 为:1

Java 程序：程序 3:计算两个数的 GCD

在这个程序中，我们将看到当数字为正数或负数时，如何使用 while 循环来计算 java 中两个数字的 GCD。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明两个变量。
4. 要求用户初始化这些变量。
5. 首先将两个数字都设置为正数。
6. 使用 while 循环计算 GCD。
7. 从较大的整数中减去较小的整数，并将结果赋给持有较大整数的变量
8. 继续这个过程，直到两个数字相等。
9. 打印结果。
10. 停下来。

//Java Program to Calculate the GCD of two numbers
import java.util.Scanner;  
public class Main   
{  
    public static void main(String[] args)    
    {
        //Take input from the user
        //Create an instance of the Scanner class
        Scanner sc = new Scanner(System.in); 
        System.out.println("Enter the first number: ");  
        int num1 = sc.nextInt();  
        System.out.println("Enter the second number: ");  
        int num2 = sc.nextInt();  
         num1 = ( num1 > 0) ? num1 : -num1;
         num2 = ( num2 > 0) ? num2 : -num2;
        while(num1 != num2) 
        {
          if(num1 > num2) 
          {
            num1 -= num2;
          }
          else 
          {
            num2 -= num1;
          }
        }

      System.out.println("HCF of given two numbers is :"+num1);
   }  
} 

输入第一个数字:-12
输入第二个数字:6
给定两个数字的 HCF 为:6

---

---

Java 程序：计算两个数 LCM

原文：https://www.studytonight.com/java-programs/java-program-to-calculate-lcm-of-two-numbers

在本教程中，我们将学习如何在 java 中找到两个数字的最小公倍数(LCM)。两个整数的 LCM 被定义为可以被两个数字完全整除的最小正整数(没有余数)。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入第一个数字:3

输入第二个数字:5

输出:3 和 5 两个数的 LCM 为 15

Java 程序：程序 1:计算两个数 LCM

在这个程序中，我们将看到如何在不使用相同两个数的 gcd 的情况下计算两个数的 lcm。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明两个变量。
4. 要求用户初始化这些变量。
5. 声明一个变量来存储 lcm。
6. 使用三元运算符将最大的数字赋给该变量。
7. 使用 while 循环计算 LCM。
8. 如果 lcm 可以被这两个数字整除，则显示 lcm。
9. 如果条件满足，中断循环。
10. 如果条件不满足，则增加 lcm 变量。
11. 打印结果。
12. 停下来。

//Java Program to Calculate the LCM of two numbers
import java.util.Scanner;  
public class Main   
{  
    public static void main(String[] args)    
    {
        //Take input from the user
        //Create an instance of the Scanner class
        Scanner sc = new Scanner(System.in); 
        System.out.println("Enter the first number: ");  
        int num1 = sc.nextInt();  
        System.out.println("Enter the second number: ");  
        int num2 = sc.nextInt();  
        int lcm = (num1 > num2) ? num1 : num2;
        // Always true
        while(true) 
        {
           if( lcm % num1 == 0 && lcm % num2 == 0 ) 
           {
               System.out.printf("The LCM of "+num1+" and "+num2+" is "+lcm);
               break;
            }
         ++lcm;
        }
   }  
} 

输入第一个数字:6
输入第二个数字:12
12 和 6 的 LCM 是 12

Java 程序：程序 2:计算两个数 LCM

在这个程序中，我们将看到如何使用相同两个数的 gcd 来计算两个数的 lcm。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明两个变量。
4. 要求用户初始化这些变量。
5. 声明一个变量来存储 HCF，并将其初始化为 0。
6. 使用 for 循环计算 GCD。
7. 如果这两个数字都可以被循环变量整除，那么将这个数字设置为 GCD。
8. 继续这个过程，直到找到最大的数，这个数除以两个数而没有余数。
9. 现在，要计算 lcm，将两个数相乘，然后除以 gcd。
10. 打印结果。
11. 停下来。

//Java Program to Calculate the LCM of two numbers
import java.util.Scanner;  
public class Main   
{  
    public static void main(String[] args)    
    {
        //Take input from the user
        //Create an instance of the Scanner class
        Scanner sc = new Scanner(System.in); 
        System.out.println("Enter the first number: ");  
        int num1 = sc.nextInt();  
        System.out.println("Enter the second number: ");  
        int num2 = sc.nextInt();  
        //Using GCD
        int gcd = 1;
        for(int i = 1; i <= num1 && i <= num2; ++i) 
        {
            // Checks if i is factor of both integers
            if(num1 % i == 0 && num2 % i == 0)
            gcd = i;
        }
        int lcm = (num1 * num2) / gcd;
        System.out.printf("The LCM of "+num1+" and "+num2+" is "+lcm);

   }  
} 

输入第一个数字:8
输入第二个数字:4
8 和 4 的 LCM 是 8

---

---

图案程序

Java 程序：生成帕斯卡三角形

原文：https://www.studytonight.com/java-programs/java-program-to-generate-pascal-triangle

在本教程中，我们将学习如何在 1D 数组中生成帕斯卡三角形。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。例如，

输入:行数:5

输出:

one

1 1

1 2 1

1 3 3 1

1 4 6 4 1

程序 1:生成帕斯卡三角形

在这种方法中，我们将看到如何使用数组生成帕斯卡三角形。

算法

1. 开始
2. 为行数声明一个变量。
3. 要求用户初始化行数。
4. 声明一个 1D 数组。
5. 使用三个 for 循环生成帕斯卡三角形。
6. 使用第一个外部 for 循环遍历所有行。
7. 使用第二个 for 循环打印空格。
8. 将每行的第一个元素指定为 1。
9. 使用第三个 for 循环打印元素。
10. 显示帕斯卡三角形。
11. 停止

下面是相同的代码。

下面的程序演示了如何生成帕斯卡三角形。

/*JAVA PROGRAM TO GENERATE PASCAL TRIANGLE IN 1D ARRAY */
import java.util.*;

public class PascalTriangle
{
     public static void main(String []args)
     {
         Scanner sc=new Scanner(System.in);   //Take input from the user
         int i, j, k, l, r;            //Declarig Variabless 
          int a[]=new int[30];     //Declare a 1d array

         System.out.println("Enter the number of rows ");
         r=sc.nextInt();      //Initialize the number of rows

         //For Pascal Triangle
         for(i=0;i<r;i++)   //Iterate through all the rows
		 {
			for(k=r; k>i; k--)    //Print the number of spaces
			{
				System.out.print(" ");
			}
            a[i] = 1;   //Initialize the first element of each row as 1
			for(j=0;j<=i;j++)    //To find the Pascal triangle element
			{
				 System.out.print(a[i]+ " ");    //Print the array elements
                 a[i] = a[i] * (i - j) / (j + 1);   //Store the pascal triangle elements in an array
			}
			System.out.println();   //To move to the next line
		 }

     }
}

输入行数 5
1
1
1 2 1
1 3 3 1
1 4 6 4 1

程序 2:生成帕斯卡三角形

在这种方法中，我们将看到如何使用两个数组生成帕斯卡三角形。

算法

1. 开始
2. 为行数声明一个变量。
3. 要求用户初始化行数。
4. 声明两个数组。
5. 为第一行的第一个元素打印 1。
6. 将两个数组的第一个元素初始化为 1。
7. 相同的循环使用四个。
8. 使用第一个 for 循环遍历所有行。
9. 使用第二个 for 循环打印空格。
10. 使用第三个 for 循环来初始化数字。
11. 使用第四个 for 循环打印数字。
12. 显示最终输出。
13. 停止

下面是相同的代码。

/*JAVA PROGRAM TO GENERATE PASCAL TRIANGLE IN 1D ARRAY */
import java.util.*;

public class PascalTriangle
{
     public static void main(String []args)
     {
         Scanner sc=new Scanner(System.in);     //Take input from the user
         int i, j, k, l;            //Declarig Variabless 
          int array[]=new int[30];     //using 1d array
          int temp[]=new int[30];       //using 1d array

         int num;    //Declaring variable for the number of rows
         System.out.println("Enter the number of rows ");
         num=sc.nextInt();      //Initialize the number of rows

         temp[0] = 1;     //Initializing first variable of the array as 1
         array[0] = 1;   //Initializing first variable of the array as 1

    System.out.println("1");     //For first element
    for (i = 1; i < num; i++)      //To iterate through all the rows 
    {
        for (j = 0; j < i; j++)    //To print the space
        System.out.print("");
        for (k = 1; k < num; k++)
        {
            array[k] = temp[k - 1] + temp[k];      //Initialize the array to store the pascal triangle elements
        }
        array[i] = 1;
        for (l = 0; l <= i; l++)
        {
            System.out.print(array[l]+" ");  //Print the array elements
            temp[l] = array[l];    //Copy the array elements to another array
        }
        System.out.println("");    //For next line
    }

     }
}

输入行数 6
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

---

---

Java 程序：打印空心菱形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-hollow-diamond-pattern

在本教程中，我们将看到如何在 Java 中打印空心菱形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印两个空心的等边三角形，这两个三角形彼此背对，但具有相同的底边。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:4

输出:模式为:

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

让我们看看这些方法中的每一种，以便更好地理解。

程序 1:打印空心钻石图案

在这个程序中，我们将看到如何使用 for 循环在 Java 中打印空心菱形图案。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明一个变量来存储行数。
4. 要求用户初始化变量。
5. 使用两个循环来打印图案。
6. 在每个 for 循环中，再使用两个 for 循环和一个 if 语句来打印空格和模式。
7. 使用第一个 for 循环打印上面的空心菱形图案。
8. 使用第二个 for 循环打印下方的空心菱形图案。
9. 显示结果。
10. 停止

下面的例子说明了上述算法的实现。

//Java Program to print the hollow diamond pattern
import java.util.Scanner;
public class Main
{
    public static void main(String args[])
    {
       int i,j;
       Scanner scan=new Scanner(System.in);
       System.out.println("Enter the number of rows");
       int rows=scan.nextInt();//get input from user
       //print upper triangle
       for(i=1; i<=rows; i++)
       {
            for(j=rows; j>i; j--)
            {
                System.out.print(" ");//print space
            }
            System.out.print("*");  //print star
            for(j=1; j<(i-1)*2; j++)
            {
                System.out.print(" ");
            }
            if(i==1)
            {
                System.out.print("\n");//move to next line
            }
            else
            {
                System.out.print("*\n");
            }
        }
        //print lower triangle
        for(i=rows-1; i>=1; i--)
        {
            for(j=rows; j>i; j--)
            {
                System.out.print(" ");
            }
            System.out.print("*");
            for(j=1; j<(i-1)*2; j++)
            {
                System.out.print(" ");
            }
            if(i==1)
            {
                System.out.print("\n");
            }
            else
            {
                 System.out.print("*\n");
            }
        }
    }
}

输入行数:7
*

程序 2:打印空心钻石图案

在这个程序中，我们将看到如何使用 while 循环在 Java 中打印空心菱形图案。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用两个 while 循环来打印图案。
6. 在每个 while 循环中，使用另外两个 while 和一个 if 语句来打印空格和模式。
7. 使用第一个 while 循环打印上面的空心菱形图案。
8. 使用第二个 while 循环打印下方的空心菱形图案。
9. 显示结果。
10. 停止

下面的例子说明了上述算法的实现。

//Java Program to print the hollow diamond pattern
import java.util.Scanner;
public class Main
{
    public static void main(String args[])
    {
       int i,j;
       Scanner scan=new Scanner(System.in);
       System.out.println("Enter the number of rows");
       int rows=scan.nextInt();   //get input from user
       i=1; 
       //print upper triangle
       while(i<=rows)
       {
           j=rows;
           while(j>i)
           {
              System.out.print(" ");
              j--;
           }
           System.out.print("*");
           j=1; 
           while(j<(i-1)*2)
           {
              System.out.print(" ");
              j++;
           }
           if(i==1)
           {
              System.out.print("\n");
           }
           else
           {
              System.out.print("*\n");
           }
           i++;
        }
        //print lower triangle
        i=rows-1; 
        while(i>=1)
        {
            j=rows; 
            while(j>i)
            {
                System.out.print(" ");   //print space
                j--;
            }
            System.out.print("*");     //print star
            j=1; 
            while(j<(i-1)*2)
            {
                System.out.print(" ");
                j++;
            }
            if(i==1)
            {
                System.out.print("\n");   //move to next line
            }
            else
            {
                System.out.print("*\n");
            }
            i--;
        }
    }
}

输入行数:7
*

---

---

Java 程序：打印加号星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-plus-star-pattern

在本教程中，我们将看到如何在 Java 中打印加号星形模式。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印加号星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:6

输出:模式为:

---

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

程序 1:打印加号星形图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印加号星形模式。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用 for 循环打印图案。
6. 首先，检查 for 循环的条件，如果为真，则检查“if”条件，如果“if”条件为真，则执行第一个内部 for 循环，否则执行其他部分，即第二个内部 for 循环。
7. 代码将一直执行，直到循环的条件为假。
8. 显示结果。
9. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Plus star pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
	for(int i=1;i<=n*2-1;i++)
    {
        if(i!=n)
	    for(int j=1;j<=n;j++)
        {      
            if(j==n)
            System.out.print("*");
            System.out.print(" ");
        }
	   else
		for(int j=1;j<=n*2-1;j++)
        {
            System.out.print("*");
        }
	   System.out.println();
       }            
    }
}

输入行数:8
*
*
*
*
*
*
*

• • • • • • • • • • • • • • T9】*

程序 2:打印加号星形图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印加号星形模式。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用 while 循环打印图案。
6. 首先检查 while 循环的条件，如果为真，则检查“如果”条件，如果“如果”条件为真，则执行第一个内部 while 循环，否则执行其他部分，即第二个内部 while 循环。
7. 代码将一直执行，直到 while 循环的条件为假，即 1<=n*2-1
8. 显示结果。
9. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Plus star pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int i=1;
        int j;
	    while(i<=n*2-1)
        {
            if(i!=n)
	        {
                j=1;
		        while(j<=n)
                {      
                    if(j==n)
                    System.out.print("*");
                    System.out.print(" ");
                    j++ ;
                }
          }
	      else
	      {
        	    j=1;
		        while(j<=n*2-1)
                {
                   System.out.print("*");
			       j++;
                }
    	   }
	         System.out.println();
	         i++; 
       }  
    }
}

输入行数:6
*
*
*
*
*

---

程序 3:打印加号星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印加号星形模式。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用边做边循环打印图案。
6. 首先，检查边做边循环的条件，如果为真，则检查“如果”条件，如果“如果”条件为真，则执行第一个内部边做边循环，否则执行其他部分，即第二个内部边做边循环。
7. 代码将一直执行，直到 do-while 循环的条件为假，即 1<=n*2-1
8. 显示结果。
9. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Plus star pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int i=1;
        int j;
	    do
        {
            if(i!=n)
	        {
                j=1;
		        do
                {      
                    if(j==n)
                    System.out.print("*");
                    System.out.print(" ");
                    j++ ;
                }while(j<=n);
            }
	        else
	        {
        	    j=1;
		        do
                {
                   System.out.print("*");
			       j++;
                }while(j<=n*2-1);
    	     }
	         System.out.println();
	         i++; 
       }while(i<=n*2-1);
    }
}

输入行数:6
*
*
*
*
*

---

---

---

Java 程序：打印镜像直角三角形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-mirrored-right-triangle-pattern

在本教程中，我们将看到如何在 Java 中打印镜像的直角三角形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:6

输出:模式为:

**

---

---

---

---

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

程序 1:打印镜像直角三角形图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印镜像直角三角形图案。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用 for 循环打印图案。
6. 首先运行外部 for 循环，结构为(int I = 1；I < = n；i++)来遍历从 i=1 到 i=n 的行。
7. 外环的条件为真，则第一个内环以(int j = 0；j < n-I；j++)，如果 i<=n，则打印空格。
8. 第二个内部循环使用该结构运行，如果 j
9. 然后光标移动到下一行，第二次迭代开始，重复直到 i<=n。
10. 显示结果。
11. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Mirrored Right Triangle Pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        System.out.println("Enter the symbol : ");
	    char ch = sc.next().charAt(0);
	    for(int i=1;i<=n;i++)
        {
	        for(int j=0;j<n-i;j++)
            {
                System.out.print(" ");
            }
            for(int j=0;j<i;j++)
            {
                System.out.print(ch);
            }
            System.out.println();
        }  
    }
}

输入行数:6
输入符号:*
*

---

---

---

---

程序 2:打印镜像直角三角形图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印镜像直角三角形模式。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用 while 循环打印图案。
6. 首先，检查外部 while 循环 i<=n 的条件，如果为真，则将 j 初始化为 0。
7. 如果 j++
8. j 值初始化为 0，第二个内部 while 循环打印字符 j
9. 光标移动到下一行，I 值增加 1，再次检查外部 while 条件，重复直到外部循环的条件为假。
10. 显示结果。
11. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Mirrored Right Triangle Pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        System.out.println("Enter the symbol : ");
	    char ch = sc.next().charAt(0);
	    int  i=1,j;
	    while(i<=n)
        {
            j=0;
            while(j++<(n-i))
            {
                System.out.print(" "); 
            }
	        j=0;
            while(j<i)
            {
                System.out.print(ch);
                j++;
            }
            System.out.println();
        i++;
       }  
    }
}

输入行数:6
输入符号:#

# # # #

程序 3:打印镜像直角三角形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印镜像直角三角形模式。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用边做边循环打印图案。
6. 首先，将 j 初始化为 0。内部 do 循环打印一次空格，然后检查条件(+j
7. 接下来，将 j 初始化为 0。第二个内部循环打印字符，然后检查 while 条件(j++
8. 光标到达下一行，然后检查外部 do-while 循环的条件，如果(+i
9. 显示结果。
10. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Mirrored Right Triangle Pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        System.out.println("Enter the symbol : ");
	    char ch = sc.next().charAt(0);
	    int  i=1,j;
	    do
        {
            j=0;
            do
            {
                System.out.print(" "); 
            }while(j++<(n-i));
	        j=0;
            do
            {
                System.out.print(ch);
                j++;
            }while(j<i);
            System.out.println();
        i++;
       }while(i<=n); 
    }
}

输入行数:6
输入符号:@
@
@ @
@ @ @
@ @ @
@ @ @ @ T7】

---

---

Java 程序：打印镜像半菱形星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-mirrored-half-diamond-star-pattern

在本教程中，我们将看到如何在 Java 中打印镜像的半菱形星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印镜像的半菱形星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:6

输出:模式为:

---

---

---

---

---

---

---

---

---

---

---

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

程序 1:打印镜像半菱形星形图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印镜像的半菱形星形图案。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用两个循环来打印图案。
6. 循环的第一个外部循环迭代，直到条件 i<=n 为假，第一个内部循环显示空间，直到条件 j<=n-i 为假。
7. 第二个内部循环将显示字符，直到条件 j
8. 第二个外部循环迭代，直到条件 i>0 为假，第一个内部循环将显示空间，直到 j<=n-i 为假。第二个内部循环将显示字符，直到条件 j<=i 为假。
9. 显示结果。
10. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Mirrored Half Diamond Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        for(int i=1;i<=n;i++)
        {
	        for(int j=1;j<=n-i;j++)
            {
                System.out.print(" ");
            }
            for(int j=1;j<=i;j++)
            {
                System.out.print("*");
            }
	         System.out.println();
        }            
        for(int i=n-1;i>0;i--)
        {
            for(int j=1;j<=n-i;j++)
            {
                System.out.print(" ");
            }
            for(int j=1;j<=i;j++)
            {
               System.out.print("*");
            }
	        System.out.println();
       }                
    }
}

输入行数:6
*

---

---

---

---

---

---

程序 2:打印镜像半菱形星形图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印镜像的半菱形星形图案。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用两个循环来打印图案。
6. 第一个外部 while 循环将执行代码，直到条件 i<=n 为假。第一个内循环将显示空格，直到条件 j++<=n-i 为假，第二个内循环将显示字符，直到条件 j++<=i 为假。第一个外环将显示镜像半菱形星形图案的前半部分。
7. 在第一个外部循环执行之后，光标会转到下一行，并执行第二个外部 while 循环。
8. 第二个外部循环将执行语句，直到条件 i>0 为假，第一个内部循环显示空格，直到条件 j++<=n-i 为假，第二个内部循环将显示字符，直到条件 j++<=i 为假。
9. 第二个外环将显示镜像半菱形图案的剩余一半。
10. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Mirrored Half Diamond Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int i=1;
        int j;
	    while(i<=n)
        {	
            j=1;
		    while(j++<=n-i)                
            {
                System.out.print(" ");
     	    }
            j=1;
            while(j++<=i) 
            {
                System.out.print("*");     		                     
    		}		      
            System.out.println();
            i++;
        }   
        i=n-1;
        while(i>0)
        {
		     j=1;
             while(j++<=n-i)
             {
     	          System.out.print(" ");                     
    		 }
            j=1;
            while(j++<=i)
            {
   	            System.out.print("*");                     
    		}		      
            System.out.println();
            i--;
        }  
    }
}

输入行数:6
*

---

---

---

---

---

---

程序 3:打印镜像半菱形星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印镜像的半菱形星形图案。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用两个边做边循环来打印图案。
6. do-while 循环执行一次代码，然后同时检查条件。
7. 第一个外部 do-while 循环执行代码，直到条件为 false ++i<=n 为 false，第一个内部循环将显示空格，直到条件++j<=n-i+1 为 false，第二个内部循环将显示字符，直到条件++j<=i 为 false。该外环显示镜像半菱形图案的一半图案。
8. 第二个外部 do-while 循环执行代码，直到条件–I > 0 为假，第一个内部循环将显示空格，直到条件++j<=n-i+1，第二个内部循环将显示字符，直到条件++j<=i 为假。此外循环显示镜像半菱形图案的剩余一半图案。
9. 显示结果。
10. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Mirrored Half Diamond Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int i=1;
        int j;	
        do 
        {
	        j=1;
            do
            {
     	          System.out.print(" ");
     	    }while(++j<=n-i+1);             
            j=1;
            do
            {
     	             System.out.print("*");
     	    }while(++j<=i);                    
 	        System.out.println();
        }while(++i<=n);  
        i=n-1;     
        do 
        {
	        j=1;
            do
            {
     	        System.out.print(" ");
     	    }while(++j<=n-i+1);  
            j=1;
            do
            {
     	      System.out.print("*");
     	    }while(++j<=i);   
            System.out.println();                 
        }  while(--i>0);   
    }
}

输入行数:6
*

---

---

---

---

---

---

---

---

Java 程序：打印左箭头星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-left-arrow-star-pattern

在本教程中，我们将看到如何在 Java 中打印左箭头星形模式。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:6

输出:模式为:

---

---

---

---

---

---

---

---

---

---

---

程序 1:打印左箭头星形图案

在这个程序中，我们将看到如何使用 for 循环在 Java 中打印左箭头星形模式。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用两个循环来打印图案。
6. 第一个 for 循环显示上方的“左箭头”图案，第二个 for 循环显示下方的图案。
7. 首先，检查循环的条件 i
8. 第一个内部 for 循环显示空间和第二个内部 for 循环显示我们给定要显示的字符。
9. 在执行第一个外部 for 循环之后，将执行第二个外部 for 循环。
10. 检查循环的条件，如果为真，则执行内部循环，直到条件 i
11. 显示结果。
12. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Left Arrow Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        for(int i=1;i<=n;i++)
        {
	        for(int j=1;j<=n-i;j++)
            { 
                System.out.print(" ");
            }
		    for(int j=i;j<=n;j++)
            {
                System.out.print("*");
            }
	        System.out.println();
        }            
        for(int i=1;i<n;i++)
        {
	        for(int j=0;j<i;j++)
            {
                System.out.print(" ");
            }
		    for(int j=0;j<=i;j++)
            {
               System.out.print("*");
            } 
	        System.out.println();
        }    
    }
}

输入行数:6

---

---

---

---

---

---

---

程序 2:打印左箭头星形图案

在这个程序中，我们将看到如何使用 while 循环在 Java 中打印左箭头星形模式。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用两个 while 循环来打印图案。
6. 首先，在 while 处检查条件 i<=n，如果为真，则在 while 循环中执行代码。
7. 第一个 while 将执行，直到 i<=n 为假。
8. 在执行第一个 while 循环后，将执行第二个 while 循环。
9. 显示结果。
10. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Left Arrow Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int i=1;
        int j;
	    while(i<=n)
        {
	        j=1;
		    while(j<=n-i)
            { 
                System.out.print(" ");
                j++;
           }
		    j=i;
            while(j<=n)  
            {
                System.out.print("*");
		        j++;
            }
	        System.out.println();
	        i++;
        }            
        i=1;
	    while(i<n)
        {
	        j=0;
		    while(j<i)
            {
                System.out.print(" ");
		        j++;
            }
		    j=0;
	        while(j<=i)
            {
                System.out.print("*");
		        j++;
            } 
	        System.out.println();
	        i++;
        }    
    }
}

输入行数:6

---

---

---

---

---

---

---

程序 3:打印左箭头星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 Java 中打印左箭头星形模式。

算法:

1. 开始
2. 创建 Scanner 类的实例。
3. 声明变量来存储行数和模式符号。
4. 要求用户初始化这些变量。
5. 使用两个边做边循环来打印图案。
6. 首先，将执行 do-while 循环，直到条件为假 i<=n。将执行内部 do-while 循环，直到条件为假。
7. 在执行第一个 do-while 循环之后，将执行第二个 do-while 循环，直到条件 i
8. 显示结果。
9. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Left Arrow Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int i=1;
        int j;
	    do
        {
	        j=1;
            do
            { 
                System.out.print(" ");
            }while(j++<=n-i);
		    j=i;
            do
            {
                System.out.print("*");
		        j++;
            }while(j<=n); 
	        System.out.println();
	        i++;
        } while(i<=n);           
        i=1;
	    do
        {
	        j=0;
            do
            {
                System.out.print(" ");
            }while(j++<i);
		    j=0;
		    do
		    {
                System.out.print("*");
		        j++;
            } while(j<=i);
	        System.out.println();
	        i++;
        }while(i<n);  
    }
}

输入行数:6

---

---

---

---

---

---

---

---

---

Java 程序：打印倒直角三角形星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-inverted-right-triangle-star-pattern

在本教程中，我们将看到如何在 Java 中打印倒直角三角形星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环打印倒直角三角形星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:5

输出:模式为:

---

---

---

---

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

Java 程序：程序 1:打印倒直角三角形星形图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印倒直角三角形星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 使用两个循环来打印图案。

6. 使用外部 for 循环迭代从 n 到 1 的行。

7. 使用内部 for 循环迭代从 0 到 I 的列。

8. 打印条件满足的图案。

9. 显示结果。

10. 停下来。

下面的例子说明了上述算法的实现。

//Java Program to Print the Inverted Right Triangle Star Pattern
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        for(int i=n;i>0;i--)
        {
           for(int j=0;j<i;j++)
           {
               System.out.print("*");
           }
           System.out.println();
        }
     }
}

输入行数:7

• • • • • T2】* * * * * T3】* * * * * T4】* * * * * T5】* * * * * T6】* *

Java 程序：程序 2:打印倒直角三角形星形图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印倒直角三角形星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 使用两个 while 循环来打印图案。

6. 将第一个循环变量初始化为行数。

7. 外部 while 循环将迭代直到 i>0。

8. 将循环变量初始化为 0。

9. 内部 while 循环将迭代直到 j++

10. 打印条件满足的图案。

11. 显示结果。

12. 停下来。

下面的例子说明了上述算法的实现。

//Java Program to Print the Inverted Right Triangle Star Pattern
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        int i=n,j;
        while(i>0)
        {
           j=0;
           while(j++<i)
           {
               System.out.print("*");
           }
           System.out.println();
           i--;
        } 
    }
}

输入行数:6

• • • • • T2】* * * * * * * T3】* * * * * T4】* * * * * T5】* *

Java 程序：程序 3:打印倒直角三角形星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印倒直角三角形星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 使用两个边做边循环来打印图案。

6. 将第一个循环变量初始化为行数。

7. 外部 do-while 循环将迭代直到- i>0。

8. 将内部循环变量初始化为 0。

9. 内部 while 循环将迭代直到++j

10. 打印条件满足的图案。

11. 显示结果。

12. 停下来。

下面的例子说明了上述算法的实现。

//Java Program to Print the Inverted Right Triangle Star Pattern
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        int i=n;
        do
        {
           int j=0;
           do
           {
               System.out.print("*");
           }while(++j<i);
           System.out.println();
        } while(--i>0) ;  
    }
}

输入行数:6

• • • • • T2】* * * * * * * T3】* * * * * T4】* * * * * T5】* *

---

---

Java 程序：打印空心倒金字塔星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-hollow-inverted-pyramid-star-pattern

在本教程中，我们将看到如何在 Java 中打印空心倒金字塔星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印空心倒金字塔星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:5

输出:模式为:

---

---

---

---

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

Java 程序：程序 1:打印空心倒金字塔星形图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印空心倒金字塔星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 用于循环打印图案。

6. 使用外部 for 循环迭代从 n 到 1 的行。

7. 使用第一个内部 for 循环从 1 迭代到 n，然后打印所需的空间。

8. 如果第一个内部循环条件为假，则检查“如果”条件。

9. 如果条件为真，则第一个循环打印(i1 或 in)和 j<=i*2-1 的字符。

10. 如果条件为假，则第二个循环打印(j1 || ji2-1)的字符，打印(j！=1&j！=i2-1)直到 j<=i*2-1

11. 显示结果。

12. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Hollow Inverted Pyramid Star Pattern
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        for(int i=n;i>0;i--)
        {
            for(int j=1;j<=n-i;j++)
            {
                System.out.print(" ");
            }
            if(i==1 || i==n)
            for(int j=1;j<=i*2-1;j++)
            {
                System.out.print("*");
            }
            else
            {
                for(int j=1;j<=i*2-1;j++)
                { 
                   if(j==1 || j==i*2-1)
                   System.out.print("*");
                   else
                   System.out.print(" ");
                }
            }
          System.out.println();
        }
    }
}

输入行数:6

---

Java 程序：程序 2:打印空心倒金字塔星形图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印空心倒金字塔星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 使用 while 循环打印图案。

6. 将外部循环变量初始化为行数。

7. 外部 while 循环将迭代直到 i>0

8. 将内部循环变量初始化为 1。

9. 使用另一个 while 循环，该循环将迭代直到++j<=i 来打印空格。

10. 现在，使用 if-else 语句打印所需的模式。

11. 如果条件为真，则循环首先打印字符，直到 j++<=i*2-1 为假。

12. 如果条件为假，则 while 循环打印 j1，j(i2)-1 的字符，直到 while(j<=(i2)-1)条件为假。

13. 还有 j 的打印空间！=1 和 J！=(i2)-1，直到 while(j<=(i2)-1)条件为假。

14. 显示结果。

15. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Hollow Inverted Pyramid Star Pattern
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        int i=n;
        int j;
        while(i>0)
        {
           j=1;
           while(j++<=n-i)
           {
               System.out.print(" ");
           }
           if(i==1 || i==n)
           {
               j=1;
               while(j++<=i*2-1)
               {
                   System.out.print("*");
               }
            }
            else
            {
                j=1;
                while(j<=(i*2)-1)
                {
                    if(j==1 || j==(i*2)-1)
                    System.out.print("*");
                    else
                    System.out.print(" ");
                    j++;
                }
            }
            System.out.println();
            i--;
        } 
    }
}

输入行数:7

---

Java 程序：程序 3:打印空心倒金字塔星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印空心倒金字塔星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 使用边做边循环打印图案。

6. 将外部循环变量初始化为行数。

7. 外部 do-while 循环将迭代直到 i>0

8. 将内部循环变量初始化为 1。

9. 使用另一个 do-while 循环，该循环将迭代到++j<=n-i+1 并打印空格。

10. 现在，使用 if-else 语句打印所需的模式。

11. 如果条件为真，则第一个 do-while 循环打印字符，直到 j++<=i*2-1 为假。

12. 如果条件为假，则下一个 do-while 循环打印 j1，j(i2)-1 的字符，直到 while(j<=(i2)-1)条件为假。

13. 还有 j 的打印空间！=1 和 j！=(i2)-1，直到 while(j<=(i2)-1)条件为假。

14. 显示结果。

15. 停止

下面的例子说明了上述算法的实现。

//Java Program to Print the Hollow Inverted Pyramid Star Pattern
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        int i=n;
        int j;
        do
        {
            j=1;
            do
            {
                System.out.print(" ");
            }while(++j <=n-i+1); 
            if(i==1 || i==n)
            {
                j=1;
                do
                {
                    System.out.print("*");
                }while(++j <=i*2-1);
            }
            else
            {
                j=1;
                do
                {
                    if(j==1 || j==i*2-1)
                    System.out.print("*");
                    else
                    System.out.print(" ");
                }while(++j<=i*2-1);
            }
            System.out.println();
            --i;
          } while(i>0); 
    }
}

输入行数:8

• • • • • • • • • • • • • T2】* *

---

---

Java 程序：打印右箭头星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-right-arrow-star-pattern

在本教程中，我们将看到如何在 java 中打印右箭头星形模式首先，我们将要求用户初始化行数。然后，我们将使用不同的循环来打印右箭头星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:6

输出:

---

---

---

---

**

**

---

---

---

---

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

Java 程序：程序 1:打印右箭头星形图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印右箭头星形模式。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 使用两个循环来打印图案。

6. 对行使用外部 for 循环。

7. 对列使用内部 for 循环。

8. 第一个外部 for 循环显示图案的一半，第二个外部 for 循环显示图案的下一半。

9. 在第一个外部循环中，将检查条件是否为真，然后检查内部循环条件是否为真，然后检查“如果”条件。“如果”条件为真，则显示空格，否则显示我们给定要显示的字符。

10. 内部 for 循环执行代码，直到条件为假。第一个外环将显示该模式。

11. 显示模式。

12. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print the Right Arrow Star Pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	
	    for(int i=0;i<n;i++)
        {
	        for(int j=0;j<n;j++)
            {
                if(j<i)
                System.out.print("  ");
		        else
                System.out.print("*");
            }
	        System.out.println();
        }            
        for(int i=2;i<=n;i++)
        {
	        for(int j=0;j<n;j++)
            {
                if(j<n-i)
                System.out.print("  ");
		        else
                System.out.print("*");
            }
	        System.out.println();
        }
    }
} 

输入行数:5

---

---

---

---

Java 程序：程序 2:打印右箭头星形图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印右箭头星形模式。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 使用两个 while 循环来打印图案。

6. While 循环首先检查条件是否为真，如果为真，则执行代码。

7. 第一个外部 while 循环将显示图案的一半，第二个外部循环将显示图案的下一半。

8. 第一个外部 while 循环的条件为真，然后进入内部循环，内部循环条件也为真，然后检查 if 条件，“if”条件为真，则显示空格，否则将显示字符“*”。内部循环将执行代码，直到条件为假。第一个外部循环执行代码，直到条件 i

9. 光标到达下一行，然后将执行第二个外部 while 循环，直到条件为假。

10. 显示结果。

11. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print the Right Arrow Star Pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	
	    int i=0;
        int j;
	    while(i<n)
        {
	          j=0;
		      while(j<n) 
              {
                    if(j<i)
                    System.out.print("  ");
	            	else
                    System.out.print("*");
		            j++;
               }
	           System.out.println();
	           i++;
        }            
        i=2;
	    while(i<=n)
        {
	       j=0;
		   while(j<n)
           {
                if(j<n-i)
                System.out.print("  ");
		        else
                System.out.print("*");
	           	j++;
            }
            System.out.println();
	        i++;
        }    
    }
} 

输入行数:5

---

---

---

---

Java 程序：程序 3:打印右箭头星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印右箭头星形模式。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明一个变量来存储行数。

4. 要求用户初始化变量。

5. 使用两个边做边循环来打印图案。

6. 在第一个外部 do-while 循环中，它执行代码，然后检查条件 i

7. 第二个外部 do-while 循环将执行代码，直到条件 i

8. 显示结果。

9. 停止

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print the Right Arrow Star Pattern 
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	
	    int i=0;
        int j;
	    do
        {
	        j=0;
	        do
            {
                if(j<i)
                System.out.print("  ");
		        else
                System.out.print("*");
		        j++;
            }while(j<n);
	        System.out.println();
	        i++;
        }while(i<n);            
        i=2;
	    do
        {
	         j=0;
		     do
		     {
                if(j<n-i)
                System.out.print("  ");
		        else
                System.out.print("*");
		        j++;
            }while(j<n);
	        System.out.println();
	        i++;
        }while(i<=n);    
    }
} 

输入行数:8

• • • • • • • T2】* * * * * * * * * T3】* * * * * T4】* * * * * T5】* * * * * T6】* * * * * T7】* *
• • • • • T12】* *
• • • • • T14】* * * * * T15】* * * * * * * * T15

---

---

Java 程序：打印方形星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-square-star-pattern

在本教程中，我们将看到如何在 java 中打印方形星形模式。首先，我们将要求用户初始化行数。然后，我们将使用不同的循环来打印方形星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:7

输出:模式为:

---

---

---

---

---

---

---

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

Java 程序：程序 1:打印方形星形图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印方形星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数。

4. 要求用户初始化行数。

5. 使用两个循环来打印图案。

6. 使用第一个 for 循环打印每行中的*号。

7. 使用第二个 for 循环在每一列中打印*号。

8. 显示结果。

9. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print the Square Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        for(int i = 1; i <= n; i++)
		{
			for(int j = 1; j <= n; j++)
			{
				System.out.print("*"); 
			}
			System.out.print("\n"); 
		}	     
    }
} 

输入行数:7

• • • • • T2】* * * * * * * T3】* * * * * T4】* * * * * T5】* * * * * T6】* * * * * * * * * T7

Java 程序：程序 2:打印方形星形图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印方形星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数。

4. 要求用户初始化行数。

5. 使用两个 while 循环来打印图案。

6. 为每个循环声明两个循环变量。

7. 将第一个循环变量初始化为 1。

8. 对行使用外部 while 循环。

9. 将第二个循环变量初始化为 1。

10. 列的内部 while 循环。

11. 如果条件满足，则打印*。

12. 显示结果。

13. 停止

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print the Square Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	
	    int i=1;
	    int j;
        while(i <= n)
		{
			j = 1;
			while(j <= n)
			{
				System.out.print("*"); 
				j++;
			}
			i++;
			System.out.print("\n"); 
		}	     
    }
} 

输入行数:7

• • • • • T2】* * * * * * * T3】* * * * * T4】* * * * * T5】* * * * * T6】* * * * * * * * * T7

Java 程序：程序 3:打印方形星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印方形星形图案。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数。

4. 要求用户初始化行数。

5. 使用两个边做边循环来打印图案。

6. 为每个循环声明两个循环变量。

7. 将第一个循环变量初始化为 1。

8. 对行使用外部 do-while 循环。

9. 将第二个循环变量初始化为 1。

10. 列的内部 do-while 循环。

11. 如果条件满足，则打印*。

12. 显示结果。

13. 停止

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print the Square Star Pattern
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        //Take input from the user
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	
	    int i=1;
	    int j;
        do
		{
			j = 1;
			do
			{
				System.out.print("*"); 
				j++;
			}while(j <= n);
			i++;
			System.out.print("\n"); 
		} while(i <= n);	     
    }
} 

输入行数:5

---

---

---

---

---

---

---

Java 程序：打印倒镜像直角三角形

原文：https://www.studytonight.com/java-programs/java-program-to-print-inverted-mirrored-right-triangle

在本教程中，我们将看到如何在 java 中打印倒置的镜像直角三角形。首先，我们将要求用户初始化行数。然后，我们将使用不同的循环来打印反向镜像的直角三角形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:6

输出:

---

---

---

---

**

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

Java 程序：程序 1:打印倒镜像直角三角形

在这个程序中，我们将看到如何使用 for 循环在 java 中打印倒置的镜像直角三角形。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数和模式符号。

4. 要求用户初始化这些变量。

5. 使用三个循环来打印图案。

6. 外部 for 循环将遍历行。

7. 第一个内部 for 循环用于打印所需的空间。

8. 第二个内部 for 循环打印所需的模式符号。

9. 显示结果。

10. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to print the Inverted Mirrored Right Triangle
import java.util.Scanner;
public class Main
{ 
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        System.out.println("Enter the symbol: ");
        char ch = sc.next().charAt(0);
        for(int i=n;i>0;i--)
        {
            for(int j=n-i;j>0;j--)
            {
                System.out.print(" ");
            }
            for(int j=0;j<i;j++)
            {
                System.out.print(ch);
            }
            System.out.println();
        }
    }
}

输入行数:7
输入符号:*

---

• • • • • T4】* * * *

Java 程序：程序 2:打印倒镜像直角三角形

在这个程序中，我们将看到如何使用 while 循环在 java 中打印反向镜像直角三角形。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数和模式符号。

4. 要求用户初始化这些变量。

5. 使用三个 while 循环来打印图案。

6. 外部 while 循环将遍历行。

7. 第一个内部 while 循环用于打印所需的空间。

8. 第二个内部 while 循环打印所需的模式符号。

9. 显示结果。

10. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to print the Inverted Mirrored Right Triangle
import java.util.Scanner;
public class Main
{ 
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        System.out.println("Enter the symbol: ");
        char ch = sc.next().charAt(0);
        int i=n,j;
        while(i>0)
        {
            j=n-i;
            while(j-->0) 
            {
               System.out.print(" ");
            } 
            j=0;
            while(j++<i)
            {
               System.out.print(ch);
            }
            System.out.println();
            i--;
        } 
    }
}

输入行数:6
输入符号:*

---

---

---

---

Java 程序：程序 3:打印倒镜像直角三角形

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印倒置的镜像直角三角形。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数和模式符号。

4. 要求用户初始化这些变量。

5. 使用三个边做边循环来打印图案。

6. 外部 do-while 循环将遍历行。

7. 第一个内部 while 循环用于打印所需的空间。

8. 第二个内部边做边循环打印所需的图案符号。

9. 显示结果。

10. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to print the Inverted Mirrored Right Triangle
import java.util.Scanner;
public class Main
{ 
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        System.out.println("Enter the symbol: ");
        char ch = sc.next().charAt(0);
        int i=n,j;
        do
        {
	        j=n-i;
            while(j-->0)
            {
                System.out.print(" ");
            } 
   	        j=0;                  
            do
            {
                System.out.print(ch);
            }while(++j<i);
            System.out.println();
        }while(--i>0);  
    }
}

输入行数:8
输入符号:*

---

---

---

---

---

---

---

---

Java 程序：打印空心倒镜像直角三角形星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-the-hollow-inverted-mirrored-right-triangle-star-pattern

在本教程中，我们将看到如何在 java 中打印中空的反向镜像直角三角形图案。首先，我们将要求用户初始化行数。然后，我们将使用不同的循环来打印中空的反向镜像直角三角形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:6

输出:

---

**

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

Java 程序：程序 1:打印空心倒镜直角三角形星形图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印中空的反向镜像直角三角形。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数和模式符号。

4. 要求用户初始化这些变量。

5. 使用三个循环来打印图案。

6. 外部 for 循环将遍历行。

7. 第一个内部 for 循环用于打印所需的空间。

8. 使用 if-else 语句检查条件。

9. 第二个内部 for 循环打印所需的模式符号。

10. 显示结果。

11. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to print the Hollow Inverted Mirrored Right Triangle
import java.util.Scanner;
public class Main
{ 
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        System.out.println("Enter the symbol: ");
        char ch = sc.next().charAt(0);
        for(int i=n;i>0;i--)
        {
            for(int j=n-i;j>0;j--)
            {
                System.out.print(" ");
            }
            if(i==1 || i==n)
            for(int j=1;j<=i;j++)
            {
                System.out.print(ch);
            }
            else
            {
                for(int j=1;j<=i;j++)
                {  
                    if(j==1 || j==i)
                    System.out.print(ch);
                    else
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}

输入行数:8
输入符号:*

---

Java 程序：程序 2:打印空心倒镜直角三角形星形图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印中空的反向镜像直角三角形。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数和模式符号。

4. 要求用户初始化这些变量。

5. 使用三个 while 循环来打印图案。

6. 外部 while 循环将遍历行。

7. 第一个 while for 循环用于打印所需的空间。

8. 使用 if-else 语句检查条件。

9. 第二个内部 while 循环打印所需的模式符号。

10. 显示结果。

11. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to print the Hollow Inverted Mirrored Right Triangle
import java.util.Scanner;
public class Main
{ 
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        System.out.println("Enter the symbol: ");
        char ch = sc.next().charAt(0);
        int i=n;
        int j; 
        while(i>0)
        {
            j=n-i;
            while(j-->0)
            {
                System.out.print(" ");
            }
            if(i==1 || i==n)
            {
                j=1;
                while(j <=i)
                {
                    System.out.print(ch);
                    j++;
                }
            }
            else
            {
                j=1;
                while(j<=i)
                {
                    if(j==1 || j==i)
                    System.out.print(ch);
                    else
                    System.out.print(" ");
                    j++;
                }
            }
            System.out.println();
            i--; 
        } 
    }
}

输入行数:8
输入符号:*

---

Java 程序：程序 3:打印空心倒镜直角三角形星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印中空的反向镜像直角三角形。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数和模式符号。

4. 要求用户初始化这些变量。

5. 使用三个边做边循环来打印图案。

6. 外部 do-while 循环将遍历行。

7. 循环的第一个 do-while 用于打印所需的空间。

8. 使用 if-else 语句检查条件。

9. 第二个内部边做边循环打印所需的图案符号。

10. 显示结果。

11. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to print the Hollow Inverted Mirrored Right Triangle
import java.util.Scanner;
public class Main
{ 
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of rows: ");
        int n=sc.nextInt(); 
        System.out.println("Enter the symbol: ");
        char ch = sc.next().charAt(0);
        int i=n;
        int j; 
        do 
        {
            j=n-i;
            while(j-->0)
            {
                System.out.print(" ");
            }
            if(i==1 || i==n)
            {
                j=1;
                do
                {
                    System.out.print(ch);
                }while(++j <=i);
            }
            else
            {
                j=1;
                do
                {
                    if(j==1 || j==i)
                    System.out.print(ch);
                    else
                    System.out.print(" ");
                }while(++j<=i);
            }
            System.out.println();
        } while(--i>0); 
    }
}

输入行数:8
输入符号:*

---

---

---

Java 程序：打印 X 星形图案

原文：https://www.studytonight.com/java-programs/java-program-to-print-x-star-pattern

在本教程中，我们将看到如何在 java 中打印 X 星形模式首先，我们将要求用户初始化行数。然后，我们将使用不同的循环来打印 X 星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。

输入:输入行数:7

输出:模式为:

这可以通过使用以下方法来实现:

方法 1:使用 For 循环

方法 2:使用 While 循环

方法 3:使用边做边循环

让我们看看这些方法中的每一种，以便更好地理解。

Java 程序：程序 1:打印 X 星图案

在这个程序中，我们将看到如何使用 for 循环在 java 中打印 X 星形模式。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数。

4. 要求用户初始化行数。

5. 使用 for 循环打印图案。

6. 在内部 for 循环中，从 j=1 迭代到 k，如果 j=i 或 j=k-i+1 显示“*”，则打印 charter，否则显示 space。

7. 这段代码将一直执行到内部 for 循环条件为假，然后进入外部 for 循环，for 循环将一直执行到条件 i<=k 为假。

8. 显示结果。

9. 停下来。

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print the X Star Pattern Using For Loop
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int k=n*2-1;
	    for(int i=1;i<=k;i++)
        {
	        for(int j=1;j<=k;j++)
            {      
                if(j==i || j==k-i+1)
                System.out.print("*");
                System.out.print(" ");
            }
	        System.out.println();
        }            
    }
} 

输入行数:6

Java 程序：程序 2:打印 X 星图案

在这个程序中，我们将看到如何使用 while 循环在 java 中打印 X 星形模式。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数。

4. 要求用户初始化行数。

5. 使用 while 循环打印图案。

6. While 循环首先检查条件，然后执行代码。

7. 首先检查 while 循环的条件，即 i<=k，如果是真的，则进入内部 while 循环。

8. 在内部 while 循环中，首先检查条件 j<=k，然后执行循环中的代码，直到条件为假，然后光标从内部循环出来并转到外部循环，这将持续到条件 i<=k 为假。

9. 显示结果。

10. 停止

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print the X Star Pattern Using While Loop
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int i=1;
        int j;
	    int k=n*2-1;
	    while(i<=k)
        {
	        j=1;
		    while(j<=k) 
            {     
                if(j==i || j==k-i+1)
                System.out.print("*");
                System.out.print(" ");
		        j++;
            }
	    System.out.println();
	    i++;
       } 
    }
} 

输入行数:6

Java 程序：程序 3:打印星形图案

在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印 X 星形模式。

算法:

1. 开始

2. 创建 Scanner 类的实例。

3. 声明变量来存储行数。

4. 要求用户初始化行数。

5. 使用边做边循环打印图案。

6. 首先，执行内部 do-while 循环。

7. 内部循环中的代码一直执行到条件 j<=k 为假。它为 j=i，j=k-i+1 打印一个字符。除了这些 j 值，打印空间。

8. 如果条件为假，则光标会转到外部 do-while 循环。如果条件 i<=k 为假，外部 do 循环执行将停止。

9. 显示结果。

10. 停止

让我们看下面的例子来理解上面算法的实现。

//Java Program to Print Star Pattern Using a do-while Loop
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
	    Scanner sc=new Scanner(System.in);
	    System.out.println("Enter the number of rows: ");
	    int n=sc.nextInt();	 
        int i=1;
        int j;
	    int k=n*2-1;
	    do
        {
	        j=1;
            do
            {   
                if(j==i || j==k-i+1)
                System.out.print(“*”);
                System.out.print(" ");
		        j++;
            }
            while(j<=k);
	        System.out.println();
	        i++;
        }while(i<=k);      
    }
} 

输入行数:7

---

---

字符串程序

Java 程序：查找字符串中重复字符

原文：https://www.studytonight.com/java-programs/java-program-to-find-the-duplicate-characters-in-a-string

在本教程中，我们将学习如何在字符串中查找重复字符。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:最大出现次数

输出:字符串中的重复字符有:

m

u

c

r

e

程序 1:查找字符串中的重复字符

在这个程序中，我们将看到当字符串被预定义时，如何在字符串中找到重复的字符。

算法

1. 开始
2. 声明字符串
3. 初始化它
4. 声明一个变量来计算字符的频率。
5. 将字符串转换为字符数组。
6. 使用两个 for 循环来计算字符串中每个元素的频率。
7. 使用第一个 for 循环来保存字符串的字符。
8. 将计数初始化为 1。
9. 使用内部 for 循环迭代字符串中的其余字符。
10. 检查字符串中是否再次出现该字符。
11. 如果发生，则增加计数。
12. 将 str[j]设置为 0，以避免计算访问字符。
13. 检查计数值是否大于 1，str[i]是否不等于 0。
14. 如果它满足上述条件，则打印该元素。
15. 停下来。

下面是相同的 Java 语言代码。

//Java Program to find the duplicate characters in a given string
public class Main
{  
     public static void main(String[] args) 
     {  
        String str1 = "Maximum and Minimum";  
        int count;  
        System.out.println("The entered string is: "+str1);
        //Converts given string into character array  
        char str[] = str1.toCharArray();  

        System.out.println("Duplicate characters in a given string: ");  
        //Count the frequency of each character present in the string  
        for(int i = 0; i <str.length; i++) 
        {  
            count = 1;  
            for(int j = i+1; j <str.length; j++) 
            {  
                if(str[i] == str[j] && str[i] != ' ') 
                {  
                    count++;  
                    //Set string[j] to 0 to avoid printing visited character  
                    str[j] = '0';  
                }  
            }  
            //A character is considered as duplicate if count is greater than 1  
            if(count > 1 && str[i] != '0')  
                System.out.println(str[i]);  
        }  
    }  
} 

输入的字符串是:给定字符串中的最大和最小
重复字符:
M
a
i
m
u
n

程序 2:查找字符串中的重复字符

在这个程序中，我们将看到当字符串是用户定义的时，如何在字符串中找到重复的字符。在这里，首先，我们将要求用户输入字符串，然后检查重复的元素。

算法

1. 开始
2. 声明字符串
3. 要求用户初始化它
4. 声明一个变量来计算字符的频率。
5. 将字符串转换为字符数组。
6. 使用两个 for 循环来计算字符串中每个元素的频率。
7. 使用第一个 for 循环来保存字符串的字符。
8. 将计数初始化为 1。
9. 使用内部 for 循环迭代字符串中的其余字符。
10. 检查字符串中是否再次出现该字符。
11. 如果发生，则增加计数。
12. 将 str[j]设置为 0，以避免计算访问字符。
13. 检查计数值是否大于 1，str[i]是否不等于 0。
14. 如果它满足上述条件，则打印该元素。
15. 停下来。

下面是相同的 Java 语言代码。

//Java Program to find the duplicate characters in a given string
import java.util.*;
public class Main
{  
     public static void main(String[] args) 
     {  
         //Take input from the user
        Scanner sc=new Scanner(System.in);  
        System.out.println("Enter the string is: ");
        String str1=sc.nextLine();
        int count;  
        //Converts given string into character array  
        char str[] = str1.toCharArray();            
        System.out.println("Duplicate characters in the given string: ");  
        //Counts each character present in the string  
        for(int i = 0; i <str.length; i++) 
        {  
            count = 1;  
            for(int j = i+1; j <str.length; j++) 
            {  
                if(str[i] == str[j] && str[i] != ' ') 
                {  
                    count++;  
                    //Set string[j] to 0 to avoid printing visited character  
                    str[j] = '0';  
                }  
            }  
            //A character is considered as duplicate if count is greater than 1  
            if(count > 1 && str[i] != '0')  
                System.out.println(str[i]);  
        }  
    }  
} 

输入字符串为:重复字符
给定字符串中的重复字符:
c
a
t
e
r

---

---

Java 程序：使用特定字符替换字符串空格

原文：https://www.studytonight.com/java-programs/java-program-to-replace-the-spaces-of-a-string-with-a-specific-character

在本教程中，我们将学习如何用特定字符替换字符串的空格。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:一鸟在手胜于两鸟在林

输入字符:-

输出:用特定字符替换字符串的空格后:

一鸟在手胜过两鸟在林

程序 1:用特定字符替换字符串中的空格

在这个程序中，我们将看到当值在程序中被预定义时，如何用特定的字符替换字符串的空格。这里，我们将使用 replace()方法用给定的指定字符替换空白。

算法

1. 开始
2. 声明一个字符串。
3. 初始化它。
4. 在用指定字符替换空格之前，打印输入的字符串。
5. 定义要替换空格的字符。
6. 使用 replace()方法用给定的指定字符替换空格。
7. 现在，在用指定字符替换空格后，打印输入的字符串。
8. 停下来。

下面是相同的 Java 语言代码。

//Java Program to replace the spaces of a string with a specific character
public class Main   
{    
    public static void main(String[] args) 
    {    
        String string = "Actions speak louder than words";    
        char ch = '-';            
        System.out.println("String before replacing spaces with given character: ");    
        System.out.println(string);         
        //Replace space with specific character ch    
        string = string.replace(' ', ch);                
        System.out.println("String after replacing spaces with given character: ");    
        System.out.println(string);    
    }    
} 

用给定字符替换空格前的字符串:
行动胜于言语
用给定字符替换空格后的字符串:
行动胜于言语

程序 2:用特定字符替换字符串中的空格

在这个程序中，我们将看到当值在程序中被预定义时，如何用特定的字符替换字符串的空格。这里，我们将使用 replaceAll()方法用给定的指定字符替换所有空白。

算法

1. 开始
2. 声明一个字符串。
3. 初始化它。
4. 在用指定字符替换空格之前，打印输入的字符串。
5. 定义要替换空格的字符。
6. 使用 replaceAll()方法用给定的指定字符替换空格。
7. 现在，在用指定字符替换空格后，打印输入的字符串。
8. 停下来。

下面是相同的 Java 语言代码。

//Java Program to replace the spaces of a string with a specific character
public class Main   
{    
    public static void main(String[] args) 
    {    
        String string = "Slow and steady wins the race";    
        char ch = '-';           
        System.out.println("String before replacing spaces with given character: ");    
        System.out.println(string);         
        //Replace space with specific character ch    
        string = string.replaceAll(" ", "-");               
        System.out.println("String after replacing spaces with given character: ");    
        System.out.println(string);    
    }    
} 

用给定字符替换空格前的字符串:
慢而稳赢得比赛
用给定字符替换空格后的字符串:
慢而稳赢得比赛

程序 3:用特定字符替换字符串中的空格

在这个程序中，我们将看到当值在程序中被预定义时，如何用特定的字符替换字符串的空格。这里，我们将使用 for 和 if 循环用给定的指定字符替换空白。

算法

1. 开始
2. 声明一个字符串。
3. 初始化它。
4. 在用指定字符替换空格之前，打印输入的字符串。
5. 定义要替换空格的字符。
6. 对相同的使用 for 和 if 循环。
7. 使用 for 循环迭代字符串的每个字符。
8. 使用 if 循环检查是否存在任何空间。
9. 如果遇到任何空格，则用指定的字符替换它。
10. 现在，在用指定字符替换空格后，打印输入的字符串。
11. 停下来。

下面是相同的 Java 语言代码。

//Java Program to replace the spaces of a string with a specific character
public class Main
{ 
    // Function to replace Space with - 
    static String replaceStr(String str) 
    {           
        String s = "";           
        // Iterate over each character of the string
        for (int i = 0; i < str.length(); ++i) 
        {       
            // If a space encounters then replace it with -
            if (str.charAt(i) == ' ')  
                s += '-';               
            else
                s += str.charAt(i);               
        } 
        // return the new string. 
        return s; 
    }       
    //Driver Code  
    public static void main(String []args) 
    { 
        // Initialize the String 
        String str = "There are other fish in the sea"; 
        System.out.println("String before replacing spaces with given character: ");    
        System.out.println(str);    
        //Print the modified string
        System.out.println("String after replacing spaces with given character: ");    
        System.out.println(replaceStr(str));     
    } 
} 

用给定字符替换空格前的字符串:
海里还有其他鱼
用给定字符替换空格后的字符串:
海里还有其他鱼

---

---

Java 程序：将字符串分成N个相等部分

原文：https://www.studytonight.com/java-programs/java-program-to-divide-a-string-in-n-equal-parts

在本教程中，我们将学习如何将一个字符串分成 n 个相等的部分。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:今晚学习

输入 n: 4 的值

输出:将输入的字符串分成 n 个相等的部分，我们有

斯图（男子名）

下肢深静脉血栓形成

office of naval intelligence 海军情报局

ghent 根特

程序 1:将一个字符串分成 N 个相等的部分

在这个程序中，我们将看到当字符串被预定义时，如何将字符串分成“N”个相等的部分。

算法

1. 开始吧。
2. 声明一个字符串。
3. 初始化它。
4. 输入 n 的值。
5. 调用一个方法将字符串分成 N 个相等的部分。
6. 检查是否可以将字符串分成 n 个相等的部分。
7. 如果不能，则打印消息无效输入，再试一次。
8. 计算零件数量以找到分割点。
9. 使用 for 循环打印分割的字符串
10. 显示结果。
11. 停下来。

下面是用 Java 语言编写的相同代码。

//Java Program to divide a string into n equal parts
public class Main  
{ 
    // Method to divide a string into n equal parts
    static void divide(String str, int n) 
    { 

        int sub_size; 
        // Check whether the string can be divided into n equal parts  
        if (str.length() % n != 0) 
        { 
            System.out.println("Invalid Input"); 
            System.out.println("String size is not divisible by n"); 
            System.out.println("Try Again"); 
            return; 
        } 

        // Calculate the number of parts to find the division points 
        sub_size = str.length() / n; 

        for (int i = 0; i< str.length(); i++) 
        { 
            if(i % sub_size == 0) 
            System.out.println();  
            System.out.print(str.charAt(i)); 
        } 
    } 

    // Driver Code 
    public static void main(String[] args) 
    { 

        String str = "abcdefghijklmnopqr"; 
        System.out.println("The entered string is: "+str);
        int n=6;
        System.out.println("On dividing the entered string into "+ n +" equal parts, we have ");
        // Print n equal parts of the string 
        divide(str, n); 
    } 
} 

输入的字符串是:abcdefghijklmnopqr
在将输入的字符串分成 6 个相等的部分时，我们有
T3】ABC
def
GHI
jkl
MnO
pqr

程序 2:将一个字符串分成 N 个相等的部分

在这个程序中，我们将看到当字符串由用户定义时，如何将字符串分成 n 个相等的部分。在这里，我们首先要求用户输入字符串，然后将字符串分成 n 个相等的部分。

算法

1. 开始吧。
2. 声明一个字符串。
3. 请用户初始化它。
4. 为“N”声明一个变量。
5. 要求用户初始化变量。
6. 声明一个临时变量并将其初始化为 0。
7. 声明另一个变量来存储每个字符串中的字符数。
8. 声明一个新的String类型数组来存储字符串数组。
9. 检查是否可以将字符串分成 n 个相等的部分。
10. 如果不能，则打印消息无效输入，再试一次。
11. 如果可能的话，使用 for 循环。
12. 迭代字符串中的所有字符。
13. 使用子字符串将字符串分成 n 个相等的部分。
14. 打印所有分开的字符串。
15. 停下来。

下面是相同的 Java 语言代码。

//Java Program to divide the string into n equal parts
import java.util.*;

public class Main 
{  
    public static void main(String[] args) 
    {  
        //Take input from the user
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the string: ");
        String str = sc.nextLine();  
        //Enter the total number of parts 
        System.out.println("Enter the value of n: ");
        int n = sc.nextInt();  
        int temp = 0, chars = str.length()/n; 

        //Stores the array of string  
        String[] newStr = new String [n];  
        //Check whether a string can be divided into n equal parts  
        if(str.length() % n != 0) 
        {  
            System.out.println("Invalid Input"); 
            System.out.println("String size is not divisible by "+n); 
            System.out.println("Try Again"); 
        }  
        else 
        {  
            for(int i = 0; i < str.length() ; i = i+chars) 
            {  
                //Dividing string in n equal part using substring()  
                String part = str.substring(i, i+chars);  
                newStr[temp] = part;  
                temp++;  
            }  
               System.out.println("On dividing the entered string into "+ n +" equal parts, we have ");  
               for(int i = 0; i < newStr.length; i++) 
               {  
                   System.out.println(newStr[i]);  
               }  
            }  
        }  
} 

输入字符串:今晚学习
输入 n: 4 的值
将输入的字符串分成 4 等份，我们有
Stu
dyT
oni
ight

---

---

Java 程序：寻找字符串所有子集

原文：https://www.studytonight.com/java-programs/java-program-to-find-all-the-subsets-of-a-string

在本教程中，我们将学习如何打印字符串的所有子集。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:世界

输出:输入字符串的子集为:

W

O

稀有

L

D

吁

运筹学

RL

致死剂量

试题

回波损耗

右腿驱动

单词

奥尔德

世界

程序 1:查找字符串的所有子集

在这个程序中，我们将使用三个嵌套的 for 循环来打印字符串的所有子集。第一个 for 循环用于选择开始元素，第二个 for 循环用于选择结束元素，第三个 for 循环用于打印从开始到结束元素的选定元素。

算法

1. 开始
2. 声明一个字符串。
3. 要求用户初始化字符串
4. 将其转换为字符数组。
5. 调用一个方法来查找字符串的所有子集。
6. 对相同的循环使用三个。
7. 使用第一个 for 循环选择子集的起始索引。
8. 使用第二个 for 循环来保存子集的结束索引。
9. 使用第三个 for 循环打印所有子集。
10. 停下来。

下面是相同的 Java 语言代码。

//Java Program to Find all the subsets of a string
import java.util.*;
public class Main
{
    //To find all the subsets of a string
   static void subString(char str[], int n)
   {
        // To select starting point
        for (int t = 1; t <= n; t++) 
        {
            // To select ending point
            for (int i = 0; i <= n - t; i++) 
            {
                //  Print characters from selected
                // starting to end point.  
                int j = i + t - 1;
                for (int k = i; k <= j; k++) 
                {
                    System.out.print(str[k]);
                }

                System.out.println();
            }
        }
    } 
    // Driver program to test above function
    public static void main(String[] args) 
    {
        //Take input from the user
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the string is "+str1);
        String str1=sc.nextLine();
        char str[] = str1.toCharArray();
        System.out.println("All the substrings of the above string are: ");
        subString(str, str.length);
    }
}

输入字符串:代码
上述字符串的所有子字符串为:
C
o
d
e
Co
od
de
Cod
ode
Code

程序 2:查找字符串的所有子集

在这个程序中，我们将使用 substr()方法打印给定字符串的所有子集。str.substr(i，j)将从字符串中的索引 i 开始打印长度为 j 的子字符串。

算法

1. 开始
2. 声明一个字符串。
3. 初始化它。
4. 调用一个方法来查找输入字符串的所有子集。
5. 将字符串和字符串长度作为参数传递。
6. 对同一个循环使用两个。
7. 使用第一个 for 循环选择子集的起始索引。
8. 使用第二个 for 循环来保存子集的结束索引。
9. 打印所有子集。
10. 停下来。

下面是相同的 Java 语言代码。

//Java Program to Find all the subsets of a string
public class Main
{
    //To find all the subsets of a string
   static void subString(String str, int n)
   {
        for (int i = 0; i < n; i++)      //To select the starting index
        {
           for (int j = i+1; j <= n; j++)    //To select the ending index
            {
                System.out.println(str.substring(i, j));
            }
        }
    }
    // Driver program to test above function
    public static void main(String[] args) 
    {
        String str="Hello";
        System.out.println("The entered string are "+str);
        System.out.println("All the substrings of the above string is: ");
        //Call to find the all the subsets of the string
        subString(str, str.length());
    }
}

输入的字符串为 Hello
上述字符串的所有子字符串为:
H
He
Hel
Hell
Hello
e
El
ell
ello
l
ll
llo
l
lo
o

---

---

Java 程序：使用递归检查回文字符串

原文：https://www.studytonight.com/java-programs/java-program-to-check-palindrome-string-using-recursion

在本教程中，我们将学习如何使用递归函数检查字符串是否是回文。递归函数是调用自身的函数。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:妈妈

输出:输入的字符串是回文。

让我们看看这个程序，看看这个字符串是否是回文。

程序 1:使用递归检查回文字符串

在这个程序中，我们将学习如何使用递归检查一个字符串是否是回文。在这里，我们将要求用户输入字符串。然后，我们将调用一个单独的递归函数来检查该字符串是否是回文，如果输入的字符串不是空的。如果字符串是空的，那么它将打印出它是一个回文。

算法

1. 开始
2. 声明一个字符串变量。
3. 要求用户初始化字符串。
4. 调用函数检查字符串是否回文。
5. 如果一个字符串是空的，那么它就是一个回文。
6. 如果字符串不为空，则调用递归函数。
7. 如果只有一个字符，那么它就是回文。
8. 如果第一个和最后一个字符不匹配，那么它就不是回文。
9. 如果有多个字符，请检查中间的子字符串是否也是回文或者没有使用递归函数。
10. 打印结果。
11. 停下来。

下面是相同的 Java 语言代码。

/*Java Program to Check whether a String is a Palindrome or not using Recursive Function*/
import java.util.Scanner;
public class Main
{
    //Recursive function that checks 
    //whether the string is palindrome or not
    static boolean checkPalindrome(String str, int s, int e) 
    { 
        if (s == e)    // If there is only one character 
            return true;  
        // If first and last characters do not match 
        if ((str.charAt(s)) != (str.charAt(e))) 
            return false;   
        // If there are multiple characters, check if 
        // middle substring is also palindrome or not. 
        if (s < e + 1) 
            return checkPalindrome(str, s + 1, e - 1);   
        return true; 
    }   
    static boolean isPalindrome(String str) 
    { 
        int n = str.length();   
    // If string is empty,then it is palindrome 
        if (n == 0) 
            return true;   
        return checkPalindrome(str, 0, n - 1); 
    }   
    // Driver Code 
    public static void main(String args[]) 
    { 
        //Take input from the user
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the String :");
        String str = sc.nextLine();   //Input the string
        //Check whether palindrome or not
        if (isPalindrome(str)) 
            System.out.println(str+" is palindrome"); 
        else
            System.out.println(str+ " is not a palindrome"); 
    }   
}

输入字符串:哇
哇是回文

程序 2:使用递归检查回文字符串

在这个程序中，我们将学习如何使用递归检查一个字符串是否是回文。这里，一旦用户输入了字符串，我们将调用一个递归函数，通过比较子字符串的第一个和最后一个字符来检查它是否是回文。

算法

1. 开始
2. 声明一个字符串变量。
3. 要求用户初始化字符串。
4. 调用递归函数检查字符串是否回文。
5. 如果一个字符串是空的或者只有一个字符，那么它就是回文。
6. 如果有多个字符，则检查字符串的第一个和最后一个字符。
7. 如果字符串的第一个和最后一个字符相同，则对子字符串执行相同的操作，去掉第一个和最后一个字符。
8. 继续该过程，直到条件失败。
9. 显示结果。
10. 停下来。

下面是相同的 Java 语言代码。

/*Java Program to Check whether a String is a Palindrome or not using Recursive Function*/
import java.util.Scanner;
public class Main
{
    //Recursive function that checks 
    //whether the string is palindrome or not
    static boolean isPalindrome(String str) 
    { 
        //If string has 0 or 1 character
        if(str.length() == 0 || str.length() == 1)
            return true; 
        //If string has multiple characters
        //Check whether first and last characters are same or not
        if(str.charAt(0) == str.charAt(str.length()-1))
            return isPalindrome(str.substring(1, str.length()-1));
        return false;
    }   
    // Driver Code 
    public static void main(String args[]) 
    { 
        //Take input from the user
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the String :");
        String str = sc.nextLine();   //Input the string
        //Check whether palindrome or not
        if (isPalindrome(str)) 
            System.out.println(str+" is palindrome"); 
        else
            System.out.println(str+ " is not a palindrome"); 
    }     
}

输入字符串:hello
hello 不是回文

---

---

Java 程序：比较字符串

原文：https://www.studytonight.com/java-programs/java-program-to-compare-strings

在本教程中，我们将学习如何比较两个字符串。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:苹果

输入字符串:apple

输出:输入的两个字符串相等:假

程序 1:比较两个字符串

在这个程序中，我们将看到当字符串是用户定义的时，如何比较两个字符串。这意味着首先，我们将要求用户输入字符串，然后通过使用 equals()方法，我们将检查输入的字符串是否相等。

算法

1. 开始
2. 声明字符串
3. 请用户初始化它。
4. 使用 equals()方法比较两个字符串。
5. 打印输出。
6. 停止

下面是相同的 Java 语言代码。

//Java Program to compare two strings
import java.util.*;
public class Main
{
    // Driver program 
    public static void main(String[] args) 
    {
        //Take input from the user
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the string: ");
        String s1=sc.nextLine();        
        System.out.println("Enter the string: ");
        String s2=sc.nextLine();
        //Compare two strings
        System.out.println("Are the two strings equal?" + s1.equals(s2));      
    }
}

输入字符串:你好
输入字符串:你好
两个字符串相等吗？真实的

程序 2:比较两个字符串

在这个程序中，我们将看到当字符串被预定义时，如何比较两个字符串。这里，我们将使用==运算符来比较字符串。

算法

1. 开始
2. 声明两个字符串
3. 初始化它们。
4. 使用==运算符检查两个字符串是否相等。
5. 打印输出。
6. 停下来。

下面是相同的 Java 语言代码。

//Java Program to compare two strings
public class Main
{
   public static void main(String []args)
   {
      String s1 = "Study tonight";
      System.out.println("The entered string is "+s1);
      String s2 = "Study tonight";
      System.out.println("The entered string is "+s2);
      System.out.println("Are the two strings equal?");
      //Compare the strings using == operator
      if(s1 == s2)
      System.out.println("Yes the entered strings are equal ");
      else
      System.out.println("No the entered strings are not equal ");
   }
}

输入的弦是今晚学习
输入的弦是今晚学习
两根弦相等吗？
是，输入的字符串相等

程序 3:比较两个字符串

在这个程序中，我们将看到当字符串被预定义时，如何比较两个字符串。在这里，我们将使用不同的方法来比较字符串。

算法

1. 开始
2. 声明两个字符串
3. 初始化字符串
4. 首先，使用 equals()方法比较字符串。
5. 打印结果。
6. 现在，再次使用==运算符进行比较。
7. 这里，比较字符串和存储在另一个字符串中的值。
8. 显示输出。
9. 同样，使用==运算符来比较字符串。
10. 比较两个字符串。
11. 显示输出。
12. 同样，使用==运算符来比较字符串。
13. 这次比较存储在两个字符串变量中的值。
14. 打印结果。
15. 停下来。

下面是相同的 Java 语言代码。

//Java Program to compare two strings
public class Main
{
   public static void main(String []args)
   {   
        String str1 = new String("Study Tonight");
        System.out.println("The entered string is: "+str1);
        String str2 = new String("Study Tonight");
        System.out.println("The entered string is: "+str2);        
        System.out.println("Are the two strings equal? (using equals() method)");
        boolean result = str1.equals("Study Tonight"); // true
        System.out.println(result);
        System.out.println("Are the two strings equal? (Comparing by using == )");
        result = str2 == "Study Tonight"; // false
        System.out.println(result);
        System.out.println("Are the two strings equal? (Comparing by using == )");
        result = str1 == str2; // false
        System.out.println(result);
        System.out.println("Are the two strings equal? (Comparing Both Strings)");
        result = "Study Tonight" == "Study Tonight"; // true
        System.out.println(result);
    }
}

输入的弦是:今晚学习
输入的弦是:今晚学习
两根弦相等吗？(使用 equals()方法)
真
两根弦相等吗？(使用)比较
假
两个字符串相等吗？(使用)比较
假
两个字符串相等吗？(比较两个字符串)
真

程序 4:比较两个字符串

在这个程序中，我们将看到当字符串被预定义时，如何比较两个字符串。这里，我们将使用 compareTo()方法来比较字符串。这里需要注意的一点是，如果字符串相等，compareTo 返回 0。

算法

1. 开始
2. 声明两个字符串
3. 初始化它们。
4. 使用 compareTo()方法检查两个字符串是否相等。
5. 打印输出。
6. 停下来。

下面是相同的 Java 语言代码。

//Java Program to compare two strings
public class Main
{
   public static void main(String []args)
   {      
        String str1 = new String("Study Tonight");
        System.out.println("The entered string is: "+str1);
        String str2 = new String("Study Tonight");
        System.out.println("The entered string is: "+str2);
        System.out.println("Are the two strings equal?");
        System.out.println( str1.compareTo(str2) );
    }
}

输入的弦是:今晚学习
输入的弦是:今晚学习
两根弦相等吗？
0

---

---

Java 程序：使用递归反转字符串

原文：https://www.studytonight.com/java-programs/java-program-to-reverse-a-string-using-recursion

在本教程中，我们将学习如何使用递归函数反转字符串。递归函数是调用自身的函数。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:字符串

输出:字符串的反转为:gnirtS

程序 1:使用递归反转字符串

在这个程序中，我们将看到如何使用带有用户定义字符串的递归来反转字符串。在这里，我们将要求用户输入字符串，然后我们将通过递归调用函数来反转该字符串，最后将打印反转的字符串。

算法

1. 开始
2. 声明一个字符串。
3. 要求用户初始化字符串。
4. 调用递归函数来反转字符串。
5. 如果字符串为空或由单个字符组成，则打印输入的字符串。
6. 如果字符串由多个字符组成，则递归调用函数来反转字符串。
7. 打印反转的字符串。
8. 停下来。

下面是相同的 Java 语言代码。

/*Java Program to reverse a string using Recursive Function*/
import java.util.Scanner;
public class Main
{
    //Recursive function that reverses a string
    static void reverse(String str) 
    { 
        //If the string is null or consists of single character
        //then print the entered string 
        if ((str==null)||(str.length() <= 1)) 
           System.out.println(str); 
        else
        { 
            //If string consists of multiple strings
            System.out.print(str.charAt(str.length()-1)); 
            //Call the function recursively to reverse the string
            reverse(str.substring(0,str.length()-1)); 
        }         
    }   
    // Driver Code 
    public static void main(String args[]) 
    { 
        //Take input from the user
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the String :");
        String str = sc.nextLine();   //Input the string
        //Call a recursive function to reverse the string
        System.out.println("The reverse of the entered the String :");
        reverse(str); 
    }     
}

进入字符串:
你好世界
进入字符串的反义词:
dlrow olleh

程序 2:使用递归反转字符串

在这个程序中，我们将看到如何使用带有用户定义字符串的递归来反转字符串。在这里，我们将要求用户输入字符串，然后我们将通过递归调用函数来反转该字符串，并将返回反转后的字符串。最后，显示反转的字符串。

算法

1. 开始
2. 声明一个字符串。
3. 初始化它。
4. 调用递归函数来反转字符串。
5. 如果字符串为空，即如果字符串为空，则返回相同的字符串。
6. 如果字符串有多个字符，则递归调用函数来反转字符串。
7. 返回反转的字符串。
8. 打印反转的字符串。
9. 停下来。

下面是相同的 Java 语言代码。

/*Java Program to reverse a string using Recursive Function*/
import java.util.Scanner;
public class Main
{
    //Driver Code
    public static void main(String[] args) 
    {
        //Take input from the user
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the String :");
        String str = sc.nextLine();   //Input the string
        //Call a recursive function to reverse the string
        String rev=reverseString(str);
        System.out.println("The reverse of the entered the String :"+rev);

    }
    //Recursive Function to Reverse the String
    public static String reverseString(String str)
    {
        //If entered string is empty
        //Return the empty string
        if (str.isEmpty())
            return str;
        //If string consists of multiple character    
        //Call the Function Recursively
        return reverseString(str.substring(1)) + str.charAt(0);
    }
}

输入字符串:世界
输入字符串的反方:dlroW

程序 3:使用递归反转字符串

在这个程序中，我们将看到如何使用带有预定义字符串的递归来反转字符串。

算法

1. 开始
2. 声明一个字符串。
3. 初始化它。
4. 调用递归函数来反转字符串。
5. 如果字符串为空，即如果字符串为空，则返回相同的字符串。
6. 如果字符串有多个字符，则递归调用函数来反转字符串。
7. 打印反转的字符串。
8. 停下来。

下面是相同的 Java 语言代码。

/*Java Program to reverse a string using Recursive Function*/
public class Main
{
    //Driver Code
    public static void main(String[] args) 
    {
        //Initialize the String
        String str = "Reverse String";
        System.out.println("The entered string is: " + str);
        String rev = reverseString(str);
        System.out.println("The reversed string is: " + rev);
    }
    //Recursive Function to Reverse the String
    public static String reverseString(String str)
    {
        //If entered string is empty
        //Return the empty string
        if (str.isEmpty())
            return str;
        //If string consists of multiple character    
        //Call the Function Recursively
        return reverseString(str.substring(1)) + str.charAt(0);
    }
}

输入的字符串是:反向字符串
反向字符串是:gnirtS esreveR

---

---

Java 程序：计算字符串中字符总数

原文：https://www.studytonight.com/java-programs/java-program-to-count-the-total-number-of-characters-in-a-string

在本教程中，我们将学习如何计算字符串中的字符总数。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:Hello World

输出:字符串中的字符总数为:10

上述问题可以通过三种方式解决:

方法 1:使用 for 循环

方法 2:使用 while 循环

方法 3:使用边做边循环

让我们分别看看这些方法。

程序 1:计算字符串中的字符总数

在这个程序中，我们将找到带有预定义值的字符串中的字符总数。这里，我们将使用 for 循环来计算字符串中的字符总数。

算法:

1. 开始
2. 声明一个字符串。
3. 初始化字符串。
4. 声明一个变量来计算给定字符串中的字符总数，并将其初始化为 0。
5. 使用 for 循环进行计算。
6. 使用 if 条件来避免计算空间。
7. 每次角色遇到时增加计数。
8. 打印给定字符串中的字符总数。
9. 停下来。

下面是相同的代码。

/*Java Program to count the total number of characters in a string using a for loop*/
public class Main
{
  public static void main(String[] args) 
  {    
        String str = "Hello World";    
        int count = 0;    
        System.out.println("The entered string is: "+str);    
        //Count the characters in the string except space    
        for(int i = 0; i < str.length(); i++) 
        {    
            if(str.charAt(i) != ' ')    
                count++;    
        }                
        //Displays the total number of characters in the string    
        System.out.println("Total number of characters in the string: " + count);    
    }      
}

输入的字符串为:Hello World
字符串中的字符总数:10

程序 2:计算字符串中的字符总数

在这个程序中，我们将找到带有用户定义值的字符串中的字符总数。在这里，我们将要求用户输入值，然后使用 while 循环来计算字符串中的字符总数。

算法

1. 开始吧。
2. 声明一个变量来计算给定字符串中的字符总数，并将其初始化为 0。
3. 声明一个字符串，并要求用户初始化它。
4. 使用 while 循环计算给定字符串中的字符总数。
5. 使用 if 条件避免计算空格。
6. 如果字符遇到，递增计数变量。
7. 打印给定字符串中的字符总数。
8. 停下来。

下面是相同的 Java 语言代码。

/*Java Program to count the total number of characters in a string using a while loop*/
import java.util.*;
public class Main
{
  public static void main(String[] args) 
  {    
        //Take input from the user
        Scanner sc=new Scanner(System.in);    
        int count = 0,i=0;    
        System.out.print("Please Enter a String to Count Characters =  ");
		String str = sc.nextLine();
		//Use a while loop to calculate the total characters in the string
		while(i < str.length())
		{
			if(str.charAt(i) != ' ') 
			{
				count++;
			}
			i++;
		}		
		System.out.println("\nThe Total Number of Characters  =  " + count);        
    }      
}

请输入一个字符串来计算字符数=计算字符串长度
字符总数= 24

程序 3:计算字符串中的字符总数

在这个程序中，我们将找到带有用户定义值的字符串中的字符总数。在这里，我们将要求用户输入值，然后我们将使用 do-while 循环来计算字符串中的字符总数。

算法

1. 开始吧。
2. 声明一个字符串。
3. 声明一个变量来计算字符串中的字符总数，并将其初始化为 0。
4. 要求用户初始化字符串。
5. 使用 do-while 循环计算字符串中的字符总数。
6. do-while 循环检查条件 I < str . length()；并执行循环，直到给定条件变为真。
7. 使用 if 条件来避免计算空间。
8. 打印给定字符串中的字符总数。
9. 停下来。

下面是相同的 Java 语言代码。

/*Java Program to count the total number of characters in a string using a do-while loop*/
import java.util.*;
public class Main
{
  public static void main(String[] args) 
  {    
        //Take input from the user
        Scanner sc=new Scanner(System.in);    
        int count = 0,i=0;    
        System.out.println("Please Enter a String to Count Characters =  ");
		String str = sc.nextLine();
		//Use a while loop to calculate the total characters
		do 
		{
           if(str.charAt(i)!=' ')
           {
              // this condition is used to avoid counting space
              count++;
           }
            i++;
        }while(i<str.length());
        //Print the total number of characters in the given string
        System.out.print("The total number of character in a string:"+count);
    }      
}

请输入一个字符串来计数字符=这是一个边做边循环的例子
一个字符串中的字符总数:30

---

---

Java 程序：计算字符串中元音和辅音总数

原文：https://www.studytonight.com/java-programs/java-program-to-count-the-total-number-of-vowels-and-consonants-in-a-string

在本教程中，我们将学习如何计算一个字符串中元音的总数和计数。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:今晚学习

输出:元音总数为 3

程序 1:计算一个字符串中元音和辅音的总数

在这个程序中，我们将看到当字符串在程序中被预定义时，如何计算一个字符串中元音和计数的总数。

算法

1. 开始
2. 声明字符串
3. 初始化它。
4. 将字符串转换为小写。
5. 声明两个变量(用于元音计数的 vcount 和用于辅音计数的 ccount)来计算字符串中的元音和辅音，并将其初始化为 0。
6. 使用 for 循环遍历字符串的每个字符。
7. 使用 if 条件检查是否有任何字符与字母表中的元音匹配。
8. 如果遇到任何元音，则增加 vcount。
9. 否则，如果遇到任何辅音，则增加计数。
10. 显示两个计数变量的值。
11. 停下来。

下面是相同的 Java 语言代码。

//Java Program to find the total number of vowels and consonants with pre-defined values
public class Main
{
     public static void main(String []args)
     {
        String str="Study Tonight";    //Given String
        System.out.println("The String is: "+str);

        int vcount=0,ccount=0;    //Variables to count the vowels and consonants
        str=str.toLowerCase();    //Convert the string to lowercase        
        for(int i=0;i<str.length();i++)
        {
            if(str.charAt(i)=='a' || str.charAt(i)=='e' || str.charAt(i)=='i' || str.charAt(i)=='o' || str.charAt(i)=='u')
            vcount++;  //Increment each time vowel encounters
            else if(str.charAt(i) >= 'a' && str.charAt(i)<='z')
            ccount++;   //Increment each time consonant encounters
        }        
        //Print the total number of vowels
        System.out.println("The total number of vowels is: "+vcount);
        //Print the total number of consonants
        System.out.println("The total number of consonants is: "+ccount);        
     }
}

字符串为:今晚学习
元音总数为:3
辅音总数为:9

程序 2:计算一个字符串中元音和辅音的总数

在这个程序中，我们将看到当字符串是用户定义的时，如何计算字符串中元音和计数的总数。这意味着，这里我们将要求用户初始化字符串，然后我们将统计输入字符串的元音和辅音的总数。

算法

1. 开始
2. 声明字符串
3. 要求用户初始化字符串。
4. 将字符串转换为小写。
5. 声明两个变量(用于元音计数的 vcount 和用于辅音计数的 ccount)来计算字符串中的元音和辅音，并将其初始化为 0。
6. 使用 for 循环遍历字符串的每个字符。
7. 使用 if 条件检查是否有任何字符与字母表中的元音匹配。
8. 如果遇到任何元音，则增加 vcount。
9. 否则，如果遇到任何辅音，则增加计数。
10. 显示两个计数变量的值。
11. 停下来。

下面是相同的 Java 语言代码。

//Java Program to find the total number of vowels and consonants with user-defined values
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
         //Take input from the user
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the String: ");
        String str=sc.nextLine();    //Initialize the String        
        int vcount=0,ccount=0;    //Variables to count the vowels and consonants
        str=str.toLowerCase();    //Convert the string to lowercase        
        for(int i=0;i<str.length();i++)
        {
            if(str.charAt(i)=='a' || str.charAt(i)=='e' || str.charAt(i)=='i' || str.charAt(i)=='o' || str.charAt(i)=='u')
            vcount++;  //Increment each time vowel encounters
            else if(str.charAt(i) >= 'a' && str.charAt(i)<='z')
            ccount++;   //Increment each time consonant encounters
        }        
        //Print the total number of vowels
        System.out.println("The total number of vowels is: "+vcount);
        //Print the total number of consonants
        System.out.println("The total number of consonants is: "+ccount);        
     }
}

入弦:今晚学习
元音总数为:3
辅音总数为:9

---

---

Java 程序：从字符串中删除所有空白

原文：https://www.studytonight.com/java-programs/java-program-to-remove-all-the-white-space-from-the-string

在本教程中，我们将学习如何从字符串中删除空格。这可以通过首先遍历字符串，然后检查字符串中是否有任何字符与空白字符匹配来实现。

如果有匹配的，那么任何内置的方法，比如 replace()都可以用来删除空白。这也可以通过使用循环来完成。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:今晚学习

输出:去除空格后输入的字符串为:今晚学习

让我们看看例子，以便更好地理解。

程序 1:删除字符串中的空格

在这个程序中，我们将看到当字符串是用户定义的时候，如何从字符串中删除所有的空白。在这里，我们将要求用户输入一个字符串，然后我们将从字符串中删除空格。

算法

1. 开始

2. 声明字符串

3. 要求用户初始化字符串。

4. 使用 replaceAll 删除查找所有空白字符(制表符、空格、换行符等)的正则表达式\s。)在字符串中加上" "(空格文字)。

5. 打印字符串

6. 停止

下面是从字符串中删除空白的 Java 代码。

//Java Program to remove all the whitespace from a string
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
         //Take input from the user
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the String :");
        String str=sc.nextLine();    //Initialize the String

        str = str.replaceAll("\\s", ""); 

        System.out.println("After Removing Whitespaces the entered string is:"+str); 
     }
}

输入字符串:今晚学习
删除空格后，输入的字符串是:今晚学习

程序 2:删除字符串中的空格

在这个程序中，我们将看到当字符串在程序中被预定义时，如何删除字符串中的所有空白。

算法

1. 开始

2. 声明字符串

3. 初始化它。

4. 使用 replaceAll 删除查找所有空白字符(制表符、空格、换行符等)的正则表达式\s。)在字符串中加上" "(空格文字)。

5. 打印字符串

6. 停止

下面是从字符串中删除空白的 Java 代码。

//Java Program to remove all the whitespace from a string
public class Main
{
     public static void main(String []args)
     {
        String str="Study   Tonight ";
        System.out.println("The entered string is: "+str);        
        str = str.replaceAll("\\s", ""); 
        System.out.println("After Removing Whitespaces the entered string is: "+str); 
     }
}

输入的字符串是:今晚学习
删除空格后，输入的字符串是:今晚学习

程序 3:在 Java 中删除字符串中的空白

在这个程序中，我们将看到当字符串是用户定义的时候，如何从字符串中删除所有的空白。在这里，我们将要求用户输入一个字符串，然后通过将其转换为字符数组来删除字符串中的空格。

算法

1. 开始

2. 声明字符串

3. 要求用户初始化字符串。

4. 将字符串转换为字符数组

5. 声明一个 StringBuffer 变量。

6. 使用 for 循环遍历字符串的所有字符

7. 使用 if 条件检查空格。

8. 如果找到了，则使用追加字符串。

9. 将字符串缓冲区转换为字符串

10. 打印字符串。

11. 停止

下面是从字符串中删除空白的 Java 代码。

//Java Program to remove all the whitespace from a string
import java.util.*;
public class Main
{
     public static void main(String []args)
     {
        //Take input from the user
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the String :");
        String str=sc.nextLine();    //Initialize the String

        char[] strArray = str.toCharArray();  
        StringBuffer stringBuffer = new StringBuffer();  
        for (int i = 0; i < strArray.length; i++) 
        {  
            if ((strArray[i] != ' ') && (strArray[i] != '\t')) 
            {  
                stringBuffer.append(strArray[i]);  
            }  
        }  
        //Print the string after the removal of white space
        String noSpaceStr2 = stringBuffer.toString();  
        System.out.println("Removing all the white space from the string is: "+noSpaceStr2);  

     }
}

输入字符串:移除空白示例
从字符串中移除所有空白示例为:移除空白示例

---

---

Java 程序：计算字符串中字符频率

原文：https://www.studytonight.com/java-programs/java-program-to-find-the-frequency-of-character-in-string

在本教程中，我们将学习如何计算字符串中字符的频率。这意味着我们将计算字符串中哪个字符出现了多少次。

这可以通过先遍历字符串，然后计算字符出现的次数来实现。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。

输入:输入字符串:今晚学习

输出:字符及其对应的频率:

字符=频率

S = 1

t = 2

u = 1

d = 1

y = 1

T = 1

o = 1

n = 1

i = 1

g = 1

h = 1

程序 1:计算字符串中字符的频率

在这个程序中，我们将看到当字符串在程序中被预定义时，如何计算字符串中字符的频率。

算法

1. 开始

2. 声明字符串

3. 初始化它。

4. 使用频率数组存储每个字符的频率。

5. 将字符串转换为字符数组

6. 使用两个 for 循环来计算每个元素的频率。

7. 使用第一个 for 循环遍历数组的每个字符。

8. 将频率数组的每个元素初始化为 1。

9. 使用另一个 for 循环遍历剩余的字符。

10. 检查元素的总出现次数。

11. 如果元素再次出现，则增加频率数组中的值。

12. 将字符数组设置为 0，以避免计算访问的字符。

13. 打印字符及其对应的频率。

14. 停下来。

下面是计算 Java 字符串中字符频率的 Java 代码。

/*Java Program to find the frequency of characters in a string*/
public class Main  
{  
     public static void main(String[] args) 
     {  
        String str = "Study Tonight";  
        int[] freq = new int[str.length()];  
        System.out.println("The entered string is "+str);
        //Convert the given string into character array  
        char str1[] = str.toCharArray();            
        for(int i = 0; i <str.length(); i++) 
        {  
            freq[i] = 1;  
            for(int j = i+1; j <str.length(); j++) 
            {  
                if(str1[i] == str1[j])
                {  
                    freq[i]++;  

                    //Set str1[j] to 0 to avoid printing visited character  
                    str1[j] = '0';  
                }  
            }  
        }            
        //Displays the characters and their corresponding frequency  
        System.out.println("Frequencies of the characters in the string are as below: "); 
        System.out.println("Characters  frequencies");  
        for(int i = 0; i <freq.length; i++) 
        {  
            if(str1[i] != ' ' && str1[i] != '0')  
                System.out.println(str1[i] + "              " + freq[i]);  
        }  
    }  
} 

输入的字符串为今晚学习
字符串中字符的频率如下:
字符频率
S1
T2
u1
D1
y 1
T1
o 1
n1
I 1
G1
h 1

程序 2:计算字符串中字符的频率

在这个程序中，我们将看到当字符串是用户定义的时，如何计算字符串中字符的频率。这里，在这个程序中，我们将要求用户输入一个字符串，然后我们将计算字符串中字符的频率。

算法

1. 开始

2. 声明字符串

3. 请用户初始化它。

4. 使用频率数组存储每个字符的频率。

5. 将字符串转换为字符数组

6. 使用两个 for 循环来计算每个元素的频率。

7. 使用第一个 for 循环遍历数组的每个字符。

8. 将频率数组的每个元素初始化为 1。

9. 使用另一个 for 循环遍历剩余的字符。

10. 检查元素的总出现次数。

11. 如果元素再次出现，则增加频率数组中的值。

12. 将字符数组设置为 0，以避免计算访问的字符。

13. 打印字符及其对应的频率。

14. 停下来。

下面是计算 Java 字符串中字符频率的 Java 代码。

/*Java Program to find the frequency of characters in a string*/
import java.util.Scanner;
public class Main  
{  
     public static void main(String[] args) 
     {  
         //Take input from the user
        Scanner sc=new Scanner(System.in); 
        System.out.println("Enter the  string is: "); 
        String str = sc.nextLine();         
        int[] freq = new int[str.length()];   //Frequency array to store the frequency of each character
        //Convert the given string into character array  
        char str1[] = str.toCharArray();            
        for(int i = 0; i <str.length(); i++) 
        {  
            freq[i] = 1;  
            for(int j = i+1; j <str.length(); j++) 
            {  
                if(str1[i] == str1[j])
                {  
                    freq[i]++;  

                    //Set str1[j] to 0 to avoid printing visited character  
                    str1[j] = '0';  
                }  
            }  
        }            
        //Displays the characters and their corresponding frequency  
        System.out.println("Frequencies of the characters in the string are as below: "); 
        System.out.println("Characters  frequencies");  
        for(int i = 0; i <freq.length; i++) 
        {  
            if(str1[i] != ' ' && str1[i] != '0')  
                System.out.println(str1[i] + "              " + freq[i]);  
        }  
    }  
} 

输入字符串为:字符频率计数
字符串中字符的频率如下:
字符频率
C2
h1
a2
r 3
C2
t 2
e 3
s 1
F 1
q 1
u 2
n 2
y 1
o 1

---

---

Java 示例

Java LocalDate类

Java LocalDate.atStartOfDay()方法示例

原文：https://www.studytonight.com/java-examples/java-localdate-atstartofday-method-with-examples

Java atStartOfDay()方法属于LocalDate类。此方法用于将日期与该日期开始时的午夜时间相结合。

此方法不接受任何参数，并返回从午夜时的日期形成的 LocalDateTime。下面给出了该方法的语法。

句法

public LocalDateTime atStartOfDay()

返回:

它返回该日期开始时午夜的本地日期时间。

现在，让我们举一些例子来理解这个方法的功能。

示例:结合日期和开始时间

这里我们使用 Java now()方法获取当前日期，然后调用atStartOfDay()方法将日期和一天的开始时间结合起来。

import java.time.LocalDate;
import java.time.LocalDateTime;

public class Demo {  
	public static void main(String[] args){  

		// Getting date of today
		LocalDate localDate = LocalDate.now();
		// Displaying date
		System.out.println("Today's Date: \n"+localDate);
		// Getting todays start time
		LocalDateTime localDateTime = localDate.atStartOfDay();
		// Displaying date and time of start of today
		System.out.println("Today's Date with time: \n"+localDateTime);
	}
} 

今日日期:
2020-05-28
今日日期与时间:
2020-05-28 00:00

示例:结合特定日期和开始时间

如果我们想获得任何特定日期的开始时间(午夜时间)，那么只需使用LocalDate类的of()方法创建一个日期，然后组合时间。这里我们使用的是返回本地日期时间的atStartOfDay()方法。

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;

public class Demo {  
	public static void main(String[] args){  

		// Getting a date
		LocalDate localDate = LocalDate.of(2018, Month.JANUARY, 18);
		// Displaying date
		System.out.println("Date: \n"+localDate);
		// Getting start time of the date
		LocalDateTime localDateTime = localDate.atStartOfDay();
		// Displaying date and time of start of the date
		System.out.println("Date with start time: \n"+localDateTime);
	}
} 

日期:
2018-01-18
开始时间日期:
2018-01-18T00:00

实时示例:

在这里，您可以测试实时代码示例。您可以执行示例，甚至可以编辑和编写自己的示例来测试 Java 代码。

---

---

Java LocalDate.atStartOfDay(ZoneId)方法

原文：https://www.studytonight.com/java-examples/java-localdate-atstartofday-method-with-time-zone

Java atStartOfDay(ZoneId)方法用于根据时区将开始时间(午夜时间)与指定日期相结合。此方法返回分区日期时间，而不是本地日期时间。

它根据时区中的规则，从最早有效时间的该日期返回分区日期时间。下面给出了该方法的语法。

句法

public ZonedDateTime atStartOfDay(ZoneId zone)

因素

它采用单个参数作为区域 id。

返回:

它从最早有效时间的该日期返回基于分区的日期时间。

例 1:

让我们根据指定的时区获取日期的午夜时间。在这里，我们将时区 id 传递给atStartOfDay()方法，并获得分区日期时间。我们可以指定区域，或者让它在系统上自动检测。

import java.time.LocalDate;
import java.time.Month;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Demo {  
	public static void main(String[] args){  

		// Getting a date
		LocalDate localDate = LocalDate.of(2018, Month.JANUARY, 18);
		// Displaying date
		System.out.println("Date: \n"+localDate);
		// Getting start time of the date
		ZonedDateTime localDateTime = localDate.atStartOfDay(ZoneId.of("Asia/Kolkata"));
		// Displaying date and time of start of the date
		System.out.println("Date with start time: \n"+localDateTime);
	}
} 

日期:
2018-01-18
开始时间日期:
2018-01-18T00:00+05:30【亚洲/加尔各答】

例 2:

如果我们不想手动指定时区，那么使用systemDefault()方法设置默认时区。在本例中，我们使用系统默认区域 id 并获取本地日期时间

import java.time.LocalDate;
import java.time.Month;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Demo {  
	public static void main(String[] args){  

		// Getting a date
		LocalDate localDate = LocalDate.of(2018, Month.JANUARY, 18);
		// Displaying date
		System.out.println("Date: \n"+localDate);
		// Getting start time of the date
		ZonedDateTime localDateTime = localDate.atStartOfDay(ZoneId.systemDefault());
		// Displaying date and time of start of the date
		System.out.println("Date with start time: \n"+localDateTime);
	}
} 

日期:
2018-01-18
开始时间日期:
2018-01-18T00:00+05:30【亚洲/加尔各答】

实时示例:

这里，我们有一个真实的 java 例子。您可以为期望的结果执行它并测试您的代码。

---

---

Java LocalDate.atTime()方法及示例

原文：https://www.studytonight.com/java-examples/java-localdate-attime-method-with-examples

atTime()方法用于将该日期与时间相结合。它接受两个参数，并返回一个本地日期时间。

我们可以使用日期和时间的所有可能的有效组合来创建日期。下面给出了该方法的语法。

句法

public LocalDateTime atTime(int hour, int minute)

因素

小时 -一天中要使用的小时，从 0 到 23

分钟 -使用的小时分钟，从 0 到 59

返回

从该日期和指定时间形成的本地日期时间。

示例:

我们使用 LocalDate 类创建一个日期，然后使用atTime()方法将时间和它结合起来。这个方法返回日期和时间，见下面的例子。

import java.time.LocalDate;
import java.time.LocalDateTime;

public class Demo {  
	public static void main(String[] args){  

		// Take a date
		LocalDate localDate1 = LocalDate.of(2018, 2, 20);
		// Displaying date
		System.out.println("Date is : "+localDate1);
		// using atTime() method
		LocalDateTime localDateTime = localDate1.atTime(12,25);
		System.out.println("Date with local time: "+localDateTime);
	}
} 

日期为:2018-02-20
日期与当地时间:2018-02-20T12:25

示例:

atTime()方法有一个重载的方法，它采用了 LocalTime 类的一个实例。当我们想要创建一个全职的日期时，这很有用。见下面的例子。

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo {  
	public static void main(String[] args){  

		// Take a date
		LocalDate localDate1 = LocalDate.of(2018, 2, 20);
		// Displaying date
		System.out.println("Date is : "+localDate1);
		// Getting a full time
		LocalTime time = LocalTime.parse("12:10:20");
		// using atTime() method
		LocalDateTime localDateTime = localDate1.atTime(time);
		System.out.println("Date with local time: "+localDateTime);
	}
}

日期为:2018-02-20
日期与当地时间:2018-02-20T12:10:20

实时示例:

尝试一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.isAfter()方法及示例

原文：https://www.studytonight.com/java-examples/java-localdate-isafter-method-with-examples

isAfter()方法用于检查该日期是否在指定日期之后。我们可以用它来检查日期是否早于指定日期。

该方法属于LocalDate类，位于**java.time**包中。下面给出了该方法的语法。

句法

public boolean isAfter(ChronoLocalDate other)

参数:

它只接受一个 ChronoLocalDate 类型的参数。

返回:

它返回真或假的布尔值。

例子

让我们举个例子来检查一个日期是否早于另一个指定的日期。这里我们有两个日期，并使用isAfter()方法进行检查。

import java.time.LocalDate;

public class Demo {  
	public static void main(String[] args){  

		// Take a date
		LocalDate localDate1 = LocalDate.of(2018, 2, 20);
		// Take another date
		LocalDate localDate2 = LocalDate.of(2018, 8, 10);
		// Displaying date
		System.out.println("is "+localDate1+" older than "+localDate2+": "+localDate1.isAfter(localDate2));
		// Displaying date
		System.out.println("is "+localDate2+" older than "+localDate1+": "+localDate2.isAfter(localDate1));
	}
} 

比 2018-08-10 大 2018-02-20:假
比 2018-02-20 大 2018-08-10:真

示例:

假设两个日期相同，那么使用isAfter()方法将总是返回假。

import java.time.LocalDate;

public class Demo {  
	public static void main(String[] args){  

		// Take a date
		LocalDate localDate1 = LocalDate.of(2018, 2, 20);
		// Take another date
		LocalDate localDate2 = LocalDate.of(2018, 2, 20);
		// Displaying date
		System.out.println("is "+localDate1+" older than "+localDate2+": "+localDate1.isAfter(localDate2));
		// Displaying date
		System.out.println("is "+localDate2+" older than "+localDate1+": "+localDate2.isAfter(localDate1));
	}
} 

比 2018-02-20 大 2018-02-20:假
比 2018-02-20 大 2018-02-20:假

实时示例:

尝试一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.CompareTo()方法

原文：https://www.studytonight.com/java-examples/java-localdate-compareto-method

compareTo()方法用于比较一个日期和另一个日期。它返回一个整数值，并以CronoLocalDate的一个实例作为参数。这个方法对于比较 Java 应用中的两个日期很有用。下面给出了该方法的语法。

句法

public int compareTo(ChronoLocalDate otherdate) 

因素

其他日期:另一个要比较的日期

返回

如果日期小于，则返回负值；如果大于，则返回正值

示例:

如果指定日期小于日期，compareTo()方法返回负整数。在本例中，我们有两个日期，并使用compareTo()检查指定日期是否早于其他日期。

import java.time.LocalDate;

public class Demo {  
	public static void main(String[] args){  

		// Take a date
		LocalDate localDate1 = LocalDate.of(2018, 2, 20);
		// Displaying date
		System.out.println("First Date is : "+localDate1);
		// Take another date
		LocalDate localDate2 = LocalDate.of(2018, 2, 22);
		// Displaying date
		System.out.println("Another Date is : "+localDate2);
		// Using compareTo() method
		int val = localDate1.compareTo(localDate2);
		System.out.println(val);
	}
} 

第一个日期为:2018-02-20
另一个日期为:2018-02-22
日期，当地时间:-2

示例:

如果指定日期大于该日期，则返回正整数。您可以注意到下面的示例返回了两个日期之差的正整数。

import java.time.LocalDate;

public class Demo {  
	public static void main(String[] args){  

		// Take a date
		LocalDate localDate1 = LocalDate.of(2018, 2, 20);
		// Displaying date
		System.out.println("First Date is : "+localDate1);
		// Take another date
		LocalDate localDate2 = LocalDate.of(2018, 2, 22);
		// Displaying date
		System.out.println("Another Date is : "+localDate2);
		// Using compareTo() method
		int val = localDate2.compareTo(localDate1);
		System.out.println(val);
	}
}

首日为:2018-02-20
另一日为:2018-02-22
2

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.equals()方法

原文：https://www.studytonight.com/java-examples/java-localdate-equals-method

equals()方法用于检查该日期是否等于另一个日期。它只需要Object``Class类型的一个参数，这实际上是我们想要比较的一个日期。下面给出了该方法的语法。

句法

public boolean equals(Object obj)

因素

obj -另一个检查相等的日期

返回

如果日期相等，则返回 true，否则返回 fale。

示例:

import java.time.LocalDate;

public class Demo {  
	public static void main(String[] args){  

		// Take a date
		LocalDate localDate1 = LocalDate.of(2018, 2, 20);
		// Displaying date
		System.out.println("First Date is : "+localDate1);
		// Take another date
		LocalDate localDate2 = LocalDate.of(2018, 2, 22);
		// Displaying date
		System.out.println("Another Date is : "+localDate2);
		// Using equals() method
		boolean val = localDate2.equals(localDate1);
		System.out.println(val);
	}
}

第一个日期是:2018-02-20
另一个日期是:2018-02-22
假

示例:

import java.time.LocalDate;

public class Demo {  
	public static void main(String[] args){  

		// Take a date
		LocalDate localDate1 = LocalDate.of(2018, 2, 20);
		// Displaying date
		System.out.println("First Date is : "+localDate1);
		// Take another date
		LocalDate localDate2 = LocalDate.of(2018, 2, 20);
		// Displaying date
		System.out.println("Another Date is : "+localDate2);
		// Using equals() method
		boolean val = localDate2.equals(localDate1);
		System.out.println(val);
	}
}

首日为:2018-02-20
另一日为:2018-02-20
真

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.format()方法示例

原文：https://www.studytonight.com/java-examples/java-localdate-format-method-with-examples

此方法用于将日期格式化为指定的格式。格式化日期需要一个参数DateTimeFormatter，并返回一个日期字符串。比如我们有一个 yyyy/mm/dd 格式的日期，想转换成 dd/mm/yyyy 格式，那么这个方法是有帮助的。方法的语法声明如下。

句法

public String format?(DateTimeFormatter formatter)

参数:

格式化器 -指定日期格式。

返回:

它返回一个格式化的日期字符串。

示例:格式化日期

让我们举一个格式化日期的例子，这里我们使用ofPattern()方法来指定格式模式，并在上面调用format()方法。它返回一个日期字符串。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class DateDemo {
public static void main(String[] args){  

		// Take a date
	    LocalDate date = LocalDate.parse("2018-02-03");
		// Displaying date
		System.out.println("Date : "+date);
		// Formatting Date
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/YYYY");
        String localDate = formatter.format(date);
        System.out.println("Date2 : "+localDate);

	}
}

日期:2018-02-03
日期 2 : 03/02/2018

示例:格式化当前日期

如果我们想格式化当前系统日期，那么只需使用now()方法获取当前日期，然后调用format()方法。见下面的例子。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class DateDemo {
public static void main(String[] args){  

		// Take a date
	    LocalDate date = LocalDate.now();
		// Displaying date
		System.out.println("Date : "+date);
		// Formatting Date
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/YYYY");
        String localDate = formatter.format(date);
        System.out.println("Date2 : "+localDate);

	}
}

日期:2020-06-01
日期:2020 年 01 月 06 日

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.from()方法及示例

原文：https://www.studytonight.com/java-examples/java-localdate-from-method-with-examples

该方法用于从TemporalAccessor实例获取 localdate。临时处理器是一个接口，任何继承它的对象都可以和from()方法一起使用。from()方法将时间对象转换为本地日期。下面给出了该方法的语法。

句法

public static LocalDate from(TemporalAccessor temporal)

参数:

时态 -要转换为 localdate 的对象。

返回:

它返回一个 localdate。

示例:date from()方法

在本例中，我们使用from()方法从TemporalAccessor对象获取 localdate。请注意，我们使用of()方法创建日期并存储到TemporalAccessor对象中，该对象进一步与from()方法一起使用以获取本地日期。

import java.time.LocalDate;
import java.time.temporal.TemporalAccessor;

public class DateDemo {
public static void main(String[] args){  

		// Take a date
	    TemporalAccessor date = LocalDate.of(2012,06,02);
		// Displaying date
		System.out.println("Date : "+date);
		// from method
		LocalDate date2 = LocalDate.from(date);
		System.out.println(date2);

	}
}

日期:2012-06-02
2012-06-02

示例:

在这个例子中，我们使用ZonedDateTime来获取当前日期，并分配给 temporalaccessor 对象，该对象进一步与from()方法一起使用来获取 localdate。

import java.time.LocalDate;
import java.time.ZonedDateTime;
import java.time.temporal.TemporalAccessor;

public class DateDemo {
public static void main(String[] args){  

		// Take a date
	    TemporalAccessor date = ZonedDateTime.now();
		// Displaying date
		System.out.println("Date : "+date);
		// from method
		LocalDate date2 = LocalDate.from(date);
		System.out.println(date2);

	}
}

日期:2020-06-01t 15:28:21.841342+05:30【亚洲/加尔各答】
2020-06-01

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.get()方法及示例

原文：https://www.studytonight.com/java-examples/java-localdate-get-method-with-examples

此方法用于从日期中获取指定字段的值。它接受TemporalField类型的参数并返回一个整数值。

我们可以使用ChronoField枚举从日期中获取字段，例如:月日、周日等。

句法

public int get?(TemporalField field)

参数:

字段-要获取的字段，不为空

返回:

字段的值

示例:查找月中的某一天

让我们举个例子，用get()方法得到一个月中的某一天。我们使用ChronoFiled来指定日期字段。

import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;

public class DateDemo {
public static void main(String[] args){  

		// Take a date
	    TemporalField field = ChronoField.DAY_OF_MONTH;
	    TemporalAccessor date = LocalDate.of(2012,06,02);

		// Displaying date
		System.out.println("Date : "+date);
		// get() method
		int val = date.get(field);
		System.out.println(val);

	}
}

日期:2012-06-02
2

示例:查找星期几

让我们通过指定ChronoField枚举的星期几来使用get()方法查找星期几。

import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalField;

public class DateDemo {
public static void main(String[] args){  

		// Take a date
	    TemporalField field = ChronoField.DAY_OF_WEEK;
	    TemporalAccessor date = LocalDate.of(2012,06,02);

		// Displaying date
		System.out.println("Date : "+date);
		// get() method
		int val = date.get(field);
		System.out.println(val);

	}
}

日期:2012-06-02
6

活生生的例子

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getChronology()方法

原文：https://www.studytonight.com/java-examples/java-localdate-getchronology-method

这种方法用于获取日期的年表。年表是指现代世界的历法系统。

ISO-8601 历法系统是当今世界大部分地区使用的现代民用历法系统。

此方法返回引用日历系统的等时图。下面给出了该方法的语法。

句法

public IsoChronology getChronology()

参数:

它不接受任何参数。

返回:

它返回 ISO 年表。

举例时间:

让我们举一个例子，我们将使用getChronology()方法获得一个日期的年表。本示例返回 ISO 年表作为结果。

import java.time.LocalDate;
import java.time.chrono.IsoChronology;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2018, 2, 20);
		System.out.println(localDate);
		IsoChronology iso = localDate.getChronology();
		System.out.println("date chronology : "+iso);
	}
}

2018-02-20
日期年表:ISO

另一个例子的时间:

这里我们有一个字符串日期，然后转换为 localdate 来获取年表。我们可以看到，它显示了国际标准化组织年表的结果。

import java.time.LocalDate;
import java.time.chrono.IsoChronology;
public class DateDemo {

	public static void main(String[] args){  

		String date = "2015-02-06";
		LocalDate localDate = LocalDate.parse(date);
		System.out.println(localDate);
		IsoChronology iso = localDate.getChronology();
		System.out.println("date chronology : "+iso);
	}
}

2015-02-06
日期年表:ISO

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getDayOfMonth()方法

原文：https://www.studytonight.com/java-examples/java-localdate-getdayofmonth-method

此方法用于从日期中获取一个月中的某一天。例如，我们有一个日期 2012/02/15，那么这个方法将返回 15 作为一个月中的一天。

它不接受任何参数，可以使用LocalDate对象调用。下面给出了该方法的语法。

句法

public int getDayOfMonth()

因素

它不接受任何参数。

返回

它返回一个整数值。

举例时间:

在这个例子中，我们使用getDayOfMonth()方法得到一个日期中一个月的某一天。此方法返回一个显示一个月中某一天的整数值。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2018, 2, 20);
		System.out.println(localDate);
		int day = localDate.getDayOfMonth();
		System.out.println("day of month : "+day);
	}
}

2018-02-20
月日:20

另一个例子的时间:

如果我们有一个日期没有直接显示月日，那么我们仍然可以通过使用getDayOfMonth()方法获得月日。见下面的例子。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.ofYearDay(2012, 203);
		System.out.println(localDate);
		int day = localDate.getDayOfMonth();
		System.out.println("day of month : "+day);
	}
}

2012-07-21
月日:21

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getDayOfWeek()方法

原文：https://www.studytonight.com/java-examples/java-localdate-getdayofweek-method

此方法用于获取日期的星期几。例如，我们有一个日期，想要得到一周中的某一天，比如:周日、周一等等，那么我们可以使用这个方法。

它不接受任何参数，并返回指定日期当天的全名。下面给出了该方法的语法。

句法

public DayOfWeek getDayOfWeek()

参数:

它不接受任何参数。

返回:

它返回显示星期全名的星期几。

举例时间:

让我们举一个例子，通过使用getDayOfWeek()方法来获取日期的星期几。当我们想从一个日期中获得完整的日期名称时，这很有帮助。

import java.time.DayOfWeek;
import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2018, 2, 20);
		System.out.println(localDate);
		DayOfWeek dayOfWeek = localDate.getDayOfWeek();
        System.out.println("day of week : "+dayOfWeek);
	}
}

2018-02-20
星期几:星期二

另一个例子的时间:

让我们再举一个例子，在这个例子中，我们得到了代表未来很长一段时间的日期。我们将迎来 2050 年的某一天，如果没有这种方法，这是不容易实现的。

import java.time.DayOfWeek;
import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2050, 2, 25);
		System.out.println(localDate);
		DayOfWeek dayOfWeek = localDate.getDayOfWeek();
		System.out.println("day of week : "+dayOfWeek);
	}
}

2050-02-25
星期几:星期五

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getDayOfYear()方法示例

原文：https://www.studytonight.com/java-examples/java-localdate-getdayofyear-method-with-examples

这种方法用来计算一年中的某一天。它在闰年返回一个介于 1 到 365 或 366 之间的整数值。例如，日期 2020/01/05 将返回 5 作为一年中的一天。

此方法不接受任何参数，并返回一个整数值。下面给出了该方法的语法。

句法

public int getDayOfYear()

参数:

它不接受任何参数。

返回:

它返回一个整数值。

时间举例:获取一年中的某一天

我们举个例子，用getDayOfYear()方法得到一年中的某一天。在这个例子中，我们有一个日期 2 月 25 日，这将导致 56 天。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2020, 2, 25);
		System.out.println(localDate);
		int year = localDate.getDayOfYear();
		System.out.println("day of year : "+year);
	}
}

2020-02-25
一年中的第几天:56

另一个例子的时间:

如果我们想知道包括今年的今天在内已经过去了多少天，我们可以将此方法与当前日期时间一起使用，从而得出一年中的总天数。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		int year = localDate.getDayOfYear();
		System.out.println("day of year : "+year);
	}
}

2020-06-03
一年中的某一天:154

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getEra()方法及示例

原文：https://www.studytonight.com/java-examples/java-localdate-getera-method-with-examples

这个方法是用来获取一个日期的纪元。例如，公元前、公元和 CE。IsoChronology从第一年开始定义纪元 CE(当前纪元)，从第零年开始定义纪元 BCE(当前纪元之前)。

此方法不接受任何参数，并返回一个 IsoEra 枚举值。下面给出了该方法的语法。

句法

public IsoEra getEra()

参数:

这不需要任何争论。

返回:

它回到了一个年代。

举例时间:

我们举个例子，用getEra()方法得到一个日期的纪元。这里有一年 2020 年代表当前时代，有年大于零的日期属于 CE。

import java.time.LocalDate;
import java.time.chrono.IsoEra; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2020, 2, 25);
		System.out.println(localDate);
		IsoEra era = localDate.getEra();
		System.out.println("Date era : "+era);
	}
}

2020-02-25
日期:CE

另一个例子的时间:

表示零年或更少年的日期属于 BCE。这里我们有一个日期，显示零年，返回 BCE 时代。

import java.time.LocalDate;
import java.time.chrono.IsoEra; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(0000, 1, 01);
		System.out.println(localDate);
		IsoEra era = localDate.getEra();
		System.out.println("Date era : "+era);
	}
}

0000-01-01
日期:欧洲央行

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getLong()方法

原文：https://www.studytonight.com/java-examples/java-localdate-getlong-method

此方法用于获取日期字段的值。日期字段可以是日、月或年。如果我们想得到一个月的日期作为长型，使用getLong()方法。

此方法接受一个参数并返回一个Long类型值。下面给出了该方法的语法。

句法

public long getLong(TemporalField field)

参数:

它需要一个临时字段类型的参数。

返回:

它返回一个Long类型值。

举个例子

让我们举一个例子来获得日期的一天作为Long类型。我们使用getLong()方法获取长值，并传递ChronoField常量，该常量返回一个长数值。

import java.time.LocalDate;
import java.time.temporal.ChronoField; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		long day = localDate.getLong(ChronoField.DAY_OF_MONTH);
		System.out.println("Day of Month : "+day);
	}
}

2015-10-21
月日:21

再举一个例子

我们再举一个例子来理解getLong()方法的使用。这里我们从ChronoField中获取一年中的某一天作为Long类型值。

import java.time.LocalDate;
import java.time.temporal.ChronoField; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		long day = localDate.getLong(ChronoField.DAY_OF_YEAR);
		System.out.println("Day of Year : "+day);
	}
}

2015-10-21
年月日:294

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getMonth()方法

原文：https://www.studytonight.com/java-examples/java-localdate-getmonth-method

Java getMonth()方法用来获取某个日期的月份。它返回一月、二月等月份的全名。例如，我们有一个日期 2012/10/12，那么结果将是 10 月。

该方法属于java.time包中的LocalDate类。下面给出了这个例子的语法。

句法

public Month getMonth()

参数

它不接受任何参数。

返回

它返回一年中的月份。

举例时间:

举个例子，用getMonth()方法获取月份名称。这里我们得到一个日期的月份，方法返回一个月的月份枚举。

import java.time.LocalDate;
import java.time.Month; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		Month month = localDate.getMonth();
		System.out.println("Month of date : "+month);
	}
}

2015-10-21
月份日期:10 月

另一个例子的时间:

让我们举另一个例子，我们从一个不包含月字段的日期获得月名，但是月能够获得月。见下面的例子。

import java.time.LocalDate;
import java.time.Month; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.ofYearDay(2020, 120);
		System.out.println(localDate);
		Month month = localDate.getMonth();
		System.out.println("Month of date : "+month);
	}
}

2020-04-29
月日:4 月

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getMonthValue()方法

原文：https://www.studytonight.com/java-examples/java-localdate-getmonthvalue-method

Java getMonthValue()方法用于获取一个日期的月份值。它返回一个代表月份的整数值。例如，我们有一个日期 2012/02/15，那么它将返回 2 作为月份值。

此方法不接受任何参数，并返回一个整数值。下面给出了该方法的语法。

句法

public int getMonthValue()

因素

此方法不接受任何参数。

返回

它返回一个整数值。

时间就是一个例子

让我们举一个例子，将一个月的值作为整数值。在这个例子中，我们使用getMonthValue()将月作为整数值返回。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 02, 15);
		System.out.println(localDate);
		int month = localDate.getMonthValue();
		System.out.println("Month of date : "+month);
	}
}

2015-02-15
月日:2

再举一个例子

我们再举一个例子来更好地理解getMonthValue()法。这里我们使用getMonthValue()方法获取月值。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.ofYearDay(2020, 120);
		System.out.println(localDate);
		int month = localDate.getMonthValue();
		System.out.println("Month of date : "+month);
	}
}

2020-04-29
月日:4

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.getYear()方法及示例

原文：https://www.studytonight.com/java-examples/java-localdate-getyear-method-with-examples

Java getYear()方法用来获取某个日期的年份。此方法返回一个代表年份的整数值。例如，我们有一个日期 2015/02/01，结果将是 2015 年。

这个方法属于LocalDate类。它不接受任何参数，并返回一个整数值。下面给出了该方法的语法。

句法

public int getYear()

因素

此方法不接受任何参数。

返回

它返回一个整数值。

举例时间:

让我们举个例子来获得一个日期的年份。在这个例子中，我们使用的是返回整数值的getYear()方法。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		int year = localDate.getYear();
		System.out.println("Year of date : "+year);
	}
}

2015-10-21
年月日:2015

另一个例子的时间:

让我们举另一个例子来得到当前日期的当前年份。这里我们使用返回当前日期的now()方法得到当前日期。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		int year = localDate.getYear();
		System.out.println("Year of date : "+year);
	}
}

2020-06-04
年月日:2020

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.hashCode()方法及示例

原文：https://www.studytonight.com/java-examples/java-localdate-hashcode-method-with-examples

Java hashCode()方法用来获取一个日期的哈希代码。哈希代码是由 JVM 分配给对象的整数。每次当我们创建一个LocalDate的对象时，JVM 都会创建一个 hashcode 数，通过使用hashCode()方法，我们可以得到这个整数值。

Java hashCode()方法不取任何参数，返回一个整数值。下面给出了该方法的语法。

句法

public int hashCode()

返回:

它返回一个整数值。

举例时间:

让我们举一个例子来获取日期对象的哈希代码。在这个例子中，我们使用hashCode()方法得到一个整数 hashcode 值。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		int hashcode = localDate.hashCode();
		System.out.println("hashcode of the above date : "+hashcode);
	}
}

2015-10-21
上述日期的 hashcode:4127381

再举一个例子

我们再举一个例子来理解hashCode()法。这里我们得到的是当前日期的 hashcode，当前日期是通过now()方法获取的。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		int hashcode = localDate.hashCode();
		System.out.println("hashcode of current date : "+hashcode);
	}
}

2020-06-05
当前日期的 hashcode:4137349

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.isBefore()方法示例

原文：https://www.studytonight.com/java-examples/java-localdate-isbefore-method-with-example

Java isBefore()方法用于检查该日期是否在指定日期之前。如果该日期早于指定日期，则返回 true，否则返回 false。例如，如果我们有两个日期 2016/15/20 和 2015/15/12，并使用此方法，则第一个日期的结果将为假。

它接受ChronoLocalDate接口的单个参数，并返回真或假。下面给出了该方法的语法。

句法

public boolean isBefore(ChronoLocalDate other)

参数:

它将一个日期作为参数与另一个日期进行比较。

返回:

如果该日期早于指定日期，则返回 true

举例时间:

让我们举个例子来检查一个日期是否在另一个日期之前。这里，我们使用返回 false 的isBefore()方法作为例子。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 10, 21);
		System.out.println(localDate);
		// Date 2
		LocalDate localDate2 = LocalDate.of(2015, 10, 21);
		System.out.println(localDate2);
		boolean d  = localDate.isBefore(localDate2);
		System.out.println("is date1 before date2 : "+d);
	}
}

2016-10-21
2015-10-21
日期 1 在日期 2 之前:假

另一个例子的时间:

我们再举一个例子来理解isBefore()法。这里，第一个日期在第二个日期之前，这就是为什么该方法返回一个 true。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		// Date 2
		LocalDate localDate2 = LocalDate.of(2016, 10, 21);
		System.out.println(localDate2);
		boolean d  = localDate.isBefore(localDate2);
		System.out.println("is date1 before date2 : "+d);
	}
}

2015-10-21
2016-10-21
是日期 1 先于日期 2:真

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.isEqual()方法

原文：https://www.studytonight.com/java-examples/java-localdate-isequal-method

Java isEqual()方法用于检查两个日期是否相等。检查日期是否等于另一个日期是有帮助的，例如，我们有两个日期 2012/12/10 和 2012/12/12，那么使用isEqual()方法将返回 false。

它接受ChronoLocalDate类型的参数，并返回真或假。下面给出了该方法的语法。

句法

public boolean isEqual(ChronoLocalDate other)

参数:

其他 -要比较的其他日期。

返回:

如果该日期等于指定日期，则为真。

举个例子

让我们举个例子来检查这两个日期是否相等。这里，我们使用两个不同的日期，并使用返回 false 的方法进行检查。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		// Date 2
		LocalDate localDate2 = LocalDate.of(2016, 10, 21);
		System.out.println(localDate2);
		boolean d  = localDate.isEqual(localDate2);
		System.out.println("is date1 is equal date2 : "+d);
	}
}

2015-10-21
2016-10-21
是日期 1 等于日期 2:假

再举一个例子

我们再举一个例子来了解一下isEqual()法的用法。这里，我们使用两个不同的日期，并应用返回真的isEqual()方法。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		// Date 2
		LocalDate localDate2 = LocalDate.of(2015, 10, 21);
		System.out.println(localDate2);
		boolean d  = localDate.isEqual(localDate2);
		System.out.println("is date1 is equal date2 : "+d);
	}
}

2015-10-21
2015-10-21
是日期 1 等于日期 2:真

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.isLeapYear()方法

原文：https://www.studytonight.com/java-examples/java-localdate-isleapyear-method

Java isLeapYear()方法用于检查日期是否为闰年。它根据国际标准化组织的日历系统规则检查闰年。

如果一年能被四整除而不留余数，那它就是闰年。例如，2004 年是闰年，它可以被 4 整除。1900 年不是闰年，因为它可以被 100 整除。

此方法不接受任何参数，返回 true 或 false。下面给出了该方法的语法。

句法

public boolean isLeapYear()

参数:

它不接受任何参数。

返回:

它返回真或假。

举例时间:

让我们举个例子来检查一年是否是闰年。这里，我们有一个 2015 年，这不是闰年，这就是为什么该方法返回假。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		boolean d  = localDate.isLeapYear();
		System.out.println("Is leap Year : "+d);
	}
}

2015-10-21
是闰年:假

另一个例子的时间:

我们再举一个例子来理解isLeapYear()方法的用法。在这里，我们有一年，并通过使用方法检查，返回真。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2020, 10, 21);
		System.out.println(localDate);
		boolean d  = localDate.isLeapYear();
		System.out.println("Is leap Year : "+d);
	}
}

2020-10-21
是闰年吗:是

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.isSupported()方法

原文：https://www.studytonight.com/java-examples/java-localdate-issupported-method

Java isSupported()方法用于检查是否支持指定的日期单位。日期单位是日期的一部分，如日、月、年等。例如，如果我们想在日期上检查一个月的字段，那么我们可以使用这个方法。

此方法接受一个参数，并返回 true 或 false。如果支持指定的字段，则返回 true，否则返回 false。

有支持的字段:

• 星期几

• 对齐 _ 周 _ 月 _ 日

• 年 _ 月 _ 日 _ 周 _ 对齐

• 月日

• 一年中的第 _ 天

• 纪元日

• 每月的第 _ 周

• 对齐 _ 周 _ 年

• 年月日

• prolective _ MONTH

• 纪元年

• 年

• 时代

除上述单位外，所有其他ChronoField实例都将返回 false。

句法

public boolean isSupported(TemporalField field)

参数:

它采用单个参数作为日期字段。

返回:

如果支持指定字段，则返回 true，否则返回 false。

举例时间:

让我们举个例子，检查指定的字段是否被日期支持。这里，我们使用 DAY_OF_MONTH 作为字段，输出为真。

import java.time.LocalDate;
import java.time.temporal.ChronoField; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2020, 10, 21);
		System.out.println(localDate);
		boolean d  = localDate.isSupported(ChronoField.DAY_OF_MONTH);
		System.out.println("Is day of Month Supported : "+d);
	}
}

2020-10-21
是否支持月日:真

另一个例子的时间:

我们再举一个例子来了解一下isSupported()法的用法。这里，我们使用的是指定日期不支持的 HOUR_OF_DAY 字段，因此我们得到的结果是 false。

import java.time.LocalDate;
import java.time.temporal.ChronoField; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2020, 10, 21);
		System.out.println(localDate);
		boolean d  = localDate.isSupported(ChronoField.HOUR_OF_DAY);
		System.out.println("Is Hour of Day Supported : "+d);
	}
}

2020-10-21
是否支持一天中的小时:假

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.lengthOfMonth()方法及示例

原文：https://www.studytonight.com/java-examples/java-localdate-lengthofmonth-method-with-examples

Java lengthOfMonth()方法用于获取日期中一个月的长度。一个月的长度代表一个月的总天数。比如我们有一个日期 2012/01/25 那么这个方法返回 31 作为结果。

它不接受任何参数，但返回一个整数值。下面给出了该方法的语法。

句法

public int lengthOfMonth()

参数:

这不需要任何争论。

返回:

它返回一个整数值。

举个例子

让我们举个例子来得到月的长度。在这里，我们得到 10 月份的长度是 31。因此该方法返回 31 作为结果。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 10, 21);
		System.out.println(localDate);
		int length  = localDate.lengthOfMonth();
		System.out.println("Length of Month : "+length);
	}
}

2015-10-21
月长:31

再举一个例子

我们再举一个例子来了解一下lengthOfMonth()法的用法。这里，我们得到了二月的长度，有 28 或 29。所以根据年份，它会返回 28。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 02, 21);
		System.out.println(localDate);
		int length  = localDate.lengthOfMonth();
		System.out.println("Length of Month : "+length);
	}
}

2015-02-21
月长:28

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.lengthOfYear()方法

原文：https://www.studytonight.com/java-examples/java-localdate-lengthofyear-method

Java lengthOfYear()方法用于获取日期中一年的长度。一年的长度代表一年中的总天数。例如，我们有一个日期 2012/01/25，那么这个方法返回 366 作为结果。

它不接受任何参数，但返回一个整数值。下面给出了该方法的语法。

句法

public int lengthOfYear()

参数:

这不需要任何争论。

返回:

它返回一个整数值。

举个例子

让我们举个例子来得到一年的长度。这里，我们得到 2015 年的长度是 365。因此该方法返回 365 作为结果。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2015, 02, 21);
		System.out.println(localDate);
		int length  = localDate.lengthOfYear();
		System.out.println("Length of Year : "+length);
	}
}

2015-02-21
年长度:365

再举一个例子

我们再举一个例子来了解一下lengthOfYear()法的用法。在这里，我们得到了闰年的长度，有 366 天。所以根据年份，它会返回 366。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 02, 21);
		System.out.println(localDate);
		int length  = localDate.lengthOfYear();
		System.out.println("Length of Year : "+length);
	}
}

2016-02-21
年长度:366

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.minus()方法

原文：https://www.studytonight.com/java-examples/java-localdate-minus-method

Java minus()方法用于减去一个日期的字段。字段可以是一天、一个月或一年。此方法在减去指定字段后返回一个新日期。例如，我们有一个日期 2012/02/10，想要从该日期减去 2 天，那么减方法适用于此。

它需要两个参数，一个是字段的数量，第二个是字段的名称。减去指定字段后返回新的LocalDate。

句法

public LocalDate minus(long amountToSubtract, TemporalUnit unit)

参数:

amountToSubtract - 要减去的字段量。

单位- 字段的名称如:日、月等。

返回:

它在减去后返回一个新的 localdate。

举个例子

我们举个例子，用minus()法减去两天。这里，我们提到第一个参数为 2，第二个参数为天。见下面的例子。

import java.time.LocalDate;
import java.time.temporal.ChronoUnit; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 10, 21);
		System.out.println(localDate);
		localDate = localDate.minus(2,ChronoUnit.DAYS);
		System.out.println("New date : "+localDate);
	}
}

2016-10-21
新日期:2016-10-19

再举一个例子

我们再举一个例子来理解minus()方法的用法。在这里，日期减去 2 个月后，我们得到了一个新的LocalDate。

import java.time.LocalDate;
import java.time.temporal.ChronoUnit; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 10, 21);
		System.out.println(localDate);
		localDate = localDate.minus(2,ChronoUnit.MONTHS);
		System.out.println("New date : "+localDate);
	}
}

2016-10-21
新日期:2016-08-21

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.minusDays()方法

原文：https://www.studytonight.com/java-examples/java-localdate-minusdays-method

Java minusDays()方法是用来减去一个日期的指定天数。它减去天数并返回一个新的LocalDate。例如，2009-01-10 减去一天将得到 2009-01-09。

它需要一个表示天数的Long类型参数，并返回一个新的LocalDate。下面给出了该方法的语法。

句法

public LocalDate minusDays(long daysToSubtract)

参数:

它接受一个Long类型的参数。

返回:

它在减去天数后返回一个 localdate。

举例时间:

让我们举一个从日期中减去天数的例子。这里，我们使用minusDays()方法从日期中减去 2 天，结果得到一个新的日期。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 10, 21);
		System.out.println(localDate);
		localDate = localDate.minusDays(2);
		System.out.println("New date : "+localDate);
	}
}

2016-10-21
新日期:2016-10-19

另一个例子的时间:

我们再举一个例子，从日期中减去指定的天数。这里，我们从当前日期减去 2 天。我们用now()方法得到当前日期，minusDays()方法得到减去日期后的新日期。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		localDate = localDate.minusDays(2);
		System.out.println("New date : "+localDate);
	}
}

2020-06-10
新日期:2020-06-08

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.minusMonth()方法

原文：https://www.studytonight.com/java-examples/java-localdate-minusmonth-method

Java minusMonth()方法用于减去某个日期的指定月数。它减去月份并返回一个新的LocalDate。例如，2009-10-10 减去一个月将产生 2009-09-10。

它需要一个表示月数的Long类型参数，并返回一个新的LocalDate。下面给出了该方法的语法。

句法

public LocalDate minusMonths(long monthsToSubtract)

参数:

它接受一个Long类型的参数。

返回:

它在从日期中减去指定月份后返回本地日期。

举例时间:

让我们举个例子，从日期中减去月份。这里，我们使用返回新的本地日期的minusMonths()方法减去 2 个月。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 10, 21);
		System.out.println(localDate);
		localDate = localDate.minusMonths(2);
		System.out.println("New date : "+localDate);
	}
}

2016-10-21
新日期:2016-08-21

另一个例子的时间:

我们再举一个例子来理解minusMonths()法。这里，我们从当前日期减去 2 个月。请看下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		localDate = localDate.minusMonths(2);
		System.out.println("New date : "+localDate);
	}
}

2020-06-10
新日期:2020-04-10

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.minusWeeks()方法

原文：https://www.studytonight.com/java-examples/java-localdate-minusweeks-method

Java minusWeeks()方法用于从一个日期减去指定的周数。它减去周并返回一个新的LocalDate。例如，2009-10-10 减去一周将产生 2009-10-03。

它需要一个表示周数的Long类型参数，并返回一个新的LocalDate。下面给出了该方法的语法。

句法

public LocalDate minusWeeks(long weeksToSubtract)

参数:

它采用代表周数的 long 类型参数。

返回:

它在从日期中减去指定的星期后返回一个本地日期。

举例时间:

让我们举个例子，从一个日期中减去几周。这里，我们使用返回新的本地日期的minusWeeks()方法减去 2 周。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 10, 21);
		System.out.println(localDate);
		localDate = localDate.minusWeeks(2);
		System.out.println("New date : "+localDate);
	}
}

2016-10-21
新日期:2016-10-07

另一个例子的时间:

我们再举一个例子来理解minusWeeks()法。这里，我们从当前日期减去 2 周。请看下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		localDate = localDate.minusWeeks(2);
		System.out.println("New date : "+localDate);
	}
}

2020-06-10
新日期:2020-05-27

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.minusYears()方法

原文：https://www.studytonight.com/java-examples/java-localdate-minusyears-method

Java minusYears()方法用于从本地日期中减去指定的年份。它返回这个LocalDate的一个副本，减去指定的年数。

此方法分三步减去指定的年份字段:

1. 从年份字段中减去输入年份

2. 检查结果日期是否无效

3. 如有必要，将每月的某一天调整为最后一个有效日期

例如，2008-02-29(闰年)减去一年将导致无效日期 2007-02-29(标准年)。取而代之的是选择该月的最后一个有效日期 2007-02-28，而不是返回无效结果。

句法

public LocalDate minusYears(long yearsToSubtract)

参数:

指定年数需要一个长型的参数。

返回:

它在减去年份后返回一个本地日期。

举例时间:

在这个例子中，我们从本地日期中减去一年。minusYear()方法在减去指定年份后返回一个新的日期。请看下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2009, 10, 10);
		System.out.println(localDate);
		localDate = localDate.minusYears(1);
		System.out.println("New date : "+localDate);
	}
}

2009-10-10
新日期:2008-10-10

另一个例子的时间:

如果减去年份后，日期无效，则结果将是日期的最后一个有效日期。看，我们从闰年中减去一年，导致日期无效，所以编译器返回日期的最后一天。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2012, 02, 29);
		System.out.println(localDate);
		localDate = localDate.minusYears(1);
		System.out.println("New date : "+localDate);
	}
}

2012-02-29
新日期:2011-02-28

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.now()方法

原文：https://www.studytonight.com/java-examples/java-localdate-now-method

Java LocalDate now()方法用于获取当前本地日期。它根据区域设置返回默认系统日期。

我们可以用它从默认时区的系统时钟中获取当前日期。属于 Java LocalDate类，返回当前日期。下面给出了该方法的语法。

句法

public static LocalDate now()

参数:

它不接受任何参数。

返回:

它返回一个本地日期。

举例时间:

让我们举个例子来获取当前的本地日期。这里，我们使用now()方法，该方法根据区域设置返回当前日期。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
	}
}

2020-06-11

另一个例子的时间:

让我们举另一个例子来获得当前日期。在这里，我们也使用 format 方法来获取所需格式的当前日期。请看下面的例子。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();	
		System.out.println(localDate);
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/YYYY");
        String date = formatter.format(localDate);
        System.out.println("New date : "+date);
	}
}

2020-06-11
新日期:2020 年 6 月 11 日

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.now(Clock)方法

原文：https://www.studytonight.com/java-examples/java-localdate-nowclock-method

Java LocalDate now(Clock)方法用于根据指定的时钟获取当前日期。时钟是一个抽象类，它提供静态方法来创建各种场景的日期。

我们可以使用时钟的方法根据世界各地的区域生成本地日期。

它从指定的时钟返回本地日期。下面给出了该方法的语法。

句法

public static LocalDate now(Clock clock)

参数:

它采用时钟类型的单个参数。

返回:

它返回一个本地日期

举例时间:

让我们举个例子，用最好的系统时钟创建一个当前日期。这里，我们使用Clock类的systemUTC()方法，使用世界协调时时区转换为日期和时间。

import java.time.Clock;
import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now(Clock.systemUTC());	
		System.out.println(localDate);
	}
}

2020-06-11

另一个例子的时间:

让我们举另一个例子来获得当前日期。这里，我们使用systemDefaultZone()方法返回当前系统默认的基于时钟的日期。

import java.time.Clock;
import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now(Clock.systemDefaultZone());	
		System.out.println(localDate);
	}
}

2020-06-11

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate now(ZoneId)方法

原文：https://www.studytonight.com/java-examples/java-localdate-nowzoneid-method

Java LocalDate now(ZoneId)方法用于从指定时区的系统时钟中获取当前日期。它返回指定时区的当前本地日期。

时区是遵守统一标准时间的城市或国家的一个区域。例如亚洲/加尔各答、亚洲/钦奈等。

该方法将一个参数作为ZoneId来指定时区，并返回一个本地日期。下面给出了该方法的语法。

句法

public static LocalDate now(ZoneId zone)

参数:

它只需要一个 ZoneId 参数。

返回:

它返回一个本地日期。

举例时间:

在这里，我们得到了默认系统时区的当前日期。我们使用ZoneId的systemDefault()方法获取默认时区。

import java.time.LocalDate;
import java.time.ZoneId;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now(ZoneId.systemDefault());
		System.out.println(localDate);		
	}
}

2020-06-12

另一个例子的时间:

如果我们想要一个不同于系统默认的时区日期，那么我们可以使用of()方法通过时区。它根据指定的时区返回日期。

import java.time.LocalDate;
import java.time.ZoneId;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now(ZoneId.of("Asia/Tokyo"));
		System.out.println(localDate);		
	}
}

2020-06-12

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.of()方法

原文：https://www.studytonight.com/java-examples/java-localdate-of-method

Java LocalDate of()方法用于从年、月、日获取LocalDate的一个实例。它可以通过传递年、月和日作为参数来创建日期。它在从参数创建日期后返回本地日期。例如，我们有三个整数值:2012、10 和 20，然后我们可以通过使用这些值来获得日期，该方法将返回一个日期，如:2012-10-20。

它返回一个带有指定年、月、日的LocalDate。日期必须对年和月有效，否则将引发异常。下面给出了该方法的语法。

句法

public static LocalDate of(int year, int month, int dayOfMonth)

参数:

年份- 表示有效年份的整数值。

月- 表示有效月份的整数值。

dayOfMonth - 是表示有效日期的整数值。

返回:

它在组合指定的年、月和日之后返回一个本地日期。

举例时间:

让我们举一个例子，通过传递年、月和日作为参数来创建日期。在这里，我们可以看到结果是我们得到了一个有效的年份。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2012,10,12);
		System.out.println(localDate);		
	}
}

2012-10-12

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.of()方法和月份枚举

原文：https://www.studytonight.com/java-examples/java-localdate-of-method-with-month-enum

Java LocalDate of()方法用于从年、月、日获取LocalDate的一个实例。它可以用来创建以年、月、日为参数的日期。它在从参数创建日期后返回本地日期。

对于月份的值，它使用提供一年中所有月份的Month 枚举。

它返回一个带有指定年、月、日的LocalDate。日期必须对年和月有效，否则将引发异常。下面给出了该方法的语法。

句法

public static LocalDate of(int year, Month month, int dayOfMonth)

参数:

年份- 表示有效年份的整数值。

月- 这是一个表示有效月份的Month枚举值。

dayOfMonth - 是表示有效日期的整数值。

返回:

它在组合指定的年、月和日之后返回一个本地日期。

举例时间:

让我们举一个例子，用经过的年份、月份枚举和日期作为参数来创建日期。在这里，我们可以看到结果是我们得到了一个有效的年份。

import java.time.LocalDate;
import java.time.Month;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2020,Month.APRIL,10);
		System.out.println(localDate);		
	}
}

2020-04-10

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.ofEpochDay()方法

原文：https://www.studytonight.com/java-examples/java-localdate-ofepochday-method

Java LocalDate ofEpochDay()方法用于从历元日计数中获取一个 LocalDate。纪元日是从 1970-01-01 简单递增的天数。

我们可以用它从指定的历元日计数中得到LocalDate的一个实例。例如，如果我们经过 31 个纪元日，那么我们得到 1970-02-01，它表示一个月之后的一个日期。

句法

public static LocalDate ofEpochDay(long epochDay)

参数:

它接受一个Long类型的参数。

返回:

它返回一个本地日期。

举例时间:

我们举个例子，用ofEpochDay()方法提前 10 天得到日期。在这里，我们向该方法传递了 10 天，并获得了一个新的本地日期。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.ofEpochDay(10);
		System.out.println(localDate);		
	}
}

1970-01-11

另一个例子的时间:

我们再举一个例子来理解ofEpochDay()法。在这里，我们通过增加 365 个纪元日获得了一个提前 1 年的日期。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.ofEpochDay(365);
		System.out.println(localDate);		
	}
}

1971-01-01

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.ofYearDay()方法

原文：https://www.studytonight.com/java-examples/java-localdate-ofyearday-method

Java LocalDate ofYearDay()方法用于从指定的年份和天数中获取一个 LocalDate。例如，如果我们想知道 2015 年第 55 天的日期，那么结果将是 2015-02-24。

它是一个带有指定年份和日期的LocalDate。年中的某一天必须对该年有效，否则将引发异常。

句法

public static LocalDate ofYearDay(int year, int dayOfYear) 

参数:

它需要两个参数，第一个是年，第二个是年月日。

返回:

它返回一个本地日期。

举例时间:

我们举个例子，用ofYearDay()方法得到 2015 年第 10 天的日期。在这里，我们将 2015 年作为年份，将 10 作为天数传递给方法，并获得新的本地日期。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.ofYearDay(2015, 10);
		System.out.println(localDate);		
	}
}

1970-01-11

另一个例子的时间:

我们再举一个例子来理解ofYearDay()法。这里，我们通过将 2015 年作为年，将 100 年作为日，得到 2015 年的第 100 天。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.ofYearDay(2015, 100);
		System.out.println(localDate);		
	}
}

2015-04-10

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.parse()方法

原文：https://www.studytonight.com/java-examples/java-localdate-parse-method

Java LocalDate parse()方法用于从文本日期中获取一个 LocalDate。它从文本字符串(如 2007-12-03)中返回LocalDate的实例。

它可用于将String类型的日期转换为 localdate 实例。该字符串必须以国际标准化组织LocalDate的格式表示有效日期。例如，2015-02-10 是有效的，而 20-10-2015 是无效的日期字符串。

句法

public static LocalDate parse(CharSequence text)

参数:

它接受String类型的单个参数。

返回:

它在解析字符串日期后返回一个本地日期。

举例时间:

让我们举一个例子，从字符串日期中获取本地日期。在这里，我们使用parse()方法解析一个文本序列来获得LocalDate实例。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.parse("2015-12-10");
		System.out.println(localDate);		
	}
}

2015-12-10

另一个例子的时间:

让我们再举一个例子来理解一下parse()方法，它可以用来将字符串转换为 localdate。请注意，在本例中，字符串 date 被解析并转换为 localdate 对象。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.parse("2011-02-28");
		System.out.println(localDate);		
	}
}

2011-02-28

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.parse()和格式化器

原文：https://www.studytonight.com/java-examples/java-localdate-parse-with-formatter

Java LocalDate parse()方法用于从指定格式的文本日期中获取一个 localdate。它从文本字符串(如 2007-12-03)中返回LocalDate的实例。

该方法类似于解析(CharSequence text) 方法，该方法解析不带日期格式的字符串日期。这两种方法的区别在于parse(CharSequence text, DateTimeFormatter)需要一个额外的参数。

它可用于将String类型的日期转换为 localdate 实例。该字符串必须以国际标准化组织LocalDate的格式表示有效日期。例如，2015-02-10 是有效的日期字符串。

句法

public static LocalDate parse(CharSequence text, DateTimeFormatter formatter)

参数:

它接受参数首先是String类型的日期，其次是格式化器。

返回:

它在解析指定格式的字符串日期后返回本地日期。

举例时间:

让我们举一个例子，从字符串日期和日期格式中获取本地日期。这里，我们使用parse()方法解析一个指定格式的文本序列，得到LocalDate一个实例。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.parse("2011-02-28", DateTimeFormatter.ISO_LOCAL_DATE);
		System.out.println(localDate);		
	}
}

2011-02-28

另一个例子的时间:

让我们再举一个例子来理解一下parse()方法，它可以用来将字符串转换为 localdate。请注意，在本例中，字符串 date 被解析并转换为 localdate 对象。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class DateDemo {

	public static void main(String[] args){  
		DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd");
		LocalDate localDate = LocalDate.parse("2011-02-28", df);
		System.out.println(localDate);		
	}
}

2011-02-28

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.plus(long, Temporal)方法

原文：https://www.studytonight.com/java-examples/java-localdate-pluslong-temporal-method

plus()方法用于将单位金额添加到日期中。单位可以是日、月、周等。

此方法返回添加了指定金额的该日期的副本。

我们可以使用ChronoUnit枚举给日期添加单位，因为它实现了TemporalUnit接口。ChronoUnit提供以下字段:

• 天

• 周末

• 月份

• 年

• 数十年

• 世纪

• 一千年

• 年代

句法

public LocalDate plus(long amountToAdd, TemporalUnit unit)

参数:

金额添加 -要添加到日期的单位金额。

单位 -要添加的金额单位，如:天、月等。

返回:

在日期中添加单位后，它会返回一个新的 localdate。

举例时间:

让我们举个例子来给一个日期添加天数。这里我们用plus()方法给 localdate 加 10 天。结果，它会在 10 天后返回下个月的日期。

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
public class DateDemo {

	public static void main(String[] args){  
		LocalDate localDate = LocalDate.of(2011,02,28);
		System.out.println(localDate);
		localDate = localDate.plus(10, ChronoUnit.DAYS);
		System.out.println(localDate);		
	}
}

2011-02-28
2011-03-10

另一个例子的时间:

我们再举一个例子来理解plus()法。在这里，我们使用 WEEKS 单位来添加 2 周的日期，并获得 2 周后的日期。

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
public class DateDemo {

	public static void main(String[] args){  
		LocalDate localDate = LocalDate.of(2011,02,28);
		System.out.println(localDate);
		localDate = localDate.plus(2, ChronoUnit.WEEKS);
		System.out.println(localDate);		
	}
}

2011-02-28
2011-03-14

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.plus(Temporal)方法

原文：https://www.studytonight.com/java-examples/java-localdate-plustemporal-method

plus()方法用于将单位金额添加到日期中。单位可以是日、月、周等。

它采用TemporalAmount类型的参数，并返回添加了指定金额的该日期的副本。

该数量通常为Period，但也可以是实现TemporalAmount接口的任何其他类型。

我们可以使用Period类给日期添加(日、月、年)，因为它实现了TemporalAmount接口。Period类提供以下方法:

• of(整数年，整数月，整数天)

• 天数(整数天)

• 月数(整数个月)

• 工作周(整数周)

• 年数(年)

句法

public LocalDate plus(TemporalAmount amountToAdd)

参数:

金额添加 -要添加到日期的单位金额。

返回:

它返回一个新的 localdate。

举例时间:

让我们举个例子来给一个日期添加天数。这里我们用plus()方法给 localdate 加 10 天。结果，它会在 10 天后返回下个月的日期。

import java.time.LocalDate;
import java.time.Period;
public class DateDemo {

	public static void main(String[] args){  
		LocalDate localDate = LocalDate.of(2011,02,28);
		System.out.println(localDate);
		localDate = localDate.plus(Period.ofDays(10));
		System.out.println(localDate);		
	}
}

2011-02-28
2011-03-10

另一个例子的时间:

我们再举一个例子来理解plus()法。在这里，我们使用 Period 类的ofMonths()方法添加 2 个月的日期，得到 2 个月后的日期。

import java.time.LocalDate;
import java.time.Period;
public class DateDemo {

	public static void main(String[] args){  
		LocalDate localDate = LocalDate.of(2011,02,28);
		System.out.println(localDate);
		localDate = localDate.plus(Period.ofMonths(2));
		System.out.println(localDate);		
	}
}

2011-02-28
2011-04-28

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.plusDays()方法

原文：https://www.studytonight.com/java-examples/java-localdate-plusdays-method

Java plusDays()方法用于将指定的天数加到一个日期上。它增加天数并返回一个新的LocalDate。例如，2009-01-10 加上一天将导致 2009-01-11。

它需要一个表示天数的Long类型参数，并返回一个新的LocalDate。下面给出了该方法的语法。

句法

public LocalDate plusDays(long daysToAdd)

参数:

它接受一个Long类型的参数。

返回:

它在添加天数后返回一个 localdate。

举例时间:

让我们举个例子来给一个日期添加天数。在这里，我们使用plusDays()方法添加 2 天到日期，结果我们得到一个新的日期。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2018, 10, 10);
		System.out.println(localDate);
		localDate = localDate.plusDays(2);
		System.out.println("New date : "+localDate);
	}
}

2018-10-10
新日期:2018-10-12

另一个例子的时间:

让我们再举一个例子，将指定的日期添加到日期中。在这里，我们将当前日期增加 2 天。我们使用now()方法获取当前日期，plusDays()方法在添加天数后获取新日期。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		localDate = localDate.plusDays(2);
		System.out.println("New date : "+localDate);
	}
}

2020-06-17
新日期:2020-06-19

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.plusMonths()方法

原文：https://www.studytonight.com/java-examples/java-localdate-plusmonths-method

Java plusMonths()方法用于给一个日期加上指定的月数。它添加月份并返回一个新的LocalDate。例如，2009-10-10 加上一个月将导致 2009-11-10。

它需要一个表示月数的Long类型参数，并返回一个新的LocalDate。下面给出了该方法的语法。

句法

public LocalDate plusMonths(long monthsToAdd)

参数:

它接受一个Long类型的参数。

返回:

它在将指定月份添加到日期后返回本地日期。

举例时间:

让我们举个例子来给一个日期添加月份。这里，我们通过使用返回新的本地日期的plusMonths()方法来添加 2 个月。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 10, 21);
		System.out.println(localDate);
		localDate = localDate.plusMonths(2);
		System.out.println("New date : "+localDate);
	}
}

2016-10-21
新日期:2016-12-21

另一个例子的时间:

我们再举一个例子来理解加号Months()法。在这里，我们将当前日期增加 2 个月。请看下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		localDate = localDate.plusMonths(2);
		System.out.println("New date : "+localDate);
	}
}

2020-06-17
新日期:2020-08-17

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.plusWeeks()方法

原文：https://www.studytonight.com/java-examples/java-localdate-plusweeks-method

Java plusWeeks()方法用于将一个日期加上指定的周数。它增加了周数并返回一个新的LocalDate。例如，2009-10-10 加上一周将产生 2009-10-17。

它需要一个表示周数的Long类型参数，并返回一个新的LocalDate。下面给出了该方法的语法。

句法

public LocalDate plusWeeks(long weeksToAdd)

参数:

它采用一个 long 类型的参数，表示周数。

返回:

它在将指定的周添加到日期后返回本地日期。

举例时间:

让我们举个例子来给一个日期增加几周。这里，我们通过使用返回新的本地日期的plusWeeks()方法来添加 2 周。见下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2016, 10, 21);
		System.out.println(localDate);
		localDate = localDate.plusWeeks(2);
		System.out.println("New date : "+localDate);
	}
}

2016-10-21
新日期:2016-11-04

另一个例子的时间:

我们再举一个例子来理解plusWeeks()法。在这里，我们在当前日期的基础上增加了 5 周。请看下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		localDate = localDate.plusWeeks(5);
		System.out.println("New date : "+localDate);
	}
}

2020-06-17
新日期:2020-07-22

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.plusYears()方法

原文：https://www.studytonight.com/java-examples/java-localdate-plusyears-method

此方法用于将指定的年份加到本地日期。它会返回一个添加了指定年数的LocalDate副本。

此方法分三步添加指定的年份字段:

1. 将输入年份添加到年份字段

2. 检查结果日期是否无效

3. 如有必要，将每月的某一天调整为最后一个有效日期

例如，2008-02-29(闰年)加上一年将导致无效日期 2009-02-29(标准年)。取而代之的是选择该月的最后一个有效日期 2007-02-28，而不是返回无效结果。

句法

public LocalDate plusYears(long yearsToAdd)

参数:

需要一个Long类型的参数来指定年数。

返回:

它会在添加年份后返回一个本地日期。

举例时间:

在这个例子中，我们在本地日期上增加了一年。plusYear()方法在添加指定的年份后返回一个新的日期。请看下面的例子。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2019, 8, 10);
		System.out.println(localDate);
		localDate = localDate.plusYears(2);
		System.out.println("New date : "+localDate);
	}
}

2019-08-10
新日期:2021-08-10

另一个例子的时间:

如果在加上年份后，日期无效，那么结果将是该日期的最后一个有效日期。看，我们在闰年中添加了一年，这导致了一个无效的日期，所以编译器返回了该日期的最后一个有效日期。

import java.time.LocalDate; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2012, 02, 29);
		System.out.println(localDate);
		localDate = localDate.plusYears(1);
		System.out.println("New date : "+localDate);
	}
}

2012-02-29
新日期:2013-02-28

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.range()方法

原文：https://www.studytonight.com/java-examples/java-localdate-range-method

Java range()方法用于获取指定字段的有效值范围。范围值表示字段的最小和最大有效值。例如，如果我们想得到10 月的天数，那么我们得到这个月的范围 1-31 。

我们可以使用ChronoField枚举作为参数来获取指定字段的范围。ChronoField枚举有以下值:

| 田 | 描述 |
| 对齐 _ 周 _ 月 _ 日 | 一个月内一致的星期几。 |
| 年 _ 月 _ 日 _ 周 _ 对齐 | 一年中一致的星期几。 |
| 每月的第 _ 周 | 一个月内一致的一周。 |
| 对齐 _ 周 _ 年 | 一年内一致的一周。 |
| 当日 AMPM | 每天的上午-下午。 |
| AMPM 时间 | 上午 10 点至下午 1 点的时钟。 |
| 一天中的钟点 | 一天中的整点钟。 |
| 月日 | 每月的某一天。 |
| 星期几 | 一周中的某一天，如星期二。 |
| 一年中的第 _ 天 | 一年中的某一天。 |
| 纪元日 | 纪元日，基于 1970-01-01(国际标准化组织)的 Java 纪元。 |
| 时代 | 时代。 |
| AMPM 时间 | 上午-下午的时间。 |
| 一天中的小时 | 一天中的某个时刻。 |
| 即时 _ 秒 | 瞬间划时代-秒。 |
| 微观 _OF_DAY | 微观的一天。 |
| 微秒 | 几分之一秒。 |
| 百万分之日 | 日复一日。 |
| 毫欧秒 | 毫秒。 |
| 每天分钟 | 一天中的一分钟。 |
| 分钟/小时 | 分秒必争。 |
| 年月日 | 一年中的月份，如三月。 |
| 纳米日 | 纳米时代。 |
| 第二纳米 | 纳米秒。 |
| 偏移量 _ 秒 | 与世界协调时/格林威治时间的偏移量。 |
| prolective _ MONTH | 基于月份的预测，从第 0 年开始按顺序计算月份。 |
| 第二天 | 第二天。 |
| 第二分钟 | 一分一秒。 |
| 年 | 预测年，如 2012 年。 |
| 纪元年 | 时代内的一年。 |

句法

public ValueRange range(TemporalField field)

参数:

字段- 要查询范围的字段。

返回:

它返回字段的有效值范围。

举例时间:

让我们举个例子来获取日期中月份的范围。我们正在使用ChronoField枚举通过使用range()方法来获取范围。

import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.ValueRange; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2012, 02, 29);
		System.out.println(localDate);
		ValueRange vr = localDate.range(ChronoField.DAY_OF_MONTH);
		System.out.println("Range : "+vr);
	}
}

2012-02-29
区间:1 - 29

另一个例子的时间:

我们再举一个例子来理解range()法。在这里，我们得到了日期中的年份范围，范围从 1 到 366。

import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.ValueRange; 
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2012, 02, 29);
		System.out.println(localDate);
		ValueRange vr = localDate.range(ChronoField.DAY_OF_YEAR);
		System.out.println("Range : "+vr);
	}
}

2012-02-29
区间:1 - 366

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.toEpochDay()方法

原文：https://www.studytonight.com/java-examples/java-localdate-toepochday-method

Java toEpochDay()方法用于将此日期转换为大纪元日。历元日计数是简单的递增计数，其中第 0 天是 1970-01-01(国际标准化组织)。例如，我们有一个日期 1970-01-11，那么这个方法将返回 10 个纪元日。

它不接受任何参数，但返回一个表示总纪元天数的Long类型值。下面给出了该方法的语法。

句法

public long toEpochDay()

参数:

它不接受任何参数。

返回:

它返回相当于该日期的纪元日。

举例时间:

我们举个例子，用toEpochDay()方法得到历元日。这里，我们使用的日期是 1970-01-10，总共包含 9 个纪元日。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(1970, 01, 10);
		System.out.println(localDate);
		long l = localDate.toEpochDay();
		System.out.println("Epoch Days : "+l);
	}
}

1970-01-10
纪元天数:9

另一个例子的时间:

我们再举一个例子来理解toEpochDay()法。在这里，我们有一个长期日期 2020-01-10，它总共返回 18271 个纪元日。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2020, 01, 10);
		System.out.println(localDate);
		long l = localDate.toEpochDay();
		System.out.println("Epoch Days : "+l);
	}
}

2020-01-10
纪元天数:18271

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.toString()方法

原文：https://www.studytonight.com/java-examples/java-localdate-tostring-method

该方法用于获取该日期的String表示。它将该日期返回为String，如 2017-12-03。

如果我们想把LocalDate对象转换成 String 对象，这是很有帮助的。输出将采用国际标准化组织 8601 格式uuuu-MM-dd。

它不接受任何参数，但返回一个String。下面给出了该方法的语法。

句法

public String toString()

参数:

它不接受任何参数。

返回:

此日期的字符串表示形式。

举例时间:

让我们举个例子来获取 localdate 的字符串表示形式。这里，我们有一个 localdate 类的对象，并使用toString()方法获取字符串。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2020, 01, 10);
		System.out.println(localDate);
		String date = localDate.toString();
		System.out.println("String date : "+date);
	}
}

1970-01-10
纪元天数:9

另一个例子的时间:

我们再举一个例子来理解 toString()法。这里，我们使用toString()方法获取 localdate 对象的字符串表示。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		String date = localDate.toString();
		System.out.println("String date : "+date);
	}
}

2020-06-19
串日期:2020-06-19

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.until(ChronoLocalDate)方法

原文：https://www.studytonight.com/java-examples/java-localdate-untilchronolocaldate-method

Java 直到()方法用于获取此日期和另一个日期之间的期间作为期间。它根据年、月和日计算两个日期之间的时间段。如果结束日期早于开始日期，结果将为负。负号在每年、每月和每天都是一样的。

它采用ChronoLocalDate类型的参数，该参数可以是实现它的任何类对象。给出了该方法的语法。

句法

public Period until(ChronoLocalDate endDateExclusive)

参数:

endDateExclusive - 表示结束日期的日期。

返回:

它返回此日期和结束日期之间的期间。

举例时间:

让我们举个例子来得到两个日期之间的周期。这里，我们使用直到()方法来获取 2002-01-10 和 2005-10-12 日期之间的期间。

import java.time.LocalDate;
import java.time.Period;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		Period period = localDate.until(LocalDate.of(2005,10,12));
		System.out.println("Total Periods : "+period);
	}
}

2002-01-10
总周期:P3Y9M2D

另一个例子的时间:

我们再举一个例子来理解until()法。在这里，我们得到两个日期的周期，并使用getYears()、getMonths()和getDays()得到周期的个体值。

import java.time.LocalDate;
import java.time.Period;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		Period period = localDate.until(LocalDate.of(2005,10,12));
		System.out.println("Total Periods : "+period);
		System.out.println("Total Years : "+period.getYears());
		System.out.println("Total Months : "+period.getMonths());
		System.out.println("Total Days : "+period.getDays());
	}
}

2020-06-19
串日期:2020-06-19

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.until(Temporal, TemporalUnit)方法

原文：https://www.studytonight.com/java-examples/java-localdate-untiltemporal-temporalunit-method

Java 直到()方法用于获取到另一个日期为止的时间量，以指定的单位表示。它根据单个TemporalUnit计算两个LocalDate对象之间的时间量。如果结束日期早于开始日期，结果将为负。传递给此方法的Temporal使用from(TemporalAccessor)方法转换为LocalDate。

例如，如果我们想要获取两个本地日期之间的天数，然后使用ChronoUnit枚举值。ChronoUnit是提供单位DAYS、WEEKS、MONTHS、YEARS、DECADES、CENTURIES、MILLENNIA和ERAS的枚举。

这种方法类似于直到(ChronalDate)，它返回两个本地日期对象之间的周期。我们建议你也读读这个方法。

它需要两个参数，第一个是Temporal类型，第二个是TemporalUnit类型。给出了该方法的语法。

句法

public long until(Temporal endExclusive, TemporalUnit unit) 

参数:

endExclusive - 结束日期，这是一个LocalDate

单位- 指定日期字段的单位。

返回:

它返回一个Long类型值。

举例时间:

让我们举个例子来说明两个日期之间的年份。这里，我们使用直到()方法来获取 2002-01-10 和 2005-10-12 日期之间的年份。

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		long period = localDate.until(LocalDate.of(2005,10,12), ChronoUnit.YEARS);
		System.out.println("Years : "+period);
	}
}

2002-01-10
年:3

另一个例子的时间:

我们再举一个例子来理解until()法。在这里，我们得到两个日期之间的天数，并使用计时单位。两次约会的天数。

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		long period = localDate.until(LocalDate.of(2005,10,12), ChronoUnit.DAYS);
		System.out.println("Days : "+period);
	}
}

2002-01-10
日数:1371

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.with()方法

原文：https://www.studytonight.com/java-examples/java-localdate-with-method

Java with()方法用于通过设置指定字段的新值来获取新日期。它返回此日期的副本，并将指定字段设置为新值。

例如，我们有一个日期 2012-10-12，然后通过将 DAY_OF_MONTH 值指定为 15，我们得到一个新的日期 2012-10-15。

时态类型可以用时间域来指定。计时场支持的字段如下:

• 星期几

• 对齐 _ 周 _ 月 _ 日

• 年 _ 月 _ 日 _ 周 _ 对齐

• 月日

• 一年中的第 _ 天

• 纪元日

• 每月的第 _ 周

• 对齐 _ 周 _ 年

• 年月日

• prolective _ MONTH

• 纪元年

• 年

• 时代

它需要两个参数，第一个是时态类型，第二个是Long类型。给出了该方法的语法。

句法

public LocalDate with(TemporalField field, long newValue)

参数:

字段- 要在结果中设置的字段。

新值- 日期中字段的新值。

返回:

它基于此返回带有指定字段的本地日期。

举例时间:

让我们举一个例子，通过设置字段的新值来创建新日期。这里，我们使用with()方法设置日期的新日期。

import java.time.LocalDate;
import java.time.temporal.ChronoField;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.with(ChronoField.DAY_OF_MONTH, 15);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:2002-01-15

另一个例子的时间:

我们再举一个例子来理解with()法。这里，我们通过指定年中的某一天值来设置新的日期值。

import java.time.LocalDate;
import java.time.temporal.ChronoField;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.with(ChronoField.DAY_OF_YEAR, 35);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:2002-02-04

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.withDayOfMonth()方法

原文：https://www.studytonight.com/java-examples/java-localdate-withdayofmonth-method

方法用于获取带有新的月日的日期。它返回这个LocalDate的一个副本，更改了月日。例如，我们有一个日期 2015-12-14，那么将月日设置为 10 将导致 2015-12-10。

如果结果日期无效，则会引发异常。

它需要一个 int 类型的参数。给出了该方法的语法。

句法

public LocalDate withDayOfMonth(int dayOfMonth)

参数:

日期月- 要在结果日期中设置的月份中的某一天。

返回:

根据请求日期返回一个本地日期。

举例时间:

让我们举个例子，通过设置一个月中某一天的新值来创建一个新日期。在这里，我们使用withDayOfMonth()方法为日期设置新的一天。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.withDayOfMonth(30);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:2002-01-30

实时示例:

尝试一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.withDayOfYear()方法

原文：https://www.studytonight.com/java-examples/java-localdate-withdayofyear-method

方法用于获取一年中新的一天的日期。它会返回一份更改了日期的本LocalDate。例如，我们有一个日期 2015-01-14，那么将一年中的某一天设置为 20 将导致 2015-01-20。

如果结果日期无效，则会引发异常。

它需要一个 int 类型的参数。给出了该方法的语法。

句法

public LocalDate withDayOfYear(int dayOfYear)

参数:

dayOfYear - 在结果日期中设置的一年中的某一天。

返回:

根据请求日期返回一个本地日期。

举例时间:

让我们举个例子，通过设置一年中某一天的新值来创建一个新日期。在这里，我们使用withDayOfYear()方法为日期设置新的一天。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.withDayOfYear(30);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:2002-01-30

另一个例子的时间:

我们再举一个例子来理解withDayOfYear()法。在这里，我们将一年中的某一天设置为 300，并获得一个新的日期。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.withDayOfYear(300);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:2002-10-27

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.withMonth()方法

原文：https://www.studytonight.com/java-examples/java-localdate-withmonth-method

方法用于获取一年中新月份的日期。它会返回一份这个LocalDate的副本，并更改月份。例如，我们有一个日期 2015-01-14，那么将一年中的月份设置为 10 将导致 2015-10-14。

如果年月日对该年无效，它将被更改为该月的最后一个有效日期。

它需要一个 int 类型的参数。给出了该方法的语法。

句法

public LocalDate withMonth(int month)

参数:

月- 要在结果中设置的年月。

返回:

根据请求月份的日期返回本地日期。

举例时间:

让我们举个例子，通过设置一年中某个月的新值来创建一个新日期。这里，我们使用withMonth()方法为日期设置一个新的月份。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.withMonth(10);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:2002-10-10

另一个例子的时间:

我们再举一个例子来理解withMonth()法。在这里，我们将一年中的某个月设置为 12，并获得一个新的日期。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.withMonth(12);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:2002-12-10

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java LocalDate.withYear()方法

原文：https://www.studytonight.com/java-examples/java-localdate-withyear-method

Java withYear()方法用于获取具有指定新年的日期。它返回一份带有年份变更的本LocalDate。例如，我们有一个日期 2015-01-14，然后将年份设置为 2010 将导致 2010-01-14。

如果年月日对该年无效，它将被更改为该月的最后一个有效日期。

它需要一个 int 类型的参数。给出了该方法的语法。

句法

public LocalDate withYear(int year)

参数:

年份- 要在结果中设置的年份。

返回:

根据请求年份的日期返回本地日期。

举例时间:

让我们举个例子，通过设置一年的新值来创建一个新的日期。在这里，我们使用withYear()方法为日期设置新的一年。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.withYear(2011);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:2011-01-10

另一个例子的时间:

我们再举一个例子来理解withYear()法。在这里，我们将年份设置为 20，并获得一个新的日期。

import java.time.LocalDate;
public class DateDemo {

	public static void main(String[] args){  

		LocalDate localDate = LocalDate.of(2002, 01, 10);
		System.out.println(localDate);
		localDate = localDate.withYear(20);
		System.out.println("New Date : "+localDate);
	}
}

2002-01-10
新日期:0020-01-10

实时示例:

试着用一个真实的例子，用我们强大的在线 Java 编译器立即执行代码。

---

---

Java 示例

Java 中的TreeMap

原文：https://www.studytonight.com/java-examples/treemap-in-java

TreeMap类实现了映射接口，并且是 Java 集合接口的一部分。与其他映射实现不同，TreeMap以排序顺序存储键值对。

在本教程中，我们将了解更多关于 TreeMap 的排序功能。

TreeMap中的自然排序

默认情况下，TreeMap存储按关键字排序的条目。按键通过使用它们的自然排序来排序。例如，整数的自然顺序是升序。同样，字符串的自然顺序是字母顺序。

让我们创建一个存储整数-字符串对的TreeMap。当我们打印映射时，输出按排序顺序显示。

import java.util.Map.Entry;
import java.util.TreeMap;

public class TreeMapDemo
{
	public static void main(String[] args)
	{
		TreeMap<Integer, String> map = new TreeMap<>();
		map.put(4, "Harry");
		map.put(3, "Simon");
		map.put(2, "Jessica");
		map.put(5, "Victor");
		map.put(1, "Justin");

		//Printing the TreeMap
		for(Entry<Integer, String> e : map.entrySet())
			System.out.println(e.getKey() + "-->" + e.getValue());
	}
}

【Justin】
【2】>【Jessica】
【3】>【Simon】
【4】>【Harry】
【5】>victor

让我们使用字符串作为键并查看输出。

import java.util.Map.Entry;
import java.util.TreeMap;

public class TreeMapDemo
{
	public static void main(String[] args)
	{
		TreeMap<String, Integer> map = new TreeMap<>();
		map.put("Harry", 4);
		map.put("Jessica", 2);
		map.put("Victor", 5);
		map.put("Simon", 3);
		map.put("Justin", 1);

		//Printing the TreeMap
		for(Entry<String, Integer> e : map.entrySet())
			System.out.println(e.getKey() + "-->" + e.getValue());
	}
}

【哈利】>【4】【杰西卡】>【2】【贾斯汀】>【1】【西蒙】>【3】【维克多】> 5

Comparable接口用于设置自定义类的自然顺序。让我们创建一个实现Comparable接口的学生类。我们需要按学生的姓名(字母顺序)对他们进行排序。TreeMap 将自动使用 compareTo()方法中定义的自然顺序对数据进行排序和存储。

import java.util.Map.Entry;
import java.util.TreeMap;

class Student implements Comparable
{
	String name;
	Double gpa;

	Student(String s, Double d)
	{
		this.name = s;
		this.gpa = d;
	}

	//Defining the natural ordering for Students
	@Override
	public int compareTo(Object o)
	{
		return this.name.compareTo(( (Student) o).name);
	}
}
public class TreeMapDemo
{
	public static void main(String[] args)
	{
		TreeMap<Student, String> map = new TreeMap<>() ;
		map.put((new Student("Harry", 4.0)), "Harry");
		map.put((new Student("Jessica", 2.8)), "Jessica");
		map.put((new Student("Victor", 3.9)), "Victor");
		map.put((new Student("Simon", 4.4)), "Simon");
		map.put((new Student("Justin",3.01)), "Justin");

		//Printing the TreeMap
		for(Entry<Student, String> e : map.entrySet())
			System.out.println(e.getKey().gpa + "-->" + e.getValue());
	}
}

4.0 - >哈利
【2.8】>【Jessica】
【3.01】>【Justin】
【4.4】>【Simon】
【3.9】>victor

定义不同的排序顺序

在某些情况下，自然排序可能并不理想。TreeMap构造器可以用一个Comparator作为参数。我们可以使用这个Comparator来定义排序关键字的不同顺序。

例如，如果我们想以降序存储密钥，我们可以使用逆序Comparator。

import java.util.Comparator;
import java.util.Map.Entry;
import java.util.TreeMap;

public class TreeMapDemo
{
	public static void main(String[] args)
	{
        //Passing reverse order Comparator
		TreeMap<String, Integer> map = new TreeMap<>(Comparator.reverseOrder());
		map.put("Harry", 4);
		map.put("Jessica", 2);
		map.put("Victor", 5);
		map.put("Simon", 3);
		map.put("Justin", 1);

		//Printing the TreeMap
		for(Entry<String, Integer> e : map.entrySet())
			System.out.println(e.getKey() + "-->" + e.getValue());
	}
}

【西蒙】>【3】【贾斯汀】>
【杰西卡】>【2】【哈利】> 4

让我们尝试创建一个自定义的Comparator来处理前面定义的学生类。我们将根据学生的平均成绩对他们进行排序，而不是按他们的名字进行排序。在TreeMap中，绩点较高的学生应该是第一名。

import java.util.Comparator;
import java.util.Map.Entry;
import java.util.TreeMap;

class Student
{
	String name;
	Double gpa;

	Student(String s, Double d)
	{
		this.name = s;
		this.gpa = d;
	}
}
public class TreeMapDemo
{
	public static void main(String[] args)
	{
		//Comparator to sort by descending order of GPA
        Comparator<Student> c = (Student s1, Student s2) -> (-s1.gpa.compareTo(s2.gpa));		
		TreeMap<Student, String> map = new TreeMap<>(c) ;
		map.put((new Student("Harry", 4.0)), "Harry");
		map.put((new Student("Jessica", 2.8)), "Jessica");
		map.put((new Student("Victor", 3.9)), "Victor");
		map.put((new Student("Simon", 4.4)), "Simon");
		map.put((new Student("Justin",3.01)), "Justin");

		//Printing the TreeMap
		for(Entry<Student, String> e : map.entrySet())
			System.out.println(e.getKey().gpa + "-->" + e.getValue());
	}
}

4.4 - >西蒙
【4.0】>【哈利】
【3.9】>【victor】
【3.01】>【Justin】
【2.8】>Jessica

TreeMap是如何在 Java 中实现的？

• TreeMap 实现了 NavigableMap 接口。它使用名为红黑树的高级数据结构来存储和排序键值对。
• 红黑树和普通的二分搜索法树非常相似。就像二叉查找树一样，红黑树将包含一个根，一个左子树和一个右子树。左子树的所有节点都应该小于该节点，右树的所有节点都应该大于该节点。
• 对于所有其他节点，该属性应该为真。物体的自然顺序决定了物体的大小。
• 与普通的 BST 不同，红黑树是自动平衡的。这确保了没有一半的树变得比另一半更深。
• 简而言之，对于树上的基本操作，这个属性给出了 O(logN)的时间复杂度。另一方面，BST 可以给出 O(N)的最坏情况时间复杂度。

常见的TreeMap方法

TreeMap 类提供了额外的方法来利用键的排序顺序。让我们来看看 TreeMap 类的一些重要方法。

• firstKey() 方法用于从TreeMap中获取第一个或最小的键。
• 同样，使用 lastKey() 方法从映射中获取最大的关键点。
• 头标()方法以一个按键作为输入。它返回一个包含小于传递的键的键-值对的映射。
• 类似地， tailMap() 方法获取一个键，并返回一个包含所有大于等于传递的键的键值对的映射。

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapDemo
{
	public static void main(String[] args)
	{
		TreeMap<String, Integer> map = new TreeMap<>();
		map.put("Harry", 4);
		map.put("Jessica", 2);
		map.put("Victor", 5);
		map.put("Simon", 3);
		map.put("Justin", 1);
		System.out.println("The TreeMap is: ");
		for(Entry<String, Integer> e : map.entrySet())
			System.out.println(e.getKey() + "-->" + e.getValue());

		String smallestKey = map.firstKey();
		String largestKey = map.lastKey();
		Set<String> keysSmallerThanVictor = map.headMap("Victor").keySet();//Excludes Victor
		Set<String> keysGreaterThanJustin = map.tailMap("Justin").keySet();//Includes Justin

		System.out.println("\nSmallest Key: " + smallestKey);
		System.out.println("Largest Key: " + largestKey);
		System.out.println("Keys Smaller than Victor: " + keysSmallerThanVictor);
		System.out.println("Keys Greater than Justin: " + keysGreaterThanJustin);
	}
}

TreeMap为:
哈利- > 4
杰西卡- > 2
贾斯汀- > 1
西蒙- > 3
维克多->5
T7】最小的钥匙:哈利
最大的钥匙:维克多
比维克多小的钥匙:【哈利、杰西卡、贾斯汀、西蒙】
比贾斯汀大的钥匙:【贾斯汀、西蒙、维克多】

什么时候使用 TreeMap？

• HashMap 没有保持插入的顺序，更多地被用作通用映射。存储和获取数据非常高效和快速。
• LinkedHashMap 也非常快，并且还保持了插入的顺序。
• 当我们想要以排序顺序存储键值对时，TreeMap比 HashMap 和 LinkedHashMap 更受欢迎。我们可以完全控制数据在TreeMap中的存储顺序。
• 然而，排序会对TreeMap的整体性能造成影响。
• 这一切都归结为我们正在努力完成的任务。如果性能至关重要，那么更喜欢 HashMap 或 LinkedHashMap。如果数据必须按排序顺序存储，那么 TreeMap 应该是首选。

摘要

TreeMap 是一个重要的 Java 集合。TreeMap使用红黑树。这将确保元素的插入、删除和搜索花费对数时间。但是它的性能不如 HashMap 或者 LinkedHashMap。TreeMap 类为键值对的排序提供了很大的灵活性。我们可以使用键的自然顺序，也可以使用Comparator定义自己的顺序。在本教程中，我们讨论了 TreeMap 类的基础知识以及如何有效地使用它。

---

---

Java 中的快速排序

原文：https://www.studytonight.com/java-examples/quicksort-in-java

快速排序是一种流行的排序算法，使用分治范式对数组进行排序。快速排序和归并排序一样，平均时间复杂度为 O(N log N) ，但在最坏的情况下，其性能可能会恶化。

在本教程中，我们将学习快速排序算法，并在 Java 中实现它。

快速排序算法

• 如上所述，快速排序算法使用分治方法对数组进行排序。
• 快速排序算法从选择一个枢轴元素开始。我们需要把这个枢轴放在正确的位置。
• 但并没有就此结束。我们还需要把所有小于枢轴的元素放在枢轴元素的左边，所有大于枢轴的元素都要放在它的右边。
• 我们的问题现在被分成两个更小的子问题，我们也有一个数组元素在它的正确位置。现在，我们只需要在枢轴左边的元素和数组右边的元素上递归地重复这个过程。

让我们借助一个例子来理解上面的方法。假设我们必须对以下数组进行排序- [5，10，7，1，2，11，25，6]，元素六被选为轴心。我们将使用最初设置为-1 的指针。

这个指针左边的所有数组元素(包括指针上的元素)都应该小于我们的轴。

我们将遍历整个数组，每当我们遇到比轴小的元素时，我们将增加我们的指针，并将这个较小的元素放在那个位置。以下步骤解释了分区过程。

迭代从数组的第一个元素开始，即 5。这小于透视，因此我们将更新指针值，并将此元素放在索引处。

• 下一个元素是 10，它不小于 6，所以我们将简单地移动到下一个元素。
• 7 也大于 6，所以我们继续。
• 下一个元素是 1，小于 6。我们将增加我们的指针，并用元素 1 交换那个位置的元素。

• 下一个元素是 2，它再次小于 6，所以我们将增加指针，并交换值。

• 接下来的元素是 11 和 25，它们都大于 6，所以我们不会改变任何东西。
• 循环结束，我们将再次增加指针，并将枢轴放在这个位置。

枢轴元素的重要性

• 枢轴元素在决定快速排序算法的效率方面起着至关重要的作用。为了获得最佳效率，枢轴元件应将数组分成相等的两半。但是在数组中寻找这样的元素会增加时间复杂度。
• 最坏的情况是枢轴总是被选为数组中最小或最大的元素。在这些情况下，数组根本不会被划分，因为所有剩余的元素要么大于透视，要么小于透视。
• 快速排序的大多数实现要么选择第一个元素，要么选择最后一个元素作为轴心。这种方法的一个主要缺点是，如果数组已经排序，那么我们总是选择数组中最小或最大的元素。
• 解决这个问题常用的方法是随机选择一个支点。这将大大减少在每次迭代中获得最小或最大元素的机会。

Java 中的快速排序实现

我们将使用两种方法来实现快速排序。一种方法是选择一个枢轴，并将其放置在正确的位置，它还会将数组拆分为两个更小和更大的元素。我们将此称为分区()方法。

public static int partition(int[] arrToSort, int leftIdx, int rightIdx)
{
	int i = leftIdx - 1;
	int pivot = arrToSort[rightIdx];//the rightmost element is chosen as the pivot

	for(int j = leftIdx; j < rightIdx; j++)
	{
		//if current element is smaller than pivot then add it to the left half
		if(arrToSort[j] < pivot)
		{
			i += 1;
			int temp = arrToSort[j];
			arrToSort[j] = arrToSort[i];
			arrToSort[i] = temp;
		}
	}

	//add pivot element at its correct position
	int temp = arrToSort[i + 1];
	arrToSort[i + 1] = pivot;
	arrToSort[rightIdx] = temp;

	//return the sorted position of the pivot element
	return i + 1;
}

另一个方法将被称为 quicksort() ，它将负责递归调用。

public static void quickSort(int[] arrToSort, int leftIdx, int rightIdx)
{
	if(leftIdx >= rightIdx)//array contains less than 2 elements
		return;

	int partitionIdx = partition(arrToSort, leftIdx, rightIdx);//getting the index of the pivot

	quickSort(arrToSort, leftIdx, partitionIdx - 1);//sorting the array to the left of pivot
	quickSort(arrToSort, partitionIdx + 1, rightIdx);//sorting the array to the right of pivot
}

让我们检查我们的代码是否正确工作，并给出所需的输出。

import java.util.Arrays;
public class QuickSortDemo
{
    public static void main(String[] args)
	{
		int[] arr1 = {7, 9, 1, 2, 10, 15, 6};
		int[] arr2 = {1, 2, 3, 4, 5, 6, 7, 8};
		int[] arr3 = {1};
		int[] arr4 = {-5, 2,-1, 0, 11, 20, -20};

		quickSort(arr1, 0, arr1.length - 1);
		quickSort(arr2, 0, arr2.length - 1);
		quickSort(arr3, 0, arr3.length - 1);
		quickSort(arr4, 0, arr4.length - 1);

		System.out.println(Arrays.toString(arr1));
		System.out.println(Arrays.toString(arr2));
		System.out.println(Arrays.toString(arr3));
		System.out.println(Arrays.toString(arr4));
	}
}

【1、2、6、7、9、10、15】
【1、2、3、4、5、6、7、8】
【1】
【-20、-5、-1、0、2、11、20】

时间和空间复杂性

正如前面几节所讨论的，快速排序的效率取决于枢轴元素的选择。最佳情况和平均情况的时间复杂度为 O(NLogN) ，其中 N 是输入数组的长度。然而，在最坏的情况下，时间复杂度可以上升到 O(N^2) 。

QuickSort 是一个原地算法，也就是说它使用的是常数空间。所以空间复杂度的快速排序是 O(1) 。

摘要

快速排序是一种高效的排序算法，对于排序大量数据非常有用。快速排序算法的工作原理是选择一个枢轴元素并将其放置在正确的位置。它还将所有较小的元素放在枢轴的左侧，所有较大的元素放在其右侧。枢轴的选择会影响该算法的整体复杂度，但是随机选择枢轴将最大程度地给出最优复杂度。

---

---

Java POJO 类

原文：https://www.studytonight.com/java-examples/java-pojo-class

POJO 代表普通旧 Java 对象。它们是没有限制的普通物体。他们不受任何框架的约束。它们易于创建，增加了代码的可读性和可重用性。在本教程中，我们将了解更多关于 POJO 的信息。

普通旧 Java 对象

如上所述，这些对象没有任何限制。它们可以以任何方式创建和使用。POJO 的方法和属性不需要遵循任何命名约定。

示例类中显示了一个 POJO 示例。它包含三个属性。这些属性不遵循任何特定的访问规则。字段 1 是公共的，而字段 2 是私有的。没有固定的约定用来定义设置者和获取者。字段 1 和字段 3 有 getters，但类中没有使用 setters。

//POJO
public class Sample
{
	public String field1;
	private int field2;
	double field3;

	Sample(String s, int i, double d)
	{
		this.field1 = s;
		this.field2 = i;
		this.field3 = d;
	}	
	public String getField1()
	{
		return this.field1;
	}	
	public double getField3()
	{
		return this.field3;
	}
}

有一些东西不应该成为任何 POJO 类的一部分。

• 一个 POJO 类不应该扩展任何类。
• 它不应该实现任何接口。
• POJO 不应包含任何预先指定的注释。

由于缺乏约定，POJO 类可能很难被其他程序员理解。当使用反射 API 分析时，POJO 类可能无法完美地工作。例如，如果我们试图查看前面定义的 POJO 类的属性，那么我们将不会得到预期的结果。字段 2 的数据丢失。

public static void main(String[] args) 
{
	Sample s = new Sample("f1", 0, 0.0);
	try
	{
		Map<String, Object> properties = BeanUtils.describe(s);//Fetching object class details
		for(Map.Entry<String, Object> e : properties.entrySet())
			System.out.println(e.getKey() + "->" + e.getValue());
	}
	catch(Exception e)
	{
		System.out.print(e);
	}		
}

field 1->f1
field 3->0.0
级- >级样品

组件

Java Bean 类是一种特殊类型的 POJO 类。所有的 Java Bean 类都是 POJO，但并不是所有的 POJO 都可以称为 Java Bean。为了纠正 POJO 类的一些问题，Java Bean 类必须遵循一些标准的规则和约定。下面给出了一个 Java Bean 类应该遵循的约定。

• 所有类属性必须是私有的。
• 必须编写标准的 Getter 和 Setter 方法。
• 需要创建一个默认无参数构造器。
• 这个类必须实现 Serializable 接口。

让我们将示例 POJO 类转换成一个 Java Bean 类。

import java.io.Serializable;
//JavaBean
public class Sample implements Serializable//Class must implement Serializable
{
	//All fields must be private
	private String field1;
	private int field2;
	private double field3;

	//A default no-argument constructor must be present
	Sample()
	{}

	Sample(String s, int i, double d)
	{
		this.field1 = s;
		this.field2 = i;
		this.field3 = d;
	}
	//Getters and Setters must be present for all fields
	public String getField1() {
		return field1;
	}
	public void setField1(String field1) {
		this.field1 = field1;
	}
	public int getField2() {
		return field2;
	}
	public void setField2(int field2) {
		this.field2 = field2;
	}
	public double getField3() {
		return field3;
	}
	public void setField3(double field3) {
		this.field3 = field3;
	}
}

现在，我们还可以使用反射来查看属性。所有三个字段都显示在输出中。

public static void main(String[] args) 
{
	Sample s = new Sample("f1", 0, 0.0);
	try
	{
		Map<String, Object> properties = BeanUtils.describe(s);
		for(Map.Entry<String, Object> e : properties.entrySet())
			System.out.println(e.getKey() + "->" + e.getValue());
	}
	catch(Exception e)
	{
		System.out.print(e);
	}		
}

field 1->f1
field 3->0.0
class->class 样本
field2- > 0

Java Bean 类解决了 POJO 类的一些问题，但是它们并不完美。我们的 Java Bean 类必须为每个属性都有一个 getter 和 setter 方法，即使对它没有要求。由于强制 setter 方法的存在，Java Bean 类属性是可变的。默认构造器在某些情况下是不需要的，但是对于一个 Java Bean 类来说是必需的。

摘要

POJO 或普通的旧 Java 对象是简单的对象，不需要遵循任何严格的约定。用户可以用任何方式创建 POJO 类。Java Bean 类试图通过在它们身上强加一组规则来解决 POJO 类的问题。

---

---

Java 类型转换（向下转换，向上转换）

原文：https://www.studytonight.com/java-examples/java-object-type-casting

类型转换是数据类型的转换过程。对象类型转换可以有两种类型，这取决于我们是从父类型转换为子类型，还是从父类型转换为子类型。在本教程中，我们将学习 Java 中对象的向上转换和向下转换。

向上抛

• 将子类的一个对象投射到父类的过程称为向上投射。
• 可以通过隐式或显式进行向上转换。
• 上播会减少方法的选择，我们可以用在类型化的对象上。
• 但是，对于被覆盖的方法，静态或动态绑定开始起作用，它将决定要使用的方法实现。

为了演示向上转换，我们将使用一个子类和一个父类。子类有一个覆盖的 print()方法和一个 printName()方法。下面的代码显示了实现。

class SuperClass
{
    public void print()
    {
        System.out.println("Printing from SuperClass");
    }
}
class Child extends SuperClass
{
	String name;
	Child(String s)
	{
		this.name = s;
	}	
	@Override
    public void print()
	{
    	System.out.println("Printing from Child class");
    }	
    public void printName()
    {
    	System.out.println(this.name); 
    }
}

隐式向上转换

当我们将子类的一个对象分配给超Class类型的引用变量时，就会发生隐式上转换。我们可以在这个对象上使用 print()方法，并且将使用 Child 类的方法实现。

public static void main(String[] args)
{
	Child c = new Child("child");
	c.print();

	//Implicit Upcasting
	SuperClass s2 = new Child("Second Child");
	s2.print();//print() method of Child class is called due to dynamic binding
}

从子类打印
从子类打印

隐式向上转换的另一个例子如下所示。如果我们创建一个超Class类型的 ArrayList ，并向其中添加子类对象，那么它们将被隐式地向上投射到超类中。我们还创建了一个新类(另一个子类)。

import java.util.ArrayList;
class AnotherChild extends SuperClass
{
	public void print()
    {
        System.out.println("Printing from AnotherChild class");
    }
}
public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		SuperClass obj1 = new SuperClass();
		Child obj2 = new Child("First Child");
		AnotherChild obj3 = new AnotherChild();

		ArrayList<SuperClass> superClassList = new ArrayList<>();
		superClassList.add(obj1);
		superClassList.add(obj2);
		superClassList.add(obj3);

		for(int i=0; i<superClassList.size(); i++)
			superClassList.get(i).print();
	}
}

从父类打印
从子类打印
从另一子类打印

显式向上转换

我们也可以显式地强制转换对象，但这并不是真正必需的。

public static void main(String[] args)
{
	Child c = new Child("child");
	c.print();

	//Explicit Upcasting
	SuperClass s2 = (SuperClass) new Child("Second Child");
	s2.print();//print() method of Child class is called due to dynamic binding
}

从子类打印
从子类打印

向上广播缩小了方法的选择范围

如上所述，上播将缩小我们对方法的选择。例如，在将一个子类对象向上转换为超类之后，我们就不能再使用子类的 printName()方法了。我们会得到一个编译错误。

public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		SuperClass s = new Child("First Child");
		s.printName();//Error
	}
}

线程“main”Java . lang . error:未解决的编译问题:
方法 printName()对于 type casting demo . main(type casting demo . Java:36)处的类型 SuperClass

未定义

带接口的上播

上播也适用于接口。让我们创建一个新的接口，并在我们的子类中实现它。

interface Name
{
	public void printName();
}
class Child extends SuperClass implements Name
{
	String name;
	Child(String s)
	{
		this.name = s;
	}	
	@Override
    public void print()
	{
    	System.out.println("Printing from Child class");
    }	
    public void printName()
    {
    	System.out.println(this.name); 
    }
}

现在，我们将创建一个子类的对象，并将其分配给一个接口类型变量。在这种情况下，将发生隐式类型转换。我们可以使用实现的 printName()方法。

public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		Name obj = new Child("First Child");
		obj.printName();
	}
}

第一个孩子

但是我们不能使用覆盖的 print()方法。

public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		Name obj = new Child("First Child");
		obj.print();//Error
	}
}

线程“main”Java . lang . error:未解决的编译问题:
type casting demo . main(type casting demo . Java:51)处的类型 Name

的方法 print()未定义

向上转换到对象类

所有类在内部扩展对象类。对象类是所有其他类的超类。因此，我们可以将子类(或任何其他类)向上转换为对象类。

public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		Object o = new Child("hello");
		System.out.print(o.getClass());
	}
}

儿童班

Java 中的向下转换

• 下播可以认为是上播的反转。我们正在将父类的一个对象类型化为子类。
• 与向上转换不同，向下转换不是由编译器隐式完成的。

正如我们在 upcasting 中看到的，下面的代码给出了一个错误。

public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		SuperClass s = new Child("First Child");
		s.printName();//Error
	}
}

为了使它工作，我们可以从超类向下转换到子类。这将使我们能够访问 Child 类的 print()方法。

public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		SuperClass s = new Child("First Child");
		((Child) s ).printName();//Downcasting from SuperClass to Child class.
	}
}

第一个孩子

类型转换中的类转换异常

ClassCastException是向下转换时经常遇到的异常。下面的代码演示了这个错误。

我们创建了一个新的另一个子类，在 main()方法中，我们创建了三个对象，每个类一个(超Class类、子类和另一个子类)，我们将它们添加到一个ArrayList中。现在，当我们将每个对象转换到 Child 类时，我们会得到这个错误。这是因为在另一个子类和子类之间没有父子关系。所以我们不能从一个孩子变成另一个孩子。

class AnotherChild extends SuperClass
{
	public void print()
    {
        System.out.println("Printing from AnotherChild class");
    }
}
public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		ArrayList<SuperClass> list = new ArrayList<>();
		SuperClass s = new Child("First Child");
		Child c1 = new Child("Second Child");
		AnotherChild c2 = new AnotherChild();

		list.add(s);
		list.add(c1);
		list.add(c2);

		for(int i=0; i<list.size(); i++)
		{
			((Child) list.get(i)).printName();
		}	
	}
}

第一个孩子
第二个孩子
线程“main”中出现异常 java.lang.ClassCastException:类 otherChild 不能强制转换为类 Child(other Child 和 Child 位于加载程序“app”的未命名模块中)
的 typescasting demo . main(typescasting demo . Java:57)

我们可以使用运算符的实例来纠正这个错误。如果对象是特定类型的，该运算符返回真。在向下转换之前，我们可以通过使用 instanceof 运算符来更正上面的代码。

public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		ArrayList<SuperClass> list = new ArrayList<>();
		SuperClass s = new Child("First Child");
		Child c1 = new Child("Second Child");
		AnotherChild c2 = new AnotherChild();

		list.add(s);
		list.add(c1);
		list.add(c2);

		for(int i=0; i<list.size(); i++)
		{
			if(list.get(i) instanceof Child)
				((Child) list.get(i)).printName();
		}
	}
}

第一个孩子
第二个孩子

使用 cast()和 isInstance()方法

Java 提供了一种向下转换的替代方式。我们可以使用 cast()方法从超类向下转换到子类。同样，isInstance()方法可以替换 instanceof 运算符。这两种方法在泛型方法中经常一起使用。让我们使用这些方法覆盖上面的代码。

public class TypeCastingDemo
{
	public static void main(String[] args)
	{
		ArrayList<SuperClass> list = new ArrayList<>();
		SuperClass s = new Child("First Child");
		Child c1 = new Child("Second Child");
		AnotherChild c2 = new AnotherChild();

		list.add(s);
		list.add(c1);
		list.add(c2);

		for(int i=0; i<list.size(); i++)
		{
			if(Child.class.isInstance(list.get(i)))
			{
				Child c = Child.class.cast(list.get(i));
				c.printName();
			}
		}
    }
}

第一个孩子
第二个孩子

总结

在本教程中，我们学习了如何在 Java 中向上转换和向下转换对象。上转换可以隐式或显式完成，并将类型从子类转换为超类。它缩小了我们可以对对象使用的方法的范围。向下转换是将超类转换为子类的过程。我们只能显式向下转换对象。执行向下转换是为了访问子类的方法和属性。我们必须使用 instanceof 运算符或 isInstance()方法来安全地进行向下转换。这样做是为了避免 ClassCastException。

---

---

Java 中的迪克斯特拉算法

原文：https://www.studytonight.com/java-examples/dijkstras-algorithm-in-java

迪克斯特拉算法是一种流行的算法，用于处理图形。该算法寻找从源顶点到加权图的所有其他顶点的最短距离。

在本教程中，我们将学习该算法的工作原理，并在 Java 中实现它。

迪克斯特拉算法

如上所述，迪克斯特拉算法用于解决加权图的最短路径问题。在每次迭代中，算法都会找到最接近当前节点的节点。然后，它探索这个最近的节点，并重复上述步骤。我们需要维护到每个节点的距离列表。这将有助于我们确定下一个要探索的节点。

该算法在每次迭代中选择最优路径，而不用担心后面会发生什么，因此被归类为贪婪算法。以下步骤解释了算法的工作原理。

• 我们首先创建一个距离数组来存储从源到顶点的距离。我们还创建了一个访问过的数组来指示我们是否已经确定了一个节点的最短距离。
• 接下来，我们将创建一个循环，只要我们没有找到每个节点的最短距离，这个循环就会运行。
• 在循环中，我们将找到最近的节点，其最短距离尚未计算。该节点不应出现在受访数组中。
• 接下来，我们将探索该节点的所有相邻邻居。如果我们可以通过最近的节点到达一个节点，并且移动的距离更少，那么我们将更新该节点的最短距离。基本上，我们将更新节点 X 的最短距离，如果:

(current shortest distance from source to the current closest node) + (distance from the current closest node to node X) < (current shortest distance from source to node X)

让我们借助一个例子来试着理解这个算法。我们将处理下图。我们将创建一个距离数组，并将每个元素(除了源)初始化为无穷大。顶点的命名从 0 到 5。使用索引更新距离数组会更容易。

我们将当前节点的每个邻居的距离(此步骤中为 0)添加到数组中。现在我们从距离数组中选择最近的未访问节点。所以选择节点 3。节点 3 的最短距离已经确定。

接下来，我们将为节点 3 的所有邻居更新距离数组。我们只会更新距离，如果我们可以通过更少的距离到达一个节点。现在距离最后确定的最近节点是节点 4。节点 4 的最短距离已经确定。

现在，从节点 4，我们可以通过更短的距离到达节点 1。因此，我们将更新节点 1 的距离数组值。下一个最近的未处理节点是节点 5。

从节点 5 开始，我们无法通过更短的距离到达任何节点。所以这一步不会更新距离值。节点 1 被选为下一个最接近的节点。

从节点 1 开始，唯一可以更新距离的节点是节点 2。下一个最近的节点也将是节点 2。现在，已经访问了所有节点，并且为所有节点确定了最短距离。循环将终止。

最后的最短距离数组是[0，27，34，18，21，25]。

迪克斯特拉算法的缺点

Dijkstra 算法的一个主要缺点是它不能处理负边缘权重。发生这种情况是因为 Dijkstra 的算法使用了贪婪的方法。无论何时从距离数组中选择最近的节点，我们都会将该节点的距离标记为最终确定。我们永远不会更新那个节点的距离。这对于正权重非常有效，但是对于负边缘权重可能给出不一致的解决方案。

例如，考虑以下具有负边权重的有向加权图。

让我们考虑顶点 A 作为源。在第一次迭代中，更新了 B 和 C 的距离。由于 C 是最近的节点，我们将该节点的最短最终距离标记为 5。从 C 开始，我们无法到达任何其他节点。下一个节点 B 将被选为最近的，并且该节点的距离也被标记为最终距离。所有节点都已被访问，最短距离已确定，因此算法结束。但是我们可以通过更短的距离(-6)经由节点 B 到达节点 C。但是 Dijkstra 的算法说从 A 到 C 的最短距离是 5。

迪克斯特拉算法的实现

让我们先来看看我们的 Graph 类。它有一个二维邻接矩阵，和一个用于存储顶点数量的整数变量。它还有一个 addEdge() 方法。我们使用有向图来实现，因此当添加边时，邻接矩阵的两个单元将被更新。

class Graph
{
	int[][] adjMatrix;
	int numOfvertices;

	Graph(int[][] mat, int v)
	{
		this.adjMatrix = mat;
		this.numOfvertices = v;
	}

	void addEdge(int src, int dest, int edgeWeight)
	{
		adjMatrix[src][dest] = edgeWeight;
		adjMatrix[dest][src] = edgeWeight;
	}
}

让我们用 Java 实现 Dijkstra 的算法。我们将使用名为 getClosestVertex() 的辅助方法来查找最近的未访问节点。该方法的代码如下所示。

public static int getClosestVertex(int[] distance, boolean[] visited)
{
	int min = Integer.MAX_VALUE;
	int minIdx = -1;
	for(int i=0; i<distance.length; i++)
	{
		if(distance[i] < min)
			if(visited[i] == false)
			{
				min = distance[i];
				minIdx = i;
			}
	}
	return minIdx;
}

接下来，我们将在一个dijkstrashortestpath()方法中实现主算法。该方法将采用一个图形和一个源顶点作为参数。它将返回一个最短距离数组。

public static int[] dijkstrasShortestPath(Graph g, int src)
{
	//final shortest distance array
	int[] distance = new int[g.numOfvertices];
	//array to tell whether shortest distance of vertex has been found
	boolean[] visited = new boolean[g.numOfvertices];

	//initializing the arrays
	for(int i=0; i<g.numOfvertices; i++)
	{
		distance[i] = Integer.MAX_VALUE;//initial distance is infinite
		visited[i] = false;//shortest distance for any node has not been found yet
	}
	distance[src] = 0;

	for(int i=0; i<g.numOfvertices; i++)
	{
		int closestVertex = getClosestVertex(distance, visited);//get the closest node
		//if closest node is infinite distance away, it means that no other node can be reached. So 
        return
		if(closestVertex == Integer.MAX_VALUE)
			return distance;

		visited[closestVertex] = true;
		for(int j=0; j<g.numOfvertices; j++)
		{
			if(visited[j] == false)//shortest distance of the node j should not have been finalized
			{
				if(g.adjMatrix[closestVertex][j] != 0)
				{
					int d = distance[closestVertex] + g.adjMatrix[closestVertex][j];
					if(d < distance[j])//distance via closestVertex is less than the initial distance
						distance[j] = d;
				}
			}		
		}
	}
	return distance;
}

让我们检查一下我们的代码是否给出了预期的结果。

import java.util.Arrays;

public static void main(String[] args)
{
	int numOfVertices = 6;
	int[][] adjMat = new int[6][6];
	Graph graph = new Graph(adjMat, numOfVertices);
	graph.addEdge(0, 4, 21);
    graph.addEdge(0, 3, 18);
    graph.addEdge(2, 1, 7);
    graph.addEdge(1, 4, 6);
    graph.addEdge(4, 5, 10);
    graph.addEdge(4, 3, 11);
    graph.addEdge(5, 3, 7);
    int[] dist = dijkstrasShortestPath(graph, 0);
	System.out.print(Arrays.toString(dist));
}

【0、27、34、18、21、25】

空间和时间复杂性

对于每次迭代，我们都在计算从最近的节点到所有剩余节点的距离。这导致了 O(V^2) 的时间复杂性，其中 v 是顶点的数量。

我们还维护了两个数组(距离和访问)，因此需要一个与顶点数量相等的额外空间。上述实现的空间复杂度为 O(V) 。

摘要

Dijkstra 算法用于寻找图的节点之间的最短距离。我们可以将该算法用于有向图和无向图，但它不适用于负边权重。我们可以通过使用最小堆或优先级队列来找到最近的节点，从而进一步优化我们的实现。

---

---

Java 中的ArrayDeque

原文：https://www.studytonight.com/java-examples/arraydeque-in-java

一个队列是一个简单的线性数据结构，允许我们从一端插入元素，从另一端移除元素。德清代表双头队列。与队列不同，一个队列可以在任意一端插入和移除元素。

在本教程中，我们将学习如何借助 ArrayDeque 类在 Java 中实现一个 Deque。

德格数据结构

如上所述，一个de quee 是一个允许从两端插入和删除的线性数据结构。这就是它被称为双端队列的原因。我们可以使用这种数据结构来实现其他线性数据结构，如栈和队列。我们将只允许从 Deque 的一个公共端插入和删除，以实现一个栈。为了使用 Deque 实现一个队列，我们将允许从一端插入，从另一端删除。

Java 中的 ArrayDeque

• Java 中的 ArrayDeque 类提供了一个动态数组，可以作为一个 Deque 使用。这个类 i 实现了德客和Queue接口。
• 它使用两个称为头和尾的指针。头部从前面负责插入和删除，尾部从末端负责插入和删除。
• 如果在前面添加了一个元素，则头部会向前移动(从左到右)。如果一个元素从前面移除，那么头部向后移动。
• 如果在末尾添加了一个元素，那么尾部会从右向左移动。如果从末端移除元素，则尾部会向前移动(从左到右)。

让我们来看看在数组上执行的一些常见操作。

插入(向数组添加元素)

我们可以在德格的前面或后面插入元素。ArrayDeque 提供了 offerFirst() 和 addFirst() 方法在 ArrayDeque 的前面添加元素。

import java.util.ArrayDeque;
import java.util.Deque;
public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    deck.addFirst(5);
	    deck.addFirst(10);
	    System.out.println("Deque After Inserting using addFirst(): " + deck);

	    deck.offerFirst(15);
	    deck.offerFirst(20);
	    System.out.println("Deque After Inserting using offerFirst(): " + deck);
	}
}

使用 addFirst()插入后的德格:【10，5】
使用 offerFirst()插入后的德格:【20，15，10，5】

我们可以使用 offerLast() 或 addLast() 方法在数组的后面插入元素。

import java.util.ArrayDeque;
import java.util.Deque;
public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    deck.addLast(5);
	    deck.addLast(10);
	    System.out.println("Deque After Inserting using addLast(): " + deck);

	    deck.offerLast(15);
	    deck.offerLast(20);
	    System.out.println("Deque After Inserting using offerLast(): " + deck);
	}
}

使用 addLast()插入后的去重:【5，10】
使用 offerLast()插入后的去重:【5，10，15，20】

删除(从数组中删除元素)

我们有 pollFirst() 和 removeFirst() 方法，它们可以从数组的前面移除元素，并返回出现在头部或 Deque 前面的元素。

import java.util.ArrayDeque;
import java.util.Deque;
public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    deck.addLast(5);
	    deck.addLast(10);  
	    deck.addLast(15);
	    deck.addLast(20);
	    System.out.println("Deque After Insertion: " + deck);

	    Integer i1 = deck.removeFirst();
	    System.out.println("Deleted Element: " + i1);
	    System.out.println("Deque after Deletion: " + deck);

	    Integer i2 = deck.pollFirst();
	    System.out.println("Deleted Element: " + i2);
	    System.out.println("Deque after Deletion: " + deck);
	}
}

插入后的德克尔:[5，10，15，20]
删除后的元素:5
删除后的德克尔:[10，15，20]
删除后的元素:10
删除后的德克尔:[15，20]

类似地，使用 pollLast() 和 removeLast() 方法来移除 Deque 的最后一个元素。

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    deck.addLast(5);
	    deck.addLast(10);  
	    deck.addLast(15);
	    deck.addLast(20);
	    System.out.println("Deque After Insertion: " + deck);

	    Integer i1 = deck.removeLast();
	    System.out.println("Deleted Element: " + i1);
	    System.out.println("Deque after Deletion: " + deck);

	    Integer i2 = deck.pollLast();
	    System.out.println("Deleted Element: " + i2);
	    System.out.println("Deque after Deletion: " + deck);
	}
}

插入后的德格:[5，10，15，20]
删除后的元素:20
删除后的德格:[5，10，15]
删除后的元素:15
删除后的德格:[5，10]

从数组中获取元素

我们可以使用 peekFirst() 或 getFirst() 方法轻松地从数组中获取第一个元素。正如您可能已经猜到的，我们有一个 peekLast() 和一个 getLast() 方法来从一个 Deque 中获取最后一个元素。

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    deck.addLast(5);
	    deck.addLast(10);  
	    deck.addLast(15);
	    deck.addLast(20);
	    System.out.println("Deque After Insertion: " + deck);

	    Integer i1 = deck.peekFirst();
	    Integer i2 = deck.getFirst();
	    System.out.println("First Element is(using peekFirst()): " + i1);
	    System.out.println("First Element is(using getFirst()): " + i2);

	    Integer i3 = deck.peekLast();
	    Integer i4 = deck.getLast();
	    System.out.println("Last Element is(using peekLast()): " + i3);
	    System.out.println("Last Element is(using getLast()): " + i4);
	}
}

插入后的 Deque，10，15，20]
第一个元素是(使用 peekFirst()): 5
第一个元素是(使用 getFirst()): 5
最后一个元素是(使用 peekLast()): 20
最后一个元素是(使用 getLast()): 20

遍历数组

我们可以在迭代器的帮助下遍历数组，就像我们访问其他集合元素一样。

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Iterator;

public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    deck.addLast(5);
	    deck.addLast(10);  
	    deck.addLast(15);
	    deck.addLast(20);

	    Iterator i = deck.iterator();
	    while(i.hasNext())
	    	System.out.print(i.next() + " "); 
	}
}

5 10 15 20

反向迭代数组

我们可以使用降序迭代器以相反的顺序迭代数组。

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Iterator;

public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    deck.addLast(5);
	    deck.addLast(10);  
	    deck.addLast(15);
	    deck.addLast(20);

	    Iterator i = deck.descendingIterator();
	    while(i.hasNext())
	    	System.out.print(i.next() + " "); 
	}
}

20 15 10 5

为什么我们每次手术都有两种方法？

您可能已经注意到，我们有两种方法可以执行相同的操作。例如，我们可以使用 removeLast()方法或 pollLast()方法从数组中移除最后一个元素。这些方法的区别在于，如果操作失败，其中一个方法会返回异常。另一个返回表示失败操作的值。

操作失败时返回异常的方法有:

• addFirst()
• addLast()
• removeFirst()
• removeLast()
• getFirst()
• getLast（）

如果操作失败，无异常返回值的方法有:

• offerFirst()
• offerLast()
• pollFirst()
• pollLast()
• peekFirst()
• 扫视最后（）

让我们借助一个例子来理解这一点。我们有一个空的 Deque，我们在它上面使用了 removeLast()方法。我们会得到一个nosucheelementexception。

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    System.out.print(deck.removeLast());
	}
}

线程" main " Java . util . nosuchinterexception
at Java . base/Java . util . arraydequa . removelast(arraydequa . Java:372)
at 片段. arraydequademo . main(arraydequademo . Java:11)

但是如果我们使用 pollLast()方法，我们不会得到任何异常。在下面的输出中，我们可以看到该方法返回了一个 null 。这表示删除不成功。

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> deck = new ArrayDeque<Integer>();
	    System.out.print(deck.pollLast());
	}
}

零

arraydeque as 栈

如前几节所述，我们可以使用 ArrayDeque 实现一个栈。我们将选择 Deque 的一端(前部或后部)，仅从该端插入和删除元素。我们可以使用我们讨论过的插入和删除方法。或者我们可以用方便的推()和爆()的方法搭配 ArrayDeque。

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> stk = new ArrayDeque<Integer>();
		stk.push(15);
	    stk.push(10);
	    stk.push(5);
	    System.out.println("Stack after insertion: " + stk);

	    stk.pop();
	    System.out.println("Stack after deletion: " + stk);
	    stk.pop();
	    System.out.println("Stack after deletion: " + stk);
	}
}

插入后堆叠:[5，10，15]
删除后堆叠:[10，15]
删除后堆叠:[15]

拉起尾巴

我们可以使用 ArrayDeque 实现一个队列，方法是在一端插入元素，然后从另一端移除它们。我们可以使用上面讨论的方法。或者我们可以使用 add() 和 remove() 方法。这些方法自动决定前端和后端，并相应地插入和删除元素。

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeDemo
{
	public static void main(String[] args)
	{
		Deque<Integer> que = new ArrayDeque<Integer>();
		que.add(5);
		que.add(15);
		que.add(20);
	    System.out.println("Queue after insertion: " + que);

	    que.remove();
	    System.out.println("Queue after deletion: " + que);
	    que.remove();
	    System.out.println("Queue after deletion: " + que);
	}
}

插入后排队:[5，15，20]
删除后排队:[15，20]
删除后排队:[20]

摘要

以下几点总结了 ArrayDeque 类的主要特性。

• Deque 可以被认为是一个队列，在这个队列中，插入和删除可以在两端进行。
• ArrayDeque 使用动态数组来实现 Deque 数据结构。当我们用完空间时，数组会自动加倍。
• 我们可以使用数组来实现栈和队列数据结构。
• 当使用 ArrayDeques 实现栈时，它的工作速度比普通的 Stack 类快得多。
• 同样，使用 ArrayDeques 实现的队列比用作队列的LinkedList更快。
• 请注意，ArrayDeque 类不是线程安全的，我们需要同步它们以实现并发访问。
• 数组不允许在其中插入空元素。

---

---

Java 中的模运算符

原文：https://www.studytonight.com/java-examples/modulo-operator-in-java

模运算符用于求两个数除法的余数。它也被称为余数运算符。百分比符号(%)用于表示该运算符。该运算符的基本语法如下所示。

Dividend % Divisor

让我们看一些模运算符的例子。

模运算符示例

让我们对整数和浮点数使用模运算符，并查看其输出。我们也可以对负数使用模运算符。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		System.out.println("10 % 3 = " + 10 % 3);
		System.out.println("3 % 10 = " + 3 % 10);
		System.out.println("10.0 % 3.0 = " + 10.0 % 3.0);
		System.out.println("10.0 % 3 = " + 10.0 % 3);
		System.out.println("-10 % 3 = " + -10 % 3);
	}
}

10% 3 = 1
3% 10 = 3
10.0% 3.0 = 1.0
10.0% 3 = 1.0
-10% 3 =-1

需要模运算符

需要模运算符，因为使用简单除法运算符时，我们可能会丢失余数部分。如果被除数和除数都是整数，那么我们可以很容易地计算出如下所示的余数。这种情况的一个例子如下所示。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		int dividend = 10;
		int divisor = 3;
		int remainder = dividend - (divisor * (dividend/divisor));
		System.out.print("The remainder is: " + remainder);
	}
}

余数为:1

当被除数或除数不是整数时

但如果被除数或除数有小数点，那么商也将是小数，我们就找不到余数了。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		double dividend = 10;
		int divisor = 3;
		double remainder = dividend - (divisor * (dividend/divisor));
		System.out.print("The remainder is: " + remainder);
	}
}

余数为:0.0

然而，模运算符仍然可以找到正确的余数。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		double dividend = 10;
		int divisor = 3;
		double remainder = dividend % divisor;
		System.out.print("The remainder is: " + remainder);
	}
}

余数为:1.0

模运算符的算术异常

模运算符，就像除法运算符一样，如果除数为零，抛出ArithmeticException。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		System.out.print("The remainder is: " + 10 % 0);
	}
}

线程“main”中的异常 Java . lang . arithmeticexception:/by 零
在代码片段处。modulooterardemo . main(modulooterardemo . Java:7)

模运算符的常见用例

查找偶数

模运算符最常见的用法之一是检查一个数是奇数还是偶数。一个数是偶数，即使我们把一个数除以二，余数为零。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		int[] arr = {7, 5, 2, 4, 6, 19, 18, 25, 22};
		for(int i=0; i<arr.length; i++)
		{
			int num = arr[i];
			if((num % 2) == 0)
				System.out.println(num + " is even.");
			else
				System.out.println(num + " is NOT even.");
		}
	}
}

7 不是偶数。
5 不是偶数。
二是偶数。
4 是偶数。
6 是偶数。
19 不是偶数。
18 是偶数。
25 不是偶数。
22 是偶数。

将数字限制在一定范围内

如果我们想把一个数限制在某个范围内，我们可以使用模运算符。当数小于极限时，模运算符返回数本身。如果该数大于或等于极限，运算符将返回余数。这非常常用于维护循环数组中的索引。

例如，如果我们有一个月，其中第一天发生在星期一，我们需要找到给定一个月中某一天的名称。在模运算符的帮助下，我们将以循环的方式遍历日名数组。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		 String[] dayNames = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
		 int dayOfTheMonth1 = 21;
		 String dayName1 = dayNames[(dayOfTheMonth1 - 1) % 7];
		 int dayOfTheMonth2 = 12;
		 String dayName2 = dayNames[(dayOfTheMonth2 - 1) % 7];

		 System.out.println(dayOfTheMonth1 + " occurs on " + dayName1);
		 System.out.println(dayOfTheMonth2 + " occurs on " + dayName2);
	}
}

21 发生在周日
12 发生在周五

让一个数完全被另一个数整除

假设我们有两个数字，X 和 Y，我们想从 X 中减去最小值，使它完全被 Y 整除。这个最小值将是我们除以它们后得到的余数。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		int X = 291;
		int Y = 17;

		int remainder = X % Y;
		X = X - remainder;
		System.out.println("The minimum number to subtract is: " + remainder);
		System.out.println("The number after subtraction is: " + X);
	}
} 

最小减法数为:2
减法后的数为:289

获取整数的单个数字

我们可以使用模和除运算符来打印数字的每个数字。我们可以通过将一个数除以 10 并取余数来找到它的最后一位。然后我们将这个数字除以 10，去掉最后一个数字。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		int num = 7912064;
		while(num > 0)
		{
			int lastDigit = num % 10;
			num = num / 10;
			System.out.print(lastDigit + " ");
		}
	}
}

4 6 0 2 1 9 7

每隔 n 次重复某事

假设我们有一个 for 循环，将变量的值从 1 增加到 30。在循环的每 5 次迭代中，我们需要打印一条语句。模运算符可以轻松实现这一点。

public class Demo
{
	public static void main(String[] args) throws JSONException
	{
		for(int i = 1; i <= 30; i++)
		{
			if(i % 5 == 0)
				System.out.println("Do Something");
		}
	}
}

做点什么
做点什么
做点什么
做点什么
做点什么
做点什么

将秒转换为分钟和秒

我们可以使用模运算符和除法运算符将秒转换为分钟和秒。将总秒数除以 60 会得到分钟数，余数会得到剩余的秒数(< 60)。

public class ModuloOperatorDemo
{
	public static void main(String[] args)
	{
		int seconds = 401;
		int minutes = seconds / 60;
		int remainingSeconds = seconds % 60;
		System.out.print(seconds + " seconds is equal to " + minutes +" minutes " + remainingSeconds + " seconds");
	}
}

401 秒等于 6 分 41 秒

摘要

模运算符是一个简单的运算符，它返回两个数相除后的余数。如果除数为零，则返回ArthimeticException，因为不允许除以零。这个操作符有很多不同的用例，我们在本教程中讨论了其中的一些。

---

---

Java 原始类型

原文：https://www.studytonight.com/java-examples/java-primitives

基本数据类型是由编程语言提供的基本数据类型。 Java 包含八个原始类型数据。与对象不同，原始类型类型直接存储在栈内存中，而不是堆内存中。下图说明了原始数据类型是如何分类的。

Java 内部原始类型数据类型

int 数据类型(整数的缩写)用于存储整数值。它使用 32 位内存，因此值的范围可以从 -2，147，483，648 (-2^31)到 2，147，483，647 (2^31-1) 。

对 int 数据类型执行不同的算术运算。请记住，如果我们对小数执行算术运算并将其存储在整型变量中，那么结果的小数部分将丢失。如果没有赋值，int 数据类型采用默认值 0。

int i = 5;

Java 字节原始类型数据类型

字节数据类型也用于存储整数，但只能占用 8 位的空间(因此得名字节)。数值范围从 -128 到+127，默认值为零。

byte b = 5;

Java 短原始类型数据类型

short 也是整数数据类型，使用 16 位内存存储整数。这些值的范围可以从 -32,768(-2^15 到 32,767(2^15–1)。你可能已经猜到了，的缺省值也是零。

short s = 5;

Java 长原始类型数据类型

如果我们需要更多的空间，那么长数据类型是完美的。它使用内存的 64 位来存储内存。数值范围从-2^63 到 2^63 - 1 。就像其他整数数据类型一样，其默认值为零。它可以与所有标准算术运算符一起工作。

long l = 5;

Java 浮点基本数据类型

浮点数据类型用于存储和处理十进制数值。Float 是单精度数据类型。这意味着在小数点后六位后，数值变得不太精确。

如果精度有问题，建议使用其他十进制类，如BIgDecimal。它使用 32 位内存。数值范围从 1.40239846 x 10^-45 到 3.40282347 x 10^38 。这个范围可以是正的，也可以是负的。其默认值为 0.0 。我们需要在给浮点数据类型变量赋值时指定字母‘f’。我们需要这样做，因为双精度是小数的默认类型。

float f = 5.0f;

Java 双原始类型数据类型

double 类型用于存储小数，就像 float 一样。但是它使用的是 64 位内存，而不是 32 位。与 float 不同，double 使用双精度，因此精度没有限制。这些值的范围从 4.9406564584124654 x 10^-324 到 1.79793148623157 x 10^308。这个范围可以是正的，也可以是负的。其默认值为 0.0 。

double d = 5.0;

Java 布尔原始数据类型

布尔数据类型属于不同的类别。它只用来存储两个值，真或假。只需要一个位来存储这些值，但是 Java 填充该值并将其存储为一个字节。它的默认值是 false。这种类型在控制流语句中非常常用。

boolean t = true;
boolean f = false;

Java 字符基本数据类型

字符数据类型使用 16 位内存来存储 Unicode 字符。它的值可以在 0 到 65535 之间。在 Unicode 中，这个范围是从 10000 到 5000 的。char 数据类型的默认值为 0 或\u0000** 。**

public static void main(String[] args)
{
	char c1 = 67;
	char c2 = 'C';
	System.out.println(c1);
	System.out.println(c2);
	System.out.println(c1 + c2);
}

C
C
134

基元类型中的上溢和下溢

当值超过其最大定义范围值时，就会发生溢出。同样，如果该值大于指定的最低范围值，则会发生下溢。

在 Java 中，如果我们分配的值不在其范围内，整数和小数可能会溢出或下溢。

对于整数，当溢出发生时，该值将滚动到最小值，计数将从该值开始。

public static void main(String[] args)
{
	int i = Integer.MAX_VALUE;
	System.out.println(i);
	i = i + 1;
	System.out.println(i);
}

2147483647
-2147483648

类似地，当整数的下溢发生时，该值翻转到正极端。

public static void main(String[] args)
{
	int i = Integer.MIN_VALUE;
	System.out.println(i);
	i = i - 1;
	System.out.println(i);
}

-2147483648
2147483647

Java 中的自动分类

Java 对每种基本类型都有一个包装类。这些包装类通常与泛型一起使用。我们不需要做任何特殊的事情来将原始类型转换为包装类的对象。Java 自动处理这种转换，这就是所谓的自动装箱。

public static void main(String[] args)
{
	Integer i = 5;
	Byte b = 5;
	Short s = 5;
	Long l = 5L;//Letter L is used as the default type for numbers is int
	Character c = 'C';
	Double d = 5.0;
	Float f = 5.0f;
	Boolean bool = true;
}

摘要

在本教程中，我们讨论了 Java 中存在的八种基本的原始数据类型。下表总结了讨论的要点。

| 原始类型 | 大小(位) | 范围 | 默认 |
| （同 Internationalorganizations）国际组织 | Thirty-two | -2^31 至(2^31)-1 | Zero |
| 字节 | eight | -2^7 至(2^7)-1 | Zero |
| 短的 | Sixteen | -2^15 至(2^15)-1 | Zero |
| 长的 | Sixty-four | -2^63 至(2^63)-1 | Zero |
| 漂浮物 | Thirty-two | 最多 7 位小数 | 0.0f |
| 两倍 | Sixty-four | 最多 16 位小数 | Zero |
| 布尔 | one | 对还是错 | 错误的 |
| 茶 | Sixteen | 0 至(2^16)-1 | \u0000 |

---

---

Jaskson ObjectMapper

原文：https://www.studytonight.com/java-examples/jackson-objectmapper

JasksonObjectMapper类用于将对象映射到 JSON 或将 JSON 映射到对象。这是一个简单易用的类，为我们提供了许多不同的选项来解析 JSON。

JSON 是一种广泛使用的文件格式，用于存储和传输类的属性值对。

在本教程中，我们将了解更多关于此类的信息。

在 Java 中使用对象映射器读取

我们可以使用ObjectMapper类从 JSON 文件、JSON 字符串或网址，甚至 JSON 字符串数组中读取对象。

我们将在本教程中使用下面定义的类。在继续学习本教程之前，请确保将必要的依赖项或 jar 文件添加到类路径中。

class DemoClass
{
    private String field1;
    private Double field2;

    //Constructors
    DemoClass()
    {}    
    DemoClass(String field1, Double field2)
    {
    	this.field1 = field1;
    	this.field2 = field2;
    }    
    //getters and setters
	public String getField1() {
		return field1;
	}
	public void setField1(String field1) {
		this.field1 = field1;
	}
	public Double getField2() {
		return field2;
	}
	public void setField2(Double field2) {
		this.field2 = field2;
	}
}

从 JSON 文件中读取对象

我们可以使用这个类的 readValue() 方法，将 JSON 文件中的数据读入一个对象。我们的 JSON 文件只包含单个对象的属性值对。

import java.io.File;

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			//File to read from
			String filePath = "C:\\Users\\Lenovo\\Desktop\\jsonDemo.json";
			File file = new File(filePath);

			ObjectMapper objMapper = new ObjectMapper();
			DemoClass obj = new DemoClass();
			obj = objMapper.readValue(file, DemoClass.class);

			System.out.print(obj.getField1() + " " + obj.getField2());
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

样品 1 20.21

从 JSON 字符串中读取对象

我们可以将 JSON 文件的内容复制到一个 Java 字符串中，并从这个字符串创建一个对象。我们将再次使用ObjectMapper类的readValue()方法。我们还需要将Class类型传递给这个方法。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21}";
			ObjectMapper objMapper = new ObjectMapper();

			DemoClass obj = new DemoClass();
			obj = objMapper.readValue(jsonString, DemoClass.class);

			System.out.print(obj.getField1() + " " + obj.getField2());
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

样品 1 20.21

从 JSON 网址读取对象

从网址中读取对象也非常简单。我们需要将 URL 对象和Class类型传递给readValue()方法。

import java.net.URL;
public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			ObjectMapper objMapper = new ObjectMapper();

			URL jsonFileUrl = new URL("file:C:\\Users\\Lenovo\\Desktop\\jsonDemo.json");
			DemoClass obj = new DemoClass();
			obj = objMapper.readValue(jsonFileUrl, DemoClass.class);

			System.out.print(obj.getField1() + " " + obj.getField2());
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

样品 1 20.21

从 JSON 字符串数组读取到对象数组

假设一个字符串包含多个 JSON 格式的对象数据(作为数组)。我们可以使用ObjectMapper类将所有这些数据读入Class类型的数组。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			//String with two DemoClass Objects
			String jsonString = "[{\"field1\":\"Sample-1\",\"field2\":20.21}, {\"field1\":\"Sample-2\",\"field2\":22.55}]";
			ObjectMapper objMapper = new ObjectMapper();
			//Reading into an object array
			DemoClass[] objectArr = objMapper.readValue(jsonString, DemoClass[].class);
			//Printing the objects
			for(DemoClass obj : objectArr)
				System.out.println(obj.getField1() + " " + obj.getField2());
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

样品 1 20.21
样品 2 22.55

从 JSON 字符串数组读取对象列表

如果不想将数据读入固定大小的对象数组，我们可以将对象读入列表。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			//String with two DemoClass Objects
			String jsonString = "[{\"field1\":\"Sample-1\",\"field2\":20.21}, {\"field1\":\"Sample-2\",\"field2\":22.55}]";
			ObjectMapper objMapper = new ObjectMapper();

			//Reading into an object List
			List<DemoClass> objectList = objMapper.readValue(jsonString, new TypeReference<List<DemoClass>>(){});

			//Printing the objects
			for(DemoClass obj : objectList)
				System.out.println(obj.getField1() + " " + obj.getField2());
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

样品 1 20.21
样品 2 22.55

从 JSON 字符串数组读取对象映射

我们还可以将 JSON 字符串中的数据读入到 Map 中。类的每个属性将成为一个键，属性值将成为值。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21}";

			ObjectMapper objMapper = new ObjectMapper();
			//Reading into an object Map
			Map<String, Object> objectMap = objMapper.readValue(jsonString, HashMap.class);

			for(Map.Entry<String, Object> e : objectMap.entrySet())
				System.out.println(e.getKey() + " " + e.getValue());
		}

		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

字段 1 样本-1
字段 2 20.21

将 JSON 读取到 JsonNode 对象

JsonNode类为我们提供了一种更灵活的解析 JSON 的方式。我们可以使用ObjectMapper类的 readTree() 方法将 JSON 读入一个 JsonNode 对象。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			//String with two DemoClass Objects
			String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21}";
			ObjectMapper objMapper = new ObjectMapper();

			JsonNode node = objMapper.readTree(jsonString);
			String field1 = node.get("field1").asText();
			String field2 = node.get("field2").asText();

			System.out.print(field1 + " " + field2);			
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

样品 1 20.21

从对象编写 JSON

我们可以使用ObjectMapper类将对象写入 JSON 文件。这个类的**writeValue()**方法用来序列化一个对象，并将它写入一个 JSON 文件。

import java.io.File;
public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		DemoClass obj = new DemoClass("Sample-1", 20.21);//object to write		
		try
		{
			//File to write object in
			String filePath = "C:\\Users\\Lenovo\\Desktop\\jsonDemo.json";
			File file = new File(filePath);

			ObjectMapper objMapper = new ObjectMapper();
			objMapper.writeValue(file, obj);
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

JSON 文件的内容如下所示。

{“field 1”:“Sample-1”、“field 2”:20.21 }

将对象序列化为 JSON

我们也可以使用**writeValueAsString()**方法将一个对象序列化为 JSON 字符串。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		DemoClass obj = new DemoClass("Sample-1", 20.21);//object to write		
		try
		{
			ObjectMapper objMapper = new ObjectMapper();
			String jsonString = objMapper.writeValueAsString(obj);//Generating JSON as a String
			System.out.print(jsonString);
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

{“field 1”:“Sample-1”、“field 2”:20.21 }

同样的，**writeValueAsBytes()**会返回一个对象对应的字节数组。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		DemoClass obj = new DemoClass("Sample-1", 20.21);//object to write		
		try
		{
			ObjectMapper objMapper = new ObjectMapper();
			byte[] jsonByteArr = objMapper.writeValueAsBytes(obj);
			String strFromByteArr = new String(jsonByteArr);
			System.out.print(strFromByteArr);
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

{“field 1”:“Sample-1”、“field 2”:20.21 }

配置对象映射器

我们可以对ObjectMapper进行配置，这样它就可以处理意外的输入。例如，读取具有一些未知属性的 JSON 字符串将导致**UnrecognizedPropertyException**。下面的代码演示了这一点。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			//String with an unknown field3 property
			String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21,\"field3\":\"Unknown\"}";
			ObjectMapper objMapper = new ObjectMapper();

			DemoClass obj = new DemoClass();
			obj = objMapper.readValue(jsonString, DemoClass.class);	
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

我们可以配置我们的ObjectMapper忽略任何新的属性。这是通过使用配置()方法完成的。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			//String with an unknown field3 property
			String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21,\"field3\":\"Unknown\"}";
			ObjectMapper objMapper = new ObjectMapper();
			objMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
			DemoClass obj = new DemoClass();
			obj = objMapper.readValue(jsonString, DemoClass.class);	
			System.out.print(obj.getField1() + " " + obj.getField2());
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

样品 1 20.21

我们还可以将ObjectMapper配置为使用原始类型的空值。

ObjectMapper objMapper = new ObjectMapper();

objMapper .configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);

使用日期

默认情况下，对象映射器将把一个java.util.date映射到一个长值。这个长值是自 1970 年 1 月 1 日以来经过的毫秒数。这不是一个非常方便的格式。

让我们向我们的 DemoClass 添加一个日期字段，并将一个对象序列化到 JSON。

class DemoClass
{
    private String field1;
    private Double field2;
    private Date dateField;

    //Constructors
    DemoClass()
    {}    
    DemoClass(String field1, Double field2, Date d)
    {
    	this.field1 = field1;
    	this.field2 = field2;
    	this.dateField = d;
    }    
    //getters and setters
}

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			DemoClass obj = new DemoClass("Sample-1", 20.21, new Date());
			ObjectMapper objMapper = new ObjectMapper();

			String jsonString = objMapper.writeValueAsString(obj);
			System.out.print(jsonString);
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

{“field 1”:“Sample-1”，“field 2”:20.21，“dateField”:1627623983148 }

但是，我们可以使用SimpleDateFormat来定义日期格式，以序列化java.util.date。

public class ObjectMapperDemo
{
	public static void main(String[] args)
	{
		try
		{
			ObjectMapper objMapper = new ObjectMapper();
			//Creating and setting a date format
			SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yy");
			objMapper.setDateFormat(dateFormat);

			DemoClass obj = new DemoClass("Sample-1", 20.21, new Date());
			String jsonString = objMapper.writeValueAsString(obj);
			System.out.print(jsonString);
		}
		catch(Exception e)
		{
			System.out.print(e);
		}
	}
}

{“field 1”:“Sample-1”，“field 2”:20.21，“dateField”:“30-07-21”}

摘要

Jaskson 库的ObjectMapper类提供了大量使用 JSON 格式的工具。在本教程中，我们学习了这门课的一些基础知识。我们学习了如何将 Java 对象序列化为 JSON，以及如何将 JSON 反序列化为 Java 对象。

---

---

从命令行运行 JAR 文件

原文：https://www.studytonight.com/java-examples/run-jar-file-from-command-line

JAR 是 Java Archive 的缩写。JAR 文件包含压缩的 Java 项目文件。它包括。项目所需的类文件和其他元数据和资源。

JAR 文件是与他人共享和分发我们的 Java 代码的好方法。

在这个简短的教程中，我们将学习如何在 Java 中创建和运行一个 JAR 文件。

创建 JAR 文件

一个 JAR 文件由编译后的 Java 组成。类文件和其他资源。我们可以创建一个可执行的或者不可执行的 JAR。

两者的区别在于，可执行的 JAR 文件包含清单文件，而不可执行的 JAR 文件不包含这一点。这个清单文件包含运行 JAR 时应该执行的类的名称。

在本教程中，我们将只使用一个类，它的主要方法是打印 Hello World。

public class HelloWorld
{
	public static void main(String args[])
	{
		System.out.print("\n\nHello World\n\n");
	}
}

我们的目录有两个文件，。java 文件和可执行 JAR 所需的清单文件。

我们需要编译后的。类文件创建一个 JAR 文件。我们首先需要运行 javac 命令来创建。类文件。java 文件。

javac HelloWorld.java

创建可执行的 JAR 文件

为了创建一个可执行的 JAR 文件，我们还需要一个清单文件。清单文件的内容如下所示。

Main-Class: HelloWorld 

接下来，我们可以通过运行下面的 jar 命令来创建一个 JAR 文件。

jar -cfm HelloWorld.jar ManifestFile.txt HelloWorld.class

-c 标志用于创建归档文件。 -f 标志用于指定文件名。并且 -m 标志将包括清单文件的内容。

执行上述命令后，在我们当前的目录中创建了一个名为 HelloWorld.jar 的新 JAR 文件。请注意。下图中显示的类文件是在运行 javac 命令后创建的。

创建不可执行的 JAR 文件

为了创建一个不可执行的 JAR 文件，我们将排除 -m 标志。我们不需要将清单文件的名称传递给我们的命令。

jar -cf HelloWorld.jar HelloWorld.class

运行 JAR 文件

运行可执行的 JAR 文件

我们可以使用以下带有 -jar 选项的 java 命令来运行可执行的 jar 文件。

java -jar HelloWorld.jar

该命令的输出如下所示。

运行不可执行的 JAR 文件

我们将使用 -cp 选项来运行一个不可执行的 JAR 文件，而不是使用 -jar 选项。我们需要在命令中指定 JAR 文件名和主类名。

java -cp HelloWorld.jar HelloWorld

该命令的输出如下所示。

用命令行参数运行 JAR 文件

任何 Java 应用都可以有任意数量的命令行参数。这些参数通过字符串数组传递给类的 main()方法。JAR 文件也包含类，我们可以在运行 JAR 文件时传递命令行参数。

参数应该用空格分隔。如果任何参数包含空格，那么我们必须用引号将该参数括起来。

让我们用一个主方法创建一个新类。main()方法应该打印传递给它的命令行参数。

public class CommandLineArgs
{
	public static void main(String args[])
	{
		for(String s : args)
			System.out.print(s);
	}
}

我们将编译。java 文件并创建可执行和不可执行的 jar 文件，如前面几节所示。

为了运行可执行的 JAR，我们将使用 java -jar 命令并传递参数。

在下面的命令中，传递了三个参数。因为前两个应该在末尾包含空白，所以我们用引号将它们括起来。

java -jar demo.jar "Welcome " "Back " User

对于不可执行的 JAR，我们将使用- cf 选项并传递主类名。我们也将像在上面的代码中一样传递参数。

java -cp demo.jar CommandLineArgs "Welcome " "Back " User

摘要

JAR 文件是与他人共享和分发我们的代码的好方法。在本教程中，我们学习了如何创建一个 JAR 文件并从命令行运行它。我们还学习了如何将命令行参数传递给 JAR 文件中类的 main()方法。

---

---

Javadoc 简介

原文：https://www.studytonight.com/java-examples/introduction-to-javadoc

文档提供了关于如何使用软件及其功能的见解。好的文档会使软件更容易适应。Java 提供了一个名为 Javadoc 的工具，可以生成 HTML 页面格式的文档。

在本教程中，我们将学习如何创建和使用 Javadoc。

Java 注释

注释是解释代码功能的一种方式。他们添加到源代码本身。在 Java 中，我们有三种类型的注释。

• 单行注释(以//开头，跨越整行)
• 多行注释(以/开头，以/结尾)
• Javadoc 注释(以/**开头，以*/结尾)

这些注释被编译器完全忽略，不会影响我们代码的性能。Javadoc 注释被 Javadoc 工具用来为我们的代码生成文档。编写好的 Javadoc 注释以创建易于阅读的文档非常重要。

Javadoc 评论

如上所述，Javadoc 注释有助于 Javadoc 工具生成更好的文档。Javadoc 注释包含两部分。它包含特定元数据的代码描述和 Javadoc 标签。这些注释放在我们要向其添加信息的类、字段或方法之前。

Javadoc 标签

Javadoc 标签用于指定关于一段代码的一些元数据。它们以@符号开始。有很多标签是为了不同的目的而定义的。下面解释一些最常用的标签。

• @author 用来描述作者的名字。
• @param 提供了有关传递给方法的参数的信息。
• @see 用于添加对代码中其他元素的引用。
• @version 用于设置代码的版本。
• @return 用于描述方法的返回值。
• @exception 用于指定异常的类型(如果方法使用了 throws 关键字)。也可以使用@throws。
• @已弃用用于说明代码部分被弃用的原因。

我们也可以根据自己的需要创建自定义标签。使用以下 Javadoc 命令创建自定义标签。

javadoc -tag <tag-name>:<location:allowed>:<text-name-in-output> <class-location>

由于 Javadoc 工具为文档生成了一个 HTML 页面，我们可以在 Javadoc 注释中添加 HTML 标签，以更好地格式化描述。

/**
*    <h1>Method to Print Hello World<h1>
*    <p> This method uses the <b>System.out.print()</b> method to print Hello World 
*    to the console.</p>
*/
public static void printHelloWorld()
{
    System.out.print("\n\nHello World\n\n");
}

类级别的 Javadoc 注释

让我们创建一个学生类，并向其中添加 Javadoc 注释。我们将包括对课程的简要描述。我们还将添加@author 标签来设置类的作者名，并添加@version 标签来指定类的版本。

/**
 * The Student class gives basic student information like student's name, and 
 * the marks scored in different subjects.
 * 
 * @author 	Justin
 * @version 1.0
 *
 */
public class Student
{
    ...
}

字段级别的 Javadoc 注释

接下来，我们将向 Student 类添加一些属性，并为它们编写 Javadoc 注释。我们将为每个字段添加简单的描述。

public class Student
{
	/**
	 * Student name field of String type
	 */
	String studentName;

	/**
	 * Marks scored in Mathematics
	 */
	Double mathMarks;

	/**
	 * Marks scored in Science
	 */	
	Double scienceMarks;

	/**
	 * Marks scored in English
	 */
	Double englishMarks;
}

方法级的 Javadoc 注释

我们将创建一个新类，并向该类添加一个方法。这种方法计算学生的百分比。让我们查看这个方法的 Javadoc 注释。

/**
	 * Calculates and returns the Student's percentage based on the marks in three subjects
	 * 
	 * @param student The Student class Object
	 * @return Double type percentage based on the student's marks
	 * @throws Exception throws exception if something goes wrong
	 *
*/
public static Double calculatePercentage(Student student) throws Exception
{
	Double math = student.getMathMarks();
	Double sci = student.getScienceMarks();
	Double eng = student.getEnglishMarks();
	return (math + sci + eng) / 300;
}

正在生成 Javadoc

我们可以通过命令行使用下面的 Javadoc 命令轻松生成 Javadoc 文档页面。

我们需要指定我们想要文档的类或包。使用-d标志指定您想要创建文档文件的位置。

javadoc -d doc <class or package name>

IDEs 还可以生成 Javadoc 文档。

我们可以通过打开index.html文件来查看生成的文档。以下图像显示了生成的文档。

包中存在的类的摘要

学生班

JavaDocDemo 类中的计算百分比()方法

摘要

Javadoc 是一个文档生成器工具。我们需要在源代码中使用 Javadoc 注释来创建描述性且易于理解的文档。Javadoc 为我们提供了内置标签，我们可以用它来指定代码的某些属性。我们还可以创建定制的 Javadoc 标签来满足我们的需求。

---

---

Java 栈和堆内存

原文：https://www.studytonight.com/java-examples/java-stack-and-heap-memory

Java 中的内存分为两部分-Stack和Heap。这样做是为了确保我们的应用有效地利用内存。

在本教程中，我们将更多地了解这两种类型的记忆以及它们之间的主要区别。

栈存储器

• 栈内存用于线程执行和静态内存分配。所有原始数据驻留在栈内存中，对其他对象的引用也存储在其中。它只包含当前线程可用的本地数据。
• 每当从 Java 应用调用一个方法时，该方法的一个新块就会被添加到栈中。该块将包含方法所需的所有原始数据和引用。
• 栈内存，顾名思义，使用栈数据结构的后进先出(LIFO) 方法来添加和移除方法调用。
• 栈内存比堆内存快得多。它也比堆内存更安全，因为数据只能由正在运行的线程访问。它是线程安全的，不需要同步，因为每个线程都有自己的栈。
• 内存的分配和解除分配是自动完成的。每当调用一个方法时，都会在栈的顶部为该方法添加一个新的块。当方法完成执行或返回时，则块和所有相应的数据被移除，空间变得可用于新的方法调用。
• 如果耗尽栈内存，我们可能会遇到栈溢出错误或。我们可以编写一个简单的程序来模拟这个错误。如果我们重复调用一个方法，那么这些方法调用将在栈中累积，最终，我们会得到这个错误。在下面的代码中，我们递归调用其定义中的overflowError()方法，这导致了StackOverflowError。

public class JavaMemoryManagement
{
	public static void overflowError()
	{
		overflowError();
	}	
	public static void main(String[] args)
	{
		overflowError();
	}
}

让我们看一个例子来理解内存是如何在栈中分配的。

在下面的代码中，我们在main()方法中创建了原始整数数据和 char 数据。这个main()方法会被推到栈顶。然后我们调用print()方法，该方法将再次添加到栈顶部。在 print()方法内部，我们正在调用printChar()方法，并且在栈上为该方法分配了一个块。栈中的所有这些方法块都有所需的可用数据。

public class JavaMemoryManagement
{
	public static void print(int i, char c)
	{
		System.out.println(i);
        printChar(c);
	}	
	public static void printChar(char c)
	{
		System.out.println(c);
	}	
	public static void main(String[] args)
	{
		int i = 5;
		char c = 'a';
		print(i, c);
	}
}

最终的栈内存如下图所示。

堆内存

• 堆内存是所有类实例或对象被分配内存的地方。如上所述，对这些对象的引用存储在栈存储器中。所有动态内存分配都发生在堆中。堆内存也是全局可访问的，任何线程都可以访问内存。
• 与使用栈数据结构的栈内存不同，堆数据结构与堆内存没有任何联系。
• 堆内存不如栈内存安全，因为所有线程都可以访问对象，我们必须同步它们。
• 它也比栈内存慢很多。
• 内存分配和释放不是很简单，堆内存使用复杂的内存管理技术。内存释放不是自动完成的，Java 使用垃圾收集机制来释放空间。
• 堆内存进一步分为三个部分:
  • Young Generation: 这部分堆内存是所有新分配对象驻留的地方。当这部分内存变满时，就会发生垃圾收集。
  • 老一代:当年轻一代对象跨越一个阈值时间限制时，则转移到老一代空间。这通常包含不经常使用的对象。
  • 永久生成:这是 JVM 存储运行时类和应用方法的元数据的地方。
• 如果我们用完了堆内存，那么 JVM 抛出**OutOfMemoryError**。如果我们继续分配空间而不删除旧的对象，就会发生这种情况。我们可以通过创建一个无限循环来模拟这个错误，该循环不断为新的String类对象分配内存。下面的代码将运行几秒钟，然后我们将得到 OutOfMemory 错误

public class JavaMemoryManagement
{
	public static void outOfMemoryError()
	{
		List<String> list = new ArrayList<String>();
		while(true)
		{
			String s = "str";
			list.add(s);
		}
	}	
	public static void main(String[] args)
	{
		outOfMemoryError();
	}
}

考虑下面的例子来更好地理解堆内存。

在下面的代码中，我们正在创建一个字符串对象，它将在堆内存的字符串池中被分配空间。我们还创建了一个对象类的实例，并将为这个对象分配空间。对这些对象的引用将存储在栈内存中。

public class JavaMemoryManagement
{
	public static void main(String[] args)
	{
		String s = "str";
		Object o = new Object();
	}
}

最终的堆内存如下图所示。

栈和堆内存的主要区别

下表解释了这两种内存之间的一些主要区别。

| 参数 | 栈内存 | 堆内存 |
| 使用 | 栈内存用于线程执行和存储方法调用以及与方法相关联的原始数据和引用。 | 堆内存用于存储动态分配的对象。 |
| 大小 | 栈的大小要小得多。 | 堆内存比栈大得多。 |
| 一生 | 栈内存仅在线程执行期间或当前方法运行时使用。栈内存是短暂的。 | 堆内存在应用的整个运行期间使用。 |
| 效率 | 栈内存非常高效，内存访问也更快。 | 堆的效率较低，比栈慢得多。 |
| 内存分配和释放 | 调用新方法时会自动分配内存，方法返回时也会自动取消分配。 | 当创建新对象时，内存由程序员手动分配。垃圾收集器通过移除不再被引用的对象来释放内存。 |
| 安全 | 栈内存是线程安全的，每个线程都有自己的栈，只能由所有者线程访问。 | 堆内存不是线程安全的，程序员必须使用同步技术，因为对象可以被任何线程访问。 |
| 内存管理 | 栈内存使用后进先出法进行内存管理。 | 内存管理在堆内存中相当复杂。 |
| 错误 | 当栈内存满了，我们得到一个栈溢出错误。 | 当堆内存满了，我们会得到一个 OutOfMemoryError。 |
| 改变尺寸 | 可以使用-Xss 命令改变栈的大小。 | 我们可以通过使用-Xms 命令来更改堆的初始大小。我们可以通过使用-Xmx 命令来声明最大堆大小。 |

栈和堆内存示例

让我们试着理解当我们创建新对象和调用方法时，引擎盖下会发生什么。考虑下面的代码，它创建了一个新的 int 变量、一个 String 对象和 object 类的另一个对象。然后调用 print()方法打印字符串和对象。

public class JavaMemoryManagement
{
	public static void print(String s, Object o)
	{
		System.out.println(s);
        System.out.println(o);
	}	
	public static void main(String[] args)
	{
		int i = 5;
		String s = "str";
		Object o = new Object();
		print(s, o);
	}
}

下面的步骤解释了当我们运行上面的代码时会发生什么。

• 执行从main()方法开始。此方法将被添加到栈的顶部。
• 在main()方法中，创建 int 类型的原始数据。这将出现在栈本身中。
• 接下来，创建String类的对象。将在堆内存中为该对象分配空间，对该对象的引用将存储在栈中。创建Object类的实例时也会发生同样的事情。
• 接下来print()方法将被添加到栈的顶部。对String类实例和Object类实例的引用将可用于该方法。记忆将如下所示。

摘要

JVM 使用两种类型的内存来高效执行我们的应用。所有原始类型和方法调用都存储在栈内存中，所有动态分配的对象都存储在堆内存中。栈是一种简单的内存类型，它使用后进先出的顺序(就像栈数据结构一样)，而内存管理在堆中相当复杂。堆内存进一步分为年轻一代、老一代和永久一代。

---

---

Java 断言

原文：https://www.studytonight.com/java-examples/java-assertions

Assert 是 Java 中的一个关键字，它允许我们测试一个假设。布尔表达式与 assert 关键字一起使用。

断言(assert 关键字和布尔表达式的组合)最初被认为是真的。如果断言为假，那么我们将得到AssertionError。

资产错误是一个未检查的异常。我们不需要在方法中用 throws 关键字声明它。对于这个错误，我们也不需要使用 try-catch 块。

我们可以遵循以下任意一种语法来创建断言。

在第二种情况下，表达式二以AssertionError返回。它帮助我们理解错误的原因，并相应地帮助我们调试代码。

assert <Boolean-expression>;
assert <expression-1> <expression-2>;

启用和禁用断言

默认情况下，Java 中禁用断言。在早期版本的 Java 中，我们可以使用 assert 这个词来表示变量和方法名。这可能会导致不一致。但是，我们可以通过使用 -enableassertions 选项或 -ea 选项轻松启用断言。

java -enableassertions :<package-name>... :<class-name>

java -ea:<package-name>... :<class-name>

禁用它们也很简单。对此，我们可以使用-disablessers或 -da 选项。

java -disableassertions :<package-name>... :<class-name>

java -da:<package-name>... :<class-name>

断言示例

让我们创建一个断言语句，假设数组的长度是 5。当长度等于 5 时，我们不会得到任何 AssertionError。

public class Demo
{
	public static void main(String args[])
	{
		int[] arrOfLengthTwo = {6, 8, 2, 1, 1};
		assert arrOfLengthTwo.length == 5;
		System.out.print("Array Length is: " + arrOfLengthTwo.length);
	}
}

数组长度为:5

让我们改变数组长度并运行代码。在这种情况下，我们应该得到一个 assessority error。

public class Demo
{
	public static void main(String args[])
	{
		int[] arrOfLengthTwo = {2, 1, 1};
		assert arrOfLengthTwo.length == 5;
		System.out.print("Array Length is: " + arrOfLengthTwo.length);
	}
}

在 Demo.main(Demo.java:6)的线程“main”中出现异常

让我们也添加一条消息，如果抛出错误，将显示这条消息。

public class Demo
{
	public static void main(String args[])
	{
		int[] arrOfLengthTwo = {2, 1, 1};
		assert arrOfLengthTwo.length == 5 : "Array Length is Not 5";
		System.out.print("Array Length is:" + arrOfLengthTwo.length);
	}
}

线程“main”Java . lang . assertionerror:在 Demo.main(Demo.java:6)处数组长度不是 5

什么时候在 Java 中使用断言？

断言用于代码中不可到达的部分。这确保了如果程序试图执行不可到达的代码，那么就会抛出一个 AssertionError。

public static void main(String[] args)
{
	while(true)
	{
		System.out.println("Reachable part of the code");
	}

	//Unreachable
	assert false;
}

断言还用于使 switch 语句的默认情况不可达。

public static void main(String[] args)
{
	int booleanInt = 0;
	switch (booleanInt) {
		case 0:
	        System.out.println("False");
		    break;
		case 1:
		    System.out.println("True");
		    break;
		default:
			assert false : "boolean integer can only be 0 or 1"; 
    }
} 

我们还可以使用断言来暗示潜在的假设，或者确保注释提供正确的信息。

public static void main(String[] args)
{
	int num = 10;
	if(num > 0)//Positive number
		System.out.print("Positive");

	else//Negative number
	{
		assert num < 0 : "Number is zero";
		System.out.print("Negative");
	}
}

何时不使用断言？

• 断言被用在许多不同的地方。然而，我们应该避免使用它们来检查公共方法的输入。如果我们在这种情况下得到一个 AssertionError，那么就很难确定实际的错误。
• 我们也不应该在断言中调用方法。相反，我们可以使用一个临时变量来存储结果，并在断言中使用这个变量。这样做是为了确保操作的执行与断言是否被启用无关。

摘要

断言是检测错误和调试代码的好方法。它们主要用于软件的测试阶段。断言也使我们的代码更易读。Java 中禁用了断言，但是我们可以轻松地启用它们。在本教程中，我们学习了如何在 Java 中使用断言。

---

---

Java 创建泛型数组

原文：https://www.studytonight.com/java-examples/creating-generic-array-in-java

数组用于存储相似类型数据的集合。用 Java 创建一个通用数组可能有点复杂。数组在运行时使用其元素的类型信息来分配内存。但是在泛型的情况下，由于类型擦除，该信息不可用。

泛型在编译时检查类型信息，在运行时没有信息可用。

对于数组，类型信息在运行时被检查，因为它们是协变的。这意味着我们可以将子类型数组赋给父类型(就像字符串[]赋给对象[])。

String[] strArr = new String[5];
Object[] objArr = strArr; //No Error

上述代码不会返回任何编译时错误。我们还可以向上面的数组添加不同的对象，而不用担心任何编译错误。但是对所有元素的类型检查是在运行时对数组进行的。如果在运行时发现任何差异，那么我们将得到ArrayStoreException。

public class Demo
{
	public static void main(String[] args)
	{
		String[] strArr = new String[5];
		Object[] objArr = strArr; //No Error
		objArr[0] = new Object();
		objArr[1] = new Exception();
	}
}

线程“main”Java . lang . arraystorexception:Java . lang . object
在 Demo.main(Demo.java:7)出现异常

建议使用像列表这样的集合框架，而不是通用数组。但是，如果我们在编译时有关于类型的一些信息，我们可以创建一个泛型数组。让我们学习如何在 Java 中创建一个泛型数组。

使用对象数组创建通用数组

我们可以创建一个带有对象数组的泛型类来模仿泛型数组。我们将在本课中使用一个get()方法和一个set()方法。get()方法将使用显式强制转换。

import java.util.Arrays;
class GenericArray<T>
{
	private Object[] genericArr;

	GenericArray(int size)
	{
		genericArr = new Object[size];
	}	
	public T get(int index)
	{
		return (T) genericArr[index];
	}	
	public void set(int index, T element)
	{
		genericArr[index] = element;
	}	
	@Override
    public String toString()
	{
        return Arrays.toString(genericArr);
    }
}
public class Demo
{
	public static void main(String[] args)
	{
		GenericArray<String> strArr = new GenericArray(3);
		strArr.set(0, "five");
		strArr.set(1, "ten");
		strArr.set(2, "twenty");		
		GenericArray<Integer> intArr = new GenericArray(3);
		intArr.set(0, 5);
		intArr.set(1, 10);
		intArr.set(2, 20);		
		GenericArray<Double> doubleArr = new GenericArray(3);
		doubleArr.set(0, 5.0);
		doubleArr.set(1, 10.0);
		doubleArr.set(2, 20.0);		
		System.out.println("Integer Array: " + intArr);
		System.out.println("String Array: " + strArr);
		System.out.println("Double Array: " + doubleArr);
	}
}

整数数组:[5，10，20]
字符串数组:[5，10，20]
双数组:[5.0，10.0，20.0]

如果我们只使用 get()和 set()方法，而不为用户提供对对象数组的直接访问，那么上述方法可以很好地工作。这里需要注意的一点是，即使是ArrayList也使用对象数组来存储元素。ArrayList不提供对此对象数组的直接访问。

使用反射创建通用数组

这种方法类似于上一节讨论的方法。唯一不同的是构造器会取类型信息，然后我们会用Array.newInstance()方法初始化我们的数组。完整的实现如下所示。

import java.lang.reflect.Array;
import java.util.Arrays;
class GenericArray<T>
{
	private T[] genericArr;

	GenericArray(Class<T> classType, int size)
	{
		genericArr = (T[]) Array.newInstance(classType, size);
	}	
	public T get(int index)
	{
		return genericArr[index];
	}	
	public void set(int index, T element)
	{
		genericArr[index] = element;
	}	
	@Override
    public String toString()
	{
        return Arrays.toString(genericArr);
    }
}
public class Demo
{
	public static void main(String[] args)
	{
		GenericArray<String> strArr = new GenericArray(String.class, 3);
		strArr.set(0, "five");
		strArr.set(1, "ten");
		strArr.set(2, "twenty");

		GenericArray<Integer> intArr = new GenericArray(Integer.class, 3);
		intArr.set(0, 5);
		intArr.set(1, 10);
		intArr.set(2, 20);

		GenericArray<Double> doubleArr = new GenericArray(Double.class, 3);
		doubleArr.set(0, 5.0);
		doubleArr.set(1, 10.0);
		doubleArr.set(2, 20.0);

		System.out.println("Integer Array: " + intArr);
		System.out.println("String Array: " + strArr);
		System.out.println("Double Array: " + doubleArr);
	}
}

整数数组:[5，10，20]
字符串数组:[5，10，20]
双数组:[5.0，10.0，20.0]

摘要

我们可以借助泛型类在 Java 中实现泛型数组。我们可以使用对象数组和适当的方法让用户与这个通用数组交互。ArrayList类也使用了对象数组的概念。我们还可以使用 Array.newInstance()方法，让用户将类型信息传递给构造器。一些集合的泛型方法也使用类似的方法，如 LinkedList。总的来说，建议使用ArrayList或LinkedList来代替创建我们自己的通用列表。

---

---

Java 序列化和反序列化

原文：https://www.studytonight.com/java-examples/java-serialization-and-deserialization

序列化意味着将对象转换为字节流。顾名思义，反序列化是序列化的逆过程。反序列化从字节流生成对象。

执行序列化和反序列化是为了保存或保持对象的状态。它也用于通过网络传输对象。通过序列化生成的字节流与平台无关。

因此，一个对象可以在一个系统上序列化，然后传输到另一个系统，在那里它可以反序列化以获得原始对象。

在本教程中，我们将学习如何在 Java 中序列化和反序列化对象。

序列化和反序列化

• 一个类应该实现Serializable接口，使其对象可序列化。
• Serializable 接口是一个标记接口，这意味着它没有任何字段或方法。
• 如果一个类实现了 Serializable 接口，那么它的所有子类也将是可序列化的。子类不需要实现 Serializable 接口。
• 只有非静态字段被序列化，静态字段不会被序列化。
• 请注意，瞬态字段在序列化过程中被完全忽略，并将被反序列化为默认值。
• 如果一个对象包含对其他对象的引用，那么这些对象也应该是可序列化的。否则，一个 NotSerializableException 就扔了。

对象输出流

ObjectOutputStream 类扩展了 OutputStream 类。它用于将对象作为字节写入输出流。该类的 writeObject() 方法将可序列化的对象转换为字节流。

public final void writeObject(Object o) throws IOException

输入流

ObjectInputStream 类扩展了 InputStream 类，用于读取字节流并从中生成对象。该类的 readObject() 方法用于反序列化。

public final Object readObject() throws IOException, ClassNotFoundException

序列化和反序列化示例

让我们尝试序列化和反序列化如下所示的学生类的对象。

class Student implements Serializable
{
	String name;
	Double gpa;
	static int regNo;
	transient boolean isHosteller;

	Student(String name, Double gpa, int regNo, boolean isHosteller)
	{
		this.name = name;
		this.gpa = gpa;
		this.regNo = regNo;
		this.isHosteller = isHosteller;
	}	
	public void print()
	{
		System.out.println("Name: " + this.name);
		System.out.println("GPA: " + this.gpa);
		System.out.println("Registration Number: " + this.regNo);
		System.out.println("Is Hosteller: " + this.isHosteller);
	}
}

在序列化过程中，瞬态字段将被忽略。它将被反序列化为默认的布尔值(false)。静态字段将采用当前设置的值。请注意，在下面的代码中，当我们更改注册号时，反序列化对象的注册号也会发生变化。这是因为 regNo 字段是静态的。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Demo
{
	public static void main(String[] args) throws IOException, ClassNotFoundException
	{
		Student student = new Student("Justin", 8.51, 101, true);
		System.out.println("Before Deserialization:");
		student.print();

		//Serialization
		FileOutputStream fileOut = new FileOutputStream("demo.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fileOut);
		oos.writeObject(student);
		oos.close();
		fileOut.close();

		student.regNo = 102;//Changing the static field

		//Deserialization
		FileInputStream fileIn = new FileInputStream("demo.txt");
		ObjectInputStream ois = new ObjectInputStream(fileIn);

		Student deserializedStudent = (Student) ois.readObject();

		System.out.println("\nAfter Deserialization:");
		deserializedStudent.print();
		ois.close();
		fileIn.close();
	}
} 

反序列化前:
姓名:贾斯汀
GPA: 8.51
注册号:101
是霍斯特勒:真
T6】反序列化后:
姓名:贾斯汀
GPA: 8.51
注册号:102
是霍斯特勒:假

NotSerializableException 示例

如果学生类包含地址类的字段，那么地址类也必须是可序列化的，以使学生类可序列化。如果没有遵循，则抛出NotSerializableException。让我们尝试模拟 NotSerializableException 。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Student implements Serializable
{
	String name;
	Address add;

	Student(String s, Address a)
	{
		this.name = s;
		this.add = a;
	}
}
class Address//Does not implements Serializable
{
	int postalCode;
	Address(int i)
	{
		this.postalCode = i;
	}
}
public class Demo
{
	public static void main(String[] args) throws IOException, ClassNotFoundException
	{
		Address add = new Address(10001);
		Student student = new Student("Justin", add);

		//Serialization
		FileOutputStream fileOut = new FileOutputStream("demo.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fileOut);
		oos.writeObject(student);
		oos.close();
		fileOut.close();
	}
}

执行绪「main」Java . io . notserializable exception:address
at Java . base/Java . io . object output stream . writeobject 0(object output stream . Java:1193)
at Java . base/Java . io . object output stream . default writefields(object output stream . Java:1579)
at Java . base/Java . io . object output stream . writeserializada(object output stream . Java

串行版本 UID

实现 Serializable 接口的每个类都有一个与之关联的类型为 long 的版本号。该标识用于验证在序列化和反序列化过程中是否加载了正确的类并具有相同的属性。如有出入，则抛出 InvalidClassException 。

我们可以自己声明这个标识，也可以让 JVM 为我们声明。但是，建议我们自己提供版本号，因为 JVM 生成的版本号依赖于编译器。这会导致InvalidClassExceptions。这个字段必须是静态的和最终的，我们可以使用任何访问修饰符。

public static final long serialversionUID = 123L;

自定义序列化和反序列化

我们还可以自定义默认的序列化和反序列化过程。这是通过在我们的类中实现 writeObject()和 readObject()来实现的。

private void writeObject(ObjectOutputStream oos) throws IOException

private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException

自定义序列化和反序列化通常用于被忽略的字段(如瞬态)。我们可以为这些字段定义自定义行为，而不是完全忽略它们。

例如，在下面的代码中，反序列化的对象包含 null 作为注册号。

class Student implements Serializable
{
	String name;
	Double gpa;
	transient String regNo;

	Student(String name, Double gpa, String regNo)
	{
		this.name = name;
		this.gpa = gpa;
		this.regNo = regNo;
	}	
	public void print()
	{
		System.out.println("Name: " + this.name);
		System.out.println("GPA: " + this.gpa);
		System.out.println("Registration Number: " + this.regNo);
	}
}
public class Demo
{
	public static void main(String[] args) throws IOException, ClassNotFoundException
	{
		Student student = new Student("Justin", 8.51, "101");
		System.out.println("Before Deserialization:");
		student.print();

		//Serialization
		FileOutputStream fileOut = new FileOutputStream("demo.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fileOut);
		oos.writeObject(student);
		oos.close();
		fileOut.close();

		//Deserialization
		FileInputStream fileIn = new FileInputStream("demo.txt");
		ObjectInputStream ois = new ObjectInputStream(fileIn);

		Student deserializedStudent = (Student) ois.readObject();

		System.out.println("\nAfter Deserialization:");
		deserializedStudent.print();
		ois.close();
		fileIn.close();
	}
}

反序列化前:
姓名:贾斯汀
GPA: 8.51
注册号:101
T5】反序列化后:
姓名:贾斯汀
GPA: 8.51
注册号:空

假设我们想要序列化瞬态 regNo 字段。当我们序列化这个字段时，应该将当前年份添加到注册号中。这将反映在反序列化的对象中。我们还需要使用 defaultReadObject()和 defaultWriteObject()以默认方式序列化其他字段。使用 writeObject()和 readObject()方法更新的类如下所示。

class Student implements Serializable
{
	String name;
	Double gpa;
	transient String regNo;

	Student(String name, Double gpa, String regNo)
	{
		this.name = name;
		this.gpa = gpa;
		this.regNo = regNo;
	}	
	private void writeObject(ObjectOutputStream oos)throws IOException
	{
		oos.defaultWriteObject();//For default serialization of Student class		
		//Adding current year to the registration number
		LocalDate d = LocalDate.now();
		this.regNo = d.getYear() + "-" + this.regNo;

		//serialization of regNo
		oos.writeObject(this.regNo);
	}	
	private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException
	{
		ois.defaultReadObject();////For default deserialization of Student class
		String s = (String)ois.readObject();
		this.regNo = s;
	}	
	public void print()
	{
		System.out.println("Name: " + this.name);
		System.out.println("GPA: " + this.gpa);
		System.out.println("Registration Number: " + this.regNo);
	}
}

让我们测试一下我们的自定义序列化和反序列化过程。

public class Demo
{
	public static void main(String[] args) throws IOException, ClassNotFoundException
	{
		Student student = new Student("Justin", 8.51, "101");
		System.out.println("Before Deserialization:");
		student.print();

		//Serialization
		FileOutputStream fileOut = new FileOutputStream("demo.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fileOut);
		oos.writeObject(student);
		oos.close();
		fileOut.close();		

		//Deserialization
		FileInputStream fileIn = new FileInputStream("demo.txt");
		ObjectInputStream ois = new ObjectInputStream(fileIn);		
		Student deserializedStudent = (Student) ois.readObject();		
		System.out.println("\nAfter Deserialization:");
		deserializedStudent.print();
		ois.close();
		fileIn.close();
	}
}

反序列化前:
姓名:贾斯汀
GPA: 8.51
注册号:101
T5】反序列化后:
姓名:贾斯汀
GPA: 8.51
注册号:2021-101

摘要

序列化和反序列化通常在存储或传输对象时执行。它们允许我们将对象转换成独立于平台的字节流，并在其他系统上反序列化该流。序列化是使用 ObjectOutputStream 的 writeObject()方法执行的。反序列化是使用 ObjectInputStream 的 readObject()方法执行的。我们还可以为序列化和反序列化定义自定义行为。

---

---

Java 枚举

原文：https://www.studytonight.com/java-examples/java-enum

枚举(枚举的缩写)是 Java 中的一种特殊数据类型，它包含一组固定的常量。Enum 是一种特殊的类，它扩展了 java.lang.Enum 类。枚举允许我们在编译时知道字段的所有可能值，并使我们的代码更易读。我们可以使用它们来避免由于无效输入而导致的不良行为。例如，方向枚举只能有四个可能的值-北、南、东和西。在本教程中，我们将学习更多关于 Java 中枚举的知识。

创建简单枚举

• 枚举是通过指定它可以具有的常数值来创建的。
• 我们使用枚举关键字在 Java 中创建一个枚举。所有枚举常量必须用大写字母 (NORTH，不是 NORTH)书写。
• 所有枚举常量都是静态和最终。静态允许我们通过使用枚举的名称来访问常量。

例子

让我们创建一个简单的枚举来表示学生考试的结果。这个学生可能通过或没有通过考试，也可能缺席考试。

public enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

我们可以通过使用其中一个常量来创建枚举类型的变量。

public class Demo
{
	public static void main(String[] args)
	{
		StudentResult result1 = StudentResult.ABSENT;
		StudentResult result2 = StudentResult.FAIL;
		StudentResult result3 = StudentResult.PASS;

		System.out.println(result1);
		System.out.println(result2);
		System.out.println(result3);
	}
}

缺席
失败
通过

将枚举与 If-Else 语句一起使用

枚举经常与条件语句一起使用，因为它们只能有一个固定的常数值。下面的代码演示了这一点。

enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

public class Demo
{
	public static void main(String[] args)
	{
		StudentResult result = StudentResult.FAIL;

		if(result == StudentResult.ABSENT)
			System.out.println("The student was absent for the exam.");

		else if(result == StudentResult.PASS)
			System.out.println("The student passed the exam.");

		else if(result == StudentResult.FAIL)
			System.out.println("The student failed the exam.");
	}
}

这个学生考试不及格。

使用带有switch语句的枚举

如果常量的数量更多，那么 switch-case 语句是比 if-else 语句更好的选择。

enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

public class Demo
{
	public static void main(String[] args)
	{
		StudentResult result = StudentResult.FAIL;

		switch(result)
		{
			case ABSENT : System.out.println("The Student was absent for the exam.");
			break;

			case PASS : System.out.println("The Student passed the exam.");
			break;

			case FAIL : System.out.println("The Student failed the exam.");
			break;
		}
	}
}

这个学生考试不及格。

迭代枚举

我们可以通过使用值()方法获得所有枚举常数的数组。然后，我们可以遍历这个数组并获取单个常量。我们还可以使用序数()方法获取每个常数的数组索引。

enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

public class Demo
{
	public static void main(String[] args)
	{
		StudentResult[] resultArr = StudentResult.values();

		for(StudentResult sr : resultArr)
		{
			System.out.println(sr + " at index " + sr.ordinal());
		}
	}
}

在指数 0 时通过
在指数 1 时失败
在指数 2 时缺席

枚举的 toString()方法

所有枚举类型都获得一个 toString() 方法，该方法返回枚举常量的字符串值。这允许我们对返回值执行常见的字符串操作。

在下面的代码中，我们首先获取每个常量，并将其转换为字符串。接下来，我们将把它们全部转换成小写并打印出来。

enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

public class Demo
{
	public static void main(String[] args)
	{	
		for(StudentResult sr : StudentResult.values())
		{
			String resultStr = sr.toString();
			System.out.println("Uppercase: " + resultStr);
			System.out.println("Lowercase: " + resultStr.toLowerCase());
			System.out.println();
		}
	}
}

大写:通过
小写:通过
T3】大写:失败
小写:失败
T6】大写:缺席
小写:缺席

字符串中的枚举

在前一节中，我们学习了如何将枚举常量转换为字符串。我们还可以从字符串值创建枚举类型变量。该转换使用 valueOf() 方法。

enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

public class Demo
{
	public static void main(String[] args)
	{	
		String resultStr = "FAIL";
		StudentResult result = StudentResult.valueOf(resultStr);
		System.out.print("Enum from String: " + result);
	}
}

字符串中的枚举:失败

如果字符串无效或不代表任何枚举常量，则会引发 IllegalArgumentException 。

enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

public class Demo
{
	public static void main(String[] args)
	{	
		String resultStr = "PRESENT";//Invalid enum constant
		StudentResult result = StudentResult.valueOf(resultStr);
	}
}

线程“main”中出现异常 Java . lang . illegalargumentexception:无枚举常量 StudentResult。在 Java . base/Java . lang . enum . value of(enum . Java:273)
的 studentresult . value of(demo . Java:1)
的 Demo.main(Demo.java:13)的 PRESENT

类内枚举

我们还可以在类中定义枚举类型，并将它们用作类的数据成员。在下面的代码中，我们有一个带有名称字段的学生类。让我们在这个类中定义 StudentResult 枚举。我们还将为类的数据成员提供这种枚举类型。让我们也定义一些使用枚举数据成员的方法。

package saddas;

public class Student
{
	String name;
	StudentResult result;

	//Defining an enum type
	enum StudentResult
	{
		PASS,
		FAIL,
		ABSENT;
	}

	//Constructor
	Student(String s, StudentResult sr)
	{
		name = s;
		result = sr;
	}

	//enum if-else method
	public void printResult()
	{
		if(this.result == StudentResult.ABSENT)
			System.out.println(this.name + " was absent for the exam.");

		else if(this.result == StudentResult.PASS)
			System.out.println(this.name + " passed the exam.");

		else
			System.out.println(this.name + " failed the exam.");
	}

	//enum method
	public boolean wasAbsent()
	{
		if(this.result == StudentResult.ABSENT)
			return true;
		else
			return false;
	}

	//main method
	public static void main(String[] args)
	{
		Student s1 = new Student("Justin", StudentResult.ABSENT);
		Student s2 = new Student("Jessica", StudentResult.PASS);

		s1.printResult();
		s2.printResult();

		System.out.println("Student s1 was absent: " + s1.wasAbsent());
	}
} 

贾斯汀没有参加考试。
杰西卡通过了考试。
学生 s1 缺席:没错

enumset 集

EnumSet是一种特殊类型的集合，旨在以高效的格式存储枚举常量。枚举使用位向量表示来存储枚举常数。EnumSet 可以执行所有常规的 Set 操作。在使用枚举类型时，总是建议首选EnumSet而不是常规集。我们可以使用()方法创建所选常数的枚举。或者我们可以使用 allOf()方法来创建集合中所有常数的枚举。

import java.util.EnumSet;

enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

public class Demo
{
	public static void main(String[] args)
	{
		EnumSet resultSet1 = EnumSet.of(StudentResult.FAIL, StudentResult.PASS);
		EnumSet resultSet2 = EnumSet.allOf(StudentResult.class);

		System.out.println("Enum Set-1: " + resultSet1);
		System.out.print("Enum Set-2: " + resultSet2);
	}
}

EnumSet-1:[通过，失败]
EnumSet-2:[通过，失败，缺席]

枚举

EnumMap是为枚举类型设计的特殊映射实现。EnumMaps 存储键-值对，其中键总是 enum 常量，值可以是任何类型。就像枚举一样，在存储枚举方面，EnumMap比普通的HashMap更好、更有效。我们可以在 EnumMap 上执行所有正常的映射操作。

import java.util.EnumMap;
import java.util.Map;

enum StudentResult
{
	PASS,
	FAIL,
	ABSENT;
}

public class Demo
{
	public static void main(String[] args)
	{
		EnumMap<StudentResult, String> resultMap = new EnumMap<>(StudentResult.class);
		resultMap.put(StudentResult.PASS, "Student Passed the exam");
		resultMap.put(StudentResult.FAIL, "Student Failed the exam");
		resultMap.put(StudentResult.ABSENT, "Student was absent for the exam");

		for(Map.Entry<StudentResult, String> e : resultMap.entrySet())
			System.out.println(e.getKey() + " --> " + e.getValue());
	}
}

及格- >学生通过考试
不及格- >学生考试不及格
缺课- >学生考试缺课

枚举字段

我们可以向枚举类型添加一个字段或数据成员。该字段将与每个常数相关联。我们可以使用构造器为每个常量初始化这个枚举字段。

例如，在下面的代码中，我们向枚举添加了一个String类型的百分比字段。我们还为这个字段编写了一个构造器。所有枚举常数都用不同的参数调用了此构造器。

请注意，枚举的构造器总是私有的。我们不能使用任何其他修饰语。如果未指定访问修饰符，则隐式添加 Private。

enum StudentResult
{	
	PASS("Above 35%"),//Constructor called with value "Above 35%"
	FAIL("Below 35%"),//Constructor called with value "Below 35%"
	ABSENT("N/A");//Constructor called with value "N/A"

	String percent; //Enum Field

	private StudentResult(String percent)//Private constructor
	{
		this.percent = percent;
	}
}

public class Demo
{
	public static void main(String[] args)
	{
		for(StudentResult s : StudentResult.values())
			System.out.println(s + " -> " + s.percent);
	}
}

通过- >高于 35%
未通过- >低于 35%
缺席- >不适用

枚举方法

枚举可以包含具体和抽象方法。对于抽象方法，枚举的每个实例或常数都必须实现它。让我们看一下这两种场景的示例。

具体方法

让我们在枚举中添加一个 print()方法。这将打印枚举常数和常数的百分比字段。

enum StudentResult
{
	PASS("Above 35%"),//Constructor called with value "Above 35%"
	FAIL("Below 35%"),//Constructor called with value "Below 35%"
	ABSENT("N/A");//Constructor called with value "N/A"

	String percent; //Enum Field

	private StudentResult(String percent)//Private constructor
	{
		this.percent = percent;
	}

	//Enum Method
	public void print()
	{
		System.out.println(this + " --> " + this.percent);
	}
}

public class Demo
{
	public static void main(String[] args)
	{
		for(StudentResult s : StudentResult.values())
			s.print();
	}
}

通过- >高于 35%
未通过- >低于 35%
缺席- >不适用

抽象方法

让我们将 print()方法抽象化。现在，每个常量都应该覆盖它。

enum StudentResult
{
	PASS("Above 35%"){
		//Override the abstract print method
		@Override 
		void print() {
			System.out.println("Pass(Above 35%)");
		}
	},
	FAIL("Below 35%"){
		//Override the abstract print method
		@Override 
		void print() {
			System.out.println("Fail(Below 35%)");
		}
	},
	ABSENT("N/A"){
		//Override the abstract print method
		@Override 
		void print() {
			System.out.println("Absent for the exam");
		}
	};

	String percent;//Enum field

	StudentResult(String percent)//private constructor
	{
		this.percent = percent;
	}

	//Abstract Enum Method
	abstract void print();
}

public class Demo
{
	public static void main(String[] args)
	{
		for(StudentResult s : StudentResult.values())
			s.print();
	}
}

及格(35%以上)
不及格(35%以下)
缺考

实现接口

枚举类型不能扩展其他类，因为它隐式扩展了 java.lang.Enum 类。但是，它可以实现其他接口。下面的代码演示了这一点。

interface DemoInterface
{
	void print();
}

enum StudentResult implements DemoInterface
{
	PASS("Above 35%"),//Constructor called with value "Above 35%"
	FAIL("Below 35%"),//Constructor called with value "Below 35%"
	ABSENT("N/A");//Constructor called with value "N/A"

	String percent;//Enum Field

	private StudentResult(String percent)//Private constructor
	{
		this.percent = percent;
	}

	//implementing the interface method
	@Override
	public void print()
	{
		System.out.println(this + " --> " + this.percent);
	}
}

public class Demo
{
	public static void main(String[] args)
	{
		for(StudentResult s : StudentResult.values())
			s.print();
	}
}

通过- >高于 35%
未通过- >低于 35%
缺席- >不适用

摘要

枚举用于定义常量值的集合。以下几点总结了本教程中学习的关键概念。

• 它们非常类似于具有最终成员和静态成员的类。
• 枚举使用最终类在内部实现。每个枚举常数都是该类的静态和最终数据成员。
• 编译器在内部将 values()、valueOf()和序数()方法添加到我们的枚举中。
• 枚举还可以包含其他字段和构造器来初始化这些字段。
• 构造器必须始终是私有的，我们不能使用 new 关键字来创建枚举的实例。
• 枚举也可以包含具体的和抽象的方法。枚举实例必须为抽象方法实现。
• Enum 隐式扩展了 java.lang.Enum 类，因此不能扩展任何其他类。但是它们可以实现其他接口。
• 它们提高了类型安全性，因为编译器确切地知道枚举类型实例的常量。

---

---

在 Java 中迭代映射

原文：https://www.studytonight.com/java-examples/iterate-a-map-in-java

映射是 Java 中的一个接口，用于存储键值对。我们不能使用迭代器直接迭代映射，因为它不是一个真正的集合。然而，还有其他遍历映射的方法。我们将使用映射。入口界面。它用于存储单个键值映射。我们可以应用以下技术来迭代任何映射(HashMap、LinkedHashMap 或 TreeMap)。

使用 EntrySet 和 For 循环

Map.entrySet() 方法返回我们映射的集合视图(集合)，返回集合的每个元素都是 Map.Entry 类型，所以我们基本上得到一个集合<映射。词条< K，V > > 。我们可以遍历这个集合，并使用 getKey() 和 getValue() 方法从每个 Map.Entry 中获取键和值。

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo
{
	public static void main(String[] args)
	{
		Map<Integer, String> map = new HashMap<>();
		map.put(101, "Justin");
		map.put(102, "Jessica");
		map.put(103, "Simon");
		map.put(104, "Harry");

		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();

		for(Map.Entry<Integer, String> e : entrySet)
			System.out.println(e.getKey() + "--->" + e.getValue());
	}
}

【T11】>【Justin】
【102】>【Jessica】
【103】>【Simon】
【104】>哈利

使用迭代器和 EntrySet

在上面的代码中，我们使用了 for 循环。我们还可以使用迭代器遍历 Map.entrySet()返回的集合。我们将首先使用条目集上的迭代器()方法获得一个迭代器实例。然后，我们可以使用 hasNext() 和 next() 方法循环遍历每个元素并获取它。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo
{
	public static void main(String[] args)
	{
		Map<Integer, String> map = new HashMap<>();
		map.put(101, "Justin");
		map.put(102, "Jessica");
		map.put(103, "Simon");
		map.put(104, "Harry");

		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
		Iterator<Entry<Integer, String>> entrySetIterator = entrySet.iterator();

		while(entrySetIterator.hasNext())
		{
			Map.Entry<Integer, String> e = entrySetIterator.next();
			Integer key = e.getKey();
			String value = e.getValue();
			System.out.println(key + "--->" + value);
		}
	}
}

【T11】>【Justin】
【102】>【Jessica】
【103】>【Simon】
【104】>哈利

使用映射的键集()方法

顾名思义， Map.keySet() 方法返回一个包含映射实例所有键的集合。我们可以使用 get() 方法迭代每个键并检索相应的值。

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo
{
	public static void main(String[] args)
	{
		Map<Integer, String> map = new HashMap<>();
		map.put(101, "Justin");
		map.put(102, "Jessica");
		map.put(103, "Simon");
		map.put(104, "Harry");

		Set<Integer> keySet = map.keySet();

		for(Integer key : keySet)
			System.out.println(key + "--->" + map.get(key));
	}
}

【T11】>【Justin】
【102】>【Jessica】
【103】>【Simon】
【104】>哈利

使用 forEach()和 Lambda 表达式(Java 8)

这可能是最简单的方法，我们可以用它在一行代码中迭代一个 Map。下面的代码演示了这种技术。

import java.util.HashMap;
import java.util.Map;

public class Demo
{
	public static void main(String[] args)
	{
		Map<Integer, String> map = new HashMap<>();
		map.put(101, "Justin");
		map.put(102, "Jessica");
		map.put(103, "Simon");
		map.put(104, "Harry");

		map.forEach((key, value) -> System.out.println(key + "-->" + value));
	}
}

【T11】>【Justin】
【102】>【Jessica】
【103】>【Simon】
【104】>哈利

使用流(Java 8)

我们可以使用流 API 在映射中循环。我们将再次使用 entrySet()方法，然后从这个集合创建一个流。接下来，我们将在每个映射上使用 forEach()方法。条目并获取其键和值。

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo
{
	public static void main(String[] args)
	{
		Map<Integer, String> map = new HashMap<>();
		map.put(101, "Justin");
		map.put(102, "Jessica");
		map.put(103, "Simon");
		map.put(104, "Harry");

		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();

		entrySet.stream()
		   		.forEach(e -> System.out.println(e.getKey() + "-->" + e.getValue()));
	}
}

【T11】>【Justin】
【102】>【Jessica】
【103】>【Simon】
【104】>哈利

分别迭代键和值

在上面所有的部分中，我们并行遍历键和值。但是，我们可以分别遍历键和值。我们可以通过使用 Map.keySet()方法得到一个包含所有键的集合。然后，我们可以简单地使用 for 循环遍历集合。

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo
{
	public static void main(String[] args)
	{
		Map<Integer, String> map = new HashMap<>();
		map.put(101, "Justin");
		map.put(102, "Jessica");
		map.put(103, "Simon");
		map.put(104, "Harry");

		Set<Integer> keySet = map.keySet();

		for(Integer key : keySet)
			System.out.println(key);
	}
}

101
102
103
104

同样，我们可以使用值()方法获取包含映射所有值的集合。

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Demo
{
	public static void main(String[] args)
	{
		Map<Integer, String> map = new HashMap<>();
		map.put(101, "Justin");
		map.put(102, "Jessica");
		map.put(103, "Simon");
		map.put(104, "Harry");

		Collection<String> valueSet = map.values();

		for(String value : valueSet)
			System.out.println(value);
	}
}

贾斯汀杰西卡 T2 西蒙哈利

摘要

在本教程中，我们学习了如何在 Java 中迭代映射。大多数方法都使用了 Map.entrySet()。此方法返回包含映射条目的集合。然后，我们可以使用 for 循环或迭代器遍历这些条目。我们还可以使用 keySet()方法从映射中获取密钥。将 values()方法与 for 循环一起使用，以迭代映射值。我们也可以使用带有 lambda 表达式或流的 forEach()方法来迭代一个映射，但是它们只在 Java 8 和更高版本中可用。

---

---

自定义 Java 异常

原文：https://www.studytonight.com/java-examples/custom-java-exception

异常是执行程序时发生的不良事件。异常干扰了我们代码的正常执行流程。Java 定义了许多内置的异常，涵盖了可能发生错误的不同场景。但是，我们可能需要自定义异常来处理一些特殊情况。在本教程中，我们将学习如何在 Java 中创建自定义异常。

为什么我们需要自定义例外？

• Java 提供了不同的异常，它们几乎涵盖了我们在编程过程中可能遇到的每一种情况。但是在一些情况下，我们可能需要一个定制的例外。
• 例如，假设我们有一个银行类。如果账户余额低于 0 美元，那么我们可能需要抛出资金不足异常。
• 以下是我们可能需要自定义的、用户定义的异常的两种一般情况。
  • 与我们的业务逻辑或工作流程相关的异常(如银行示例)。
  • 为现有异常提供特定处理。

自定义检查例外

检查异常是在编译时检查的异常。如果代码的某些部分引发了选中的异常，则必须使用 try-catch 块或方法定义中的 throws 关键字来处理该异常。

为了创建一个用户定义的检查异常，我们需要扩展异常类。

例子

让我们创建一个 MyArray 类并实现一个 get()方法。如果索引无效，此方法将引发 IndexNotValidException 异常。

//Custom Checked exception
class IndexNotValidException extends Exception
{
	IndexNotValidException(String msg)//Constructor with error message
	{
		super(msg);
	}
}	
class MyArray
{
	int[] array;
	MyArray(int size)//Constructor for our array class
	{
		array = new int[size];
		for(int i=0; i<size; i++)
			array[i] = i*5;
	}	
	//Get Method may throw IndexNotValidException
	public int get(int index) throws IndexNotValidException
	{
		if(index >= array.length)
			throw new IndexNotValidException("Index " + index+ " is invalid.");//Throwing the exception

		else
			return array[index];
	}
}
public class Demo
{	
	public static void main(String[] args)
	{
			MyArray arr = new MyArray(5);
			try {
				arr.get(10);//Error
			} 
			catch (IndexNotValidException e) {
				e.printStackTrace();
			}
	}
}

IndexNotValidException:索引 10 无效。
在 MyArray.get(Demo.java:24)
在 Demo.main(Demo.java:39)

如上面的代码所示，IndexNotValidException 扩展了异常类。我们在 IndexNotValidException 类中使用了一个构造器。这会调用带有错误消息的父构造器。

自定义未检查的例外

编译时不检查未检查的异常。此类异常仅在运行时检测到。要创建自定义的未检查异常，我们需要扩展 RuntimeException 类。

例子

我们可以扩展 RuntimeException 类而不是 Exception 类来创建一个未检查的异常。我们还可以定义一个可抛出的异常，它定义了潜在的异常或异常的原因。在我们的例子中，潜在的例外是 ArrayIndexOutOfBounds 。完整的代码如下所示。

//Custom Unchecked exception
class IndexNotValidException extends RuntimeException
{
	IndexNotValidException(String msg, Throwable cause)//Constructor with error message and cause 
	{
		super(msg, cause);
	}
}	
class MyArray
{
	int[] array;
	MyArray(int size)//Constructor for our array class
	{
		array = new int[size];
		for(int i=0; i<size; i++)
			array[i] = i*5;
	}	
	//Get Method may throw IndexNotValidException
	public int get(int index) throws IndexNotValidException
	{
		if(index >= array.length)
		{
			Exception cause = new ArrayIndexOutOfBoundsException();//Cause of our exception
			throw new IndexNotValidException("Index " + index+ " is invalid.", cause);//Throwing the exception
		}			
		else
			return array[index];
	}
}
public class Demo
{

	public static void main(String[] args)
	{
			MyArray arr = new MyArray(5);
			arr.get(10);//Exception occurs here
	}
}

线程“main”中出现异常 IndexNotValidException:索引 10 无效。
在 MyArray.get(Demo.java:24)
在 Demo.main(Demo.java:39)
由:Java . lang . arrayindexoutofboundsexception
在 MyArray.get(Demo.java:23)
引起...1 个以上

摘要

当我们使用任何编程语言时，异常和错误都很常见。自定义异常帮助我们识别特定于我们自己的应用的错误。自定义异常用于识别我们的业务逻辑和工作流中的错误。它们也用于在现有异常的基础上构建一些东西。

---

---

Java 中的回文

原文：https://www.studytonight.com/java-examples/palindrome-in-java

如果一个字符串从头到尾读起来都一样，那么它就被称为回文。从字符串的开头或结尾读取时，所有字符都以相同的顺序出现。回文的例子有“Bob”、“Naman”、“Racecar”、“dide”等。

在本教程中，我们将学习如何检查一个字符串是否是回文。

解决方案 1:使用两个指针

我们可以使用两个指针来检查一个字符串是否是回文。一个指针将从字符串的开头开始，并向前移动。第二个指针从字符串的末尾开始，并向后移动。在每次迭代中，如果出现在两个指针上的字符相同，那么我们将移动指针。否则，我们将返回 false。我们还会将输入字符串转换为小写。

public class Demo
{
	public static boolean isPalindrome(String str)
	{
		int startIdx = 0;
		int endIdx = str.length() - 1;		
		while(startIdx < endIdx)
		{
			char start = str.charAt(startIdx);
			char end = str.charAt(endIdx);
			if(Character.toLowerCase(start) != Character.toLowerCase(end))
				return false;
			startIdx += 1;
			endIdx -= 1;
		}
		return true;
	}	
	public static void main(String[] args)
	{
		System.out.println("racecar is palindrome: " + isPalindrome("racecar"));
		System.out.println("RaCeCar is palindrome: " + isPalindrome("RaCeCar"));
		System.out.println("naman is palindrome: " + isPalindrome("naman"));
		System.out.println("Deed is palindrome: " + isPalindrome("Deed"));
		System.out.println("Java is palindrome: " + isPalindrome("Java"));
	}
}

racecar 是回文:真
RaCeCar 是回文:真
纳曼是回文:真
契是回文:真
Java 是回文:假

使用递归方法查找回文

我们可以递归地实现上面的代码。递归可以有两种基本情况:

• 如果字符串包含单个字符，则返回 true。

• 如果开始指针和结束指针字符在任何时候都不相等，则返回 false。

递归解决方案的完整代码如下所示。

public class Demo
{
	public static boolean isPalindrome(String str)
	{
		String lowercaseStr = str.toLowerCase();

		return isPalindromeRecursive(lowercaseStr, 0, lowercaseStr.length() - 1);
	}

	public static boolean isPalindromeRecursive(String str, int startIdx, int endIdx)
	{
		if(startIdx == endIdx)//Single character string
			return true;

		if(str.charAt(startIdx) != str.charAt(endIdx))
			return false;

		if(startIdx < endIdx + 1)
			return isPalindromeRecursive(str, startIdx + 1, endIdx - 1);

		return true;
	}

	public static void main(String[] args)
	{
		System.out.println("racecar is a palindrome: " + isPalindrome("racecar"));
		System.out.println("RaCeCar is a palindrome: " + isPalindrome("RaCeCar"));
		System.out.println("naman is a palindrome: " + isPalindrome("naman"));
		System.out.println("Deed is a palindrome: " + isPalindrome("Deed"));
		System.out.println("Java is a palindrome: " + isPalindrome("Java"));
	}
}

racecar 是回文:真
RaCeCar 是回文:真
纳曼是回文:真
契是回文:真
Java 是回文:假

解决方案 2:反转字符串

我们可以使用 StringBuilder 或 StringBuffer 类来反转输入字符串。如果反串和原串一样，那么就是回文。

我们可以通过以相反的方向(从右到左)遍历字符串来手动反转字符串。

public static boolean isPalindrome(String str)
{
	String lowercaseStr = str.toLowerCase();
	StringBuilder reverseSB = new StringBuilder();
	//Reversing the string
	for(int i = lowercaseStr.length() - 1; i >= 0; i--)
		reverseSB.append(lowercaseStr.charAt(i));

	String reversedStr = reverseSB.toString();
	return lowercaseStr.equals(reversedStr);
}

或者我们可以使用 StringBuilder 类的 reverse() 方法。

public static boolean isPalindrome(String str)
{
	String lowercaseStr = str.toLowerCase();

	StringBuilder sb = new StringBuilder(lowercaseStr);
	StringBuilder reversedSB = sb.reverse();//Reversing the string

	String reversedStr = reversedSB.toString();
	return lowercaseStr.equals(reversedStr);
}

让我们在一些字符串上测试这种方法，并查看输出。

public static void main(String[] args)
{
	System.out.println("racecar is a palindrome: " + isPalindrome("racecar"));
	System.out.println("RaCeCar is a palindrome: " + isPalindrome("RaCeCar"));
	System.out.println("naman is a palindrome: " + isPalindrome("naman"));
	System.out.println("Deed is a palindrome: " + isPalindrome("Deed"));
	System.out.println("Java is a palindrome: " + isPalindrome("Java"));
}

racecar 是回文:真
RaCeCar 是回文:真
纳曼是回文:真
契是回文:真
Java 是回文:假

解决方案 3:使用 Java 8 流

流 API 也可以用来检查回文字符串。我们将使用 IntStream 类来遍历字符串。接下来，我们将使用 noneMatch() 方法和一个谓词。

import java.util.stream.IntStream;

public class Demo
{
	public static boolean isPalindrome(String str)
	{
		String lowercaseStr = str.toLowerCase();
		return IntStream.range(0, lowercaseStr.length() / 2)
					   .noneMatch(i -> lowercaseStr.charAt(i) != lowercaseStr.charAt(lowercaseStr.length() - i - 1));
	}

	public static void main(String[] args)
	{
		System.out.println("racecar is a palindrome: " + isPalindrome("racecar"));
		System.out.println("RaCeCar is a palindrome: " + isPalindrome("RaCeCar"));
		System.out.println("naman is a palindrome: " + isPalindrome("naman"));
		System.out.println("Deed is a palindrome: " + isPalindrome("Deed"));
		System.out.println("Java is a palindrome: " + isPalindrome("Java"));
	}
}

racecar 是回文:真
RaCeCar 是回文:真
纳曼是回文:真
契是回文:真
Java 是回文:假

摘要

在本教程中，我们讨论了检查字符串是否是回文的不同方法。我们可以使用简单的两点方法。该方法可以迭代或递归实现。我们还可以反转字符串，检查反转后的字符串是否与原始字符串相同。也可以使用 Java 8 流。

反转字符串将总是给出 0(n)的时间复杂度。另一方面，双指针方法性能更好，并且返回 O(1)的最佳时间复杂度。当字符串两端的字符不匹配时，出现双指针方法的最佳情况。双指针方法最差的时间复杂度是 O(n)。

---

---

为什么 Java 中的字符串是不可变的？

原文：https://www.studytonight.com/java-examples/why-are-strings-in-java-immutable

一个字符串是一个字符序列或者一个字符数组。 Java 为我们提供了一个不可变的String类来处理字符串。不可变类的实例一旦创建，就不能修改。

这些对象的内部状态在整个程序执行过程中保持不变。我们无法更新对此对象或其属性的引用。

在本教程中，我们将学习为什么String类在 Java 中是不可变的，以及它的好处。

为什么字符串是不可变的？

Java 中字符串不可变的原因有几个。让我们来看看这些原因。

字符串池

字符串池是堆内存中的一个内存位置。字符串池存储所有字符串，并优化字符串使用的内存。它通过只为重复字符串存储一个副本来实现这一点。它工作得非常好，不会出现不一致，因为字符串是不可变的。

例如，如果我们运行以下代码，str1 和 str2 将指向字符串池中的同一个字符串对象。如果我们想为一个字符串指定一个单独的空格，我们可以使用新的关键字。

public static void main(String args[])
{
	String str1 = "String";
	String str2 = "String";
	String str3 = new String("String");
}

安全

字符串用于存储敏感信息，如用户名、密码、网址等。如果字符串不是不可变的，那么任何有权访问字符串引用的人都可以修改它。字符串的不变性确保了我们可以安全地使用敏感值，而不用担心有人修改它。

例如，假设我们有一个方法，该方法将字符串密码作为输入，并验证密码是否有效。现在，如果某个黑客可以访问该字符串，那么黑客可以在验证之前修改该字符串。这可能会导致我们的应用出现不一致和安全漏洞。

多线程

所有不可变对象都是线程安全的。多个线程可以同时访问字符串，因为多次读取操作不会导致任何同步问题。即使某个线程修改了该值，也会创建一个全新的字符串，而不会影响原始字符串。

Hashcode 缓存

因为字符串是不可变的，所以它提高了使用哈希来存储对象的集合的整体性能。

例如，如果一个 HashMap 包含一个 String 键，它的 Hashcode 将总是相同的，因为它是不可变的。如果字符串是可变的，那么插入后该值可以改变。它将不再生成相同的 Hashcode，这将导致不一致。

摘要

我们不能在创建不可变对象后修改它们。Java 中的 String 类是最终的、不可变的。这使得字符串安全且线程安全。我们可以自由地将字符串传递给方法和线程，而不用担心它的值被改变。

不变性还提高了整体性能，因为它允许 JVM 使用字符串池并避免存储重复项。在本教程中，我们学习了与不可变字符串相关的好处。

---

---

Java 中的 Base64 编码和解码

原文：https://www.studytonight.com/java-examples/base64-encoding-and-decoding-in-java

Base64 类是java.util 类的一部分，为 Base64 编码和解码方案提供静态方法。 Java 8 引入了 Base64 类。这个类支持三种类型的 Base64 编码——基本、网址和文件名安全以及 MIME。

在本教程中，我们将使用java.util.Base64类和 Apache Commons 库学习 Base64 编码和解码。

Base64 基本编码和解码

基本编码器使用 Base64 字母表进行编码和解码。它不会向编码字符串添加任何行分隔符。我们将使用getEncoder()方法返回一个简单的 Base64。编码器。

如上所述，该编码器使用基本类型 base64 编码方案。接下来，我们将使用encodeToString()方法。它接受一个字节数组作为输入，并返回一个编码字符串。

import java.util.Base64;
public class Demo
{
	public static void main(String args[])
	{
		String strToEncode = "Hello World";
		byte[] bytesToEncode = strToEncode.getBytes();
		String encodedStr = Base64.getEncoder().encodeToString(bytesToEncode);		
		System.out.print(encodedStr);
	}
}

SGVsbG8gV29ybGQ=

为了解码一个编码的字符串，我们将使用 Base64。解码器通过getDecoder()方法返回。然后，我们将使用解码器的decode() 方法。它将接受一个编码的字符串作为输入，并返回解码的字符串。

import java.util.Base64;
public class Demo
{
	public static void main(String args[])
	{
		String strToEncode = "Hello World";
         //encoding
		byte[] bytesToEncode = strToEncode.getBytes();
		String encodedStr = Base64.getEncoder().encodeToString(bytesToEncode);
		System.out.println("Encoded String: " + encodedStr);
		//decoding
		byte[] decodedByteArr = Base64.getDecoder().decode(encodedStr);
		String decodedStr = new String(decodedByteArr);
		System.out.println("Decoded String: " + decodedStr);
	}
}

编码字符串:SGVsbG8gV29ybGQ=
解码字符串:Hello World

无填充的 Base64 编码

如果编码字符串的长度不是三的倍数，上一节中执行的编码会添加额外的填充字符( = )。下面的代码演示了这一点。我们可以在编码字符串的末尾看到两个等号(=)。

import java.util.Base64;
public class Demo
{
	public static void main(String args[])
	{
		String strToEncode = "Java";
		byte[] bytesToEncode = strToEncode.getBytes();
		String encodedStr = Base64.getEncoder().encodeToString(bytesToEncode);//Encoding with padding
		System.out.println("Encoded String: " + encodedStr);
	}
}

编码字符串:SmF2YQ==

如果我们不想要这个填充，我们可以在编码器上使用withoutPadding()方法。

import java.util.Base64;
public class Demo
{
	public static void main(String args[])
	{
		String strToEncode = "Java";
		byte[] bytesToEncode = strToEncode.getBytes();
		String encodedStr = Base64.getEncoder().withoutPadding().encodeToString(bytesToEncode);//encoding without padding
		System.out.println("Encoded String: " + encodedStr);
	}
}

编码字符串:SmF2YQ

Base64 网址编码和解码

Base64 类通过使用网址和文件名安全的 Base64 字母表来处理网址编码和解码。我们可以使用getUrlEncoder()方法获得一个 Base64 URL 编码器。然后，我们可以像上一节一样使用encodeToString()方法。

同样，我们有一个getUrlDecoder()方法，返回一个 URL 解码器。同样，我们可以使用这个解码器的decode() 方法。

import java.util.Base64;
public class Demo
{
	public static void main(String args[])
	{
		String urlToEncode = "https://go.java/?intcmp=gojava-banner-java-com";
         //Encoding
		String encodedUrl = Base64.getUrlEncoder().encodeToString(urlToEncode.getBytes());
		System.out.println("Encoded URL: " + encodedUrl);
		//Decoding
		byte[] decodedUrlBytes = Base64.getUrlDecoder().decode(encodedUrl);
		String decodedUrl = new String(decodedUrlBytes);
		System.out.print("Decoded URL: " + decodedUrl);
	}
}

编码的 URL:ahr 0 CHM 6 ly 9 nby 5 qyzhlz 9 pbnrjbxa 9 z29 qyzhlwbm 5 LCI 1 qyxzhnvbq = =
编码的 URL: https://go.java/？intcmp=gojava 横幅 java-com

Base64 MIME 编码和解码

MIME 代表多用途互联网邮件扩展，Base64 类使用 Base64 字母表进行编码和解码操作。在编码输出中，每行最多包含 76 个字符。

每一行以回车符( \r )结束，后跟换行符( \n )作为行分隔符。请注意，编码字符串的末尾没有行分隔符。

我们可以使用getMimeEncoder()和encodeToString()方法进行编码。

import java.util.Base64;
import java.util.UUID;
public class Demo
{
	public static void main(String args[])
	{
        //Creating a MIME input for encoding
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 10; ++i) {
            sb.append(UUID.randomUUID().toString());
         }
		//Encoding
         byte[] bytes = sb.toString().getBytes();
         String mimeEncodedStr = Base64.getMimeEncoder().encodeToString(bytes);
         System.out.println("Encoded String: " + mimeEncodedStr);
	}
}

编码字串:ntdjmzlmgmtowfmys 00 yj5lwxntnzntzlzwmzlnwvztyhhngemzmms 00 nwxlwfj
mmunitywi 4 zjldjlmzljngizmgexotktodc 0 ny 00 zjwlwmqtmdgxmgq 4y J1 mgnjntaxzdj
njctowmwos 00 m2 lw2

要解码，我们将使用getMimeDecoder()获得一个解码器，然后我们将使用decode()方法。

import java.util.Base64;
import java.util.UUID;
public class Demo
{
	public static void main(String args[])
	{
        //Creating a MIME input for encoding
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 10; ++i) {
            sb.append(UUID.randomUUID().toString());
         }		
		//Encoding
         byte[] bytes = sb.toString().getBytes();
         String mimeEncodedStr = Base64.getMimeEncoder().encodeToString(bytes);         
         //Decoding
         byte[] mimeDecodedBytes = Base64.getMimeDecoder().decode(mimeEncodedStr);
         String mimeDecodedStr = new String(mimeDecodedBytes);
	}
}

使用阿帕奇公共图书馆

Apache Commons 库还在其org.apache.commons.codec.binary包中提供了一个 Base64 类。这个类包含五个不同的构造器，用于不同的编码方案。创建 Base64 实例后，我们可以对字符串字节使用encode()和 decode()方法来执行编码和解码。

import org.apache.commons.codec.binary.Base64;
public class Demo
{
	public static void main(String args[])
	{
		Base64 base64 = new Base64();
        //encoding
		String strToEncode = "Hello World";
		byte[] encodedBytes = base64.encode(strToEncode.getBytes());
		String encodedStr = new String(encodedBytes);
		System.out.println("Encoded String: " + encodedStr);
		//decoding
		byte[] decodedByteArr = base64.decode(encodedStr.getBytes());
		String decodedStr = new String(decodedByteArr);
		System.out.println("Decoded String: " + decodedStr);
	}
}

编码字符串:SGVsbG8gV29ybGQ=
解码字符串:Hello World

我们也可以使用静态方法encodeBase64()和decodeBase64().`` 直接访问 API

import org.apache.commons.codec.binary.Base64;
public class Demo
{
	public static void main(String args[])
	{
		String strToEncode = "Hello World";
        //encoding
		String encodedStr = new String(Base64.encodeBase64(strToEncode.getBytes()));
		System.out.println("Encoded String: " + encodedStr);
		//decoding
		String decodedStr = new String(Base64.decodeBase64(encodedStr.getBytes()));
		System.out.print("Decoded String: " + decodedStr);
	}
}

编码字符串:SGVsbG8gV29ybGQ=
解码字符串:Hello World

摘要

在 Java 8 中添加了java.util 包的 Base64，以提供 Base64 编码和解码功能。它支持三种不同的 Base64 编码和解码方案——基本、网址和文件名安全以及 MIME。这个类提供像getEncoder()和getDecoder()这样的静态方法来获取 base64 编码器和解码器。

然后，我们可以使用encodeToString()和decode()方法来执行编码和解码操作。我们还可以使用 Apache Commons 库的 Base64 类来执行 Base64 编码和解码。

---

---

Java 中的归并排序

原文：https://www.studytonight.com/java-examples/merge-sort-in-java

归并排序是一种高效稳定的排序算法。它基于分治算法方法。在本教程中，我们将了解更多关于归并排序及其在 Java 中的实现。

归并排序算法

归并排序使用分治技术进行排序。算法的除法部分包括将输入数组分成两个较小的数组。较小的数组再次分成两半。

只要数组包含不止一个元素，这个过程就递归地继续。记住一个只有一个元素的数组已经被排序了。归并排序利用了这个属性，并将其用于算法的征服部分。

这部分的算法总结如下。

• 如果输入数组长度小于 2，则返回。
• 否则，计算数组的中间索引并递归拆分前半部分。
• 然后递归拆分数组的右半部分。
• 将数组的左半部分和右半部分合并成一个排序数组。

分割输入数组后，算法将这些较小尺寸的数组合并成一个排序数组。合并总是在两个排序的数组上进行。发生这种情况是因为合并过程将在将输入数组划分为单元素数组后开始。

让我们考虑一个例子来更好地理解数组的合并。假设我们有两个排序数组，[4，7，9]和[2，3，8]。以下步骤解释了如何将这两个数组合并成一个排序数组。

最初，我们在两个数组的开头都有一个指针。我们将重复以下步骤，直到任何一个数组中的元素用完。

比较两个数组指针引用的元素。第二数组的第一元素小于第一数组的第一元素(2<4)。因此，我们将较小的元素添加到最终排序的数组中，并将第二个数组的指针向左移动一个位置。

同样，第二个数组的引用元素更小(3<4)。所以 3 被加到最后一个数组中，第二个数组的指针向前移动。

现在，第一个数组的引用元素变小了(4<8)。所以 4 被添加到结果数组中，第一个数组的指针向前移动到 7。

7 小于 8，所以它被添加到结果数组中，第一个数组的指针移到 9。

第二个数组的被引用元素小于第一个数组的被引用元素(8<9)。所以 8 被添加到最终的排序数组中。第二个数组指针不能向前移动，因为我们用完了第二个数组中的元素。所以循环结束。

另一个数组的所有元素都被添加到最终的数组中。我们的最终数组看起来像[2，3，4，7，8，9]。

Java 中归并排序的实现

让我们在 Java 中实现归并排序。我们将使用两种方法来实现归并排序算法。一个 mergeSort() 方法将递归地划分输入数组，并对它们调用 merge()方法。 merge() 方法将包含合并逻辑。

mergeSort() 方法代码如下。

public static void mergeSort(int[] arrToSort, int startIdx, int endIdx)
{
	if (startIdx >= endIdx) //array contains just a single element
		return; 

	int midIdx = startIdx + (endIdx - startIdx) / 2; //middle index
	mergeSort(arrToSort, startIdx, midIdx); //Divide the left half recursively
	mergeSort(arrToSort, midIdx + 1, endIdx); //Divide the right half recursively

	merge(arrToSort, startIdx, midIdx, endIdx); //merge the left and right half
} 

合并()方法代码如下。

public static void merge(int[] arrToSort, int startIdx, int midIdx, int endIdx)
{
	int[] leftArr = new int[midIdx - startIdx + 1]; 
	int[] rightArr = new int[endIdx - midIdx];

	//Initializing the left and right arrays
	for(int i=0; i<leftArr.length; i++)
		leftArr[i] = arrToSort[startIdx + i];

	for(int i=0; i<rightArr.length; i++)
		rightArr[i] = arrToSort[midIdx + i + 1];

	//merging the left and right arrays into a single sorted array
	int leftArrIdx = 0, rightArrIdx = 0, sortedArrIdx = startIdx;
	while((leftArrIdx < leftArr.length) && (rightArrIdx < rightArr.length))
	{
		if(leftArr[leftArrIdx] < rightArr[rightArrIdx])
		{
			arrToSort[sortedArrIdx] = leftArr[leftArrIdx];
			leftArrIdx += 1;
		}
		else
		{
			arrToSort[sortedArrIdx] = rightArr[rightArrIdx];
			rightArrIdx += 1;
		}
		sortedArrIdx += 1;
	}

	//Adding the rest of the elements of left array if present
	while(leftArrIdx < leftArr.length)
	{
		arrToSort[sortedArrIdx] = leftArr[leftArrIdx];
		leftArrIdx += 1;
		sortedArrIdx += 1;
	}

	//Adding the rest of the elements of right array if present
	while(rightArrIdx < rightArr.length)
	{
		arrToSort[sortedArrIdx] = rightArr[rightArrIdx];
		rightArrIdx += 1;
		sortedArrIdx += 1;
	}
}

让我们运行几个例子来检查我们的方法是否工作正常。

public static void main(String[] args)
{
	int[] arr1 = { 4, 2, 3, 0, 1, 7, 6 };
	mergeSort(arr1, 0, arr1.length - 1);
	System.out.println(Arrays.toString(arr1));

	int[] arr2 = {};
	mergeSort(arr2, 0, arr2.length - 1);
	System.out.println(Arrays.toString(arr2));

	int[] arr3 = {7};
	mergeSort(arr3, 0, arr3.length - 1);
	System.out.println(Arrays.toString(arr3));

	int[] arr4 = {-1, -7, 0, 11, 102, -11};
	mergeSort(arr4, 0, arr4.length - 1);
	System.out.println(Arrays.toString(arr4));
}

【0，1，2，3，4，6，7】
[]
【7】
[-11，-7，-1，0，11，102]

时间和空间复杂性

归并排序算法的递归关系将是 T(n) = 2T(n/2) + O(n) 。这就导致了 O(nLogn) 的时间复杂度。记住归并排序是一个稳定的算法，它的时间复杂度不会改变。它的最佳情况、最坏情况和平均情况的时间复杂度将总是等于 O(nLogn) 。

我们需要额外的空间，它等于输入数组的大小。这使得空间复杂度等于 O(n)，，其中 n 是输入数组的长度。

摘要

归并排序是最有效的算法之一，它可以很容易地用递归实现。它使用分治模式对数组进行排序。这是一个非常稳定的算法，其时间复杂度在所有三种情况下(最佳、最差和平均)都保持不变。

---

---

在 Java 中排序HashMap

原文：https://www.studytonight.com/java-examples/sorting-a-hashmap-in-java

Java 中的 HashMap 类用于存储键值对的集合。实现映射界面。HashMap 不按排序顺序存储键值对，也不维护元素的插入顺序。

然而，有时我们希望以排序的方式查看存储的数据。我们可以根据键或值对HashMap进行排序。

在本教程中，我们将学习如何对HashMap进行排序。

使用集合对HashMap进行排序

Collections 框架提供了一种方便的 sort()方法来对元素进行排序。我们可以将HashMap中的键或值复制到ArrayList中，然后，我们可以使用 Collections.sort()方法轻松地对它们进行排序。

按关键字排序

我们可以通过使用 keySet()方法获得HashMap中存在的键。我们可以将这个键集传递给ArrayList构造器。这将使用HashMap键初始化ArrayList。接下来，我们将简单地使用 sort()方法并打印排序后的键和相应的值。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map.Entry;

public class HashMapSortDemo
{
	public static void main(String args[])
	{
		HashMap<String, Integer> unsortedMap = new HashMap<>();
		unsortedMap.put("one", 1);
		unsortedMap.put("two", 2);
		unsortedMap.put("three", 3);
		unsortedMap.put("four", 4);
		unsortedMap.put("five", 5);

		System.out.println("Printing the Unsorted HashMap");
		for(Entry<String, Integer> e : unsortedMap.entrySet())
		{
			System.out.println(e.getKey() + "-->" + e.getValue());
		}
		//Creating an ArrayList with the HashMap keys
		ArrayList<String> sortedList = new ArrayList<>(unsortedMap.keySet());
		Collections.sort(sortedList);//Sorting the ArrayList

		System.out.println("\nPrinting the Alphabetically Sorted Keys");
		for(String s : sortedList)
		{
			System.out.println(s + "-->" + unsortedMap.get(s));
		}
	}
}

打印未排序的HashMap
四- > 4
一- > 1
二- > 2
三- > 3
五->5
T7】打印按字母顺序排序的键
五- > 5
四- > 4
一- > 1
三- > 3
二- > 2

按值排序

同样，方法也是一样的。我们将首先使用 values()方法用 HashMap 值初始化一个ArrayList。然后，我们可以使用 sort()方法对它们进行排序。我们将无法看到排序值的对应键。给定一个值，没有办法从 HashMap 中获取键。

package snippet;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map.Entry;

public class HashMapSortDemo
{
	public static void main(String args[])
	{
		HashMap<String, Integer> unsortedMap = new HashMap<>();
		unsortedMap.put("one", 1);
		unsortedMap.put("two", 2);
		unsortedMap.put("three", 3);
		unsortedMap.put("four", 4);
		unsortedMap.put("five", 5);

		System.out.println("Printing the Unsorted HashMap");
		for(Entry<String, Integer> e : unsortedMap.entrySet())
		{
			System.out.println(e.getKey() + "-->" + e.getValue());
		}
		//Creating an ArrayList with HashMap values
		ArrayList<Integer> sortedList = new ArrayList<>(unsortedMap.values());
		Collections.sort(sortedList);//Sorting the ArrayList

		System.out.println("\nPrinting the Sorted Values");
		for(Integer i : sortedList)
		{
			System.out.println(i);
		}
	}
} 

打印未排序HashMap
四- > 4
一- > 1
二- > 2
三- > 3
五->5
T7】打印排序值
1
2
3
4
5

利用TreeMap对HashMap进行排序

如果您经常想查看按关键字排序的HashMap，那么TreeMap将是比HashMap更好的选择。TreeMap自动按排序顺序存储键值对(按键排序)。我们可以将 HashMap 中的所有数据复制到一个 TreeMap 中，数据将被排序。我们可以使用 putAll()方法，也可以将 HashMap 传递给 TreeMap 构造器。

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.TreeMap;

public class HashMapSortDemo
{
	public static void main(String args[])
	{
		HashMap<String, Integer> unsortedMap = new HashMap<>();
		unsortedMap.put("one", 1);
		unsortedMap.put("two", 2);
		unsortedMap.put("three", 3);
		unsortedMap.put("four", 4);
		unsortedMap.put("five", 5);

		System.out.println("Printing the Unsorted HashMap");
		for(Entry<String, Integer> e : unsortedMap.entrySet())
		{
			System.out.println(e.getKey() + "-->" + e.getValue());
		}

		TreeMap<String, Integer> sortedMap = new TreeMap<>(unsortedMap);//Passing HashMap object to TreeMap constructor
		//We can also use sortedMap.putAll(unsortedMap); 

		System.out.println("\nPrinting the Sorted TreeMap");
		for(Entry<String, Integer> e : sortedMap.entrySet())
		{
			System.out.println(e.getKey() + "-->" + e.getValue());
		}	
	}
}

打印未排序的HashMap
四- > 4
一- > 1
二- > 2
三- > 3
五->5
T7】打印已排序的TreeMap
五- > 5
四- > 4
一- > 1
三- > 3
二- > 2

使用TreeSet按值对HashMap进行排序

HashMap必须包含唯一的键，但是对值没有限制。它可以包含重复的值。如果我们只想考虑一次重复的值，我们可以在 TreeSet 的帮助下按键对HashMap进行排序。就像 TreeMap 一样，TreeSet 也按排序顺序存储数据。我们需要将值从映射复制到集合中，就这样。

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.TreeSet;

public class HashMapSortDemo
{
	public static void main(String args[])
	{
		HashMap<String, Integer> unsortedMap = new HashMap<>();
		unsortedMap.put("one", 1);
		unsortedMap.put("two", 2);
		unsortedMap.put("three", 3);
		unsortedMap.put("four", 4);
		unsortedMap.put("five", 5);

		//Adding Duplicate Values
		unsortedMap.put("fourteen", 4);
		unsortedMap.put("fifteen", 5);
		unsortedMap.put("twenty", 2);

		System.out.println("Printing the Unsorted HashMap");
		for(Entry<String, Integer> e : unsortedMap.entrySet())
		{
			System.out.println(e.getKey() + "-->" + e.getValue());
		}
		//Creating a TreeSet using the HashMap values
		TreeSet<Integer> sortedSet = new TreeSet<>(unsortedMap.values());

		System.out.println("\nThe sorted values are: " + sortedSet);
	}
}

打印未排序的 HashMap
十五- > 5
四- > 4
一- > 1
二- > 2
三- > 3
五- > 5
十四- > 4
二十- > 2

排序后的值为:【1，2，3，4，5】

使用流和 Lambda 表达式对HashMap进行排序

我们可以使用 Java Streams 和 Lambda 表达式在一行代码中对 HashMap 进行排序。我们将使用对键值条目流调用 sorted()对象。

按关键字排序

我们将使用 comparingByKey Comparator和 sorted()方法按关键字对映射进行排序。

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Stream;

public class HashMapSortDemo
{
	public static void main(String args[])
	{
		HashMap<String, Integer> unsortedMap = new HashMap<>();
		unsortedMap.put("one", 1);
		unsortedMap.put("two", 2);
		unsortedMap.put("three", 3);
		unsortedMap.put("four", 4);
		unsortedMap.put("five", 5);

		System.out.println("Printing the Unsorted HashMap");
		for(Entry<String, Integer> e : unsortedMap.entrySet())
		{
			System.out.println(e.getKey() + "-->" + e.getValue());
		}

		Stream sortedStream = unsortedMap.entrySet()
										 .stream()
										 .sorted(Map.Entry.<String, Integer>comparingByKey());
		System.out.println("\nPrinting the Sorted Key-Value Pairs");
		sortedStream.forEach(System.out :: println);

	}
}

打印未排序的HashMap
四- > 4
一- > 1
二- > 2
三- > 3
五->5
T7】打印已排序的键值对
五=5
四=4
一=1
三=3
二=2

按值排序

我们将使用 comparingByValue Comparator根据值对 HashMap 进行排序。

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Stream;

public class HashMapSortDemo
{
	public static void main(String args[])
	{
		HashMap<String, Integer> unsortedMap = new HashMap<>();
		unsortedMap.put("one", 1);
		unsortedMap.put("two", 2);
		unsortedMap.put("three", 3);
		unsortedMap.put("four", 4);
		unsortedMap.put("five", 5);

		System.out.println("Printing the Unsorted HashMap");
		for(Entry<String, Integer> e : unsortedMap.entrySet())
		{
			System.out.println(e.getKey() + "-->" + e.getValue());
		}

		Stream sortedStream = unsortedMap.entrySet()
										 .stream()
										 .sorted(Map.Entry.<String, Integer>comparingByValue());
		System.out.println("\nPrinting the Sorted Key-Value Pairs");
		sortedStream.forEach(System.out :: println);

	}
}

打印未排序的HashMap
四- > 4
一- > 1
二- > 2
三- > 3
五->5
T7】打印已排序的键值对
一=1
二=2
三=3
四=4
五=5

使用谷歌的番石榴图书馆

谷歌的番石榴库为我们提供了一个 ImmutableSortedMap 类。我们可以使用这个类的 copyOf()方法来对 HashMap 进行排序。我们需要将 HashMap 对象作为一个参数传递给这个方法，它将返回一个 ImmutableSortedMap 对象。返回的 ImmutableSortedMap 包含我们的 HashMap 中所有按键排序的条目。自然排序用于排序。

import java.util.HashMap;
import java.util.Map.Entry;
import com.google.common.collect.ImmutableSortedMap;

public class HashMapSortDemo
{
	public static void main(String args[])
	{
		HashMap<String, Integer> unsortedMap = new HashMap<>();
		unsortedMap.put("one", 1);
		unsortedMap.put("two", 2);
		unsortedMap.put("three", 3);
		unsortedMap.put("four", 4);
		unsortedMap.put("five", 5);

		System.out.println("Printing the Unsorted HashMap");
		for(Entry<String, Integer> e : unsortedMap.entrySet())
		{
			System.out.println(e.getKey() + "-->" + e.getValue());
		}

		//Creating an ImmutableSortedMap using the HashMap
		ImmutableSortedMap sortedMap = ImmutableSortedMap.copyOf(unsortedMap);

		System.out.println("\nPrinting the Sorted ImmutableSortedMap");
		System.out.println(sortedMap);
	}
}

打印未排序的HashMap
四- > 4
一- > 1
二- > 2
三- > 3
五->5
T7】打印已排序的不变HashMap

总结

当我们想要存储键值对时，HashMap 是一个方便的集合。在内部，它使用HashMap的概念。没有内置的方法对HashMap进行排序。但是，我们可以通过使用ArrayList和TreeSet等其他集合来查看排序后的HashMap条目。如果您想保持映射条目的排序顺序，树形映射是一个很好的选择。我们还可以将排序后的键值对存储在 LinkedHashMap 中。LinkedHashMap 维护元素的插入顺序，我们只需要对映射排序一次。

---

---

在 Java 中实现一个二叉查找树

原文：https://www.studytonight.com/java-examples/implementing-a-binary-search-tree-in-java

二叉查找树是由节点和链接组成的非线性数据结构。这是一种二叉树，这意味着每个节点最多可以有两个子节点。

一个二叉查找树还必须遵循给定的两个条件。

1. 左节点的值应该小于其父节点的值。
2. 右节点的值应该大于其父节点的值。

对于树的所有节点，上述两个条件必须为真。下图显示了一个二叉查找树。

二叉树节点的一般结构如下所示。它由一个值和两个指针组成——一个指向它的左子，另一个指向它的右子。

二叉查找树的节点类别如下所示。

class BSTNode
{
	int value;
	BSTNode leftChild;
	BSTNode rightChild;

	BSTNode(int val)
	{
		this.value = val;
		this.leftChild = null;
		this.rightChild = null;
	}
}

一个二叉查找树可以有四个基本操作- 插入、删除、搜索和遍历。让我们学习如何在 Java 中实现二叉查找树。

插入二叉查找树

在二叉查找树中插入一个元素非常简单。我们只需要用下面的算法找到它的正确位置。这样做是为了确保插入后的树符合二叉查找树的两个必要条件。

• 如果新值小于当前节点值，则递归到左子。
• 如果新值大于当前节点值，则递归到其右子节点。
• 如果当前节点为空，则在此位置添加新值。

public static BSTNode insert(int value, BSTNode current)
{		
	if(current == null)
	{
		BSTNode newNode = new BSTNode(value);
		return newNode;
	}
	else
	{
		if(value < current.value)
			current.leftChild = insert(value, current.leftChild);
		else
			current.rightChild = insert(value, current.rightChild);
	}		
	return current;
}

例如让我们尝试将值 6 插入到下面的树中。

我们首先将 6 与根值 12 进行比较。6 比 12 小，所以我们将移动到左子树，并将 6 与左子树的根进行比较。6 比 7 小，所以我们将再次移动到左边的子树。现在，6 大于 5，所以我们移到右边的子树。但是右边的子树为空或者不存在，所以会在这个位置添加新节点。

在二叉查找树搜索

在二叉查找树中搜索一个值遵循与我们讨论的元素插入基本相同的逻辑。唯一的区别是，如果在任何时刻当前节点为空，则表明该值不在树中。我们将返回 False，而不是插入值。

• 如果当前节点的值与我们试图找到的值匹配，则返回真。
• 如果当前节点的值大于我们试图找到的值，则递归到左边的子节点。
• 如果当前节点的值小于我们试图找到的值，则递归到右边的子节点。
• 如果当前节点为空，则返回假。

该方法的代码如下所示。

public static boolean search(int key, BSTNode current)
{
	if(current == null)
		return false;
	if(current.value == key)
		return true;
	else
	{
		if(key < current.value)
			return search(key, current.leftChild);
		else
			return search(key, current.rightChild);
	}					
}

在二叉查找树删除

从二叉查找树中删除节点的过程比插入和搜索要复杂一些。首先，我们需要找到要删除的节点。这部分的逻辑将与插入和搜索中讨论的相同。

在找到正确的节点后，我们需要根据节点的性质遵循以下步骤之一。

• 如果它是一个叶节点(一个没有子节点的节点)，那么我们可以简单地用空替换那个节点。
• 如果节点只有一个子节点，那么它将被删除，子节点将占据其位置。
• 如果节点有两个子节点，那么它将被删除，并且来自其左子树的最大节点取其位置，或者来自其右子树的最小值取其位置。对于我们的代码，我们将使用右子树中的最小值。

public static BSTNode delete(int value, BSTNode current)
{
	if(current == null)
		return current;		
	if(value < current.value)
	    current.leftChild = delete(value, current.leftChild);
	else if(value > current.value)
		current.rightChild = delete(value, current.rightChild);
	else if(value == current.value)
	{
		if(current.leftChild != null && current.rightChild != null)
		{
			int min = current.rightChild.value;
			BSTNode temp = current.rightChild;
			while(temp.leftChild != null)
			{
				min = temp.leftChild.value;
				temp = temp.leftChild;
			}
			current.value = min;
			current.rightChild = delete(min, current.rightChild);
		}			
		else if(current.leftChild == null)
			return current.rightChild;
		else if(current.rightChild == null)
			return current.leftChild;			
		else
			return null;
	}
	return current;
}

例如，让我们试着从下面的树中删除 12、20 和 9。

从二叉查找树删除 12 个

从二叉查找树删除 20 个:

从二叉查找树删除 9:

穿越二叉查找树

我们可以用两种不同的方式穿越二叉查找树。让我们学习这两个技巧。

深度优先搜索

顾名思义，在深度优先搜索中，我们将在继续下一个节点之前，尽可能地探索一个特定的节点。它有三种变体，取决于我们探索根、左子和右子的顺序。

Preorder: 如果我们首先访问根节点，然后访问左子节点，最后访问右子节点，那么这种遍历方法称为 Preorder 遍历。

public static void preorder(BSTNode current)
{
	if(current == null)
		return;
	else
	{
		System.out.print(current.value + " ");
		preorder(current.leftChild);
		preorder(current.rightChild);
	}
}

后序:如果我们先探索左边的子节点，然后是右边的子节点，最后访问根节点，那么这种遍历的方法就叫做后序遍历。

public static void postorder(BSTNode current)
{
	if(current == null)
		return;
	else
	{
		postorder(current.leftChild);
		postorder(current.rightChild);
		System.out.print(current.value + " ");
	}
}

inoder:如果我们首先探索左边的子节点，然后访问根节点，最后访问右边的子节点，那么这种遍历的方法称为 inoder 遍历。对于二分搜索法树，有序遍历将按排序顺序返回值。出现这种情况是因为左边的子对象比根对象小，而根对象本身比右边的子对象小。

public static void inorder(BSTNode current)
{
	if(current == null)
		return;
	else
	{
		inorder(current.leftChild);
		System.out.print(current.value + " ");
		inorder(current.rightChild);
	}
}

广度优先搜索

广度优先搜索逐层遍历树。它将首先打印一个级别中的所有值，然后再进入下一个级别。也称为级顺序遍历。下图显示了二叉树的不同层次。以下树的级别顺序遍历将是- 12 7 20 5 9 21。

迭代广度优先搜索实现如下所示。队列用于存储节点。

public void static levelOrder(BSTNode current)
{
	if(current == null)
		return;
	Queue<BSTNode> q = new LinkedList<BSTNode>();
	q.add(current);
	while(q.isEmpty() == false)
	{
		BSTNode temp = q.remove();
		System.out.print(temp.value + " ");

		if(temp.leftChild != null)
			q.add(temp.leftChild);
		if(temp.rightChild != null)
			q.add(temp.rightChild);
	}		
}

实践演示

让我们看一下所有上述方法的实际演示。

首先，让我们创建上图所示的二叉树。

public static void main(String args[])
{
    //constructing the tree
	BSTNode root = new BSTNode(12);
	root = insert(7, root);
	root = insert(20, root);
	root = insert(5, root);
	root = insert(9, root);
    root = insert(21, root);
}

现在，让我们使用搜索方法来搜索一些现有的和不存在的值。

public static void main(String args[])
{
    //constructing the tree
	BSTNode root = new BSTNode(12);
	root = insert(7, root);
	root = insert(20, root);
	root = insert(5, root);
	root = insert(9, root);
    root = insert(21, root);

    //searching
    System.out.println(search(7, root));
	System.out.println(search(9, root));
	System.out.println(search(17, root));
}

真
真
假

让我们通过使用不同的遍历技术来打印整个树。

public static void main(String args[])
{
    //constructing the tree
	BSTNode root = new BSTNode(12);
	root = insert(7, root);
	root = insert(20, root);
	root = insert(5, root);
	root = insert(9, root);
    root = insert(21, root);

    //Traversals
    System.out.print("\nPreorder Traversal: ");
	preorder(root);
	System.out.print("\nPostorder Traversal: ");
	postorder(root);
	System.out.print("\nInorder Traversal: ");
	inorder(root);
	System.out.print("\nLevel Order Traversal: ");
	levelOrder(root);
}

前序遍历:12 7 5 9 20 21
后序遍历:5 9 7 21 20 12
中序遍历:5 7 9 12 20 21
级序遍历:12 7 20 5 9 21

让我们删除一些节点并打印遍历。

public static void main(String args[])
{
    //constructing the tree
	BSTNode root = new BSTNode(12);
	root = insert(7, root);
	root = insert(20, root);
	root = insert(5, root);
	root = insert(9, root);
    root = insert(21, root);

    //Deleting nodes
    root = delete(12, root);
	root = delete(9, root);

    //Traversals			
	System.out.println("\n\nAfter deletion");
	System.out.print("\nPreorder Traversal: ");
	preorder(root);
	System.out.print("\nPostorder Traversal: ");
	postorder(root);
	System.out.print("\nInorder Traversal: ");
	inorder(root);
	System.out.print("\nLevel Order Traversal: ");
	levelOrder(root);
}

删除后

前序遍历:20 7 5 21
后序遍历:5 7 21 20
中序遍历:5 7 20 21
级序遍历:20 7 21 5

常见问题

问:二叉树和二叉查找树有什么区别？

对于特定节点，二叉树和二叉查找树树最多可以有两个子节点。在二叉查找树中，左边的子节点应该小于根节点，右边的子节点应该大于根节点，并且这个条件应该适用于所有节点。二叉树在左右子树上没有任何这样的条件。

问:二叉查找树使用二分搜索法算法搜索树中的元素吗？

二叉查找树搜索算法的原理与二分搜索法算法相同。在每次迭代中，我们都将搜索范围缩小到树的一半。这导致 O(log(n))的平均时间复杂度。

问:二叉查找树有哪些真实的用例？

二分搜索法树在三维游戏引擎中非常常用来渲染和生成对象。编译器还使用二分搜索法树来高效解析语法表达式。

摘要

二叉查找树树是普通二叉树的变种。在本教程中，我们学习了如何在二叉查找树中执行插入和删除元素。我们还学习了如何搜索一个元素，以及如何使用广度优先和深度优先的方法遍历整个树。希望你觉得这个教程有帮助，学到了一些新东西。

---

---

如何在 Java 中制作对象的深度副本？

原文：https://www.studytonight.com/java-examples/how-to-make-a-deep-copy-of-an-object-in-java

在 Java 中复制对象时，我们可能会得到一个浅拷贝，对克隆对象的任何修改也会改变原始对象。为了避免这种情况，我们使用深度复制的概念。当使用这种技术时，复制的对象不依赖于原始对象，我们可以独立处理这两个对象。

什么是浅拷贝？

一个浅拷贝将简单地把原始对象的字段值拷贝到新对象中。在浅拷贝中，如果原始对象有任何对其他类对象的引用(一个类成员本身就是某个其他类的对象)，那么只克隆该对象的引用。因此，此引用对象中的任何更改都将反映在原始对象和克隆对象上。

例如，假设我们有一个学生类，它有一个 GPA 类型的成员变量(用户定义的类)。现在，让我们创建一个名为 s 的学生类对象。接下来，我们将创建这个对象的克隆，并将其称为副本。现在，如果我们对副本对象的 GPA 进行任何更改，那么这个更改也会反映在原始 s 对象的 GPA 字段中。这是浅层克隆的一个例子。

请记住，我们需要实现可克隆接口和覆盖克隆()方法以允许克隆。我们将简单地使用标准的 clone()方法来执行浅层克隆。标准克隆()方法如下所示。

//Standard clone() method to perform Shallow Cloning

@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
}

示例:Java 中的吞咽复制

下面的代码演示了浅层克隆的完整示例。

class GPA
{
	int firstYear;
	int secondYear;

	GPA(int fy, int sy)
	{
		this.firstYear = fy;
		this.secondYear = sy;
	}

	public int getFirstYear() {
		return firstYear;
	}

	public void setFirstYear(int firstYear) {
		this.firstYear = firstYear;
	}

	public int getSecondYear() {
		return secondYear;
	}

	public void setSecondYear(int secondYear) {
		this.secondYear = secondYear;
	}
}

class Student implements Cloneable
{
	private String name;
	private GPA gpa;

	Student(String name, GPA gpa)
	{
		this.name = name;
		this.gpa = gpa;
	}

    //Standard clone() method to perform Shallow Cloning
	@Override
	protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

	public String getName()
	{
		return this.name;
	}

	public GPA getGPA()
	{
		return this.gpa;
	}
	public void setName(String name)
	{
		this.name = name;
	}	
	public void setGPA(GPA g)
	{
		this.gpa = g;
	}
}

public class CopyDemo
{
	public static void main(String[] args) throws CloneNotSupportedException
	{
		GPA g = new GPA(7, 8);
		Student s = new Student("Justin", g);//original object

		Student copy = (Student)s.clone();//shallow copy

		System.out.println("Original Object's GPA: " + s.getGPA().getFirstYear() + " " + s.getGPA().getSecondYear());
		System.out.println("Cloned Object's GPA: " + copy.getGPA().getFirstYear() + " " + copy.getGPA().getSecondYear());

		copy.getGPA().setFirstYear(10);//Changing the GPA field of the shallow copy

		System.out.println("\nAfter changing the shallow copy");
		System.out.println("Original Object's GPA: " + s.getGPA().getFirstYear() + " " + s.getGPA().getSecondYear());
		System.out.println("Cloned Object's GPA: " + copy.getGPA().getFirstYear() + " " + copy.getGPA().getSecondYear());

	}
} 

原始对象的 GPA: 7 8
克隆对象的 GPA:7 8
T3】在更改了浅拷贝
原始对象的 GPA: 10 8
克隆对象的 GPA: 10 8 之后

什么是深度复制？

一个深度副本将为原始类引用的对象创建一个新对象。这确保了原始对象和克隆对象是独立的。对于原始数据类型，浅克隆和深克隆的工作方式相同，因为不涉及引用。

通过覆盖克隆()方法制作深度拷贝

在浅层克隆示例中，我们使用了标准的 clone()方法，但是如果我们希望创建深层拷贝，则必须对此方法进行一些更改。

我们将基本上克隆被引用的类，由于被引用的类只包含基本类型，因此创建了一个深度副本。然后，我们将这个深度副本分配给我们在 clone()方法中创建的新对象，并简单地返回它。修改后的克隆()方法如下所示。

@Override
protected Object clone() throws CloneNotSupportedException
{
    Student s = (Student)super.clone();
    s.setGPA((GPA)s.getGPA().clone());
    return s;
}

我们还需要覆盖引用类(本例中为 GPA)中的 clone()方法，以确保我们可以在其上使用 clone()方法。

class GPA implements Cloneable
{
	int firstYear;
	int secondYear;

	GPA(int fy, int sy)
	{
		this.firstYear = fy;
		this.secondYear = sy;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    //getters and setters
}

示例:Java 中的深度复制

完整的代码如下所示。正如我们在输出中看到的，改变复制对象中的某些东西不会修改原始对象。

class GPA implements Cloneable
{
	int firstYear;
	int secondYear;

	GPA(int fy, int sy)
	{
		this.firstYear = fy;
		this.secondYear = sy;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

	public int getFirstYear() {
		return firstYear;
	}

	public void setFirstYear(int firstYear) {
		this.firstYear = firstYear;
	}

	public int getSecondYear() {
		return secondYear;
	}

	public void setSecondYear(int secondYear) {
		this.secondYear = secondYear;
	}
}

class Student implements Cloneable
{
	private String name;
	private GPA gpa;

	Student(String name, GPA gpa)
	{
		this.name = name;
		this.gpa = gpa;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
        Student s = (Student)super.clone();
        s.setGPA((GPA)s.getGPA().clone());
        return s;
    }

	public String getName()
	{
		return this.name;
	}

	public GPA getGPA()
	{
		return this.gpa;
	}
	public void setName(String name)
	{
		this.name = name;
	}	
	public void setGPA(GPA g)
	{
		this.gpa = g;
	}
}

public class CopyDemo
{
	public static void main(String[] args) throws CloneNotSupportedException
	{
		GPA g = new GPA(7, 8);
		Student s = new Student("Justin", g);//original object

		Student copy = (Student)s.clone();//deep copy

		System.out.println("Original Object's GPA: " + s.getGPA().getFirstYear() + " " + s.getGPA().getSecondYear());
		System.out.println("Cloned Object's GPA: " + copy.getGPA().getFirstYear() + " " + copy.getGPA().getSecondYear());

		copy.getGPA().setFirstYear(10);//Changing the GPA field of the deep copy

		System.out.println("\nAfter changing the Deep copy");
		System.out.println("Original Object's GPA: " + s.getGPA().getFirstYear() + " " + s.getGPA().getSecondYear());
		System.out.println("Cloned Object's GPA: " + copy.getGPA().getFirstYear() + " " + copy.getGPA().getSecondYear());

	}
} 

原始对象的 GPA: 7 8
克隆对象的 GPA: 7 8

更改深度副本
后原始对象的 GPA: 7 8
克隆对象的 GPA: 10 8

在 Java 中使用复制构造器

复制构造器是进行深度复制的最简单方法。我们只需创建一个构造器，该构造器将同一个类的对象作为输入，并返回一个具有相同值但有新引用的新对象(如果涉及被引用的类)。

GPA 类的复制构造器如下所示。

GPA(GPA g)
{
	this.firstYear = g.firstYear;
	this.secondYear = g.secondYear;
}

学生类的复制构造器如下所示。

Student(Student s)
{
	this.name = new String(s.name);
	this.gpa = new GPA(s.gpa);
} 

示例:Java 中的复制构造器

完整的代码如下所示。正如我们所看到的，修改复制的对象不会改变原始对象。

class GPA
{
	int firstYear;
	int secondYear;

	GPA(int fy, int sy)
	{
		this.firstYear = fy;
		this.secondYear = sy;
	}

	GPA(GPA g)
	{
		this.firstYear = g.firstYear;
		this.secondYear = g.secondYear;
	}

	public int getFirstYear() {
		return firstYear;
	}

	public void setFirstYear(int firstYear) {
		this.firstYear = firstYear;
	}

	public int getSecondYear() {
		return secondYear;
	}

	public void setSecondYear(int secondYear) {
		this.secondYear = secondYear;
	}
}

class Student
{
	private String name;
	private GPA gpa;

	Student(String name, GPA gpa)
	{
		this.name = name;
		this.gpa = gpa;
	}

	Student(Student s)
	{
		this.name = new String(s.name);
		this.gpa = new GPA(s.gpa);
	}

	public String getName()
	{
		return this.name;
	}

	public GPA getGPA()
	{
		return this.gpa;
	}
	public void setName(String name)
	{
		this.name = name;
	}	
	public void setGPA(GPA g)
	{
		this.gpa = g;
	}
}

public class CopyDemo
{
	public static void main(String[] args) throws CloneNotSupportedException
	{

		GPA g = new GPA(7, 8);
		Student s = new Student("Justin", g);//Original Object

		Student copy = new Student(s);//Deep copy

		System.out.println("Original Object's GPA: " + s.getGPA().getFirstYear() + " " + s.getGPA().getSecondYear());
		System.out.println("Cloned Object's GPA: " + copy.getGPA().getFirstYear() + " " + copy.getGPA().getSecondYear());

		copy.getGPA().setFirstYear(10);//Changing the GPA field of the deep copy

		System.out.println("\nAfter changing the Deep copy");
		System.out.println("Original Object's GPA: " + s.getGPA().getFirstYear() + " " + s.getGPA().getSecondYear());
		System.out.println("Cloned Object's GPA: " + copy.getGPA().getFirstYear() + " " + copy.getGPA().getSecondYear());
	}
} 

原始对象的 GPA: 7 8
克隆对象的 GPA: 7 8

更改深度副本
后原始对象的 GPA: 7 8
克隆对象的 GPA: 10 8

使用序列化的深度复制

序列化是执行深度复制的另一种简单方式。S 对一个对象进行序列化，然后反序列化它，本质上产生了一个具有新引用但值相同的新对象。这将返回一个新对象，它是原始对象的深度副本。需要克隆的对象类必须实现 Serializable 接口。我们将按照以下步骤使用序列化创建深度拷贝。

• 首先，创建输入和输出流，然后，使用它们创建对象输入和对象输出流。
• 要克隆的对象被传递给对象输出流。
• 使用对象输入流读取新对象。这将是原始对象的深层副本。

序列化并不总是进行深度复制的首选方式，因为它比 clone()方法昂贵得多，并且不是所有的类都是可序列化的。完整的代码如下所示。

学生类中使用序列化的深度复制方法如下所示。

public Student deepCopyUsingSerialization()
{
	try
	{
		ByteArrayOutputStream bo = new ByteArrayOutputStream();
		ObjectOutputStream o = new ObjectOutputStream(bo);
		o.writeObject(this);

		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
		ObjectInputStream i = new ObjectInputStream(bi);

		return (Student)i.readObject();
	}
	catch(Exception e)
	{
	    return null;
	}	
}

示例:使用序列化的深度复制

完整的代码如下所示。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

@SuppressWarnings("serial")
class GPA implements Serializable 
{
	int firstYear;
	int secondYear;

	GPA(int fy, int sy)
	{
		this.firstYear = fy;
		this.secondYear = sy;
	}

	public int getFirstYear() {
		return firstYear;
	}

	public void setFirstYear(int firstYear) {
		this.firstYear = firstYear;
	}

	public int getSecondYear() {
		return secondYear;
	}

	public void setSecondYear(int secondYear) {
		this.secondYear = secondYear;
	}
}

@SuppressWarnings("serial")
class Student implements Serializable
{
	private String name;
	private GPA gpa;

	Student(String name, GPA gpa)
	{
		this.name = name;
		this.gpa = gpa;
	}

	public Student deepCopyUsingSerialization()
	{
		try
		{
			ByteArrayOutputStream bo = new ByteArrayOutputStream();
			ObjectOutputStream o = new ObjectOutputStream(bo);
			o.writeObject(this);

			ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
			ObjectInputStream i = new ObjectInputStream(bi);

			return (Student)i.readObject();
		}
		catch(Exception e)
		{
			return null;
		}	
	}

	public String getName()
	{
		return this.name;
	}

	public GPA getGPA()
	{
		return this.gpa;
	}
	public void setName(String name)
	{
		this.name = name;
	}	
	public void setGPA(GPA g)
	{
		this.gpa = g;
	}
}

public class CopyDemo
{
	public static void main(String[] args) throws CloneNotSupportedException
	{
		//deep cloning
		GPA g = new GPA(7, 8);
		Student s = new Student("Justin", g);

		Student copy = s.deepCopyUsingSerialization();

		System.out.println("Original Object's GPA: " + s.getGPA().getFirstYear() + " " + s.getGPA().getSecondYear());
		System.out.println("Cloned Object's GPA: " + copy.getGPA().getFirstYear() + " " + copy.getGPA().getSecondYear());

		copy.getGPA().setFirstYear(10);//Changing the GPA field of the deep copy

		System.out.println("\nAfter changing the Deep copy");
		System.out.println("Original Object's GPA: " + s.getGPA().getFirstYear() + " " + s.getGPA().getSecondYear());
		System.out.println("Cloned Object's GPA: " + copy.getGPA().getFirstYear() + " " + copy.getGPA().getSecondYear());
	}
} 

原始对象的 GPA: 7 8
克隆对象的 GPA: 7 8

更改深度副本
后原始对象的 GPA: 7 8
克隆对象的 GPA: 10 8

摘要

浅拷贝只是将字段值从原始对象拷贝到新对象中，但是如果原始对象包含对其他对象的引用，我们可能会得到未接受的结果。为了解决这个问题，我们使用深度复制。如果对象仅使用基元字段，浅拷贝和深拷贝将给出相同的结果。我们可以通过使用 Cloneable()接口并覆盖 clone()方法来制作对象的深度副本。复制构造器是执行深度复制的一种更简单、更灵活的方式。我们也可以使用序列化，但是我们需要记住，它的计算比其他方法更昂贵。

---

---