常用API

kkwlgs

已于 2024-06-28 10:56:13 修改

阅读量570

点赞数 8

文章标签： java

于 2024-04-04 19:22:55 首次发布

本文链接：https://blog.csdn.net/2301_78248948/article/details/137370900

版权

Object类

Class Object是类Object结构的根。每个班都有Object作为超类。所有对象（包括数组）都实现了这个类的方法。

直接打印对象的名字.其实就是调用对象的toString方法
String s1 = new String("aaaaa");
System.out.println(s1);//==System.out.println(s1.toString);

重写toString方法

在一些自定义类中jdk没有给我们重写toString方法打印出来的对象的地址,为了解决这一问题就需要自己重写toString方法

public class TestPerson {
    public static void main(String[] args) {
        /*
        Person类默认继承了Object类,所以可以使用Object类中的toString方法
        String toString() 返回该方法的字符串表示
         */

        Person p =new Person("张三",20);
        /*
        输出一个对象,凡是对象在内存中储存,是不能输出的,
        只能把对象信息以字符串的形式输出
        当输出一个对象时,会默认调用此对象的toString(),

        如果类中没有定义toString(),会调用Object类中的toString(),
        Object类中的toString(),是把对象在内存中的哈希值返回(以16进制)也就是打印对象的地址


        我们自己类中可以对Object类中的tiString进行重写,后面调用时,就调用我们自己类的toString()
         */
        String s = p.toString();
        System.out.println(s);//Person{name='张三', age=20}
        //直接打印对象的名字.其实就是调用对象的toString方法
        System.out.println(p);//Person{name='张三', age=20}
    }
public class Person extends Object{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person(){

    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

重写equals方法

自定义类默认继承的是Object类,所以使用Object类的equals方法

==和equals的区别

 ==比较等号两边是否相等
当==用于基本类型比较时，比较的是变最值是否相等
当==开于引用类型比较时,比较的是对象的地址是否相等

boolean equals(object obj) 判断两个对象是否相等
Object类中的equals
  public boolean equals(object obj){
       return(this == obj):默认比较的是两个对象的地址是否相等
       }

一般都重写了equals(),把它改造为比较对象中的内容是否相等

public class TestPersom2 {
    public static void main(String[] args) {
       
        int a=10;
        int b=10;
        System.out.println(a==b);
       
        Person p1= new Person("张三",14);
        Person p2 = new Person("张三",14);

        System.out.println(p1.equals(p2));//true
        //System.out.println(p1==p2);//比较对象地址

        String s1 = new String("aaaaa");
        String s2 = new String("aaaaa");
        System.out.println(s1.equals(s2));//true
    }
}
public class Person extends Object{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person(){

    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /*
    问题:
    隐含着一个多态问题
    Object obj =new Person("张三",20);
    多态弊端:无法使用子类特有的内容(方法,属性)
    解决:可以使用向下转型(强转)把Object类型转换为Person
     */
    @Override
    public boolean equals(Object obj) {
       /* //使用向下转型(强转)把Object类型转换为Person
        Person p = (Person)obj;
        //比较连个对象的属性;一个是调用方法的this(p1),一个就是p(obj=p2)
        boolean b = this.name.equals(p.name)&&this.age== p.age;
        return b;*/
        if (obj instanceof Person) {
            Person other = (Person) obj;
            return this.name.equals(other.name) && this.age == other.age;
        }
        return false;
    }
}

Date类

java.until.Date:表示日期和时间类
类 Date 表示特定的瞬间,精确到毫秒.
毫米:千分之一秒 1000毫秒=1秒
特定的瞬间:一个时间点,一霎那的时间

毫秒值的作用:可以对时间和日期进行计算
2099-01-03 到2088-04-01中间一共有多少天
可以将日期转为毫秒进行计算,计算完毕,在把毫秒值转换为日期

毫秒值的作用:可以对时间和日期进行计算
2099-01-03 到2088-04-01中间一共有多少天
可以将日期转为毫秒进行计算,计算完毕,在把毫秒值转换为日期

把日期转换为毫秒:
    当前日期:2008-01-01
    事件原点(0毫秒):1970年1月1日 00:00:00(英国格林威治)
    就是计算当时日期到时间原点之间一共经历了多少毫秒

注意:
    中国属于东八区, 会把时间增加8个小时
    1970年1月1日 08:00:00

把毫秒转换为日期:
     1天 = 24 * 60 * 60 = 86400 * 1000 = 8640000毫秒

import java.util.Date;

public class DataDemo {
    public static void main(String[] args) {
        demo1();
    }
    public static void demo1(){

        /*
        Date的无参构造方法:
          Date()获取的就是当前系统的日期和时间
         */

        Date date1 = new Date();//Thu Apr 04 12:40:26 CST 2024
        System.out.println(date1);
    }
}

public class DataDemo {
    public static void main(String[] args) {
        demo2();
    }
    public static void demo2(){

        /*
        Date类的有参构造方法:
          Date(long date) : 传递毫秒值,把毫秒转化为Date日期
         */
        Date date2 = new Date(1708843288519L);//将指定的long类型的时间戳构造出一个时间对象
        System.out.println(date2);//Sun Feb 25 14:41:28 CST 2024

        Date date = new Date(0L);
        System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
    }
}

DateFormatDemo类

java.text.DateFormat:是日期/时间格式化子类的抽象类

作用:

格式化(日期 -> 文本) , 解析(文本 -> 日期)

成员方法:

String format(Date date) 按照指定的模式,把date日期格式化为符合模式的字符串

Date parse(String source) 把符合模式的字符串解析为Date日期

DateFormat类是一个抽象类,无法直接创建对象使用,可以使用DateFormat的子类-->SimpleDateFormat

构造方法:

SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造

参数:

String pattern:传递指定的模式

模式:

区分大小写的

y 年

M 月

d 日

H 时

m 分

s 秒

写对应的模式,会把模式替换为对应的日期和时间

" yyyy-MM-dd HH:mm:ss"

"yyyy年MM月dd日 HH时mm分ss秒"

注意:

模式中的字母不能更改,链接模式的符号可以改变

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        /*
        把字符串日期转为Date对象
         */
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse("2024年04月04日 16时26分24秒");
        System.out.println(date);//Thu Apr 04 00:00:00 CST 2024

        /*
        把日期的对象转为指定格式的字符串
         */
        Date date1 = new Date();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");//2024年02月25日 15:31:04 星期日  HH:mm:ss E
        String s1 = sdf1.format(date1);
        System.out.println(s1);//2024年04月04日 16时26分24秒
        System.out.println(date1);//Thu Apr 04 16:25:15 CST 2024
    }
}

Calendar类

java.util.Calendar类:日历类

Calendar类是一个抽象类,里边提供了许多操作日历的旧字段的方法(YEAR,MONTH)

Calendar类无法直接创建对象使用,里边有一个静态方法叫做 getInstance(), 该方法返回了Calendar类的子类对象

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();//多态
        //System.out.println(calendar);
        calendar.set(2024,3,11);

        demo();
        demo2();
    }

    private static void demo2() {
        //直接用set方法 set(int year, int month, int date)设置时间
        Calendar c = Calendar.getInstance();
        c.set(2024,4,4);
 int year = c.get(Calendar.YEAR);
        System.out.println(year);
        int month = c.get(Calendar.MONTH);
        System.out.println(month);
        int day = c.get(Calendar.DATE);
        System.out.println(day);
    }

    /*
    public void set(int field,int vaule) 将给定的如理字段设置为给定值
       参数:
            int field:传递指定的日历字段
            int vaule:传递的字段设置就提的值
     */
    public static void demo() {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR,2024);
        int year = c.get(Calendar.YEAR);
        System.out.println(year);
        c.set(Calendar.MONTH,4);
        int month = c.get(Calendar.MONTH);
        System.out.println(month);
        c.set(Calendar.DATE,4);
        int day = c.get(Calendar.DATE);
        System.out.println(day);
    }
}

Math类

java.util.Math是数学相关的工具类,里面提供了大量的静态方法,完成与数学运算相关的操作

public class MathDemo {
    public static void main(String[] args) {
        /*
       abs 绝对值
       sqrt 平方根
       pow(double a, double b) a的b次幂
       max(double a, double b)
       min(double a, double b)
       random() 返回 0.0 到 1.0 的随机数
       long round(double a) double型的数据a转换为long型五入）
         */


        System.out.println(Math.floor(9.9));//9  ---向下取整
        System.out.println(Math.ceil(9.1));//10  ----向上取整
        System.out.println(Math.round(9.5));//四舍五入
        System.out.println(Math.random());//返回0-1之间的随机数,可能会等于0,一定小于1

    }
}

Random类

Random类用来生成随机数

import java.util.Arrays;
import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();//在true和false之间随机返回一个
        System.out.println(random.nextBoolean());
        System.out.println(random.nextInt());//在int的取值范围内随机返回一个整数
        System.out.println(random.nextInt(5));//在给定的范围内,随机获取一个数,0=<res<小于给定的数

        byte[] bytes = new byte[5];
        random.nextBytes(bytes);//随机取出数组长度哥byte类型的随机数
        System.out.println(Arrays.toString(bytes));


    }
}

String类

java.lang.String
    java中所有字符串都是此类的实例
    "abc"--->字符串对象   底层是char数组  private final char value[];

1.创建方法:

String s = "abc"; 创建时,先去字符串常量池中查询有没有相同对象,如果没有,就创建一个字符串对象.并返回地址, 如果字符串已经储存,不用创建新的,直接返回已存在对象的地址
String s1 = new String(); new 每次都在堆中创建一个新对象

public class String1 {
    public static void main(String[] args) {
       
        String s = "abc";
        String ss = "abc";
        System.out.println(s==ss);//true

        String s1 = new String("aaa");
        String s2 = new String("aaa");
        System.out.println(s1==s2);//flase
    }
}

字符串可以用过 + 连接起来

//字符串不变;它们的值在创建后不能被更改
        String s= "abcd";//第一个字符串对象
        s+="efg";//第二个字符串对象
        s+="hijk";//第三个字符串对象
        System.out.println(s);

2.构造方法

String()
String(String s)
String(byte[] bytes)把字节数组转化为字符串 s3.getBytes(); 把字符串转为字节数组
String(char []chars)把char数组转为字符串  s4.toCharArray()把字符串转化为字符数组

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class String3 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //无参
        String s1 = new String();
        //有参
        String s2 = new String("aa");
        //字节数组
        String s3 = "你好";
        byte[] bytes = s3.getBytes();//编码  把字符转为字节数组(数字)
        System.out.println(Arrays.toString(bytes));
        
        String s4 = new String(bytes);//解码 把字节数组转为字符
        System.out.println(s4);

        String s4 = "bca";
         char[] chars = s4.toCharArray();//把字符串转为一个字符数组
        System.out.println(chars);
         Arrays.sort(chars);
         String s5 = new String(chars);//把字符数组转为字符串
         System.out.println(s5);

    }
}

3.构造功能

    boolean equals(0bject obj)比较字符申对象中内容是否相等
    boolean equalsIgnorecase(String str)比较字符串对象中内容是否相等 忽略大小写
    boolean contains(string str) 判断字符串是否包含指定的子串
    boolean isEmpty() 判断字符串是否为"",不是null
    boolean startsWith(string prefix) 判断是否以指定的字符串开头
    boolean endsWith(string suffix)  判断是否以指定的字符串开结尾

public class String4 {
    public static void main(String[] args) {
         
        String s1= new String("abced");
        String s2 = new String("abcde");
        String s3 = new String("");
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//false

        System.out.println(s1.contains("abc"));//true

        System.out.println(s3.isEmpty());//true

        System.out.println(s1.startsWith("a"));//true
        System.out.println(s1.endsWith("e"));//false
    }
}

4.获取功能

     int length() 获取字符串长度
     char charAt(int index) 获取指定位置上的字符
     int indexOf(String str) 返回指定字符串首次出现的位置
     int indexOf(String str,int fromIndex)  从指定的位置开始找,返回指定字符串首次出现的位置
     int lastindexOf(String str) 从后往前
     int lastindexOf(String str,int fromIndex)
     String substring(int start) 从指定的开始位置获取一个字符串副本到完
     String substring(int start,int end) 从指定的开始位置开始截取一个字符串到指定位置(不包括结束位置)

public class String5 {
    public static void main(String[] args) {
        String s1 = new String("abcdefcefg");
                        //下标：0123456789
        System.out.println(s1.charAt(4));//结果：e，获取字符串指定位置上的字符
        System.out.println(s1.indexOf("ef"));//结果：4，返回字符串首次出现的位置
        System.out.println(s1.indexOf("c",4));//结果：6，从指定位置查找，返回字符串首次出现的位置
        System.out.println(s1.lastIndexOf("d"));//结果：3，从后向前查找，返回字符串首次出现的位置
        System.out.println(s1.substring(4));//结果：efcefg，从指定位置开始截取一个字符串的副本到完
        System.out.println(s1.substring(4,7));//结果：fc，从指定位置开始截取一个字符串的副本到指定的位置结束（不包含指定位置）
        s1.length();//获取字符串的长度
    }
}

5.转换功能

 byte[] getBytes()  将字符串转为byte数组
 char[] toCharArray() 将字符串转为字符数组
 static String valueOf(char[] chs)
  static String valueOf(int a) 将转入的参数转为字符串类型
 String toLowerCase() 将英文字母全部传为小写
 String toUpperCase() 全部转为大写
 String concat(String str) 拼接指定的字符串内容到原字符串末尾,并返回一个新字符串
 Stirng[] split(分割符); 将一个字符串用指定的分隔符拆分成一个字符串数组

public class String6 {
    public static void main(String[] args) {
        String s1=new String("abcddfgs");
        System.out.println(Arrays.toString(s1.getBytes()));//结果：[97, 98, 99, 100, 100, 102, 103, 115]，将字符串转为字节数组
        System.out.println(Arrays.toString(s1.toCharArray()));//结果：[a, b, c, d, d, f, g, s]，将字符串转为字符数组
 
        String s2=String.valueOf(1234);
        System.out.println(s2);//结果：1234，将传入的参数转为字符串类型
        System.out.println(s2.charAt(3));//结果：4，将返回传入的参数作为下标的字符
 
        String s3=String.valueOf("abc2".toCharArray());
        System.out.println(s3);//结果：abc2，将传入的字符串用toCharArray转为字符数组，然后将字符数组转为字符串类型
 
        String s4="abcEDF";
        System.out.println(s4.toLowerCase());//结果：abcedf，将字符串中的英文字母全部改成小写
        System.out.println(s4.toUpperCase());//结果：ABCEDF，将字符串中的英文字母全部改成大写
 
        String s5="a3;b2;c4";
        System.out.println(s5.concat(";"));//结果a3;b2;c4;，拼接指定的字符串内容到原来的字符串末尾，返回一个新的字符串
 
        String[] strings=s5.split(";");//分隔符，将字符串用指定的分隔符，拆分成一个个字符串存入一个新的字符串数组中并返回
        System.out.println(Arrays.toString(strings));//结果：[a3, b2, c4]
    }
 
}

6.替换功能

 String replace(char old,char new)   用新内容替换字符串中的指定字符
 String replace(String old,String new)  用新内容替换字符串中的指定字符
 replaceAll(String regex, String replacement) 用新内容替换被字符串中的正则表达式匹配的字符串
 replaceFirst(String regex, String replacement) 用新内容替换字符串中正则表达式匹配的字符串,只替换第一个
 String trim()     去除字符串两空格

public class String7 {
    public static void main(String[] args) {
        String s1=new String(" a4b3c5ed4 ");
 
        System.out.println(s1.replace('a','b'));//结果：b4b3c5ed4 ，用新内容替换字符串中指定的字符串
        System.out.println(s1.replace("3","4"));//结果：a4b4c5ed4
 
        System.out.println(s1.replaceAll("4","1"));//结果：a1b3c5ed1 ，用新内容替换字符串中正则表达式匹配的字符串
        System.out.println(s1.replaceAll("\\d","t"));//结果：atbtctedt ，用新内容替换字符串中正则表达式匹配的字符串（所有数字）。
        System.out.println(s1.replaceFirst("4","0"));//结果：a0b3c5ed4 ，用新内容替换字符串中正则表达式匹配的字符串，只能替换第一个
        System.out.println(s1.replaceFirst("\\d","c"));//结果：acb3c5ed4 ，用新内容替换字符串中正则表达式匹配的字符串（\d指数字），只能替换第一个
 
        System.out.println(s1.length());//11，获取字符串的长度
        System.out.println(s1.trim().length());//结果：9，去除字符串两端的空格
 
    }
}

正则表达式

概念:

正则表达式(Regular Expression 简称regex) 正则表达式是一种规则(模式)匹配语法, 可以使他一些正则表达式中定义的特殊符号来定义一种规则,然后用子规则去撇皮,某个字符,.

如果字符串与规则相匹配返回true,否则返回false.

public class RegExDemo1 {
    public static void main(String[] args) {
        //匹配手机号
        String s ="15229005823";

        //System.out.println(s.matches("[0-9]*"));//[0-9]* 允许出现一次或多次数字
        //System.out.println(s.matches("[0-9]+"));[0-9]+ 允许出现至少一次
        //System.out.println(s.matches("1 [0-9]{3}"));[0-9]{3}只能是n次数字
        //System.out.println(s.matches("[0-9]{3}"));[0-9]{3}至少n次数字
        //System.out.println(s.matches("[0-9]{3,6}"));至少n次,不大于m次
        //System.out.println(s.matches("[1-9]{3,6}"));
        //System.out.println(s.matches("[357]{3}"));
        //System.out.println(s.matches("\\d{3,6}"));\\d  == [0-9]匹配数字   \\D匹配非数字
        System.out.println(s.matches("1[357]\\d{9}"));//判断是否匹配手机号
        System.out.println(s.matches("[1-9]\\d{4,11}"));//判断是否数字位数在5-12之间

    }
}

StringBuffer

String声明的字符串对象值一旦给定就不能被改变了。那我们在每次拼接的时候都会创建新的字符串对象，既耗时又占用空间。这里Java就创建了一个新的类.

1.特点:

字符串缓冲区,可以提高字符串的操作效率,底层也是一个数组,但是没有别final修饰,可以改变长度
StringBuffer在内存中始终是一个数组,占用空间少,效率高,如果超出范围会自动扩容.

2.创建对象
构造方法

public StringBuffer( ) //空参

public StringBuffer(String str) //有参

//空参的构造方法中默认指定：底层数组的长度是16
StringBuffer s = new StringBuffer();
//当然我们也可以指定数组的容量
StringBuffer s2 = new StringBuffer(10);

//有参的构造方法中默认数组长度：内容长度+16

StringBuffer s=new StringBuffer("abcdefg");
public class StringBuffer1 {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();//空参的构造方法 指定底层数组的长度是16
        StringBuffer s=new StringBuffer("abcdefg");//创建 内容长度+16的char数组
        StringBuffer s2 = new StringBuffer(10);//指定数组的容量
        
        System.out.println(s);
    }
}

3、添加功能

public StringBuffer append(String str)//在原字符串后添加字符串

public StringBuffer insert(int offset,String str)//向指定位置上插入指定的字符串

4、删除功能

public StringBuffer deleteCharAt(int index)//删除指定位置上的字符

public StringBuffer delete(int start,int end)//删除指定区间上的字符，包含开始位置，不包含结束位置

5、替换功能

public StringBuffer replace(int start,int end,String str)//替换指定区间上的字符串，包含开始位置，不包含结束位置。

6、反转功能

public StringBuffer reverse()//反转字符

7、截取功能

public String substring(int start)//从当前位置截取字符

public String substring(int start,int end)//从当前位置截取字符串，包含开始，不包含结尾。

注意：截取字符串时，从StringBuffer中截取一个字符串副本，返回一个新的String类型对象，StringBuffer本身的对象不变。

public class StringBuffer1 {
    public static void main(String[] args) {
        //创建对象
        StringBuffer s1 = new StringBuffer();//空参的构造方法16 指定底层数组的长度是16
        StringBuffer s=new StringBuffer("abcdefg");//创建 内容长度+16的char数
组
        StringBuffer s1 = new StringBuffer(10);
                     s1.append("efg");
                     s1.append("efg");
                     s1.append("efggg");

        System.out.println(s1.insert(1, "H"));//向指定位置上插入指定的字符串
        System.out.println(s1.deleteCharAt(1));//删除指定位置上的字符
        System.out.println(s1.delete(0, 3));//删除指定区间上的字符，包含开始位置，不包含结尾
        System.out.println(s1.replace(0, 3, "QQQ"));
        System.out.println(s1.reverse());//反转字符

        String s2 =  s1.substring(0,5);//截取字符串,从StrongBuffer中截取一个字符串副本,返回一个新的String对象
        System.out.println(s2);

 
    }
 
}

StringBuilder

String :是一个值不可以改变的字符串
StringBuilder:值可以改变,且不需要创建新对象,由于方法上都没有加锁,在多线程执行时是线程不安全的,蛇和单线程
StringBuffer:值可以改变,且不需要创建新对象,方法上都加了锁,是多线程(任务),执行时是线程安全的

构造方法

BigInteger(byte[] val)
　　　　将包含 BigInteger 的二进制补码表示形式的 byte 数组转换为 BigInteger。
BigInteger(int signum, byte[] magnitude)
　　　　将 BigInteger 的符号-数量表示形式转换为 BigInteger。

BIgInteger类

BigInteger类位于java.math包中。

在java中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。

BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息.

import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {
        BigInteger bigInteger = new BigInteger("111111111111111111111111111");
        BigInteger bigInteger1 = new BigInteger("99999999999999999999999999999");

        BigInteger bigInteger2 = bigInteger.multiply(bigInteger1);
        System.out.println(bigInteger2);
    }
}

BigDecimal类

BigDecimal是Java中用于高精度计算的类，它可以处理任意精度的整数和小数。在Java中，使用double或float进行浮点数计算时可能会遇到精度丢失的问题，而BigDecimal可以避免这种问题。

下面是BigDecimal类的一些重要特性和用法：

1. 精度控制：BigDecimal允许你控制数字的精度，包括小数位数和舍入方式。可以使用setScale()方法设置小数位数，使用setRoundingMode()方法设置舍入模式。

2. 精确计算：`BigDecimal`可以准确表示和计算大数字和小数，而不会丢失精度。

3. 字符串转换：`BigDecimal`提供了丰富的构造函数，可以从字符串中创建`BigDecimal`对象，这对于需要处理精确数字的场景非常有用。

4. 常见运算：BigDecimal`支持加减乘除等基本运算，并提供了方法来处理除法中的舍入方式和精度控制。

5. 比较和判断：BigDecimal提供了compareTo()方法来比较两个BigDecimal对象的大小，并且提供了equals()方法来判断两个BigDecimal对象是否相等。

6. 线程安全：BigDecimal是线程安全的，可以在多线程环境中安全地使用。

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal num1 = new BigDecimal("10.25");
        BigDecimal num2 = new BigDecimal("20.50");

        // 加法
        BigDecimal sum = num1.add(num2);
        System.out.println("Sum: " + sum); // Sum: 30.75

        // 减法
        BigDecimal difference = num2.subtract(num1);
        System.out.println("Difference: " + difference); // Difference: 10.25

        // 乘法
        BigDecimal product = num1.multiply(num2);
        System.out.println("Product: " + product); // Product: 209.125

        // 除法
        BigDecimal quotient = num2.divide(num1, 2, BigDecimal.ROUND_HALF_UP);
        System.out.println("Quotient: " + quotient); // Quotient: 2.00
    }
}

基本数据类型包装类

基本数据类型（如int、double等）是Java中的基础数据类型，用于存储简单的数值或布尔值。但是，有时候我们需要在程序中进行更复杂的操作，这时引入基本数据类型的包装类会更有帮助。

引用基本数据类型包装类的主要原因是它们提供了更多的功能和灵活性，包括：
1. 可以将基本数据类型转换为对象，方便在需要对象的地方使用。
2. 可以表示空值（null），而基本数据类型不能表示空值。
3. 提供了一些常用的方法，如类型转换、常量等。

Integer类

1.成员变量

(1)public static final int MAX_VALUE：int 类型能够表示的最大值

(2)public static final int MIN_VALUE：int 类型能够表示的最小值

public class IntegerDemo {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);//最大值2147483647
        System.out.println(Integer.MIN_VALUE);//最小值-2147483648
        System.out.println(Integer.SIZE);//32
        System.out.println(Integer.BYTES);//4
   }
}

2.构造方法：

(1)public Integer(int value)。

(2)public Integer(String s)注意：这个字符串必须是由数字字符组成。

public class IntegerDemo {
    public static void main(String[] args) {
       
        //构造Integer对象，里面包装了一个基本类型的值，用该对象表示一个int值
        Integer a = new Integer(8);
        Integer b = new Integer("4");
 
        System.out.println(a);
        System.out.println(b);

3. 静态方法

System.out.println(Integer.toHexString(17));
System.out.println(Integer.toBinaryString(17));
System.out.println(Integer.max(10,5));
System.out.println(Integer.compare(10,5));//两个整数比较大小  小于-1 等于0  大于 1

public class IntegerDemo {
    public static void main(String[] args) {
        //构造Integer对象，里面包装了一个基本类型的值，用该对象表示一个int值
        Integer a = new Integer(8);
        Integer b = new Integer("4");
 
        System.out.println(a);
        System.out.println(b);
 
        //一类是静态方法：（拿Integer包装类型直接）
        System.out.println(Integer.toHexString(17));
        System.out.println(Integer.toOctalString(22));
        System.out.println(Integer.toBinaryString(23));
        System.out.println(Integer.max(a, b));
        System.out.println(Integer.compare(a, b));//1,0,-1
    }
}

4.非静态方法

用new关键字创建出来的对象，实例化。
a.equals(b)//判断a和b的内容是否相等
b.compareTo(a)//比较大小，b>a,返回1;b<a,返回-1;b=a,返回0;

public class IntegerDemo {
    public static void main(String[] args) {
 
        //构造Integer对象，里面包装了一个基本类型的值，用该对象表示一个int值
        Integer a = new Integer(8);
        Integer b = new Integer("4");
 
        //二类是非静态方法（拿new出来的对象来实例化)
        System.out.println(a.equals(b));//是否相等 false
        System.out.println(b.compareTo(a));//比较大小，小：-1，大：1，相等：0
   }
}

5.装箱

概念:

自动装箱（Autoboxing）是指Java编译器在需要时自动将基本数据类型转换为对应的包装类对象，反之亦然。这样可以让我们在使用基本数据类型和包装类对象时更加方便，不需要显式地进行类型转换。

注意:自动装箱时,会默认调用Vaulueof()方法
在valueof()方法中,如果基本类型的值在-128---127之间,会从缓存数组中直接取出一个Integer对象,减少创建次数
如果两个值相同,获取的是同一个对象,
基本类型如果不在这个区间,每次都创建以后个新Integer对象

自动装箱:吧基本类型转为引用类型
if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];

 int x = 128;
        Integer yy = Integer.valueOf(x);
        Integer y = x;//自动装箱 会默认调用Vaulueof()方法
        Integer z= x;
        System.out.println(y==z);//false
        System.out.println(y.equals(z));//true
        System.out.println(yy);//128

6.拆箱

自动拆箱（Unboxing）是指Java编译器在需要时自动将包装类对象转换为对应的基本数据类型的过程。它发生在以下情况下：

1. 将包装类对象赋值给对应的基本数据类型。
2. 将包装类对象作为参数传递给需要基本数据类型的方法。
3. 将包装类对象与基本数据类型进行比较。

举例来说，当你这样赋值时：
Integer integer = 10;
int i = integer; // 自动拆箱

实际上，编译器会将它转换为：

int i = integer.intValue();

类似地，如果你这样传递参数：

public void processInt(int value) {
// 处理int值
}

Integer integer = 20;
processInt(integer); // 自动拆箱

编译器会将其转换为：

processInt(integer.intValue());

自动拆箱也是在编译期间完成的，而不是在运行时。它不会影响程序的性能，但同样也可能导致意外的行为，尤其是在需要进行比较时。因为比较的是基本数据类型的值，而不是对象的引用。

 

Integer a = new Integer(10);//构造一个Integer对象,里面包含一个基本数据类型,用该对象表示一个int值
int b = new Integer("20");
int c = a.intValue();
int d= a;//自动拆箱,会默认自动的调用intValue()方法