本文还在跟新，最新跟新时间3/11

！！！ 格式一定要符合要求，（输入，输出格式）

• 本人多次，在自己开始写的时候会输出一些结果有助于自己的理解（输出在控制台），到最后题目写好了，就提交了。但是出错。就因为一些没有必要的输出
• 注意我们在测试的时候可能会有包名，类名不一样一定要改。起类名字的时候尽量Main+数字。到时候只要记好把包名，类名改了就是。
  

1. nextInt () next() nextLine() 的注意事项

• nextInt(): 该方法用于读取输入中的下一个整数，并将其作为返回值。它会读取输入的整数并且忽略输入中的换行符（\n）。

Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();

要是换行 ，还要执行

scanner.nextLine();

• nextLine(): 该方法用于读取输入中的下一行内容，并将其作为返回值。它会读取输入中的一行文本，包括换行符，并将其作为字符串返回。

Scanner scanner = new Scanner(System.in);
String line = scanner.nextLine();

• next()方法分别读取这两个单词。注意，next()方法会将空格作为单词的分隔符，因此如果用户输入了多个单词，next()会依次读取每个单词。

import java.util.Scanner;

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

        System.out.print("请输入两个单词: ");
        String word1 = scanner.next();
        String word2 = scanner.next();

        System.out.println("第一个单词是: " + word1);
        System.out.println("第二个单词是: " + word2);

        scanner.close();
    }
}

2 .数的幂 a^2等

//比如 a 的二次幂
a * a 
//但是最好还是写成 
Math.pow(a,2);

3.得到最大长度（最大…）问题

private static String getMaxLength(String[] n1){
        int max = 0; //这种问题一般都会在循环的外面设置一个值，来存储最大值，当遇到别的最大值的时候在把原本的那个最大是够替换掉
        for (int i = 1; i < n1.length; i++) {
            if (n1[i].length() > n1[max].length()) { //n1[max].length 根据实际情况，一般因为要比最大值还要大，所以正常情况下都是要那一个值跟最大值比较。例如： a > max ? max = a  
                max = i;
            }
        }
        return n1[max];
    }

4 . 转换数据类型int ,string,char

int -> string , char

• 将int转换为String类型：

java
int number = 123;
String strNumber = String.valueOf(number);

// fang fa 2 
java
int number = 123;
String strNumber = Integer.toString(number);
// 方法3
int numve = 123;
String strNumber = "" + number;

• 将int转换为char类型：

int number = 65; // 代表字符'A'的ASCII码
char charNumber = (char) number;

string -> int ,char

• 将String转换为int类型：

java
String strNumber = "123";
int number = Integer.parseInt(strNumber);
//方法2
java
String strNumber = "123";
int number = Integer.valueOf(strNumber);

• 将String转换为char类型：

String strChar = "A";
char character = strChar.charAt(0);

• 当将字符串转换为字符时，我们假设字符串长度为1，因为char类型只能存储一个字符。

char -> int , string

• 将char转换为int类型：

java
char character = 'A';
int asciiValue = (int) character;
//‘1’  -》 1
Character.getNumericValue(char)

• 将char转换为String类型：

char character = 'A';
String strChar = Character.toString(character);
//方法二
char character = 'A';
String strChar = "" + character;
//要是想输出“A”
Character.getNumericValue(char)

5.判读是不是质数

 //判n 是不是质数
    private static boolean isTrue(int n){
        boolean flag = true;
        for (int i = 2; i < n; i++) {
            if (n % i == 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }

6. 求天、小时、分钟、秒…分析

//n 输入的是分钟
private static String getNewTime(int n){
        int t = n / 24/ 60 ; // 在这里 因为是分钟你先/60，是不是就是小时（可能24小时以上）。你在/24 是不是就是天（可能365天以上）。同样的你在/365 就可以的到年
        int h = n / 60  % 24;// 在这里/60 是不是就是小时 ，但是小时可能>24 所以%24
        int m = n % 60; // 在这里因为n是分钟，因为n 可能大于60 所以%60 得到分钟
        return String.format(t + " " + h +" " + m ); //输出的格式，自己看题目要求
    }

7.进制转换

十六进制转化为10 进制

• n 是输入的十六进制的数字

Integer.parseInt(n,16);

10 -> 16

//s 是输出的16进制，a 是输入的10进制
String s = Integer.toHexString(a);

8. 控制台输入的数组，存到数组中

Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        scanner.nextLine();
        //把数据存入到arr[][] 中
        int[][] arrs = new int[n][m];
        for (int i = 0; i < n; i++) {
            String[] s = scanner.nextLine.split(" ");
            for (int j = 0; j < m; j++) {
                arrs[i][j] = Integer.parseInt(s[j]);
            }
        }
        for (int i = 0; i < n; i++) {
            System.out.println(Arrays.toString(chars[i]));
        }

控制台输入：
30 20
9719 7515 5916 6467 7157 9614 8560 9075 2099 2838 1403 7652 6238 1699 8907 1804 5384 7942 7546 1978
8785 1944 8108 6040 2010 6646 2750 5410 4516 8757 5624 9257 9030 9290 6833 4646 9749 5304 5633 1573
8525 8244 8514 7474 7896 9731 8402 9036 1869 2688 2085 1667 7753 8466 4911 3812 8585 8319 4020 7350
1949 9120 4424 4057 8277 4511 6333 1533 7624 8932 1053 8682 9284 4134 1466 3607 8753 5310 3728 4163
9420 9185 7055 2342 4143 4499 2036 5374 7026 8638 8866 8364 1706 8767 1601 8309 5695 8179 4142 8489
5876 5660 4658 8307 2582 7544 8793 8207 3979 1692 1400 1893 4500 6389 7198 4836 4761 6603 2859 1312
6367 4174 9956 6668 6771 4795 6492 3937 7096 8041 8644 9379 8071 8667 5810 5794 8147 3823 7877 4822
4809 3297 8518 4972 9754 6854 3271 7891 8882 1052 3197 6035 5628 7674 7931 8085 8970 7733 4745 8785
7536 1511 6964 4763 5409 7032 8963 8576 3411 5853 3316 1267 7851 2735 6953 2970 1810 6830 5576 6903
2241 1575 2379 4679 9519 9290 4802 1562 3509 8365 6777 5143 5610 1061 7880 1935 5793 7023 5629 9571
2480 5937 4612 8890 1964 8532 3309 9737 8507 1849 8544 1500 9282 6288 2137 4730 4239 3473 4643 6377
7341 2881 3430 5815 1972 6629 3817 4547 7561 4779 6578 6114 4972 5505 7515 1800 4784 2272 4502 7541
7665 8607 2022 8192 2605 1346 4155 8725 8167 7022 6136 3615 6057 6329 8671 2033 3151 2249 5981 6412
9046 3353 8650 6965 4179 1248 5659 5219 8083 5615 3821 4436 9217 7356 3914 5717 3734 3765 4435 7210
8951 5013 2951 7401 2329 5686 6530 9581 6539 6881 8634 2663 2916 3019 8529 5645 8201 9270 1939 7275
6429 1531 6322 9586 2793 7968 4001 9665 7624 4369 6245 5146 9567 6801 6064 6199 3210 6753 2586 7795
5771 8507 7973 1470 1475 6896 6781 6572 8412 8557 8255 5268 8960 7251 9214 2489 6920 9917 3810 4605
9116 7950 3715 1697 4703 2868 8673 3106 2579 1074 3992 3547 4279 3149 3396 6081 6221 1125 9358 2471
8360 1526 4116 9278 6325 5175 5533 4107 7522 7599 7711 9211 1752 2431 8321 3844 3579 1047 3987 8487
7600 2401 8748 8945 2078 1519 4614 4576 5706 4040 9358 1928 1327 6699 5258 2846 3418 8310 1249 3866
7796 8668 4087 4258 8992 8996 4617 5997 2527 8204 8927 1456 9340 2088 1605 2299 9878 8347 7789 2122
8372 1102 4243 4208 1651 7861 4947 7802 4704 6204 4455 6012 8494 9060 3747 2786 2136 1830 7424 8309
6919 4420 2031 5399 2652 7219 4048 7013 5094 5276 4225 5976 4157 6722 8765 4679 1604 4986 5033 2623
4015 2297 3067 6261 6623 4577 4589 4747 6659 7667 7853 4040 6393 9606 7219 9334 1316 3430 9963 5187
4998 3735 9884 2990 1374 8436 6674 3018 5714 9352 8708 8789 7879 2965 1444 4671 4743 9817 6066 8057
6996 9609 2884 4601 7287 3432 4145 8858 6857 8624 4531 6579 1615 2894 4521 3274 5237 1093 3317 9289
7117 1850 3210 8010 2512 1394 4718 9332 5593 4118 4995 3994 5063 9426 1709 5128 4997 9287 1907 9068
4258 7328 6490 2603 5333 5093 8070 2116 8489 1994 7098 7409 1463 4268 9509 2358 1192 2460 5031 6292
4911 1192 1012 2494 5276 8981 3540 3306 8869 6678 7879 7526 8847 6270 7653 3109 6955 9760 8520 8673
6328 7277 7818 3285 9398 4929 4639 1617 4023 1051 9320 4955 6580 6481 3824 9611 2863 6492 6281 6203

9.求123 的和 1 + 2 + 3

• 本人这里判断了一下和是不是等与特定值

 //求和
    private static boolean isSum(int n){
        int sum = 0 ;
        while (n > 0){
            int yv = n % 10;
            int zhen = n / 10;
            n = zhen;
            sum += yv;
        }
        if (sum == 23) {
            return true;
        }else {
            return false;
        }
    }
//2
private static int sumOfDigits(int num) {
        int sum = 0;
        while (num > 0) {
            sum += num % 10;
            num /= 10;
        }
        return sum;
    }

10.最大公约数

//n1 n2 指的是两个数 return n1 输出了最大共约数
private static int isMax(int n1 ,int n2){
        while (n2!= 0){
            int r = n1 % n2;
            n1 = n2;
            n2 = r;
        }
        return n1;
    }

11.判断是不是回文

// 判断一个数字是否为回文数
    private static boolean isPalindrome(int num) {
        String numStr = String.valueOf(num);
        int left = 0, right = numStr.length() - 1;
        while (left < right) {
            if (numStr.charAt(left) != numStr.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

12.二维数组排序

package text_to_10;

import java.util.Arrays;
import java.util.Comparator;

public class text4 {
    public static void main(String[] args) {
        int[][] twoDArray = {{8, 9, 1}, {6, 5, 4}, {9, 8, 7}};

        // 使用Comparator对二维数组按照一维数组的和进行排序
        Arrays.sort(twoDArray, new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                int sumA = Arrays.stream(a).sum(); // 计算a数组的和
                int sumB = Arrays.stream(b).sum(); // 计算b数组的和
                return Integer.compare(sumA, sumB);
            }
        });

        // 打印排序后的二维数组
        for (int[] arr : twoDArray) {
            System.out.println(Arrays.toString(arr));
        }
    }
}