Java编程入门练习题【附源码】
目录
一、引言
二、练习题
1、打印"Hello, World!"到控制台。
2、将两个整数相加并打印结果。
3、从控制台读取用户输入的姓名，并打印"Hello, [姓名]!"。
4、计算并打印给定整数数组的和。
5、将给定字符串反转并打印结果。
6、检查给定字符串是否是回文，并打印结果。
7、打印1到100之间的所有奇数。
8、打印1到100之间的所有偶数。
9、将给定的整数数组按照升序排序并打印结果。
10、判断给定的整数是否为素数，并打印结果。
11、将一个字符串数组中的元素连接成一个大字符串并打印结果。
13、计算并打印给定整数的阶乘。
14、打印一个n行的等腰三角形，n由用户指定。
15、检查给定字符串是否是有效的邮箱地址，并打印结果。
16、给定一个矩阵，将其转置并打印结果。
17、计算并打印Fibonacci数列的前n个数字，n由用户指定。
18、按照给定的分隔符将一个字符串拆分成子字符串并打印结果。
19、将给定的整数数组中的元素去重并打印结果。
20、打印1到100之间所有能被3和5同时整除的数字。
21、判断给定的字符串是否是回文数，并打印结果。
22、按照给定的格式打印当前日期和时间。
23、检查给定的整数是否为完全平方数，并打印结果。
24、计算并打印斐波那契数列的第n个数字，n由用户指定。
25、给定一个字符串，统计其中每个字符出现的次数并打印结果。
26、判断给定的字符串是否是有效的IP地址，并打印结果。
27、将给定的整数数组逆序排列并打印结果。
28、检查给定的字符串是否是回文串，并打印结果。
29、判断给定的整数是否为质数，并打印结果。
30、对给定的字符串进行加密并打印结果。
31、将一个二进制字符串转换为十进制整数并打印结果。
32、检查给定的两个字符串是否是同构的，并打印结果。
33、计算并打印给定整数的平方根。
34、给定一个正整数n，打印一个n行的倒立金字塔。
35、 检查给定字符串是否是有效的URL，并打印结果。
36、 将给定的整数数组中的元素按照降序排序并打印结果。
37、判断给定的字符串是否是回文排列，并打印结果。
38、打印1到100之间所有能同时被3、5和7整除的数字。
39、计算并打印给定整数的平方。
40、给定一个整数n，打印从1到n的所有素数。
41、将一个十进制整数转换为二进制字符串并打印结果。
42、检查给定的两个字符串是否是旋转字符串，并打印结果。
43、计算并打印给定整数的立方根。
44、给定一个正整数n，打印一个n行的菱形图案。
45、检查给定字符串是否是有效的IPv4地址，并打印结果。
46、将给定的整数数组中的元素按照随机顺序排列并打印结果。
47、打印所有满足以下条件的三位数：该数字等于其各位数字的立方和。
48、计算并打印给定整数的立方。
一、引言
欢迎来到Java编程入门练习题！Java是一种通用且广泛使用的编程语言，具有跨平台性、面向对象和高性能的特点。无论你是初学者还是已经有一些编程经验的开发人员，这些练习题都将帮助你深入了解Java语言的基础知识和核心概念。
本系列练习题旨在帮助你巩固对Java语言的理解，并提供实际编码的机会。每个练习题都包含具体的问题描述和要求，你需要根据题目要求编写相应的Java代码来解决问题。通过完成这些练习题，你将学会如何使用Java编写简单的程序，处理输入和输出，以及利用常见的数据结构和算法。
这些练习题的难度逐渐增加，从简单的开始，逐步引导您掌握更多复杂的概念和技术。无论你是想要巩固基础知识，提高编程技能，还是准备进一步学习Java的高级主题，这些练习题都会给你提供一个良好的起点。
你可以在完成每个练习题后，查看提供的参考答案，并与之进行比较。这将帮助你更好地理解问题的解决方法，并发现自己可能存在的错误或改进空间。
Java编程入门练习题是一个互动学习的过程，鼓励你积极参与并尝试自己的解决方案。无论遇到什么困难，坚持下去，并不断加强你的编码能力和问题解决技巧。相信通过这些练习题，你将迅速提高自己的Java编程水平。
祝你在这个学习过程中取得成功，享受编程的乐趣！
开始吧！让我们一起探索Java编程的奇妙世界吧！
二、练习题
1、打印"Hello, World!"到控制台。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
2、将两个整数相加并打印结果。
public class AddTwoNumbers {
public static void main(String[] args) {
int num1 = 5;
int num2 = 10;
int sum = num1 + num2;
System.out.println("两个整数的和为：" + sum);
}
}
3、从控制台读取用户输入的姓名，并打印"Hello, [姓名]!"。
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
// 创建一个Scanner对象，用于读取用户输入
Scanner scanner = new Scanner(System.in);
// 提示用户输入姓名
System.out.print("请输入您的姓名: ");
// 读取用户输入的姓名
String name = scanner.nextLine();
// 打印问候语
System.out.println("Hello, " + name + "!");
// 关闭Scanner对象
scanner.close();
}
}
4、计算并打印给定整数数组的和。
public class Main {
public static void main(String[] args) {
int[] numbers = { 1, 2, 3, 4, 5 };
int sum = calculateSum(numbers);
System.out.println("数组的和为：" + sum);
}
public static int calculateSum(int[] arr) {
int sum = 0;
for (int num : arr) {
sum += num;
}
return sum;
}
}
5、将给定字符串反转并打印结果。
public class StringReverse {
public static void main(String[] args) {
String input = "Hello, World!";
String reversed = reverseString(input);
System.out.println(reversed);
}
public static String reverseString(String str) {
StringBuilder sb = new StringBuilder(str);
sb.reverse();
return sb.toString();
}
}
6、检查给定字符串是否是回文，并打印结果。
import java.util.Scanner;
public class PalindromeChecker {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个字符串：");
String input = scanner.nextLine();
if (isPalindrome(input)) {
System.out.println(input + " 是一个回文字符串。");
} else {
System.out.println(input + " 不是一个回文字符串。");
}
}
private static boolean isPalindrome(String str) {
int left = 0;
int right = str.length() - 1;
while (left < right) {
if (str.charAt(left) != str.charAt(right)) {
return false;
}
left++;
right--;
}
return true;
}
}
7、打印1到100之间的所有奇数。
public class PrintOddNumbers {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if (i % 2 != 0) {
System.out.println(i);
}
}
}
}
8、打印1到100之间的所有偶数。
public class PrintEvenNumbers {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
9、将给定的整数数组按照升序排序并打印结果。
import java.util.Arrays;
public class SortArray {
public static void main(String[] args) {
int[] array = {5, 2, 9, 1, 3};
// 使用Arrays类的sort方法对数组进行排序
Arrays.sort(array);
// 打印排序后的结果
System.out.println("排序后的数组：");
for (int num : array) {
System.out.print(num + " ");
}
}
}
10、判断给定的整数是否为素数，并打印结果。
import java.util.Scanner;
public class PrimeNumberChecker {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int number = scanner.nextInt();
boolean isPrime = true;
if (number <= 1) {
isPrime = false;
} else {
for (int i = 2; i <= Math.sqrt(number); i++) {
if (number % i == 0) {
isPrime = false;
break;
}
}
}
if (isPrime) {
System.out.println(number + " 是素数。");
} else {
System.out.println(number + " 不是素数。");
}
}
}
11、将一个字符串数组中的元素连接成一个大字符串并打印结果。
public class StringArrayConcatenation {
public static void main(String[] args) {
String[] stringArray = {"Hello", " ", "World!"};
// 使用StringBuilder来连接字符串
StringBuilder stringBuilder = new StringBuilder();
for (String str : stringArray) {
stringBuilder.append(str);
}
// 将连接后的字符串转换为普通的String对象
String result = stringBuilder.toString();
// 打印结果
System.out.println(result);
}
}
12、检查给定的字符串是否是有效的手机号码，并打印结果。
import java.util.regex.*;
public class PhoneNumberValidator {
public static void main(String[] args) {
String phoneNumber = "1234567890"; // 替换为要检查的手机号码
boolean isValid = validatePhoneNumber(phoneNumber);
if (isValid) {
System.out.println(phoneNumber + " 是有效的手机号码");
} else {
System.out.println(phoneNumber + " 不是有效的手机号码");
}
}
public static boolean validatePhoneNumber(String phoneNumber) {
// 使用正则表达式进行手机号码验证
String regex = "^(\\+\\d{1,3})?[- .]?\\(?\\d{3}\\)?[- .]?\\d{3}[- .]?\\d{4}$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(phoneNumber);
return matcher.matches();
}
}
13、计算并打印给定整数的阶乘。
import java.util.Scanner;
public class Factorial {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int num = scanner.nextInt();
long factorial = calculateFactorial(num);
System.out.println(num + "的阶乘为：" + factorial);
}
// 计算给定整数的阶乘
public static long calculateFactorial(int num) {
if (num < 0) {
throw new IllegalArgumentException("不能计算负数的阶乘");
}
long factorial = 1;
for (int i = 1; i <= num; i++) {
factorial *= i;
}
return factorial;
}
}
14、打印一个n行的等腰三角形，n由用户指定。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入要打印的等腰三角形的行数：");
int n = scanner.nextInt();
for (int i = 1; i <= n; i++) {
// 打印空格
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
// 打印星号
for (int k = 1; k <= 2 * i - 1; k++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
15、检查给定字符串是否是有效的邮箱地址，并打印结果。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class EmailValidation {
public static void main(String[] args) {
String email = "[email protected]"; // 要验证的邮箱地址
// 正则表达式模式匹配邮箱地址
String emailPattern = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
// 创建Pattern对象
Pattern pattern = Pattern.compile(emailPattern);
// 创建Matcher对象
Matcher matcher = pattern.matcher(email);
// 检查是否匹配有效的邮箱地址
if (matcher.matches()) {
System.out.println("有效的邮箱地址");
} else {
System.out.println("无效的邮箱地址");
}
}
}
16、给定一个矩阵，将其转置并打印结果。
public class MatrixTranspose {
public static void main(String[] args) {
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int rows = matrix.length;
int columns = matrix[0].length;
// 创建一个新的矩阵用于存储转置后的结果
int[][] transposeMatrix = new int[columns][rows];
// 将原矩阵的行变成转置矩阵的列
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
transposeMatrix[j][i] = matrix[i][j];
}
}
// 打印转置后的矩阵
System.out.println("转置后的矩阵：");
for (int i = 0; i < columns; i++) {
for (int j = 0; j < rows; j++) {
System.out.print(transposeMatrix[i][j] + " ");
}
System.out.println();
}
}
}
17、计算并打印Fibonacci数列的前n个数字，n由用户指定。
import java.util.Scanner;
public class FibonacciSeries {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入要计算的Fibonacci数列的长度（n）：");
int n = scanner.nextInt();
System.out.println("Fibonacci数列的前 " + n + " 个数字为：");
// 计算并打印Fibonacci数列的前n个数字
for (int i = 1; i <= n; i++) {
System.out.print(fibonacci(i) + " ");
}
}
// 计算第n个Fibonacci数
public static int fibonacci(int n) {
if (n <= 1) {
return n;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
}
请注意，此代码中使用递归来计算Fibonacci数列。对于较大的n值，可能会出现性能问题。如果需要处理更大的n值，可以尝试使用迭代方法来计算Fibonacci数列。
18、按照给定的分隔符将一个字符串拆分成子字符串并打印结果。
public class StringSplitExample {
public static void main(String[] args) {
String inputString = "Hello,World!How,are,you?";
String delimiter = ","; // 分隔符
// 使用split方法将输入字符串拆分成子字符串
String[] subStrings = inputString.split(delimiter);
// 打印拆分后的子字符串
for (String subString : subStrings) {
System.out.println(subString);
}
}
}
19、将给定的整数数组中的元素去重并打印结果。
import java.util.Arrays;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9};
// 使用 HashSet 去重
HashSet set = new HashSet<>();
for (int num : arr) {
set.add(num);
}
// 将去重后的元素转换为数组
Integer[] uniqueArr = set.toArray(new Integer[set.size()]);
// 打印去重后的数组元素
System.out.println(Arrays.toString(uniqueArr));
}
}
20、打印1到100之间所有能被3和5同时整除的数字。
public class Main {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if (i % 3 == 0 && i % 5 == 0) {
System.out.println(i);
}
}
}
}
21、判断给定的字符串是否是回文数，并打印结果。
public class Palindrome {
public static void main(String[] args) {
String str = "level"; // 要判断的字符串
// 将字符串反转
StringBuilder reversedStr = new StringBuilder(str);
reversedStr.reverse();
// 判断反转后的字符串与原始字符串是否相等
if (str.equals(reversedStr.toString())) {
System.out.println("是回文数");
} else {
System.out.println("不是回文数");
}
}
}
22、按照给定的格式打印当前日期和时间。
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class PrintDateTime {
public static void main(String[] args) {
// 获取当前日期和时间
LocalDateTime currentDateTime = LocalDateTime.now();
// 定义日期时间格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 格式化日期时间并打印
String formattedDateTime = currentDateTime.format(formatter);
System.out.println("当前日期和时间: " + formattedDateTime);
}
}
23、检查给定的整数是否为完全平方数，并打印结果。
public class PerfectSquareChecker {
public static void main(String[] args) {
int num = 16; // 要检查的整数
if (isPerfectSquare(num)) {
System.out.println(num + " 是一个完全平方数。");
} else {
System.out.println(num + " 不是一个完全平方数。");
}
}
public static boolean isPerfectSquare(int num) {
if (num < 0) {
return false;
}
if (num == 0 || num == 1) {
return true;
}
long start = 1;
long end = num;
while (start <= end) {
long mid = (start + end) / 2;
long square = mid * mid;
if (square == num) {
return true;
} else if (square < num) {
start = mid + 1;
} else {
end = mid - 1;
}
}
return false;
}
}
24、计算并打印斐波那契数列的第n个数字，n由用户指定。
import java.util.Scanner;
public class FibonacciSeries {
public static void main(String[] args) {
// 获取用户输入的n值
Scanner scanner = new Scanner(System.in);
System.out.print("请输入要计算的斐波那契数列的第几个数字：");
int n = scanner.nextInt();
// 调用方法计算并打印第n个数字
int result = fibonacci(n);
System.out.println("斐波那契数列的第" + n + "个数字是：" + result);
}
public static int fibonacci(int n) {
if (n <= 1) {
return n;
} else {
int a = 0;
int b = 1;
int temp;
for (int i = 2; i <= n; i++) {
temp = a + b;
a = b;
b = temp;
}
return b;
}
}
}
25、给定一个字符串，统计其中每个字符出现的次数并打印结果。
import java.util.HashMap;
import java.util.Map;
public class CharacterCount {
public static void main(String[] args) {
String str = "Hello, World!";
Map charCountMap = new HashMap<>();
// 遍历字符串中的每个字符
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
// 将字符添加到map中，并更新其出现次数
if (charCountMap.containsKey(ch)) {
int count = charCountMap.get(ch);
charCountMap.put(ch, count + 1);
} else {
charCountMap.put(ch, 1);
}
}
// 打印各字符出现的次数
for (Map.Entry entry : charCountMap.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
}
26、判断给定的字符串是否是有效的IP地址，并打印结果。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ValidateIPAddress {
public static void main(String[] args) {
String ipAddress = "192.168.0.1";
boolean isValidIP = validateIPAddress(ipAddress);
System.out.println("Is valid IP address: " + isValidIP);
}
public static boolean validateIPAddress(String ipAddress) {
// IP地址的正则表达式模式
String pattern = "^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\."
+ "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\."
+ "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\."
+ "([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";
Pattern regexPattern = Pattern.compile(pattern);
Matcher matcher = regexPattern.matcher(ipAddress);
return matcher.matches();
}
}
27、将给定的整数数组逆序排列并打印结果。
import java.util.Arrays;
public class ReverseArray {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
System.out.println("原始数组：");
System.out.println(Arrays.toString(arr));
reverseArray(arr);
System.out.println("逆序排列后的数组：");
System.out.println(Arrays.toString(arr));
}
public static void reverseArray(int[] arr) {
int start = 0;
int end = arr.length - 1;
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
}
28、检查给定的字符串是否是回文串，并打印结果。
public class PalindromeChecker {
public static void main(String[] args) {
String str = "madam"; // 要检查的字符串
// 去除字符串中的空格和标点符号，并转换为小写
String cleanedStr = str.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
boolean isPalindrome = checkPalindrome(cleanedStr);
if (isPalindrome) {
System.out.println(str + " 是一个回文串");
} else {
System.out.println(str + " 不是一个回文串");
}
}
private static boolean checkPalindrome(String str) {
int left = 0;
int right = str.length() - 1;
while (left < right) {
if (str.charAt(left) != str.charAt(right)) {
return false;
}
left++;
right--;
}
return true;
}
}
29、判断给定的整数是否为质数，并打印结果。
import java.util.Scanner;
public class PrimeNumberChecker {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int number = scanner.nextInt();
boolean isPrime = true;
// 如果输入的整数小于等于1，则不是质数
if (number <= 1) {
isPrime = false;
} else {
// 从2开始遍历到该整数的平方根
for (int i = 2; i <= Math.sqrt(number); i++) {
// 如果能被任何一个数整除，则不是质数
if (number % i == 0) {
isPrime = false;
break;
}
}
}
if (isPrime) {
System.out.println(number + " 是质数");
} else {
System.out.println(number + " 不是质数");
}
}
}
30、对给定的字符串进行加密并打印结果。
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class StringEncryption {
public static void main(String[] args) {
String inputString = "Hello, World!";
// 加密输入字符串
String encryptedString = encryptString(inputString);
System.out.println("加密后的字符串：" + encryptedString);
}
public static String encryptString(String input) {
try {
// 创建MD5消息摘要对象
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
// 将输入字符串转换为字节数组
byte[] inputBytes = input.getBytes();
// 计算字节数组的摘要
byte[] hashedBytes = messageDigest.digest(inputBytes);
// 将字节数组转换为十六进制字符串
StringBuilder hexString = new StringBuilder();
for (byte b : hashedBytes) {
String hex = Integer.toHexString(0xff & b);
if (hex.length() == 1) {
hexString.append('0');
}
hexString.append(hex);
}
// 返回加密后的字符串
return hexString.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
}
在此示例代码中，我们使用了java.security.MessageDigest类来进行字符串的加密。它提供了多种加密算法，这里我们选择了常用的MD5算法。首先，我们定义了一个encryptString方法，该方法接受一个字符串作为输入，将其转化为字节数组，并计算其摘要。然后，我们将摘要转化为十六进制字符串形式，并返回结果。
在main方法中，我们定义了一个输入字符串"Hello, World!"，然后调用encryptString方法对其进行加密，并将结果打印输出。
请注意，MD5算法是一种单向散列函数，它只能对数据进行加密，无法解密。因此，加密后的字符串不能被还原为原始字符串。
31、将一个二进制字符串转换为十进制整数并打印结果。
public class BinaryToDecimal {
public static void main(String[] args) {
String binaryString = "101010"; // 二进制字符串
int decimal = Integer.parseInt(binaryString, 2); // 将二进制字符串转换为十进制整数
System.out.println("Decimal: " + decimal); // 打印十进制结果
}
}
在此示例中，我们使用Integer.parseInt(binaryString, 2)方法将二进制字符串转换为十进制整数。然后，使用System.out.println()语句打印出转换后的十进制结果。请根据需要修改binaryString变量的值来测试不同的二进制字符串。
32、检查给定的两个字符串是否是同构的，并打印结果。
import java.util.HashMap;
import java.util.Map;
public class IsomorphicStrings {
public static boolean isIsomorphic(String s, String t) {
if (s.length() != t.length()) {
return false;
}
Map map = new HashMap<>();
Map used = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
char c1 = s.charAt(i);
char c2 = t.charAt(i);
if (map.containsKey(c1)) {
if (map.get(c1) != c2) {
return false;
}
} else {
if (used.containsKey(c2)) {
return false;
}
map.put(c1, c2);
used.put(c2, true);
}
}
return true;
}
public static void main(String[] args) {
String s1 = "egg";
String t1 = "add";
System.out.println("Are \"" + s1 + "\" and \"" + t1 + "\" isomorphic? " + isIsomorphic(s1, t1));
String s2 = "paper";
String t2 = "title";
System.out.println("Are \"" + s2 + "\" and \"" + t2 + "\" isomorphic? " + isIsomorphic(s2, t2));
String s3 = "foo";
String t3 = "bar";
System.out.println("Are \"" + s3 + "\" and \"" + t3 + "\" isomorphic? " + isIsomorphic(s3, t3));
}
}
这段代码定义了一个静态方法isIsomorphic，它接受两个字符串作为参数并返回一个布尔值，表示这两个字符串是否是同构的。该方法使用了两个哈希映射map和used来进行判断。
在main函数中，我们调用isIsomorphic方法来检查不同的字符串对是否是同构的，并打印出结果。
33、计算并打印给定整数的平方根。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int num = scanner.nextInt();
double squareRoot = Math.sqrt(num);
System.out.println("该整数的平方根为：" + squareRoot);
}
}
这段代码首先需要导入Scanner类，以便从控制台读取用户输入。然后，通过创建Scanner对象，并使用nextInt()方法获取用户输入的整数。
接下来，使用Math.sqrt()方法计算给定整数的平方根，并将结果存储在squareRoot变量中。最后，使用System.out.println()语句打印出平方根的值。
注意：此代码假设用户输入的是有效的整数。如果用户输入的不是整数或负数，则可能会抛出异常。因此，应添加适当的错误处理机制来处理这种情况。
34、给定一个正整数n，打印一个n行的倒立金字塔。
import java.util.Scanner;
public class InvertedPyramid {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个正整数 n：");
int n = scanner.nextInt();
for (int i = n; i >= 1; i--) {
// 打印空格
for (int j = 0; j < n - i; j++) {
System.out.print(" ");
}
// 打印星号
for (int k = 1; k <= 2 * i - 1; k++) {
System.out.print("*");
}
// 换行
System.out.println();
}
}
}
这段代码首先从用户输入中获取一个正整数n。然后使用两层循环，外层循环控制行数，内层循环分别打印空格和星号。每一行的空格数量为 n - i，星号数量为 (2 * i - 1)，其中i为当前行数。最后换行输出结果。
请注意，上述代码假设输入的n为正整数。如果需要对输入进行合法性检查，可以添加一些额外的逻辑来处理非法输入。
35、 检查给定字符串是否是有效的URL，并打印结果。
import java.net.URL;
import java.net.MalformedURLException;
public class ValidURLChecker {
public static void main(String[] args) {
String urlStr = "https://www.example.com";
try {
URL url = new URL(urlStr);
System.out.println("输入的字符串是一个有效的URL。");
} catch (MalformedURLException e) {
System.out.println("输入的字符串不是一个有效的URL。");
}
}
}
在这个例子中，我们使用java.net.URL类来创建URL对象。如果给定的字符串可以成功转换为一个URL对象，则说明它是一个有效的URL；否则，会抛出MalformedURLException异常，表示给定的字符串不是一个有效的URL。
你可以将要检查的URL替换为urlStr变量的值，然后运行该程序，它将打印结果。如果给定字符串是有效的URL，它将输出输入的字符串是一个有效的URL；如果给定字符串不是有效的URL，它将输出输入的字符串不是一个有效的URL。
36、 将给定的整数数组中的元素按照降序排序并打印结果。
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array = {5, 2, 10, 8, 3};
// 使用Arrays.sort方法对数组进行排序，默认为升序排序
Arrays.sort(array);
// 将数组元素反转，实现降序排序
for (int i = 0; i < array.length / 2; i++) {
int temp = array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = temp;
}
// 打印排序后的结果
for (int num : array) {
System.out.print(num + " ");
}
}
}
在这个程序中，我们使用了java.util.Arrays类的sort方法对整数数组进行升序排序。然后，通过交换数组元素的位置来实现降序排序，并使用for-each循环打印排序后的结果。运行该程序会输出：10 8 5 3 2。
37、判断给定的字符串是否是回文排列，并打印结果。
import java.util.HashMap;
import java.util.Map;
public class PalindromePermutation {
public static boolean isPalindromePermutation(String str) {
// 创建一个HashMap，用于存储字符出现的次数
Map charCount = new HashMap<>();
// 统计每个字符出现的次数
for (char ch : str.toCharArray()) {
if (Character.isLetter(ch)) {
ch = Character.toLowerCase(ch);
charCount.put(ch, charCount.getOrDefault(ch, 0) + 1);
}
}
// 检查是否存在多于一个奇数次出现的字符
int oddCount = 0;
for (int count : charCount.values()) {
if (count % 2 != 0) {
oddCount++;
}
// 若存在超过一个奇数次出现的字符，则不是回文排列
if (oddCount > 1) {
return false;
}
}
return true;
}
public static void main(String[] args) {
String input = "tactcoapapa";
boolean result = isPalindromePermutation(input);
if (result) {
System.out.println("给定的字符串是回文排列");
} else {
System.out.println("给定的字符串不是回文排列");
}
}
}
该程序首先使用一个HashMap来统计给定字符串中每个字符出现的次数。然后，它检查是否存在多于一个奇数次出现的字符，如果存在，则说明不是回文排列。最后，根据判断结果打印相应的消息。以上代码演示了如何在Java中判断给定的字符串是否是回文排列，并输出结果。
38、打印1到100之间所有能同时被3、5和7整除的数字。
public class Main {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if (i % 3 == 0 && i % 5 == 0 && i % 7 == 0) {
System.out.println(i);
}
}
}
}
这段代码使用for循环遍历从1到100的所有数字。对于每个数字，通过使用取余运算符（%）来检查是否能够被3、5和7整除。如果满足条件，则使用System.out.println()语句将该数字打印出来。
39、计算并打印给定整数的平方。
import java.util.Scanner;
public class SquareCalculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int number = scanner.nextInt();
int square = number * number;
System.out.println(number + "的平方是：" + square);
scanner.close();
}
}
这段代码首先导入了java.util.Scanner类，以便从控制台读取用户输入。然后，在main方法中，我们创建了一个Scanner对象scanner。
接下来，代码会提示用户输入一个整数，并将其保存在变量number中。
然后，使用number * number计算出给定整数的平方，并将结果保存在变量square中。
最后，通过使用System.out.println()方法打印给定整数和其平方。
最后，调用scanner.close()关闭Scanner对象，以释放资源。
40、给定一个整数n，打印从1到n的所有素数。
public class PrimeNumbers {
public static void main(String[] args) {
int n = 100; // 在这里将n设置为所需的数字
System.out.println("从1到" + n + "的所有素数为:");
for (int i = 2; i <= n; i++) {
if (isPrime(i)) {
System.out.print(i + " ");
}
}
}
// 判断一个数字是否为素数的方法
public static boolean isPrime(int num) {
if (num <= 1) {
return false;
}
for (int i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
}
41、将一个十进制整数转换为二进制字符串并打印结果。
public class DecimalToBinary {
public static void main(String[] args) {
int decimal = 10;
String binary = convertToBinary(decimal);
System.out.println("Binary representation of " + decimal + " is: " + binary);
}
public static String convertToBinary(int decimal) {
StringBuilder binary = new StringBuilder();
if (decimal == 0) {
return "0";
}
while (decimal > 0) {
int remainder = decimal % 2;
binary.insert(0, remainder);
decimal = decimal / 2;
}
return binary.toString();
}
}
这段代码定义了一个名为DecimalToBinary的类，其中包含一个静态方法convertToBinary。该方法接受一个十进制整数作为参数，并返回其对应的二进制表示形式的字符串。
在main方法中，定义一个整数变量decimal并赋值为10。然后调用convertToBinary方法将该整数转换为二进制字符串，并将结果存储在binary变量中。最后使用System.out.println语句打印出转换结果。
运行上述代码将输出：Binary representation of 10 is: 1010
42、检查给定的两个字符串是否是旋转字符串，并打印结果。
public class CheckRotationString {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "lohel";
if (isRotationString(str1, str2)) {
System.out.println("字符串是旋转字符串");
} else {
System.out.println("字符串不是旋转字符串");
}
}
public static boolean isRotationString(String str1, String str2) {
// 检查字符串长度是否相等
if (str1.length() != str2.length()) {
return false;
}
// 将 str1 连接自身，判断 str2 是否是连接后的字符串的子串
String concatenatedStr = str1 + str1;
if (concatenatedStr.contains(str2)) {
return true;
}
return false;
}
}
此代码将比较两个字符串 str1 和 str2 的长度是否相等。如果长度相等，则将 str1 连接自身成为 concatenatedStr，然后检查 str2 是否是 concatenatedStr 的子串。如果是，则说明它们是旋转字符串；否则，它们不是旋转字符串。
在示例中，str1 的值为 "hello"，str2 的值为 "lohel"。根据算法，它们被认为是旋转字符串，因为 str2 是 str1 连接自身后的子串。
43、计算并打印给定整数的立方根。
import java.util.Scanner;
public class CubeRoot {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int number = scanner.nextInt();
double cubeRoot = Math.cbrt(number);
System.out.println("立方根为：" + cubeRoot);
scanner.close();
}
}
这段代码首先导入java.util.Scanner类，以便从用户输入读取整数。然后，它创建一个Scanner对象并提示用户输入一个整数。
接下来，使用Math.cbrt()方法计算给定整数的立方根，并将结果存储在cubeRoot变量中。
最后，使用System.out.println()语句打印立方根的值。
请注意，在运行此代码之前，确保您已经安装了Java开发环境（JDK）并正确设置了环境变量。
44、给定一个正整数n，打印一个n行的菱形图案。
import java.util.Scanner;
public class DiamondPattern {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个正整数：");
int n = scanner.nextInt();
// 打印上半部分菱形
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
System.out.print("*");
}
System.out.println();
}
// 打印下半部分菱形
for (int i = n - 1; i >= 1; i--) {
for (int j = 1; j <= n - i; j++) {
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
这段代码首先会提示用户输入一个正整数n，然后根据输入的n来打印一个n行的菱形图案。其中，上半部分菱形是通过两个嵌套的循环来打印的，第一个循环控制行数，第二个循环控制每一行中的空格和星号个数。下半部分菱形同样采用相似的方法打印，只是循环的条件和控制输出的内容稍有不同。
45、检查给定字符串是否是有效的IPv4地址，并打印结果。
import java.util.regex.Pattern;
public class IPv4Validator {
public static void main(String[] args) {
String ipAddress = "192.168.0.1";
boolean isValid = isValidIPv4(ipAddress);
System.out.println("Is valid IPv4 address? " + isValid);
}
public static boolean isValidIPv4(String ip) {
String pattern = "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$";
return Pattern.matches(pattern, ip);
}
}
这个代码定义了一个名为IPv4Validator的类，其中包含一个静态方法isValidIPv4。该方法使用正则表达式来验证给定的IP地址字符串是否是有效的IPv4地址。
在main方法中，我们使用字符串"192.168.0.1"作为示例IP地址，并调用isValidIPv4方法进行验证。最后，将验证结果打印出来。
你可以根据需要修改代码中的IP地址来测试不同的输入。
46、将给定的整数数组中的元素按照随机顺序排列并打印结果。
import java.util.Arrays;
import java.util.Random;
public class RandomizeArray {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
// 创建一个Random对象
Random random = new Random();
for (int i = 0; i < array.length; i++) {
// 生成一个随机索引
int randomIndex = random.nextInt(array.length);
// 交换当前位置和随机位置的元素
int temp = array[i];
array[i] = array[randomIndex];
array[randomIndex] = temp;
}
// 打印结果
System.out.println(Arrays.toString(array));
}
}
这段代码使用Random类来生成随机数，并通过循环遍历数组元素，将每个元素与随机位置上的元素进行交换。最后，使用Arrays.toString()方法将打乱后的数组结果打印出来。
47、打印所有满足以下条件的三位数：该数字等于其各位数字的立方和。
public class Main {
public static void main(String[] args) {
for (int i = 100; i < 1000; i++) {
int number = i;
int sumOfCubes = 0;
// 计算各位数字的立方和
while (number > 0) {
int digit = number % 10;
sumOfCubes += Math.pow(digit, 3);
number /= 10;
}
// 检查是否满足条件并打印结果
if (sumOfCubes == i) {
System.out.println(i);
}
}
}
}
48、计算并打印给定整数的立方。
import java.util.Scanner;
public class CubeCalculator {
public static void main(String[] args) {
// 创建 Scanner 对象以接收用户输入
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数: ");
int number = scanner.nextInt();
// 计算立方
int cube = number * number * number;
// 打印结果
System.out.println("整数 " + number + " 的立方是: " + cube);
// 关闭 Scanner 对象
scanner.close();
}
}
请注意，该代码通过 Scanner 类从用户那里接收输入。用户输入的整数将被存储在 number 变量中，并使用数学运算符计算立方。最后，结果将被打印到控制台上。