java常用的类、包装类----java基础14

最新推荐文章于 2024-09-14 18:46:05 发布

风再起时0.0

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量448

点赞数

分类专栏： java基础系列文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_44124248/article/details/122371962

版权

java基础系列专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一、常用API的使用–Object类中的方法

object类是所有类的父类，任何类都默认继承了object类，所以只要object类的方法，其它类也能用，因此这里主要介绍两个常用的方法。

public String toString():
	1.默认是返回当前对象在堆内存中的地址信息：包名.类名@内存地址（如：com.test.Student@16b98256）
		默认的地址信息格式：类的全限名@内存地址
	2.直接输出对象的名称，默认会自动调用toString()方法，所以输出对象toString()调用可以
	3.开发中直接输出对象，默认输出对象的地址是毫无意义的
	4.开发中输出对象变量，更多的时候是希望看到对象的内容数据而不是对象的地址信息
	5.所以父类toSTring()方法存在的意义就是为了被子类重写，以便返回对象的内容信息！！
	小结：
	1.toString()默认是返回当前对象在堆内存中的地址信息
	2.开发中输出对象变量，更多的时候是希望看到对象的内容数据而不是都想的地址信息！
	3.重写toString()可以看到对象的内容信息，其存在的意义就是被子类重写
public boolean equals(Object o)
	1.这个方法是用来比较两个对象的地址是否一样，但是只要是不一样的对象，那么其地址肯定不一致，所以这个方法存在的意义也是被子类来重写，以便能够对内容进行一个比较。	
	2.可以子类进行重写，也可以直接右键生成，因为idea中都已经写好了这些东西。
	3.这个方法有时候在String类中可以用来直接比较字符串的内容，这是因为String类中重写了这个方法，所以才可以进行比较。

下面进行举例：
// 重写equals只要两个对象的内容一样，我们就认为他们是相等的。
    // zs1.equals(zs2)
    // 比较者：zs1 == this
    // 被比较者：zs2 == o
    @Override
    public boolean equals(Object o) {
        // 1.判断是否自己和自己比较，如果是同一个对象比较直接返回true
        if (this == o) return true;
        // 2.判断被比较者是否为null ,以及是否是学生类型。
        if (o == null || this.getClass() != o.getClass()) return false;
        // 3.o一定是学生类型，强制转换成学生，开始比较内容！
        Student student = (Student) o;
        return age == student.age &&
                sex == student.sex &&
                Objects.equals(name, student.name);
    }

    // 重写Object的toString()以便返回对象的内容数据
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

二、Objects类

目标：Objects类的使用。

Objects类与Object还是继承关系。
Objects类是从JDK 1.7开始之后才有的。

Objects的方法：
    1.public static boolean equals(Object a, Object b)
        -- 比较两个对象的。
        -- 底层进行非空判断，从而可以避免空指针异常。更安全！！推荐使用！！
         public static boolean equals(Object a, Object b) {
                 return a == b || a != null && a.equals(b);
         }
    2.public static boolean isNull(Object obj)
        -- 判断变量是否为null ,为null返回true ,反之！

举例如下：

public class ObjectsDemo {
    public static void main(String[] args) {
        Student s1 = null;
        Student s2 = new Student();
        System.out.println(Objects.equals(s1 , s2)); // 可以避免空指针异常。更安全！！
        // System.out.println(s1.equals(s2)); // 空指针异常

        // 询问s1是否为null 为null返回true ,反之！
        System.out.println(Objects.isNull(s1));
        System.out.println(s1 == null); // 可以直接用==判断也可以！
    }

三、Date类

目标：Date日期类的使用。

Java是面向对象的，会用一个类代表一个事物。
Date类在Java中代表的是系统当前此刻日期时间对象。

Date类：
    包：java.util.Date。
    构造器：
        -- public Date():创建当前系统的此刻日期时间对象。
        -- public Date(long time):
    方法：
         -- public long getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来走过的总的毫秒数。

    时间记录的两种方式：
         a.Date日期对象。
         b.时间毫秒值：从1970-01-01 00:00:00开始走到此刻的总的毫秒值。 1s = 1000ms

    小结：
        Date可以代表系统当前此刻日期时间对象。
        时间记录的两种方式：
             Date日期对象。
             时间毫秒值：从1970-01-01 00:00:00开始走到此刻的总的毫秒值。 1s = 1000ms

public class DateDemo01 {
    public static void main(String[] args) {
        // a.创建一个日期对象代表了系统此刻日期时间对象
        Date d = new Date();
        System.out.println(d);

        // b.拿当前日期对象的时间毫秒值
        long time = d.getTime();
        System.out.println(time);
    }
}

获取时间毫秒值可以用来分析性能
目标:Date类的有参数构造器的使用,可以在日期和毫秒数之间进行转换

/**

    构造器：
         -- public Date():创建当前系统的此刻日期时间对象。
         -- public Date(long time):把时间毫秒值转换成日期对象。
    流程：
        Date日期对象 -> getTime() -> 时间毫秒值
        时间毫秒值 -> new Date(时间毫秒值) -> Date日期对象
    小结：
        public Date(long time):把时间毫秒值转换成日期对象。
 */
public class DateDemo03 {
    public static void main(String[] args) {
        // 需求：问121s以后的时间是多少。

        // 1.拿到此刻日期对象
        Date d = new Date();
        System.out.println(d);

        // 2.拿到此刻日期对象的时间毫秒值 往后走 121 s
        long time = d.getTime() + 121*1000;

        // 3.把时间毫秒值转换成日期对象。
        Date d1 = new Date(time);
        System.out.println(d1);
    }

四、DateFormat类

目标：DateFormat简单日期格式化类的使用。

引入：
    我们之前得到的Date日期对象或者时间毫秒值的时间形式
    开发中并不喜欢，不符合有些时间格式的需求。

DateFormat作用：
    1.可以把“日期对象”或者“时间毫秒值”格式化成我们喜欢的时间形式。（格式化时间）
    2.可以把字符串的时间形式解析成日期对象。（解析字符串时间）

DateFormat是一个抽象类，不能直接使用，要找它的子类：SimpleDateFormat
我们需要用的是简单日期格式化类：SimpleDateFormat 

SimpleDateFormat简单日期格式化类：
    包：java.text.SimpleDateFormat
    构造器：public SimpleDateFormat(String pattern)：
           指定时间的格式创建简单日期格式化对象。
    方法：
        -- public String format(Date date):可以把日期对象格式化成我们喜欢的时间形式，返回的是字符串!
        -- public String format(Object time):可以把时间毫秒值格式化成我们喜欢的时间形式，返回的是字符串!
        -- public Date parse(String date) throws ParseException:把字符串的时间解析成日期对象
小结：
    简单日期格式化类SimpleDateFormat可以把日期对象格式化成我们喜欢的时间形式
        -- public String format(Date date):可以把日期对象格式化成我们喜欢的时间形式，返回的是字符串!

简单日期格式化类SimpleDateFormat可以把日期对象格式化成我们喜欢的时间形式
– public String format(Date date):可以把日期对象格式化成我们喜欢的时间形式，返回的是字符串!
举例：

public class SimpleDateFormatDemo01 {
    public static void main(String[] args) {
        // 需求：把此刻日期对象格式化成我们喜欢的形式。
        // 1.得到此刻日期对象
        Date d = new Date();
        System.out.println(d);

        // 2.创建一个简单日期格式化对象负责格式化日期对象
        // 注意：参数是之间的格式。自定义的格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");

        // 3.开始调用方法格式化时间得到格式化的字符串时间形式
        String rs = sdf.format(d);
        System.out.println(rs);
    }
}

简单日期格式化类SimpleDateFormat可以直接格式化时间毫秒值
public String format(Object time)

public class SimpleDateFormatDemo02 {
    public static void main(String[] args) {
        // 1.问121s后的时间是多少。格式化输出。
        // a.得到此刻日期对象
        Date date = new Date();
        System.out.println(date);

        // b.得到当前时间的时间毫秒值
        long time = date.getTime();
        time += 121 * 1000;

        // c.格式化时间毫秒值
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        System.out.println(sdf.format(time));
    }
}

简单日期格式化对象不仅可以把日期对象和时间毫秒值格式化成我们喜欢的字符串时间形式
它还可以把把字符串的时间解析成日期对象
– public Date parse(String date) throws ParseException:把字符串的时间解析成日期对象

public class SimpleDateFormatDemo03 {
    public static void main(String[] args) throws ParseException {
        // 面试题：请问 “2019-11-04 09:30:30” 往后 1天15小时，30分29s后的时间是多少
        // a.定义一个字符串时间
        String date = "2019-11-04 09:30:30";

        // b.把字符串的时间解析成Date日期对象 。（重点）
        // 1.创建一个简单日期格式化对象负责解析字符串的时间成为日期对象
        // 注意：参数必须与被解析的时间的格式完全一致，否则执行报错！！
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 2.开始解析成日期对象
        Date newDate = sdf.parse(date);

        // c.得到日期对象的时间毫秒值 + 往后走 1天15小时，30分29s
        long time = newDate.getTime() + (24L *60*60 + 15*60*60 + 30*60 + 29) * 1000;

        // d.把时间毫秒值格式化成喜欢的字符串的时间形式!
        System.out.println(sdf.format(time));
    }
}

五、Calendar类

目标：日历类Calendar的使用。

Calendar代表了系统此刻日期对应的日历对象。
Calendar是一个抽象类，不能直接创建对象。
Calendar日历类创建日历对象的语法：
    Calendar rightNow = Calendar.getInstance();
Calendar的方法：
    1.public static Calendar getInstance(): 返回一个日历类的对象。
    2.public int get(int field)：取日期中的某个字段信息。
    3.public void set(int field,int value)：修改日历的某个字段信息。
    4.public void add(int field,int amount)：为某个字段增加/减少指定的值
    5.public final Date getTime(): 拿到此刻日期对象。
    6.public long getTimeInMillis(): 拿到此刻时间毫秒值

public class CalendarDemo01 {
   public static void main(String[] args) {
       // 1.通过调用日历类的静态方法getInstance得到一个当前此刻日期对象对应的日历对象。
       Calendar rightNow = Calendar.getInstance();
       System.out.println(rightNow);

       // 2.获取年：
       int year = rightNow.get(Calendar.YEAR);
       System.out.println(year);

       int mm = rightNow.get(Calendar.MONTH) + 1;
       System.out.println(mm);

       // 3.一年中的第几天: 308
       int days = rightNow.get(Calendar.DAY_OF_YEAR);
       System.out.println(days);

       // 4.修改日历的信息
       //rightNow.set(Calendar.YEAR , 2099);
       //System.out.println(rightNow.get(Calendar.YEAR));

       // 5.日历可以得到此刻日期对象。
       Date d = rightNow.getTime();
       System.out.println(d);

       // 6.此刻时间毫秒值
       long time = rightNow.getTimeInMillis();
       System.out.println(time);

       // 7.请问701天  15小时后是哪个日期
       // 让日历的一年中的第几天往后走 701天！
       rightNow.add(Calendar.DAY_OF_YEAR , 701);
       rightNow.add(Calendar.HOUR , 15);
       long time1 = rightNow.getTimeInMillis();
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
       System.out.println(sdf.format(time1));
   }
}

六、Math类

目标：Math类的使用。

Math用于做数学运算。
Math类中的方法全部是静态方法，直接用类名调用即可。
方法：
      方法名                                        说明                
      public static int abs(int a)                  获取参数a的绝对值：
      public static double ceil(double a)           向上取整
      public static double floor(double a)          向下取整
      public static double pow(double a, double b)  获取a的b次幂        
      public static long round(double a)            四舍五入取整
小结：
    记住。

public class MathDemo {
    public static void main(String[] args) {
        // 1.取绝对值:返回正数。
        System.out.println(Math.abs(10));
        System.out.println(Math.abs(-10.3));
        // 2.向上取整: 5
        System.out.println(Math.ceil(4.00000001)); // 5.0
        // 3.向下取整：4
        System.out.println(Math.floor(4.99999999)); // 4.0
        // 4.求指数次方
        System.out.println(Math.pow(2 , 3)); // 2^3 = 8.0
        // 5.四舍五入 10
        System.out.println(Math.round(4.49999)); // 4
        System.out.println(Math.round(4.500001)); // 5
    }
}

七、System类

目标：System系统类的使用。

System代表当前系统。
静态方法：
1.public static void exit(int status):终止JVM虚拟机，非0是异常终止。
2.public static long currentTimeMillis():获取当前系统此刻时间毫秒值。
3.可以做数组的拷贝。
arraycopy(Object var0, int var1, Object var2, int var3, int var4);
* 参数一：原数组
* 参数二：从原数组的哪个位置开始赋值。
* 参数三：目标数组
* 参数四：赋值到目标数组的哪个位置
* 参数五：赋值几个。

public class SystemDemo {
   public static void main(String[] args) {
       System.out.println("程序开始。。。");

        // 1.终止当前虚拟机
       //System.exit(0); // 0代表正常终止!!

       // 2.得到系统当前时间毫秒值
       long time = System.currentTimeMillis();
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
       System.out.println(sdf.format(time));

       // 3.可以做数组的拷贝（了解）
       int[] arrs1 = new int[]{10 ,20 ,30 ,40 ,50 ,60 ,70};
       int[] arrs2 = new int[6]; // [ 0 , 0 , 0 , 0 , 0 , 0]
       // arrs2 = [0 , 30 , 40 , 50 , 0 , 0 ]
       /**
        arraycopy(Object src,int  srcPos ,Object dest, int destPos,  int length)
        参数一：原数组
        参数二：从哪个索引位置开始赋值
        参数三：目标数组
        参数四：目标数组的开始索引：
        参数五：复制几个
        */
       System.arraycopy(arrs1,2, arrs2 , 1 , 3);
       System.out.println(Arrays.toString(arrs2));

       System.out.println("程序结束。。。");
   }
}

八、BigDecimal

目标：BigDecimal大数据类。

引入：
    浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）。
    BigDecimal可以解决浮点型运算数据失真的问题。

BigDicimal类：
    包：java.math.
    创建对象的方式（最好的方式：）
          public static BigDecimal valueOf(double val) :包装浮点数成为大数据对象。
    方法声明
          public BigDecimal add(BigDecimal value)       加法运算
          public BigDecimal subtract(BigDecimal value)  减法运算 
          public BigDecimal multiply(BigDecimal value)  乘法运算 
          public BigDecimal divide(BigDecimal value)    除法运算
          public double doubleValue():把BigDecimal转换成double类型。

public class BigDecimalDemo {
    public static void main(String[] args) {
        // 浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）。
        System.out.println(0.1 + 0.2);
        System.out.println(0.09 + 0.01);
        System.out.println(1.0  - 0.32);
        System.out.println(1.015 * 100);
        System.out.println(1.301 / 100);

        System.out.println("-------------------------");
        double a = 0.1 ;
        double b = 0.2 ;
        double c = a + b ;
        System.out.println(c);

        // 1.把浮点数转换成大数据对象运算
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        //BigDecimal c1 = a1.add(b1);  // 加法
        BigDecimal c1 = a1.divide(b1); // 除法
        System.out.println(c1);

        // 结果可能需要继续使用!!!
        // BigDecimal只是解决精度问题的手段，double数据才是我们的目的！！
        double rs = c1.doubleValue();
        System.out.println(rs);
    }
}

九、包装类

目标：包装类–装箱和拆箱

引入：
    Java认为一切皆对象。引用数据类型就是对象了。
    但是在Java中8基本数据类型不是对象，只是表示一种数据的类型形式,这8种数据类型显得很突兀。
    Java为了一切皆对象的思想统一，把8种基本数据类型转换成对应的类，这个类称为
    基本数据类型的包装类。

基本数据类型                    包装类（引用数据类型）
     byte                      Byte
     short                     Short
     int                       Integer(特殊)
     long                      Long

     float                     Float
     double                    Double
     char                      Character(特殊)
     boolean                   Boolean

自动装箱：可以直接把基本数据类型的值或者变量赋值给包装类。
自动拆箱：可以把包装类的变量直接赋值给基本数据类型。

小结：
     自动装箱：可以直接把基本数据类型的值或者变量赋值给包装类。
     自动拆箱：可以把包装类的变量直接赋值给基本数据类型。

public class PackegeClass {
   public static void main(String[] args) {
       int a = 12 ;
       Integer a1 = 12 ;  // 自动装箱
       Integer a2 = a ;   // 自动装箱

       double b = 99.9;
       Double b1 = 99.9; // 自动装箱
       Double b2 = b ;   // 自动装箱

       Integer c = 100 ;
       int c1 = c ;      // 自动拆箱

       int d = 12;
       Integer d1 = null; // 引用数据类型的默认值可以为null
       Integer d2 = 0;

       System.out.println("-----------------");
       Integer it = Integer.valueOf(12);  // 手工装箱！
       // Integer it1 = new Integer(12); // 手工装箱！
       Integer it2 = 12;


       Integer it3 = 111 ;
       int it33 = it3.intValue(); // 手工拆箱
       int it333 = it3;
   }
}

2.目标：包装类的特殊功能。

Java为包装类做了一些特殊功能，以便程序员使用。
包装类作为类首先拥有了Object类的方法。
包装类作为引用类型的变量可以存储null值。

具体来看特殊功能主要有：
    1.可以把基本数据类型的值转换成字符串类型的值。（没啥用）
        -- 调用toString()方法。
        -- 调用Integer.toString(基本数据类型的值)得到字符串。
        -- 直接把基本数据类型+空字符串就得到了字符串。

    2.把字符串类型的数值转换成对应的基本数据类型的值。（真的很有用）
        -- Xxx.parseXxx("字符串类型的数值")
        -- Xxx.valueOf("字符串类型的数值"):推荐使用!
小结：
    包装类可以把字符串类型的数值转换成对应的基本数据类型的值（真的很有用）

public class PackageClass02 {
   public static void main(String[] args) {
       // 1.把基本数据类型的值转成字符串
       Integer it = 100 ;
       // a.调用toString()方法。
       String itStr = it.toString();
       System.out.println(itStr+1);
       // b.调用Integer.toString(基本数据类型的值)得到字符串。
       String itStr1 = Integer.toString(it);
       System.out.println(itStr1+1);
       // c.直接把基本数据类型+空字符串就得到了字符串。
       String itStr2 = it+"";
       System.out.println(itStr2+1);

       // 2.把字符串类型的数值转换成对应的基本数据类型的值。（真的很有用）
       String numStr = "23";
       //int numInt = Integer.parseInt(numStr);
       int numInt = Integer.valueOf(numStr);
       System.out.println(numInt+1);

       String doubleStr = "99.9";
       //double doubleDb = Double.parseDouble(doubleStr);
       double doubleDb = Double.valueOf(doubleStr);
       System.out.println(doubleDb+0.1);
   }
}