常用API

Object类

Object类概述

• Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份

toString()方法

javabean类:

//女朋友类
public class GirlFriend {
   //姓名
   private String name;
   //身高
   private int height;

   public GirlFriend() {
   }

   public GirlFriend(String name, int height) {
       this.name = name;
       this.height = height;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getHeight() {
       return height;
   }

   public void setHeight(int height) {
       this.height = height;
   }

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

//    @Override
//    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (o == null || getClass() != o.getClass()) return false;
//        GirlFriend that = (GirlFriend) o;
//        return height == that.height && Objects.equals(name, that.name);
//    }

   @Override
   public int hashCode() {
       return Objects.hash(name, height);
   }
}

//目标：Object类toString()方法的使用
/*
  Object类
    public String toString() {
        //包名.类名@十六进制地址值
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建Object对象
        Object o = new Object();

        //调用Object的toString(),获取返回值,并打印
        String s = o.toString();
        System.out.println(o);
        System.out.println(s);
        //解释返回值的含义

        //打印Object对象
        //打印Object对象的toString()

        System.out.println("-------------------------");

        //创建GirlFriend类的对象
        //打印对象名
        GirlFriend girlFriend = new GirlFriend();
        System.out.println(girlFriend);
       
    }
}

equals

   Object类:
   //Object类的equals()方法,默认比较的是对象的地址值是否相等
    public boolean equals(Object obj) {
        return (this == obj);
    }

一般使用会重写equals方法

//    @Override
//    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (o == null || getClass() != o.getClass()) return false;
//        GirlFriend that = (GirlFriend) o;
//        return height == that.height && Objects.equals(name, that.name);
//    }

StringBuilder类

作用:

代表可变变字符串,

//目标：掌握StringBuilder类对象的使用
public class Demo01 {
    public static void main(String[] args) {
        /**
         * 作用：代表可变字符串，可以提高字符串操作的效率
         *
         * 常用构造：
         *      public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
         *      public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
         *
         * 常用方法：
         *      StringBuilder append (任意类型)：添加数据，返回的是对象自己
         *      StringBuilder reverse()：返回相反的字符序列，返回的是对象自己
         *      String toString()：通过toString()就可以实现把StringBuilder转换为String
         */
        //1.利用空参构造，创建一个StringBuilder对象,打印对象
//        StringBuilder sb = new StringBuilder();
//        System.out.println(sb);

        //2.传入一个String，把String变成StringBuilder,打印对象
        StringBuilder sb = new StringBuilder("我爱java");
        System.out.println(sb);

        //3.StringBuilder有拼接字符串内容的方法！append()可以拼接任意类型的数据,接收返回值,并打印
        StringBuilder sb1 = sb.append("java是什么");
        System.out.println(sb);
        String s = sb1.toString();
        System.out.println("========");
        System.out.println(s.equals(sb1));

        //4.==可以用来判断两个对象的地址值是否相同
        sb.equals(sb1);
        System.out.println(sb == sb1);

        //5.把字符串内容反转,接收返回值,并打印
        StringBuilder sb2 = sb.reverse();

        //反转后,打印本身
        System.out.println(sb2);
        
    }
}

包装类

概述

八大基本类型都有其对应的包装类型
基本类型: byte short int 		long  float double char     boolean
包装类型: Byte Short Integer    Long  Float Double Characer Boolean

//public Integer(int value)
//public Integer(String s)
//public static Integer valueOf(int i)
//public static Integer valueOf(String s)

public class Demo01 {
    public static void main(String[] args) {
        
        //使用Integer的有参构造的方式将String类型转为Integer类数据
        Integer integer = new Integer("1");
        System.out.println(integer); //1

        //Integer(String s) 将字符串类型转为Integer类型
        Integer a = Integer.valueOf("1");
        //拆箱:包装类转为基本类型
        int i = a.intValue();
        System.out.println(a); //1
        System.out.println(i);//1

        System.out.println(integer.hashCode()); //1
        System.out.println(a.hashCode()); //1

    }
}

Arrays类

//目标：掌握Arrays数组工具类的使用
public class Demo01 {
    public static void main(String[] args) {
        /**
         * Arrays工具类常见方法：
         *   public static String toString(数组对象)：返回数组的字符串表现形式，用来打印数组内容的
         *   public static void sort(数组对象)：对数组进行默认升序排序
         *   public static int binarySearch(int[] a,int key)：二分搜索数组中的数据，存在返回索引，不存在返回-1
         */
        //1.定义一个int类型的数组
        int[] arr = {33, 11, 55, 22, 44};

        //2.如果需要返回数组的数据字符串形式，可以使用Arrays的toString()
        System.out.println(Arrays.toString(arr));

        //3.Arrays的sort方法传入数组之后，可以自动对数组进行默认的升序排序！
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        //4.数组也提供了二分查找的功能，可以找一个数据的索引。
        // 前提：数组要有顺序！
        int[] arrA = {11,22,33,44,55,66};

        System.out.println("键盘录入要查询的数据：");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        //5.调用方法，传入数组和被查的num
        int index = Arrays.binarySearch(arrA, num);

        System.out.println(index);

        //查到了就返回索引，没有查到，返回的是一个负数！

    }
}

Date类

Date构造方法的使用

//目标：掌握日期类Date的使用
public class Demo00 {
    public static void main(String[] args) {
        /**
         * 构造方法：
         *      Date()：创建Date对象，获取的是系统当前时刻的时间
         *      Date(long time)：把时间毫秒值转成Date日期对象
         *
         *
         * 需求：
         *      1.获取当前系统时间所对应的Date对象
         *      2.获取时间毫秒值为0的Date对象
         *
         *      时间原点:1970-1-1 00:00:00
         *      utc+8
         *
         */

//        1.获取当前系统时间所对应的Date对象
        Date date = new Date();
        System.out.println(date);  //Sat Nov 19 15:57:17 CST 2022

//        2.获取时间毫秒值为0的Date对象
        Date date1 = new Date(0);
        System.out.println(date1); //Thu Jan 01 08:00:00 CST 1970

//        3.获取时间毫秒值为1000L的Date对象
        Date date2 = new Date(1000L);
        System.out.println(date2); //Thu Jan 01 08:00:01 CST 1970
        
    }
}

Date类常用方法

getTime() 、setTime()

//目标：掌握日期类Date的使用
public class Demo01 {
    public static void main(String[] args) {
        /**

         *
         * 常用方法：
         *      getTime()：获取时间对象的毫秒值
         *      setTime(long time)：设置日期对象的时间为指定的时间毫秒值的时间
         *
         */
        //1.获取当前时间的毫秒值,并打印
        Date date = new Date();
        System.out.println(date.getTime()); //1668845232896
        // 它的含义是 ?
        //从时间原点到当前时间的毫秒值

        //2.请问当前时刻往后1小时121秒之后的时间是多少?
        //步骤:
        Date date1 = new Date();
        System.out.println(date);
        long currTime = date1.getTime();
        date1.setTime(currTime+121*1000+60*60*1000);
        System.out.println(date1); //Sat Nov 19 17:09:13 CST 2022
    }
}

SimpleDateFormat的用法

//目标：掌握SimpleDateFormat对日期格式化和解析操作
public class Demo02 {
    public static void main(String[] args) throws ParseException {
        /**
         * 构造器：
         *      SimpleDateFormat()：构造一个SimpleDateFormat，使用默认格式
         *      SimpleDateFormat(String pattern)：构造一个SimpleDateFormat，使用指定的格式
         *
         * 格式化模板和日期对应关系：
         *       y ——> 年
         *       M ——> 月
         *       d ——> 日
         *       H ——> 时
         *       m ——> 分
         *       s ——> 秒
         *
         * 日期对象转字符串的方法：
         *      final String format(Date date)：将Date对象格式化成字符串
         */

        //演示格式化工具类的带参构造  SimpleDateFormat(String pattern)

        //演示格式化方法
          //final String format(Date date)：将Date对象格式化成字符串
//        需求1.把当前系统时间对象，用这样的字符串内容展示："2022年9月19日 10:20:45"
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //将date对象格式化成上面设定的字符串
        String s = simpleDateFormat.format(new Date());
        System.out.println(s);
        
        //需求2:用这样的字符串内容展示："2022-9-19 10时20分45秒"
        SimpleDateFormat sdf = new SimpleDateFormat("y-M-d H时m分s秒");
        Date date = new Date();
        String currTime = sdf.format(date);
        System.out.println(currTime);

    }
}

SimpleDateFormat对日期格式化和解析操作

//目标：掌握SimpleDateFormat对日期格式化和解析操作
public class Demo02_01 {
    public static void main(String[] args) throws ParseException {
        /**

         *字符串对象转日期对象的方法：
         *         Date parse(String source)：从给定字符串的开始解析文本以生成日期

         *
         * 需求：         *
         *      2.请计算出2021年8月6日11点11分11秒，往后走2天5小时5分7秒的时间
         */

        //演示解析方法
        // Date parse(String source)：从给定字符串中解析文本以生成Date对象
        //需求1:解析字符串"2021年8月6日11点11分11秒",得到Date对象,并打印
        //步骤:
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日HH点mm分ss秒");
        Date date = df.parse("2021年8月6日11点11分11秒");
        System.out.println(date);


        //需求2:解析字符串"2021-8-6 11:11:11",得到Date对象,并打印
        //步骤:
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date1 = dateFormat.parse("2021-8-6 11:11:11");
        System.out.println(date1);

        //请计算出2021年8月6日11点11分11秒，往后走2天5小时5分7秒的时间,将时间打印出来,格式:2021-08-08 16:16:18
        DateFormat df1 = new SimpleDateFormat("yyyy年MM月dd日HH点mm分ss秒");
        //解析:将字符串转为date对象
        Date date2 = df1.parse("2021年8月6日11点11分11秒");
        long time = date2.getTime() + (1000 * 60 * 60 * 24 * 2) + (1000 * 60 * 60 * 5) + (1000 * 60 * 5) + (1000 * 7);
        date2.setTime(time);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //格式化:将date对象转换为字符串
        String s = simpleDateFormat.format(date2);
        System.out.println(s);

    }
}

Calendar日历类的常用方法

//目标：掌握Calendar日历类的使用方法
public class Demo04 {
    public static void main(String[] args) {
        /**
         * 获当前日期类对象：getInstance()
         *
         * 常用方法：
         *    int   get(int field)：获取日期中的某个字段信息
         *    void  set(int field,int value)：修改日历的某个字段信息
         *    void  add(int field,int amount)：为某个字段增加/减少指定的值
         *    Date  getTime()：拿到此刻日期对象
         *    long  getTimeInMillis()：拿到此刻时间毫秒值
         *
         * 注意：Calendar的月份是从0开始的
         */
        //1.获取日历类的对象，尝试new。抽象类不能实例化，所以报错！
//        Calendar cal = new Calendar();


        //2.利用静态方法 getInstance()拿到一个子类对象
        Calendar calendar = Calendar.getInstance();

        System.out.println(calendar.get(Calendar.MONTH)+1); //返回的月份是0-11

        //3.直接打印日历对象
        System.out.println(calendar);


        System.out.println("-----------------------------");
        //4.获取日历对象中时间的数据，用get方法。要传入时间的字段（时间单位：Calendar这个类里面的一些静态常量！）
        //获取年
        System.out.println(calendar.get(Calendar.YEAR));
        //获取月
        System.out.println(calendar.get(Calendar.MONTH));
        //获取日
        System.out.println(calendar.get(Calendar.ERA));


        //5.设置时间使用set。第一个参数指定字段，第二个参数是指定的值
        //设置年为2021年
        calendar.set(Calendar.YEAR,2021);
        calendar.set(Calendar.MONTH,12);
        System.out.println(calendar.get(Calendar.MONTH));
        System.out.println(calendar);


        //设置现在为10月，Calendar中10月是9
        calendar.set(Calendar.MONTH,9);
        System.out.println(calendar.get(Calendar.MONTH)); //9

        //System.out.println("-----------------------------");

        //6.时间也可以加减，使用add方法
        //加两年
        calendar.add(Calendar.YEAR,2);
        System.out.println(calendar.get(Calendar.YEAR));

        //减5年
        calendar.add(Calendar.YEAR,-5);
        System.out.println(calendar.get(Calendar.YEAR));

        System.out.println("-----------------------------");

        //7.通过日历对象，拿到日期对象
        //        Date  getTime()：拿到此刻日期对象
        Date time = calendar.getTime();
        System.out.println(time);


        System.out.println("-----------------------------");

        //8.通过日历对象，获取时间毫秒值
        long timeInMillis = calendar.getTimeInMillis();
        System.out.println(timeInMillis);


    }
}

BigDecimal类的使用

BigDecimal的基本使用

//目标：掌握BigDecimal的基本使用
public class Demo01 {
    public static void main(String[] args) {
        /**
         * 获取对象：
         *      构造方法:
         *              BigDecimal(String s);
         *      静态方法:
         *              valueOf(double val)
         *
         * 常用成员方法：
                 BigDecimal add(BigDecimal b)：加法
                 BigDecimal subtract(BigDecimal b)：减法
                 BigDecimal multiply(BigDecimal b)：乘法
                 BigDecimal divide(BigDecimal b)：除法
         */

        //java中的float和double,不是绝对精确的!!
        //直接使用浮点数运算，有可能精度损失！
        //System.out.println(0.1 + 0.2);//0.30000000000000004

        //使用2种方式创建对象,演示解决double的精度丢失问题

        //1.使用BigDecimal的静态valueOf()方法，传入浮点数，包装成对象
		BigDecimal bigDecimal = BigDecimal.valueOf(0.2);
        
        //使用BigDecimal(String s)构造方法创建对象
        BigDecimal bd1 = new BigDecimal("0.1");
        BigDecimal bd2 = new BigDecimal("0.3");
        
        //2.加法，使用add()   (注意:BigDecimal是不可变对象)
        BigDecimal bd3 = bd1.add(bd2);
        System.out.println(bd3);
        
        //3.减法，
        BigDecimal bd4 = bd1.subtract(bd2);
        System.out.println(bd4);
        
        //4.乘法，
        BigDecimal bd5 = bd1.multiply(bd2);
        System.out.println(bd5);
        
        //5.除法
        BigDecimal bd6 = bd1.divide(bd2,5, RoundingMode.CEILING);
        System.out.println(bd6);
        
        //注意：这种一个参数的除法，只能做精确的运算，如果结果不精确，代码会出现异常！
    }
}

BigDecimal做除法时的舍入规则

//目标：掌握BigDecimal的精确除法
public class Demo02 {
    public static void main(String[] args) {
        /**
         * divide (另一个BigDecimal对象，小数保留位数，舍入模式)：除法
         * 舍入模式：
         *      RoundingMode.CEILING  进一法
         *      RoundingMode.FLOOR 去尾法
         *      RoundingMode.HALF_UP 四舍五入
         */
        // 0.1 除以  0.3 ??
        BigDecimal bd1 = BigDecimal.valueOf(0.1);
        BigDecimal bd2 = BigDecimal.valueOf(0.3);

        //RoundingMode.CEILING  进一法
        BigDecimal result1 = bd1.divide(bd2, 3, RoundingMode.CEILING);
        System.out.println(result1);  //0.334
        
        //RoundingMode.FLOOR 去尾法
        BigDecimal result2 = bd1.divide(bd2, 3, RoundingMode.FLOOR);
        System.out.println(result2);  //0.333
        
        //RoundingMode.HALF_UP 四舍五入 
        BigDecimal result3 = bd1.divide(bd2, 3, RoundingMode.HALF_UP);
        System.out.println(result3); //0.333

    }
}