常用类

1、包装类

包装类：将基本数据类型对应进行了一个封装，产生了一个新的类，是引用数据类型。集合有个特点只能装引用数据类型的数据，所以需要包装类。

对应关系：

主要记住int和char的基本数据类型的包装类，别的都是首字母大写

基本数据类型	包装类
int	Integer
char	Character

自动装箱、自动拆箱 是从JDK1.5以后新出的特性

 //compareTo：只返回三个值：要么是0,-1,1
        Integer i1 = new Integer(6);
        Integer i2 = new Integer(12);
        System.out.println(i1.compareTo(i2));// return (x < y) ? -1 : ((x == y) ? 0 : 1);
        //equals:Integer对Object中的equals方法进行了重写，比较的是底层封装的那个value的值。
        //Integer对象是通过new关键字创建的对象：
        Integer i3 = new Integer(12);
        Integer i4 = new Integer(12);
        System.out.println(i3 == i4);//false 因为==比较的是两个对象的地址
        boolean flag = i3.equals(i4);
        System.out.println(flag);
        //Integer对象通过自动装箱来完成：
        Integer i5 = 130;
        Integer i6 = 130;
        System.out.println(i5.equals(i6));//true
        System.out.println(i5 == i6);
        /*
        如果自动装箱值在-128~127之间，那么比较的就是具体的数值
        否在，比较的就是对象的地址
         */
        //intValue() :作用将Integer--->int
        Integer i7 = 130;
        int i = i7.intValue();
        System.out.println(i);
        //parseInt(String s) :String--->int:
        int i8 = Integer.parseInt("12");
        System.out.println(i8);
        //toString:Integer--->String
        Integer i10 = 130;
        System.out.println(i10.toString());
    }
   
结果：
-1
false
true
true
false
130
12
130

2、日期相关类

util.Date和sql.Date区别：
util.Date有年月日，时分秒而sql.Date只有年月日
sql.Date和util.Date的联系：
java.sql.Date(子类) extends java.util.Date （父类）

//计算耗时
    public static void couttime(){
    long l1 = System.currentTimeMillis();//获取当前系统时间的毫秒时间
    long l = l1;
        for (int i = 0; i <100000 ; i++) {
        System.out.println(i);
    }
    long l2 = System.currentTimeMillis();
        System.out.println(l2-l1);
    }
    
    public static void demo1() {
        Date sqldate = new Date(System.currentTimeMillis());
        java.util.Date utildate = new java.util.Date(System.currentTimeMillis());
        System.out.println(sqldate);
        System.out.println(utildate);
        //string-》sql
        Date date = Date.valueOf("2021-02-21");//java.sql.Date下的date
        System.out.println(date);
    }
    
    public static void demo2() {
        DateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:ss");
        //date->String
        String format = df.format(new java.util.Date());
        System.out.println(format);
        try {
            //string-》util.date
            java.util.Date parse = df.parse("2020/02/05 12:00");
            System.out.println(parse);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

3、Math类

//常用方法：
        System.out.println("随机数："+Math.random());//取值范围在[0.0,1.0)
        System.out.println("绝对值："+Math.abs(-80));//80
        System.out.println("向上取值："+Math.ceil(9.1));//10.0
        System.out.println("向下取值："+Math.floor(9.9));//9.0
        System.out.println("四舍五入："+Math.round(3.5));//4
        System.out.println("取大的那个值："+Math.max(3, 6));//6
        System.out.println("取小的那个值："+Math.min(3, 6));//3

4、String

底层类被final修饰，不能被继承，方法被final修饰，不可改变数组大小。

public final class String
private final char value[];

//常用方法：
		String s1 = "abc";
        System.out.println("字符串的长度为："+s1.length());
        String s2 = new SZtring("abc");
        System.out.println("字符串是否为空："+s2.isEmpty());
        System.out.println("获取字符串的下标对应的字符为："+s2.charAt(1));
        //equal比较字符串是否一样
        String s3 = new String("abc");
        String s4 = new String("abc");
        System.out.println(s3.equals(s4));

        String s5 = new String("abc");
        String s6 = new String("abc");
        System.out.println(s5.compareTo(s6));
        //字符串的截取
        String s7 = "abcdefhijk";
        System.out.println(s7.substring(3));
        System.out.println(s7.substring(3, 6));//[3,6)
        //字符串拼接
        System.out.println(s7.concat("pppp"));
        //字符的替换
        String s8 = "abcdeahija";
        System.out.println(s8.replace('a', 'u'));
        //按照指定的字符串进行分裂为数组的形式：
        String s9 = "a-b-c-d-e-f";
        String[] strs = s9.split("-");
        System.out.println(Arrays.toString(strs));
        //转大小写的方法：
        String s10 = "abc";
        System.out.println(s10.toUpperCase());//大写
        System.out.println(s10.toUpperCase().toLowerCase());//小写
        //去除首尾空格：
        String s11 = "    a  b  c    ";
        System.out.println(s11.trim());
        //toString()
        String s12 = "abc";
        System.out.println(s12.toString());
        //转换为String类型：
        System.out.println(String.valueOf(false));

5、StringBuilder和StringBuffer

StringBuilder和StringBuffer的区别：

StringBuilder：效率高 线程不安全

StringBuffer： 效率低 线程安全

        StringBuilder sb3 = new StringBuilder();
        //表面上调用StringBuilder的空构造器，实际底层是对value数组进行初始化，长度为16，StringBuilder和StringBuffer大小都可以改
        StringBuilder sb2 = new StringBuilder(3);
        //表面上调用StringBuilder的有参构造器，传入一个int类型的数，实际底层就是对value数组进行初始化，长度为你传入的数字
        StringBuilder sb = new StringBuilder("abc");  
        System.out.println(sb.append("def").append("bbb").append("oo").toString());//链式调用方式：return this

6、枚举类

使用前提：类的对象是有限个、确定的，如星期、性别、季节等。

枚举类定义

public enum Season {
    Spring ("春天","春回大地"),
    Sunmmer ("夏天","烈日炎炎"),
    Autumn("秋天","硕果累累"),
    Winter ("冬天","北风呼啸");
    private final String seasonName;
    private final  String seasonDesc ;

    //私有化构造器
    private Season(String seasonName,String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //提供枚举类有限个对象
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }

}

常用方法

public class SeasonTest {
    @Test
    public void seasonTest(){
        Season spring = Season.Spring;
        //通过toString获取对象
        System.out.println(spring);
        //enum关键字对应的枚举类的上层父类是 ：java.lang.Enum
        //但是我们自定义的枚举类的上层父类：Object
        //System.out.println(Season.class.getSuperclass().getName());
        //values:返回枚举类对象的数组
        Season[] seasons = Season.values();
        for (Season s:seasons){
            System.out.println(s);
        }

        //valueOf通过对象名Spring获取枚举对象，对象的名字必须传正确，否则抛出异常
        Season spring1 = Season.valueOf("Spring");
        System.out.println(spring1);
    }
}