Java日常笔记

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
System.out.println("\t","\n");
System.out.println(); //换行
System.out.println("结果" + sum); //拼接

char gender = '男'; //字符单引号
String name = "king"; //字符串双引号
float num = 1.1F; //float型常量后面需要加 f 或者 F
String Str = num + ""; //基本数据类型转String类型
Integer.parseInt("123"); //String ——> int
Double.parseDouble("123.1"); //String ——> double
int n1 = Integer.parseInt(str);

/*命名规范
包名:字母都小写 aaa.bbb.ccc
类名、接口名:大驼峰 TankShotGame
变量名、方法名:小驼峰 tankShotGame
常量名:所有字母大写 多单词用下划线 TAX_RATE
*/

Scanner myScanner = new (System.in);
int num = myScanner.nextInt();
char ch = myScanner.next().charAt(0);
String str = myScanner.next();

if(gender == '男') //字符、数字用 == 判断相等
if("字符串".equals(str)) //字符串用 equals 判断相等

int n1 = 0b1010; //二进制 0b
int n2 = 01010; //八进制 0
int n3 = 0x1010; //十六进制 0x

(int)(Math.random()*100) + 1; //生成随机数
Random r = new Random();
int a = r.nextInt(3);

Java在处理浮点数时,需要高精度时可以使用BigDecimal

1
2
import java.math.BigDeciaml;
BigDecimal a = new BigDecimal(scanner.nextDouble());

Java向上取整 Math.ceil 将浮点数向上取整

知道两点坐标求线段长度

1
2
3
double distance = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
Math.sqrt //求平方根
Math.pow //x的Y次方

知道三点坐标求三角形面积

假设三个点的坐标为 (x1, y1), (x2, y2), 和 (x3, y3),可以按照以下步骤计算三角形的面积:

  1. 计算三个边的长度 a、b、c,其中:

    • a = sqrt((x2 - x1)^2 + (y2 - y1)^2)
    • b = sqrt((x3 - x2)^2 + (y3 - y2)^2)
    • c = sqrt((x1 - x3)^2 + (y1 - y3)^2)
  2. 使用海伦公式计算面积 s,其中 s 为半周长,可以通过以下公式计算:

    • s = (a + b + c) / 2
  3. 最后,使用以下公式计算三角形的面积 A:

    • A = sqrt(s * (s - a) * (s - b) * (s - c))
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    import java.util.Scanner;

    public class Main {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    System.out.print("请输入第一个点的 x 坐标: ");
    double x1 = scanner.nextDouble();
    System.out.print("请输入第一个点的 y 坐标: ");
    double y1 = scanner.nextDouble();
    System.out.print("请输入第二个点的 x 坐标: ");
    double x2 = scanner.nextDouble();
    System.out.print("请输入第二个点的 y 坐标: ");
    double y2 = scanner.nextDouble();
    System.out.print("请输入第三个点的 x 坐标: ");
    double x3 = scanner.nextDouble();
    System.out.print("请输入第三个点的 y 坐标: ");
    double y3 = scanner.nextDouble();

    // 计算三个边的长度
    double a = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
    double b = Math.sqrt(Math.pow(x3 - x2, 2) + Math.pow(y3 - y2, 2));
    double c = Math.sqrt(Math.pow(x1 - x3, 2) + Math.pow(y1 - y3, 2));

    // 计算半周长
    double s = (a + b + c) / 2;

    // 使用海伦公式计算三角形的面积
    double area = Math.sqrt(s * (s - a) * (s - b) * (s - c));

    // 输出结果
    System.out.println("三角形的面积为: " + area);

    scanner.close();
    }
    }

StringBuilder类

StringBuilder 是 Java 中的一个类,用于处理字符串的可变版本。它允许你在字符串对象中进行动态的添加、修改和删除操作,而不会创建新的字符串对象,因此在处理大量字符串拼接或修改操作时,使用 StringBuilder 通常比使用普通的字符串拼接操作更高效。

StringBuilder 类提供了多个方法,用于对可变字符串进行操作。以下是一些常用的 StringBuilder 方法:

  1. append(String str):将指定字符串添加到当前字符串的末尾。
  2. append(char c):将指定字符添加到当前字符串的末尾。
  3. insert(int offset, String str):在指定位置插入指定字符串。
  4. insert(int offset, char c):在指定位置插入指定字符。
  5. delete(int start, int end):删除从指定起始位置到结束位置之间的字符。
  6. deleteCharAt(int index):删除指定位置的字符。
  7. replace(int start, int end, String str):用指定字符串替换从指定起始位置到结束位置之间的字符。
  8. substring(int start):从指定位置开始提取子字符串。
  9. substring(int start, int end):从指定起始位置到结束位置之间提取子字符串。
  10. reverse():反转当前字符串。
  11. length():返回当前字符串的长度。
  12. capacity():返回当前字符串的容量(即字符数组的长度)。
  13. setLength(int newLength):设置当前字符串的长度,可以用于截取或扩展字符串。
  14. charAt(int index):返回指定位置的字符。
  15. indexOf(String str):返回指定字符串在当前字符串中第一次出现的位置。
  16. lastIndexOf(String str):返回指定字符串在当前字符串中最后一次出现的位置。
1
2
3
4
5
6
7
8
9
StringBuilder sb = new StringBuilder();
sb.append("Hello, ");
sb.append("world!");
sb.insert(7, "beautiful ");
sb.delete(0, 5);
String result = sb.toString();

System.out.println(result); // 输出:beautiful world!

读取整个输入行

1
String str = scanner.nextLine();

Character类

Character 是 Java 中的一个类,它用于表示和操作字符数据类型。在 Java 中,字符数据类型用 char 表示,而 Character 类提供了一些实用的静态方法和常量,用于处理字符数据。

以下是一些 Character 类的常用方法和常量:

  1. isLetter(char ch):检查字符是否为字母。
  2. isDigit(char ch):检查字符是否为数字。
  3. isWhitespace(char ch):检查字符是否为空白字符(空格、制表符、换行符等)。
  4. isLowerCase(char ch):检查字符是否为小写字母。
  5. isUpperCase(char ch):检查字符是否为大写字母。
  6. toLowerCase(char ch):将字符转换为小写形式。
  7. toUpperCase(char ch):将字符转换为大写形式。
  8. toString(char ch):将字符转换为字符串。
  9. MAX_VALUEchar 数据类型的最大值,对应于 Unicode 中的 65535。
  10. MIN_VALUEchar 数据类型的最小值,对应于 Unicode 中的 0。

求最大值

在 Java 中,要比较多个数并找到它们中的最大值,有几种不同的方法,具体取决于你的需求和代码的复杂性。下面列出了一些常见的方法:

  1. 使用循环:
    你可以使用循环遍历所有的数字,并在循环中比较它们,找到最大值。这是一种通用且直观的方法,适用于任意数量的数字。
1
2
3
4
5
6
7
8
int[] numbers = {5, 10, 7, 3, 8};
int max = numbers[0]; // 假设第一个元素是最大的
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] > max) {
max = numbers[i];
}
}
System.out.println("最大值是:" + max);
  1. 使用 Math.max 方法的连续调用:
    如果你要比较的数字数量较少(例如,不超过3个),你可以使用 Math.max 方法的连续调用来比较它们的大小,找到最大值。
1
2
3
4
5
int a = 5;
int b = 10;
int c = 7;
int max = Math.max(a, Math.max(b, c));
System.out.println("最大值是:" + max);
  1. 使用 Java 8 的 Stream API:
    如果你在 Java 8 或更新版本中编写代码,你可以使用 Stream API 来处理集合中的数字并找到最大值。
1
2
3
4
5
6
List<Integer> numbers = Arrays.asList(5, 10, 7, 3, 8);
int max = numbers.stream()
.mapToInt(Integer::intValue)
.max()
.orElse(0); // 如果集合为空,返回默认值
System.out.println("最大值是:" + max);

无论选择哪种方法,都可以根据具体情况来决定哪种最适合你的需求和代码结构。通常情况下,使用循环是最通用的方法,因为它可以处理任意数量的数字。而对于较少的数字,其他方法也是有效的。

做题中的点

获取字符串中某个位置字符 char c = str.charAt(位置)

想要抛出异常在可能发生异常程序后面 throw new Exception(“ “);

在该方法后面 以及主方法中 throws Exception

想知道一个字符串中是否包含某个字符用 str.contains(“@”)

截取字符串片段 str.substring(起始,终止) ,左闭右开

质数求解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public static void getPrimeNumber(int n) {
if(n<2) {//此范围内的数均不为质数
System.out.println(n+"不是质数");
return;//结束程序
}
if(n == 2) {
System.out.println("2是质数");
return;
}
//在 2到 1+n开方范围(数学理论),找能把n整除的值(这个值也称作因子)
//如果找到可以把n整除的第三个数,那n就不是质数,反之,n为质数
double max = 1+ Math.sqrt(n);//max保存的是查找因子的范围

//依次遍历范围内的所有数,验证是否存在n的因子
for(int i=2; i<max; i++) {
//判断n能不能被i整除,如果有,说明不是质数
if(n%i == 0) {
System.out.println(n+"不是质数");
return;
}
}
//如果判断了范围内的所有值,没有能整除的,则说明n是质数
System.out.println(n+"是质数");
}

随机数

Random 是 Java 中的一个类,用于生成伪随机数。它可以用于各种需要随机性的应用,例如游戏、模拟、密码学、随机测试等。以下是关于 Random 类的一些重要信息:

  1. 创建 Random 实例:要使用 Random 类,首先需要创建一个 Random 类的实例。通常可以使用无参数构造函数创建一个默认的 Random 实例,如下所示:

    1
    Random random = new Random();

    这将创建一个基于当前系统时间的种子生成器,以初始化随机数生成器。

  2. 生成随机整数Random 类的主要方法是 nextInt(),它可以生成一个随机整数。你可以选择传入一个整数参数,表示生成整数的范围。例如,生成一个0到99之间的随机整数:

    1
    int randomNumber = random.nextInt(100); // 生成0到99之间的随机整数
  3. 生成随机浮点数:除了生成整数,Random 类还可以生成随机浮点数,如下所示:

    1
    double randomDouble = random.nextDouble(); // 生成0.0(包括)到1.0(不包括)之间的随机浮点数

Math常用方法

Java中的java.lang.Math类包含了一系列常用的数学方法,可以用来执行各种数学计算。以下是一些Math类中常用的方法:

  1. abs(double a):返回一个double值的绝对值。

    1
    double absoluteValue = Math.abs(-5.5); // 结果为 5.5
  2. ceil(double a):返回不小于参数的最小整数值(向上取整)。

    1
    double roundedUp = Math.ceil(5.1); // 结果为 6.0
  3. floor(double a):返回不大于参数的最大整数值(向下取整)。

    1
    double roundedDown = Math.floor(5.9); // 结果为 5.0
  4. round(double a):返回最接近参数的整数值。

    1
    long rounded = Math.round(5.4); // 结果为 5
  5. max(double a, double b):返回两个double值中的较大值。

    1
    double maxValue = Math.max(10.5, 8.2); // 结果为 10.5
  6. min(double a, double b):返回两个double值中的较小值。

    1
    double minValue = Math.min(10.5, 8.2); // 结果为 8.2
  7. pow(double a, double b):返回a的b次方。

    1
    double result = Math.pow(2, 3); // 结果为 8.0
  8. sqrt(double a):返回a的平方根。

    1
    double squareRoot = Math.sqrt(16.0); // 结果为 4.0
  9. random():返回一个[0,1)范围内的随机双精度浮点数。

    1
    double randomValue = Math.random();
  10. sin(double a)cos(double a)tan(double a):分别返回a的正弦、余弦和正切值,参数为弧度。

    1
    2
    3
    double sineValue = Math.sin(Math.PI / 6); // 弧度30°的正弦值
    double cosineValue = Math.cos(Math.PI / 3); // 弧度60°的余弦值
    double tangentValue = Math.tan(Math.PI / 4); // 弧度45°的正切值

这些方法允许您执行各种常见的数学操作。请注意,大多数Math类方法接受和返回的数据类型为double。如果需要其他数据类型的结果,您可能需要进行类型转换。

不使用第三变量交换两个变量值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//使用加法实现——第一版
a = a + b;//a中为和的值
b = a - b;//b中为a的值
a = a - b;//a中为b的值

//使用加法实现——第二版
a += b - (b = a);

//使用异或实现——第一版
a = a ^ b;//a中为异或后的结果
b = a ^ b;//异或后的结果在与b异或,结果为a
a = a ^ b;异或后的结果在与a异或,结果为b

//使用异或实现——第二版
a ^= b ^ (b = a);

获取一个类的名字,obj.getClass().getName()

十进制转二进制:Integer.toBinaryString(int a);

对字符串进行拆分

1
2
3
4
5
6
7
8
9
ip = 192.168.100.100
user = root
pwd = 12345
String[] split = line.split("=");
System.out.println(split[0] + "值是:" + split[1]);

ip 值是: 192.168.100.100
user 值是: root
pwd 值是: 12345