算法入门-常见算法：

1.日期时间

Calendar calendar=Calendar.getInstance();
int year=calendar.YEAR;
int month=calendar.MONTH+1;
int date=calendar.DATE;
int hour=calendar.HOUR;
int day=calendar.DAY_OF_WEEK;
calendar.set(2023, 1, 25);
​
Date d=new Date();//当前时间
Date d1=new Date(1000);//初始时间加1000毫秒
System.out.println(d);
System.out.println(d1);
System.out.println(d.getDate());
System.out.println(d.getHours());
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String s=sdf.format(d);
System.out.println(s);
String s1 = "2022-01-04 02:32:22";
System.out.println(sdf.parse(s1));

2.进制转换

    String num1 = Integer.toBinaryString(15); // 1111     转为二进制
    String num2 = Integer.toOctalString(15);  // 17       转为八进制
    String num3 = Integer.toHexString(15);    // f        转为十六进制
    String num4 = Integer.toString(5,4); // 11           

//十转为任意制，在这段代码中，Integer.toString(5,4) 的意思是将数字5从十进制转换为四进制的字表就是将整数 5 转换为四进制表示的字符串。要注意的是，Java 中的 Integer.toString 方法的第二个参数是用于指定要转换的数字的进制。

3.大数类

//整数
BigInteger a=BigInteger.ONE;
String s1 = sc.next(); //150
String s2 = "2";
BigInteger a = new BigInteger(s1);
BigInteger b = new BigInteger(s2);
System.out.println(a); //150
System.out.println(a.multiply(b));//相乘 300
System.out.println(a.add(b));//相加 152
System.out.println(a.subtract(b));//相减 148
System.out.println(a.divide(b));//相除 75
​
//小数
BigDecimal a,b；//同上

4.最大公约数，最小公倍数

    /**
     * 最大公约数
     * 
     * @param a
     * @param b
     * @return
     */
    public static int getGcd(int a, int b) {
        while (a % b != 0) {
            int mod = a % b;
            a = b;
            b = mod;
        }
        return b;
    }
​
    /**
     * 最小公倍数
     * 
     * @param a
     * @param b
     * @return
     */
    public static int getLcm(int a, int b) {
        return a * b / getGcd(a, b);
    }

5.随机数字

Random rd = new Random();
int number = new Random().nextInt(end - start + 1) + start;
int temp = rd.nextInt(90)+10;//[10，100）
​
int num = (int) (Math.random()*5);//0 1 2 3 4


/*这些代码用于生成随机数。
1. 第一行代码创建了一个Random对象rd。
2. 第二行代码生成一个介于start和end之间（包括start和end）的随机整数number。
3. 第三行代码生成一个介于10和99之间（包括10但不包括100）的随机整数temp。
4. 这行代码的作用是生成一个介于0和4之间（包括0但不包括5）的随机整数。
	- 首先，Math.random()方法会返回一个大于等于0且小于1的随机double类型数值。
	- 接着，这个随机数会乘以5，得到一个介于0和5之间（不包括5）的随机数。
	- 然后，将这个随机数强制转换为int类型，会向下取整，得到0、1、2、3或4中的一个整数值。
	- 最终，将这个整数赋值给变量num，即生成了一个介于0和4之间的随机整数。
*/

6.Math类

//使用：Math.方法名()
abs(Object o)；
min(Object a, Object b) 
max(Object a, Object b)
pow(double a, double b)
sqrt(double a)
round(float a)

/*abs(Object o)：返回给定对象o的绝对值。
min(Object a, Object b)：返回两个对象a和b中的较小值。
max(Object a, Object b)：返回两个对象a和b中的较大值。
pow(double a, double b)：返回a的b次幂。
sqrt(double a)：返回a的平方根。
round(float a)：返回最接近a的整数值，四舍五入。*/

7.字符

  char ch1 = 'A';
  System.out.println(Character.isDigit(ch)); //是否为数字字符
  System.out.println(Character.isLetter(ch)); //是否为字母
  System.out.println(Character.isLowerCase(ch)); //是否为小写字符
  System.out.println(Character.isUpperCase(ch)); //是否为大写字符
  System.out.println(Character.toUpperCase(ch)); //转化为大写字符
  System.out.println(Character.toLowerCase(ch)); //转化为小写字符

8. String类

int length() 
boolean isEmpty()
char charAt(int index)
boolean equals(Object anObject) 
    
String format(String format, Object... args)
    //"String format(String format, Object... args)" 这个方法是一个字符串格式化的方法，它		接受一个字符串格式和一个可变数量的参数。在调用这个方法时，你可以传入一个字符串格式，例			如"Hello, %s!"，然后再传入对应的参数，例如"World"，这样就会返回一个格式化后的字符串"Hello, 		World!"。这个方法可以用来动态地生成字符串，根据不同的参数来填充字符串格式中的占位符。
    
int indexOf(int ch)
int lastIndexOf(int ch) 
String replace(char oldChar, char newChar)
String toLowerCase() 
String toUpperCase() 
String trim()

注意

startsWith()

String str1="lan";
String str2="lanqiao";
System.out.println(str2.startsWith(str1));//true
System.out.println(str1.startsWith(str2));//false

getChars()

//将字符从字符串复制到目标字符数组   
public static void main(String args[]) {
        String Str1 = new String("www.oooooo.com");
        char[] Str2 = new char[6];
​
        try {
            Str1.getChars(4, 10, Str2, 0);
            System.out.print("拷贝的字符串为：" );
            System.out.println(Str2 );
        } catch( Exception ex) {
            System.out.println("触发异常...");
        }
    }
//拷贝的字符串为：oooooo
//这段代码的意思是从字符串“Str1”中提取索引位置4到10之间的字符，并将其复制到字符串“Str2”的起始位置（索引位置0）开始的位置。

9.数组—排序

Arrays类（数组处理）
static void sort(Object[] a) 
数组反向排序：
String[] strArray = new String[] { “z”, “a”, “C” };
Arrays.sort(strArray, Collections.reverseOrder());//输出：[z, a, C]
//Collections.reverseOrder()方法是Java中的一个静态方法，用于获取一个比较器（Comparator）对象，该比较器可以实现降序排序。在这个例子中，我们将这个比较器传递给Arrays.sort()方法，以便对字符串数组strArray进行降序排序。
​
数组自定义排序:
    public static int compDig(Integer x) {
        int ans = 0;
        while (x > 0) {
            ans += x % 10;
            x = x / 10;
        }
        return ans;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        Integer[] arr = new Integer[n + 1];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
        Arrays.sort(arr, (a, b) -> compDig(a) != compDig(b) ? compDig(a) - compDig(b) : a - b);
        System.out.println(arr[m]);
    }
    //Arrays.sort(arr, (a, b) -> compDig(a) != compDig(b) ? compDig(a) - compDig(b) : a - b);

10.数组—数组转List

int[] arr = {2, 0, 4, 9, 3, 6, 8, 7, 1, 5, 3};
List<int[]> ints = Arrays.asList(arr);
Arrays.asList(arr).forEach(System.out::println);
//方法引用：使用 类名或对象名::方法名 的形式来引用一个方法，通常用于简化代码，特别是在函数式编程中。

public static void main(String[] args) throws Exception{
    String[] stringArray = new String[3];
    list = Arrays.asList(stringArray);
}
​
ArrayList<String> list = new ArrayList<String>(Arrays.asList(strArray)) ;

/*这行代码的作用是将一个 String 数组 `strArray` 转换为一个 ArrayList，并将其赋值给名为 `list` 的 ArrayList 对象。
1. `Arrays.asList(strArray)`: 将 String 数组 `strArray` 转换为一个 List 对象。这个方法会返回一个固定大小的、不可变的 List，可以直接用于初始化其他集合。
2. `new ArrayList<String>(...)`: 创建一个新的 ArrayList 对象，使用括号中的内容来初始化该 ArrayList。在这里，括号中传入了之前转换得到的 List，因此这个 ArrayList 包含了 `strArray` 中的元素。
3. `ArrayList<String> list = ...;`: 将创建的 ArrayList 赋值给名为 `list` 的 ArrayList 对象。

通过这行代码，就可以将一个 String 数组转换为一个可变的 ArrayList 对象，方便对其中的元素进行增删改查操作。
在这行代码中，`Arrays.asList(strArray)` 返回的是一个泛型为 `List<String>` 的 List 对象，因为 `strArray` 是一个 String 数组，所以转换后的 List 中的元素类型也是 String。

然后，通过 `new ArrayList<String>(...)` 创建了一个泛型为 `ArrayList<String>` 的 ArrayList 对象，并将之前转换得到的 List 作为其初始化参数。由于 List 中的元素类型是 String，所以在创建 ArrayList 对象时，泛型也应该指定为 `String`。

因此，即使括号中传入的是一个 List 对象，但由于这个 List 对象中的元素类型是 String，所以在创建 ArrayList 对象时，泛型也应该与其元素类型保持一致，即使用 `ArrayList<String>`。
*/