for (int i = 0; i <= 100; i++) {
    System.out.print("进度: " + i + "%\r"); // 利用 \r 回到行首不断覆盖
    Thread.sleep(100); // 暂停一小会儿
}

public class Test {

  public static void main(String args[]) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 查看  d++ 与 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("d     = " +  d);
     System.out.println("++d   = " +  (++d) );
  }
} 

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
d     =26
++d   = 27

System.out.println(10 / 4); //从数学来看是 2.5, java 中 2
System.out.println(10.0 / 4); //java 是 2.5

int total = 4;
int score = 10;
double result = score / total; // 猜猜结果是多少？ 2.0
System.out.println(result);

int i = 1；
i = i++；
System.out.println(i);

int i = 1；
i = ++i；
System.out.println(i);

public class Test {

  public static void main(String args[]) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
   } 
}  

a == b = false
a != b = true
a > b = false
a < b = true b >= a = true
b <= a = false 

对象  instanceof  类型

Object obj = new String("hello");
// 判断obj是不是String的实例
boolean res = obj instanceof String;
System.out.println(res); // true

public class Test {
  public static void main(String args[]) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );

     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );

     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );

     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );

     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );
     c = a >> 2;     /* 215 = 1111 */
     System.out.println("a >> 2  = " + c );
  
     c = a >>> 2;     /* 215 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
} 

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240 
a >> 2 = 15
a >>> 2 = 15

public class Test {
  public static void main(String args[]) {
     int a = 10;
     int b = 20;
     int c = 0;
     c = a + b;
     System.out.println("c = a + b = " + c );
     c += a ;
     System.out.println("c += a  = " + c );
     c -= a ;
     System.out.println("c -= a = " + c );
     c *= a ;
     System.out.println("c *= a = " + c );
     a = 10;
     c = 15;
     c /= a ;
     System.out.println("c /= a = " + c );
     a = 10;
     c = 15;
     c %= a ;
     System.out.println("c %= a  = " + c );
     c <<= 2 ; 
     System.out.println("c <<= 2 = " + c ); 
     c >>= 2 ;
     System.out.println("c >>= 2 = " + c );
     c >>= 2 ;
     System.out.println("c >>= a = " + c );
     c &= a ;
     System.out.println("c &= a = " + c );
     c ^= a ;
     System.out.println("c ^= a = " + c );
     c |= a ;
     System.out.println("c |= a = " + c );
  }
} 

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20 c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10

byte b = 3;
b += 2; // 等价 b = (byte)(b + 2);
b++; // b = (byte)(b+1);

int a = 1；
int b = a；
a和b是单独的空间，互不影响     基本数据类型
int[] a = [1,2];
int[] b = a;
a和b是引用同一个地址，相互影响    引用数据类型

import java.util.Arrays;

int[] arr = {1,3,2};
System.out.println(Arrays.toString(arr));
//输出：[1, 3, 2]

int[][] arr2 = {{1,2},{3,4}};
System.out.println(Arrays.deepToString(arr2));

int[] arr = {5,2,9,1};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 5, 9]

Integer[] arr = {5,2,9,1};
//降序
Arrays.sort(arr, (a,b)->b-a);

int[] arr = {1,2,5,9};
int index = Arrays.binarySearch(arr,5); //返回2
int index2 = Arrays.binarySearch(arr,3); //找不到，返回负数

copyOf (数组，新长度)

int[] old = {1,2,3};
int[] newArr = Arrays.copyOf(old,5);
// [1,2,3,0,0]

copyOfRange (数组，起始索引，结束索引)

int[] arr = {10,20,30,40};
int[] sub = Arrays.copyOfRange(arr,1,3);
// [20,30]

int[] arr = new int[5];
Arrays.fill(arr,8); //全部填充8
// [8,8,8,8,8]

Arrays.fill(arr,1,3,6); //下标1~2填充6

int[] a = {1,2,3};
int[] b = {1,2,3};
System.out.println(Arrays.equals(a,b)); //true

Integer[] nums = {1,2,3};
List<Integer> list = Arrays.asList(nums);

int a = 10;
Integer num = Integer.valueOf(a); //装箱

Integer num = new Integer(10);
int a = num.intValue(); //拆箱

//自动装箱
Integer i = 10; //等价 Integer i = Integer.valueOf(10);

//自动拆箱
int n = i; //等价 int n = i.intValue();

Integer a = 100;
Integer b = 100;
System.out.println(a == b); //true，在缓存区间

Integer c = 200;
Integer d = 200;
System.out.println(c == d); //false，超出缓存，两个不同对象

int num = 99;
String str = num + "";

String str = String.valueOf(num);

String s = "123";
int n = Integer.parseInt(s);
double d = Double.parseDouble(s);

Integer i = null;
int a = i; //运行报错！空指针

List<Integer> list = new ArrayList<>(); //正确
List<int> list = new ArrayList<>(); //编译报错

String s = "abc";
s = "def";

String str1 = "Java";

String str2 = new String("Java");

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true  都指向常量池

String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s3 == s4); // false 堆中两个不同对象

String s1 = "a"+"b"+"c";
// 编译器优化等价于 String s1 = "abc";

String a = "a";
String s = a + "b";
//底层：new StringBuilder().append(a).append("b").toString()
//toString()底层 new String()，对象在堆，不进入常量池

String s1 = new String("hello");
String s2 = "hello";
System.out.println(s1 == s2);      // false
System.out.println(s1.equals(s2)); // true

String str = "HelloJava";
str.length();                // 获取字符长度
str.charAt(索引);            // 获取指定位置字符
str.indexOf("Java");         // 查找子串起始索引，找不到返回-1
str.substring(begin,end);    // 截取字符串 [左闭右开)
str.trim();                  // 去除首尾空格(JDK11:strip支持全角空格)
str.toUpperCase();           // 转大写
str.toLowerCase();           // 转小写
str.contains("He");          // 是否包含子串
str.startsWith("He");        // 是否以指定开头
str.endsWith("va");          // 是否以指定结尾
str.split(",");              // 按照分隔符切割 → String数组
str.replace("a","b");        // 字符/字符串替换

// 空参，默认容量 16
StringBuffer sb1 = new StringBuffer();

// 指定初始容量
StringBuffer sb2 = new StringBuffer(50);

// 根据字符串创建，容量 = 字符串长度 + 16
StringBuffer sb3 = new StringBuffer("hello");

StringBuffer sb = new StringBuffer();

sb.append("java");       // 末尾追加（最常用）
sb.insert(1,"A");        // 指定索引位置插入
sb.delete(0,2);          // 删除 [左闭右开区间]
sb.replace(0,1,"Hi");    // 区间替换
sb.reverse();            // 字符串反转
sb.setCharAt(0,'X');     // 修改指定位置字符

sb.length();             // 当前实际字符长度
sb.capacity();           // 获取底层数组总容量

// 转换成String
String str = sb.toString();

// String → StringBuffer
String str = "hello";
StringBuffer sb = new StringBuffer(str);

// StringBuffer → String
String result = sb.toString();

sb.append("a").append("b").append("c");

java.lang.StringBuilder

// 1.无参构造：初始容量 16
StringBuilder sb1 = new StringBuilder();

// 2.指定初始容量
StringBuilder sb2 = new StringBuilder(30);

// 3.传入字符串，容量 = 字符串长度 + 16
StringBuilder sb3 = new StringBuilder("hello");

StringBuilder sb = new StringBuilder();

sb.append("Java");          // 末尾追加（最常用）
sb.insert(1,"_");           // 指定位置插入
sb.delete(0,2);             // 删除 [start,end) 左闭右开
sb.replace(0,1,"Hi");       // 区间替换
sb.reverse();               // 字符反转
sb.setCharAt(0,'A');        // 修改指定下标字符

sb.length();    // 实际字符个数
sb.capacity();  // 底层数组总容量

// 转为String（生成新字符串对象）
String str = sb.toString();

// String → StringBuilder
String s = "demo";
StringBuilder sb = new StringBuilder(s);

// StringBuilder → String
String res = sb.toString();

// 性能极差！每次循环产生大量中间String对象
String str = "";
for(int i=0;i<10000;i++){
    str += i;
}

// 推荐写法
StringBuilder sb = new StringBuilder();
for(int i=0;i<10000;i++){
    sb.append(i);
}
String str = sb.toString();

String s = "a"+"b"+"c";
// 编译期优化为 String s = "abc";

String a = "a";
String s = a + "b";
// 底层自动 new StringBuilder 拼接
// 但是！只限于**单行简单拼接，循环内不会优化！**

java.lang.Math

Math.PI    //圆周率 π ≈ 3.1415926535...
Math.E     //自然常数 e ≈ 2.71828...

double num = Math.abs(-10);

Math.abs(-5);        //int 绝对值 → 5
Math.abs(-3.14);     //double 绝对值 →3.14

Math.max(10,20);     //返回较大值 20
Math.min(10,20);     //返回较小值 10
//支持int long float double

//1.四舍五入 → long
Math.round(3.4);   //3
Math.round(3.5);   //4

//2.向上取整（天花板），返回double
Math.ceil(3.1);    //4.0
Math.ceil(-3.1);   //-3.0

//3.向下取整（地板），返回double
Math.floor(3.9);   //3.0
Math.floor(-3.1);  //-4.0

Math.pow(2,3);    //2^3 = 8.0  参数、返回值都是double
Math.sqrt(16);    //平方根 √16 =4.0

Math.random(); 
// 返回 [0.0 , 1.0) 之间的随机小数，包含0.0，不包含1.0

// 范围 [min,max]
int num = (int)(Math.random() * (max - min + 1)) + min;

//示例：1~10随机整数
int r = (int)(Math.random() * 10) + 1;

Math.sin(弧度);
Math.cos(弧度);
Math.tan(弧度);
Math.toRadians(角度); //角度 → 弧度
Math.toDegrees(弧度); //弧度 → 角度

double d = Math.ceil(2.2); //d=3.0 是小数类型，不是int

import java.util.Arrays;

int[] arr = {1,3,2};
System.out.println(Arrays.toString(arr));
//输出：[1, 3, 2]

int[][] arr2 = {{1,2},{3,4}};
System.out.println(Arrays.deepToString(arr2));

int[] arr = {5,2,9,1};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 5, 9]

Integer[] arr = {5,2,9,1};
//降序
Arrays.sort(arr, (a,b)->b-a);

int[] arr = {1,2,5,9};
int index = Arrays.binarySearch(arr,5); //返回2
int index2 = Arrays.binarySearch(arr,3); //找不到，返回负数

copyOf (数组，新长度)

int[] old = {1,2,3};
int[] newArr = Arrays.copyOf(old,5);
// [1,2,3,0,0]

int[] arr = {10,20,30,40};
int[] sub = Arrays.copyOfRange(arr,1,3);
// [20,30]

int[] arr = new int[5];
Arrays.fill(arr,8); //全部填充8
// [8,8,8,8,8]

Arrays.fill(arr,1,3,6); //下标1~2填充6

int[] a = {1,2,3};
int[] b = {1,2,3};
System.out.println(Arrays.equals(a,b)); //true

Integer[] nums = {1,2,3};
List<Integer> list = Arrays.asList(nums);

java.lang.System

// 标准输入流：控制台键盘输入
public static final InputStream in;
// 标准输出流：控制台打印（常用 System.out.println()）
public static final PrintStream out;
// 标准错误输出流：红色字体输出，优先打印，不受输出缓冲区控制
public static final PrintStream err;

public static void arraycopy(
Object src,     //源数组
int srcPos,     //源数组起始索引
Object dest,    //目标数组
int destPos,    //目标数组起始索引
int length      //复制元素个数
)

int[] a = {10,20,30,40,50};
int[] b = new int[5];
System.arraycopy(a,1,b,0,3);
// b = [20,30,40,0,0]

// 当前时间毫秒数：从【1970-01-01 00:00:00 UTC】到现在的毫秒
long time1 = System.currentTimeMillis();

// JDK1.8新增：纳秒！用于计算代码执行耗时，不代表系统日期
long time2 = System.nanoTime();

long start = System.currentTimeMillis();
//执行代码...
long end = System.currentTimeMillis();
System.out.println("耗时："+(end-start)+"ms");

System.exit(0);  //正常退出
System.exit(1);  //异常退出，非0代表程序异常终止

System.gc();

// 获取单个系统属性
String path = System.getProperty("user.dir"); //当前项目工作目录
String os = System.getProperty("os.name");    //操作系统名称

//获取环境变量
String javaHome = System.getenv("JAVA_HOME");

//把输出写入文件，不再打印控制台
System.setOut(new PrintStream("log.txt"));

System.out.println(0.1 + 0.2);
//输出 0.30000000000000004，不是0.3

//方式1：字符串构造【推荐】
BigInteger num1 = new BigInteger("12345678901234567890");

//方式2：long转（数值不能超过long范围）
BigInteger num2 = BigInteger.valueOf(100);

BigInteger a = new BigInteger("20");
BigInteger b = new BigInteger("7");

a.add(b);      //加法 a+b
a.subtract(b); //减法 a-b
a.multiply(b); //乘法 a*b
a.divide(b);   //除法（整除，不能有余数，否则报错）
a.remainder(b);//取余数
a.mod(b);      //模运算

a.abs();       //绝对值
a.max(b);      //最大值
a.min(b);      //最小值

BigInteger[] res = a.divideAndRemainder(b);
res[0] 商，res[1]余数

// 不推荐！double构造依然存在精度损失
BigDecimal num = new BigDecimal(0.1);

// 推荐两种写法
BigDecimal num1 = new BigDecimal("0.1");    //字符串构造
BigDecimal num2 = BigDecimal.valueOf(0.1);   //valueOf底层自动转字符串

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");

a.add(b);        //加
a.subtract(b);   //减
a.multiply(b);   //乘

// 除法极易报错！除不尽会抛出 ArithmeticException
a.divide(b);

BigDecimal a = new BigDecimal("10");
BigDecimal b = new BigDecimal("3");
//保留2位小数，四舍五入
a.divide(b,2,BigDecimal.ROUND_HALF_UP);

BigDecimal d1 = new BigDecimal("2.0");
BigDecimal d2 = new BigDecimal("2.00");
System.out.println(d1.equals(d2)); //false！位数不同

// 返回值：
// 0 相等  >0 当前数大  <0 当前数小
if(d1.compareTo(d2) == 0){
    System.out.println("数值相等");
}

bd.setScale(2,BigDecimal.ROUND_HALF_UP); //保留2位小数

//错误写法
bd.add(xxx); //结果丢失，原对象不变
//正确
bd = bd.add(xxx);

// 当前系统时间
Date date = new Date();
// 指定毫秒时间戳构造
Date date2 = new Date(1750000000000L);

// 获取时间戳毫秒
long time = date.getTime();
// 设置时间戳
date.setTime(1750000000000L);

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// Date → 字符串
String str = sdf.format(new Date());
// 字符串 → Date
Date date = sdf.parse("2026-07-28 12:30:00");

Calendar cal = Calendar.getInstance();
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH); // 依旧 0代表一月！
int day = cal.get(Calendar.DAY_OF_MONTH);

// 设置日期
cal.set(2026,6,28);
Date date = cal.getTime(); //Calendar转Date

// 获取当前时间
LocalDate nowDate = LocalDate.now();
LocalTime nowTime = LocalTime.now();
LocalDateTime nowDT = LocalDateTime.now();

// 指定时间创建
LocalDate date = LocalDate.of(2026,7,28);
LocalDateTime dt = LocalDateTime.of(2026,7,28,14,30);

// Instant 时间戳
Instant instant = Instant.now();
// 时间戳转Instant
Instant instant2 = Instant.ofEpochMilli(1750000000000L);

LocalDateTime time = LocalDateTime.now();

time.plusDays(3);    //加3天
time.minusHours(2);  //减2小时
time.plusMonths(1);  //加1月

// 获取单独字段
int month = time.getMonthValue(); //月份1~12（正常！不再从0开始）
int day = time.getDayOfMonth();

// 修改指定字段
time.withYear(2027);

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime now = LocalDateTime.now();

//时间 → 字符串
String str = now.format(formatter);
//字符串 → 时间
LocalDateTime dt = LocalDateTime.parse("2026-07-28 15:20:00",formatter);

// 时分秒间隔（LocalDateTime / Instant）
LocalDateTime t1 = LocalDateTime.of(2026,7,28,10,0);
LocalDateTime t2 = LocalDateTime.of(2026,7,28,12,30);
Duration duration = Duration.between(t1,t2);
System.out.println(duration.toHours()); //相差小时

// 年月日间隔（仅LocalDate）
LocalDate d1 = LocalDate.of(2026,1,1);
LocalDate d2 = LocalDate.of(2026,7,28);
Period period = Period.between(d1,d2);
period.getMonths();

// LocalDateTime ↔ Date
//1. LocalDateTime -> Date
Instant instant = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant();
Date date = Date.from(instant);

//2. Date -> LocalDateTime
LocalDateTime ldt = new Date().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();