algorithm_java_notebook ==~~java==
==小tips==
求某个数的整数部分/小数部分
(int)强制转换得到整数部分->转换为String 用.length()方法可以获取整数位数 小数用整数减一下即可
关于/
1.被除数和除数皆为整型数据时
如果是整型数据进行除法运算,那么得到的结果就是被除数除以除数的结果,其结果必然是整型数据.
如果除不尽,会把得到的小数部分直接抹去,抹去的时候不要考虑四舍五入的规则
2.被除数和除数至少有一个为浮点型数据时
在除法运算中,如果里面有浮点型数据参与的话,那么结果一定会是浮点类型的数据,计算数值的话就按照我们平常小数和整数之间的除法计算去进行计算即可。
结果会保留小数部分.
（所以最好在分子或者坟墓上加一个==(double)==强制转换）
打印小数点位数
printf(“%.==2==f”,123.123);//结果123.12 显示两位小数
printf(“%.==5==f”,123.123);//结果123.12300 不足补0
运行速率
java比c++慢蛮多的 所以用java做算法的时候有些时候时间太长了 可能不是你的问题 泪的教训
方法传参
==java只传值==
如果是基本类型 只会复制变量值传递过去 所以当方法内修改传递过去的值时变量值不会改变
如果是引用类型（数组也是对象） 会复制其对象地址传递过去 所以当方法内修改了 引用类型也会修改
java初始化对象数组
Student stu[] = new Student[num]; 这行代码是在创建一个数组，而不是在实例化对象。你创建了一个数组来存储多个 Student 对象的引用，但==数组中的每个元素都需要被单独实例化==，否则数组中的元素都是 null，而不是有效的 Student 对象。
在Java中，数组创建后，==数组元素默认初始化为 null（对于引用类型）==。因此，你需要在数组中的每个元素上调用构造函数，以创建实际的 Student 对象。这就是为什么我在上一个回答中建议在循环内部使用 stu[i] = new Student(); 来实例化 Student 对象的原因。
==总结：创建完数组对象后 要再次用new 对象名();进行实例化==
==基本模块==
输入
Scanner ==数据超过一百万不建议使用==
==scanner需要了解的几个重要的基本点：==
==一定要注意理解当前元素和下一个元素的含义==
1.关于hasNext方法：
1>此方法用于判断迭代器==当前指向元素==是否为空（next()默认元素之间的分隔符为空格或者换行符 可以用==scanner.useDelimiter(String)==来替换 ==注意是替换而不是增加==）
==理解：sc.hasNext()可以理解为把我们输入的值存到了sc当中而sc.next()可以理解为从sc中取值，取值后将标识符后移（可以理解为：取完值后这个值就不在了），如果sc中没有值了，它也会要求输入一个值（前面说了它们两都可以输入）。==
2>此方法判断==当前元素==不为空时 会返回结果true 但是==当当前元素为空时他会阻塞方法 并不会返回false== 所以当我们使用while(scanner.hasNext())进行判断时会导致无法退出循环 不建议使用 上网查询到的一般解决办法是采取while(!scanner.hasNext(“#”))对hasNext()方法进行重载非负判断 但是笔者不太能理解这种方法的实在意义
3>这里给出我的解决思路：当涉及scanner读取时 我一般采取next()对整行进行读取（如果涉及要读取空格采用nextLine()）,然后再对读取到的字符串进行操作，==如果用next读取 又需要换行时用nextLine()先换行 再读取 nextLine读取会自动换行==——如果只是多个int或者double则直接用nextInt…即可
2.关于next方法：
1>此方法用于获取迭代器当前元素的值 并且将引用移位++（==注意hasNext并不会使引用移位==）
3.关于nextLine方法：
1>==nextLine输入双回车，会读取中间的空白字符串 但是 next会阻塞 等待输入==
4.关于next与nextLine方法：
1> next与nextLine共用一个指针和缓冲区（参考next读取需要用nextLine进行换行）
2>next不读取换行符 不会返回下一行的令牌 因为没数据了 nextLine也不读取换行符 但是会将光标移到下一行（参考next读取需要用nextLine进行换行）
3>next与nextLine不建议共用 不然可能遇到换行符等问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import java.util.Scanner;
Scanner scan = new Scanner(System.in);
scan.nextInt();
scan.nextDouble();
scan.nextLine();
scan.next();
|
BufferedReader
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
|
import java.io.*;
public BufferedReader(Reader in,int sz)
public BufferedReader(Reader in)
public int read() throws IOException
public int read(char[] cbuf) throws IOException
public void close() throws IOException
public String readLine() throws IOException
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| import java.io.*;
try{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try {
String n = br.readLine();
System.out.println(n);
}catch(Exception e) {
}
}catch(Exception e){
}
try {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
char n = (char)br.read();
System.out.println(n);
}catch(Exception e) {
}
|
输出
默认 System.out.print
==数据太大不建议使用 效率太低==
BufferedWriter
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
37
38
|
import java.io.*;
BufferedWriter(Writer out) :
BufferedWriter(Writer out,int size):
public void write(int c) throws IOException
public void write(String str) throws IOException
public void close() throws IOException
public void newLine() throws IOException
public static void main(String[] args) throws Exception {
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")) ;
bw.write("hello");
bw.write("world");
bw.flush();
bw.close();
}
|
1
2
3
4
5
6
7
8
9
10
11
12
| import java.io.*;
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try {
char n = (char)br.read();
bw.write(n);
bw.flush();
bw.close();
}catch(Exception e) {
}
|
数值计算
Math
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import java.math.*;
Math.abs();
Math.sqrt();
Math.ceil();
Math.floor();
Math.round();
Math.max( , );
Math.min( , );
Math.random();
Math.pow( number , index );
Math.pow( number , index );
|
数组排序
Arrays
1
2
3
4
5
6
7
| import java.utils.Arrays;
Arrays.sort(数组名)
List<Integer> integersList = Ints.asList(array);
Collections.reverse(integersList);
|
字符串操作拼接、反序、替换、删减、插入
StringBuilder
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
String str = "0123456";
StringBuilder sb = new StringBuilder(str);
sb.append();
sb.setLength(0);
sb.reverse();
sb.replace(start, end, String);
sb.delete(start, end);
sb.insert(3, String);
sb.capacity();
sb.length();
char charAt(int index)
String substring(int start)
String substring(int start, int end)
String toString()
int indexOf(String str)
int indexOf(String str, int fromIndex)
int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)
|
动态数组
ArrayList LinkList List 三者的原理以及区别：
ArrayList是基于数组实现的 LinkList是基于链表实现的
ArrayList
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
|
import java.util.ArrayList;
ArrayList<E> objectName =new ArrayList<>();
ArrayList<String> sites = new ArrayList<String>();
sites.add("Google");
sites.get(1);
sites.set(2, "Wiki");
sites.remove(3);
sites.size()
import java.util.Collections;
Collections.sort(sites);
|
LinkList
List
高精度数据处理
BigDecimal
1）参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。
2）String 构造方法是完全可预知的：写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言， 通常建议优先使用String构造方法。
3）当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法。
==4）注意：BigDecimal也封装了Math类的方法 可以直接调用==
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
37
38
39
40
41
42
|
import java.math.BigDecimal;
BigDecimal bd = BigDecimal.valueOf(long or String);
BigDecimal bd = new BigDecimal(long or String);
BigDecimal add(BigDecimal val)
bd = bd2.add(bd3);
BigDecimal subtract (BigDecimal val)
BigDecimal multiply (BigDecimal val)
BigDecimal divide (BigDecimal val,2,RoundingMode mode)
int a = new bigdemical(a).compareTo(new bigdemical(b))
a = -1
a = 0
a = 1
bd.setScale(1)
setScale(1,BigDecimal.ROUND_DOWN)
setScale(1,BigDecimal.ROUND_UP)
setScale(1,BigDecimal.ROUND_HALF_UP)
setScale(1,BigDecimal.ROUND_HALF_DOWN)
|
基本数组（int string double）/二维/三维
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
|
int[] arr = {1,2,4, …};
int[] arr;
arr = new int[]{1,2,3, …};
int[] arr1= new int[3];
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = new int[m][n];
int[][][] arr = new int[m][n][q];
int[] arr = {111,222,333};
System.out.println(Arrays.toString(arr));
|
String的一些基本操作
String
==String数据范围==
在 Java 中，String 字符串的长度受到限制，但这个限制是由你的计算机硬件和内存资源决定的，而不是 Java 语言本身的限制。String 类使用一个 char 数组来存储字符串的字符，而 char 占用两个字节的内存。因此，String 的长度受限于可用的内存大小。
如果你的程序在内存充足的情况下运行，String 可以非常长。然而，如果你的字符串非常巨大，可能会导致内存不足异常。此外，Java 虚拟机（JVM）也可能会有一些特定的限制，但这些限制通常取决于 JVM 的实现和配置。
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
37
38
39
40
41
42
| String str = "hello world";
str.length();
str.charAt(index);
char c[] = str.toCharArray();
int index = str.indexOf("he");
"string".toUpperCase()
"string".toLowerCase()
String strArr[] = str.split(" ");
str.equals("string");
str.equalsIngoreCase("string");
str.trim();
str.replace(" ","");
str.replaceFirst(" ","");
str.replaceAll(" ","");
str.subString(start_index,end_index)
str.contains("string");
str.compareTo(str2);
str.startsWith("string");
str.endsWith("string");
|
==对数字/字符的一些处理==
小数位数控制/保留几位小数/保留几位有效数字
1
2
3
4
5
6
7
8
9
10
|
import java.math.BigDecimal;
import java.math.RoundingMode;
BigDecimal number = new BigDecimal("123.456789");
BigDecimal roundedNumber = number.setScale(2, RoundingMode.HALF_UP);
BigDecimal roundedNumber2 = roundedNumber.stripTrailingZeros();
|
字母的大小写转换
1
2
3
4
5
6
7
8
9
10
11
12
|
char A=Character.toUpperCase('a');
char b=Character.toLowerCase('B');
Character.isLetter(char);
String cc = "aBc123".toUpperCase();
String cc = "aBc123".toLowerCase();
|
四舍五入/向上/向下取整
1
2
3
4
5
6
7
|
int roundNum = (int) Math.round(result);
int ceilNum = (int) Math.ceil(result);
int floorNum = (int) Math.floor(result);
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
int number = 5;
String str = String.valueOf(number);
System.out.println(str);
int number = 5;
Integer itr = number;
String str = itr.toString();
System.out.println(str);
int number = 5;
String str = number + "";
System.out.println(str);
char ch = '5';
String str = String.valueOf(ch);
System.out.println(str);
char ch = '5';
String str = ch + "";
System.out.println(str);
String str = "123";
char ch = str.charAt(0);
System.out.println(ch);
arr = [1,2,2];
str1 = arr.toString();
String strArr = str2.split("\\.")
String str = "123";
int number = Integer.parseInt(str);
System.out.println(number);
int number = 5;
String temp = Integer.toString(number);
char ch = temp.charAt(0);
System.out.println("数字转字符："+ch);
char ch = '5';
String temp = String.valueOf(ch);
int a = Integer.parseInt(temp);
System.out.println(a);
int a = ch - '0';
String arr[];
int[] array = Arrays.stream(arr).mapToInt(Integer::parseInt).toArray();
|
约分/最大公约数/最小公倍数
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public static int gcd(int a,int b) {
if(b == 0)return a;
else return gcd(b,a%b);
a*b/gcd(a,b);
|
判断字符串是否为数字
1
2
3
4
5
6
7
8
9
10
| public static boolean isNumeric1(String str) {
try {
Double.parseDouble(str);
return true;
} catch(Exception e){
return false;
}
}
|
获取字母表数组
1
2
3
4
| char[] alphabet = new char[26];
for (int i = 0; i < 26; i++) {
alphabet[i] = (char) ('a' + i);
}
|
判断闰年
1
2
3
4
5
|
public static boolean leapYear(int year) {
if((year%4 == 0 && year%100 != 0)||year%400 == 0)return true;
else return false;
}
|
阶乘（factorial）
1
2
3
4
| public static int factorial(int n){
if(n == 1)return 1;
else return n*factorial(n-1);
}
|
==数学知识==
关于质数
1>质数不可能是偶数 所以遍历质数从奇数遍历即可
质数筛
1
2
3
4
5
6
7
8
9
10
11
12
|
public static boolean prime(int n) {
if( n == 2)return true;
else {
for(int i = 2;i<n;i++) {
if(n%i == 0) {
return false;
}
}
return true;
}
}
|
2>质因数分解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
if(n%2 == 0) {
System.out.println(n/2);
System.exit(0);
}
for(int i = 3;i<n;i+=2) {
if(n%i == 0) {
System.out.println(n/i);
break;
}
}
|
哥德巴赫猜想
任一大于2的整数都可写成三个质数之和。
==基本算法==
暴力枚举
模拟
官方化的诠释则是：根据题目表述进行筛选提取关键要素，按需求书写代码解决实际问题。
==这种题型一般并不难 顺着题意解决就行 但是要注意一些特殊情况的处理 以及输出结果的要求==
高精度 （见基本模块）
