[Java知识库]java中的常用类。包装类，Math类，String类，Date类，Calendar类，BigDecimal类详细汇总

Java中的几个常用类

枚举

• 枚举指由一组固定的常量组成的类型
• 关键字：enum
• 枚举里可以有方法和属性，但一般不用

public enum Ennum {
    L1,L2,L3
}

public class Application {
    public static void main(String[] args) {
        Application application = new Application();
        application.target(Ennum.L2);
        Ennum[] values = Ennum.values();  // 返回枚举类型的对象数组
        for (int i = 0; i < values.length; i++) {
            System.out.print(values[i]+"\t");
        }
    }
    public void target(Ennum a){
        switch (a){
            case L1:
                System.out.println("枚举类型一");
                break;
            case L2:
                System.out.println("枚举类型二");
                break;
            case L3:
                System.out.println("枚举类型三");
                break;
        }
    }
}
结果
枚举类型二
L1	L2	L3

包装类

• 包装类把基本数据类型转换为对象
• 每个基本类型在java.lang包中都有一个相应的包装类
• 作用
  • 提供了一系列实用的方法
  • 集合不允许存放基本数据类型，可以转换为包装类型（JDK1.5以后自动拆箱和装箱）
    

包装类的构造方法

1. 所有包装类都有的构造方法：将与之对应的基本数据类型做参数
2. 除Character之外的包装类都有的构造方法：将字符串做参数

public class Application {
    public static void main(String[] args) {
        // 所有包装类都有的构造方法：将与之对应的基本数据类型做参数
        Integer integer = new Integer(1);
        Boolean aBoolean = new Boolean(true);
        Character a = new Character('A');
        Float aFloat = new Float(5.6F);
        Double aDouble = new Double(8.5);
        System.out.println(integer+"\t"+aBoolean+"\t"+a+"\t"+aFloat+"\t"+aDouble);
        System.out.println(a instanceof Character);
        // 除Character之外的包装类都有的构造方法：将字符串做参数
        Integer integer1 = new Integer("100");
        Boolean aFalse = new Boolean("world");  // 值为false
        Boolean aTrue = new Boolean("true");   // 只有当字符串为true时才返回true，其余均为false
        Float aFloat1 = new Float("8.6F");
        Double aDouble1 = new Double("5.8");
        System.out.println(integer1+"\t"+aFalse+"\t"+aTrue+"\t"+aFloat1+"\t"+aDouble1);
        System.out.println(integer1 instanceof Integer);
    }
}
结果
1	true	A	5.6	8.5
true
100	false	true	8.6	5.8
true

注意：

1. Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则为false
2. 当包装类构造方法参数为String类型时，字符串不能为null，且该字符串必须可解析为当前的基本数据类型的数据，否则编译不通过，运行时NumberFormatException异常

包装类的常用方法

• 包装类转基本数据类型:xxxValue(); ==> 所有类型都有

public class Test {
    public static void main(String[] args) {
        int num = 10;
        int i = new Integer(num).intValue();
        boolean b = new Boolean(true).booleanValue();
        char a = new Character('A').charValue();
        float v = new Float(5.6F).floatValue();
        System.out.println(i+"\t"+b+"\t"+a+"\t"+v);
    }
}
结果
10	true	A	5.6

• 基本数据类型转字符串：（1）toString() （2）+""

public class Test2 {
    public static void main(String[] args) {
        int num = 10;
        String s = Integer.toString(num);
        String s1 = 9+"";
        String s2 = Boolean.toString(false);
        String a = Character.toString('中');
        String s3 = Float.toString(5.6F);
        System.out.println(s+"\t"+s1+"\t"+s2+"\t"+a+"\t"+s3);
    }
}
结果
10	9	false	中	5.6

• 字符串转包装类：ValueOf() ==>（Character除外）

public class Test3 {
    public static void main(String[] args) {
        String num = "10";
        Integer integer = Integer.valueOf(num);
        Boolean aFalse = Boolean.valueOf("false");
        Float aFloat = Float.valueOf("8.9");
        Double aDouble = Double.valueOf("5.2");
        System.out.println(integer+"\t"+aFalse+"\t"+aFloat+"\t"+aDouble);
    }
}
结果
10	false	8.9	5.2

• 基本数据类型转包装类，所有方法都有

public class Test4 {
    public static void main(String[] args) {
        Integer integer = Integer.valueOf(10);
        Boolean aFalse = Boolean.valueOf(false);
        Float aFloat = Float.valueOf(8.9F);
        Double aDouble = Double.valueOf(5.2);
        String str = String.valueOf("你好");
        System.out.println(integer+"\t"+aFalse+"\t"+aFloat+"\t"+aDouble+"\t"+str);
    }
}
结果
10	false	8.9	5.2	你好

• 字符串转基本数据类型：Character除外

public class Test5 {
    public static void main(String[] args) {
        int i = Integer.parseInt("89");
        boolean world = Boolean.parseBoolean("world");
        boolean aTrue = Boolean.parseBoolean("true");
        float v = Float.parseFloat("8.6");
        System.out.println(i+"\t"+world+"\t"+aTrue+"\t"+v);
    }
}
结果
89	false	true	8.6

• 装箱和拆箱
  • 装箱：基本类型转换为包装类的对象
  • 拆箱：包装类对象转换为基本类型的值

Math类

• abs(int a):绝对值
• ceil(double d):向上取整
• floor(double d):向下取整
• max(int a,int b):最大值
• pow(double a,double b):a的b次幂
• random():随机数[0.0,1.0]
• round(float f):四舍五入
• sqrt(double d):算术平方根

public class Test6 {
    public static void main(String[] args) {
        int abs = Math.abs(-8);
        double ceil = Math.ceil(-5.6);
        double ceil1 = Math.ceil(8.2);
        double floor = Math.floor(8.4);
        double max = Math.max(5.6, 2.8);
        int pow = (int) Math.pow(2, 3);
        int random = (int) (Math.random()*10);   // 生成一个0-9之间的随机数
        long round = Math.round(5.5);
        int sqrt = (int) Math.sqrt(9);
        System.out.println(abs+"\t"+ceil+"\t"+ceil1+"\t"+floor+"\t"+max+"\t"+pow+"\t"+random+"\t"+round+"\t"+sqrt);
    }
}
结果
8	-5.0	9.0	8.0	5.6	8	4	6	3

String类

• 使用String对象存储字符串
• length()方法
  • 确定字符串的长度，返回字符串中的字符数
• equals()方法
  • 检查组成字符串内容的字符是否完全一致

public class Test7 {
    public static void main(String[] args) {
        String s1 = "Hello World!";
        String s2 = new String();
        String s3 = new String("Hello World.");
        System.out.println(s1+"\t"+s2+"\t"+s3);
        System.out.println(s3.length());
        System.out.println(s1.equals("Hello"));
    }
}
结果
Hello World!		Hello World.
12
false

备注：“==”和equals()的区别

1. 比较基本数据类型时

   ? 只能采用"=="，比较的是数值

2. 当比较引用数据类型时

   ? “==” 比较的是引用对象的内存地址;

   ? 而equals分两种情况，如果类没有重写 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象的内存地址；如果类重写了 equals() 方法。那么比较的是两个对象的内容是否相等(一般都重写)；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

• 字符串比较的其他方法
  • equals(Object obj):比较两个字符串是否相等
  • equalsIngnoreCase(Object obj):忽略大小写比较两个字符串是否相等
  • contains(String str):是否包含指定字符串
  • startsWith(String str):是否以指定的字符串开头
  • endWith(String str):是否以指定的字符串结尾
  • isEmpty():是否为空
  • matches(String regex):判断字符串是否匹配给定的正则表达式。

public class Test7 {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "hello";
        System.out.println(s1.equals(s2));
        System.out.println(s1.toLowerCase().equals(s2.toLowerCase()));
        System.out.println(s1.toUpperCase().equals(s2.toUpperCase()));
        System.out.println(s1.equalsIgnoreCase(s2));
    }
}
结果
false
true
true
true

• 字符串连接
  • 方法1：使用“+”
  • 方法2：使用String类的concat()方法

public class Test8 {
    public static void main(String[] args) {
        String s1 = "Hello World!";
        String s2 = "你好世界";
        System.out.println(s1+s2);
        System.out.println(s1.concat(s2));
    }
}
结果
Hello World!你好世界
Hello World!你好世界

字符串常用提取方法

备注：String的所有操作并不影响字符串本身，影响的是字符串的一个副本（String是不可变的）

• 字符串拆分

  将一个字符串分割为子字符串，结果作为字符串数组返回

public class Test9 {
    public static void main(String[] args) {
        String string = "我爱你中国,我爱你北京";
        String[] s = string.split(""); // 空字符串表示每个字符隔开
        int count = 0;
        String c = "爱";
        for (int i = 0; i < s.length; i++) {
            if (s[i].equals(c)){
                count++;
            }
        }
        System.out.println(c+"出现的次数为："+count+"次");
    }
}
结果
爱出现的次数为：2次

StringBuffer类

对字符串频繁修改（如字符串连接）时，使用StringBuffer类可以大大提高程序执行效率。

• StringBuffer声明
  • StringBuffer str1 = new StringBuffer();
  • StringBuffer str2 = new StringBuffer(“aaa”);
• StringBuffer的使用
  • str1.toString(); //转化为String类型
  • str1.append("**"); //追加字符串
  • str1.insert (1, “**”); //在指定位置插入字符串
  • deleteCharAt(int index):删除指定索引处的元素
  • String subString(int start):截取指定位置一直到末尾
  • String subString(int start,int end):截取[start,end-1]范围

备注：StringBuffer不同于String类，它的操作改变的是字符串本身，String的操作改变副本。

扩展：

String、StringBuilder和StringBuffer的区别？

String内容不可改变
StringBuilder和StringBuffer内容可变
StringBuilder是线程不安全的，不同步，效率高
StringBuffer是线程安全的，同步，效率低

Date类

• 操作日期时间：获取系统当前时间，并按指定格式输出。分别在Java.util.Date包和java.text.SimpleDateFormat包。

public class Test9 {
    public static void main(String[] args) {
        //创建日期对象
        Date date = new Date();
        //定制日期格式
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String now = format.format(date);
        System.out.println(now);

    }
}
结果
2022-01-02 22:05:57

Calendar类

用于设置和获取日期/时间数据的特定部分。

public class Test11 {
    public static void main(String[] args) {
        Calendar instance = Calendar.getInstance();
        int i = instance.get(Calendar.YEAR);
        System.out.println(i+"\t"+(instance.get(Calendar.MONTH)+1)+"\t"+instance.get(Calendar.DAY_OF_MONTH));
        System.out.println("今天是一周的第"+instance.get(Calendar.DAY_OF_WEEK)+"天");
    }
}
结果
2022	1	2
今天是一周的第1天

BigDecimal类

用于解决浮点型运算精度损失的问题
1）构造方法

• BigDecimal(String s):通过字符创建BigDecimal对象

2）成员方法

• add(BigDecimal bi):+
• subtract(BigDecimal bi):-
• multiply(BigDecimal bi)😗
• divide(BigDecimal bi)😕

public class Test12 {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1.2");
        BigDecimal b = new BigDecimal("3.6");
        System.out.println("a+b="+a.add(b));
        System.out.println("a-b="+a.subtract(b));
        System.out.println("a*b="+a.multiply(b));
        // 结果四舍五入，保留两位小数
        System.out.println("a/b="+a.divide(b,2,BigDecimal.ROUND_HALF_UP));
    }
}
结果
a+b=4.8
a-b=-2.4
a*b=4.32
a/b=0.33

舍入模式

• ROUND_CEILING //向正无穷方向舍入
• ROUND_DOWN //向零方向舍入
• ROUND_FLOOR //向负无穷方向舍入
• ROUND_HALF_DOWN //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
• ROUND_HALF_EVEN //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用
• ROUND_HALF_UP，如果是偶数，使用ROUND_HALF_DOWN
• ROUND_HALF_UP //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6,也就是我们常说的“四舍五入”
• ROUND_UNNECESSARY //计算结果是精确的，不需要舍入模式
• ROUND_UP //向远离0的方向舍入