ACM中使用，不介绍OOP（面向对象编程）
部分概念只为了快速使用理解，并不准确

java基本语法：

基本结构：

import java.math.BigDecimal; // 导入工具类的包，和#include<queue>那些一样的作用
import java.math.BigInteger;
import java.lang.String;

public class Main {

    static int a; // 全局变量

    public static void main(String[] args) {

        // 核心代码
        int b; // 局部变量
    }
}

public class Main的Main代表是一个类，这里需要引入OOP面向对象的概念。在学习java语言之前这样写即可，在ACM中一般这个Main是不能改的。

public static void main是程序的入口函数，相当于C语言的int main(void)

如果想要声明一个全局变量，就要写在Main类里面，main函数之外，并且要加static，这里固定写即可（原因在于java程序加载，暂时不用管）

如果想要声明局部变量，将public static void main当成main函数往里面写就行了

基本数据类型：

java拥有八种基本类型：

1. short
2. int
3. long
4. byte
5. char
6. boolean
7. float
8. double

使用方法和C语言无差异，如下：

public class Main {
    public static void main(String[] args) {
        int a = 10; // -2147483648 ~ 2147483647的范围
        // 浮点数直接用double即可
        double b = 10.5;
        boolean flag = true; // 布尔类型

        // char类型一般用不到，后面面会介绍String字符串
    }
}

分支语句：

也和C语言没什么区别，如下：

public class Main {
    public static void main(String[] args) {

        boolean flag = true;

        if (flag) {
            System.out.println("判断条件为真");
        } else {
            System.out.println("判断条件为假");
        }
    }
}

需要注意在C中可以写if (5)这种，只要不是0就会判定为真，但是Java中不行，括号内必须为布尔值

循环语句：

跟C一样，有两种：
1. while循环
2. for循环

用法也是一样的，如下：

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i ++ ) {
            System.out.println(i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println(i);
            i ++ ;
        }
    }
}

输入输出：

要引入一个概念叫对象，最上面的类其实是一个抽象，就类似于猫，是一个种类，把他实例化之后就叫做对象，就像家里有一只猫叫做tom，这个tom就是一个对象。

如果需要输入的话，就需要一个输入对象Scanner，将一个猫实例化成tom这个过程需要用new这个关键字，关键字就类似于C语言的struct return都是关键字

所以用Scanner这个对象就需要操作：

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

下面展示输入基本类型：

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        double b = scanner.nextDouble();
        // 其他类型也是一样的，需要什么就nextXX()
    }
}

输出直接看例子就懂了：

public class Main {
    public static void main(String[] args) {
        System.out.println("输出的第一段话，这句话输出完会换行");
        System.out.print("将ln去掉，将不会换行");
        System.out.println(); // 这个单纯为了换行好看

        int a = 1, b= 2;
        System.out.printf("这里和C的用法一致，输出数字%d和%d\n", a, b);
    }
}

数组：

数组的写法可以有下面两种：
1. int a[] = {1, 2, 3}; 这种跟C的就比较类似，但是java习惯于第二种写法
2. int[] a = {1, 2, 3};

上面是直接做了初始化，如果想要获取数组的长度可以直接a.length，这里注意没括号。

而不做直接的初始化C可以直接声明int a[100]即可，
但是java需要int[] a = new int[];否则是不能用的

方法（函数）：

思想不同，叫法不同而已，java的函数需要的结构如下：

修饰符 其他 返回值 函数名(形式参数) {
}

// ACM中修饰符我们可以不要，暂时不用管他是什么
// 其他我们需要加个static，这个原因是因为main入口函数固定了static，也不用管
// 所以java和c的区别就在于多了一个static
static int sum(int a, int b) {
    return a + b;
}
// 这样就可以正常调用了

java工具类

String类：

上面说到char基本不会用到，就是因为java封装了一个和C++一样的字符串类，也是需要一个字符串对象操作：
1. String str = new String();
2. 或者更简便的直接赋值String str = "这是字符串";

下面列举常用的方法：

public class Main {
    public static void main(String[] args) {
        String str = "这是一段字符串";

        // 判断字符串是否包含其他的字符串
        if (str.contains("字符串")) {
            System.out.println("str字符串中含有字符串三个字");
        }

        // 截取函数，从下标为2截取到最后
        String substring = str.substring(2);
        System.out.println(substring);

        // 截取函数的另一种使用方法 从下标为2截取到下标为(4-1)
        String substring1 = str.substring(2, 4);
        System.out.println(substring1);

        // 分割，用一做分割符，就会分成 "这是" "段字符串" 这两个字符串
        String[] s = str.split("一");
        for (int i = 0; i < s.length; i ++ ) {
            System.out.println(s[i]);
        }

        // 替换函数，将一个字符串替换成其他的
        str = str.replace("一段字符串", "123");
        System.out.println(str);

        // 找到字符串的第i位，java的字符串不像C++可以直接str[i]
        char c = str.charAt(0);

        // 判断是否两个字符串相同，这里不能用==号
        str.equals("另一端字符串");

    }
}

大数类：

常用的有整数的大数类和浮点数的大数类
如果对类的概念还是很模糊就像成一个物种就行了，其实就是一个能操作大数的工具。

1. 能操作整数的工具：BigInteger

public class Main {
    public static void main(String[] args) {
        // 这个小括号内的叫实参，和c里面调用函数时传递的那个参数一样
        // 这里需要一个字符串，但是这个字符串必须是一个数字
        BigInteger a = new BigInteger("15000000000000000000000000");
        // 判断是否两个数相同
        boolean equals = a.equals("15000000000000000000000000");
        boolean equals2 = a.equals(new BigInteger("15000000000000000000000000"));
        // 取模运算
        a = a.mod(new BigInteger("150"));
        System.out.println(a);
        // 下面是加减乘除
        a.add(new BigInteger("100")); // + 100
        a.subtract(new BigInteger("100")); // -100
        a.multiply(new BigInteger("200")); // * 200
        a.divide(new BigInteger("200")); // 除200
        // 需要注意的是都要用a = a.xxx(new BigInteger()); 这种写法，要用a=再去赋值一遍，否则原数不会变

        a = a.abs();// 绝对值
    }
}

1. 能操作浮点数的工具：BigDecimal

public class Main {
    public static void main(String[] args) {
        // 需要注意的是这个对象可以通过字符串来模拟出没有精度错误的浮点数，在C++中某些浮点数是无法存储的，一定有误差
        BigDecimal a = new BigDecimal("120.841684848484898498489495");
        System.out.println(a);

        a = a.abs(); // 绝对值

        // 加减乘除都和BigInteger一样，将参数换成new BigDecimal即可
        a = a.add(new BigDecimal("150"));
        System.out.println(a); // 270.841684848484898498489495

        // 比较谁大
        BigDecimal b = new BigDecimal("130.6");
        System.out.println(a.compareTo(b)); // a比较b， 如果a大返回1，b大返回-1，相等返回0


        System.out.println(a.max(b)); // 返回a和b大的
        System.out.println(a.min(b)); // 返回a和b小的
    }
}