Java中常见API（Object）（Objects）（包装类）（Stringbuilder）（StringBuffer）（StringJoiner）（Math）（System）（Runtime）

向右看齐 2024-03-23 23:48 62阅读 0赞

#### Object ####

Object类是所有类的祖宗类，Java中的所有类可以直接使用Object提供的方法；

##### Public String toString（） #####

返回对象的字符串表示形式

toString存在的意义：toString()方法存在的意义就是为了被子类重写，以便返回对象具体的内容。

##### public boolean equals（Object o） #####

判断两个对象是否相等（子类没有重写Object方法，默认判断地址值）

equals存在的意义就是为了被子类重写，以便子类自己来定制比较规则（比如比较对象内容）。

####  ####

Objects

Objects是一个工具类，提供了很多操作对象的静态方法给我们使用。

##### equals #####

public static boolean equals(Obiect o)//先做非空判断，在做两个地址值的比较
    
    
    //源码
    
     public static boolean equals(Object a, Object b) {
            return (a == b) || (a != null && a.equals(b));
        }

##### isNull #####

public static boolean isNull（Object o）//判断对象是否为Null
    
    
    //源码
    
    public static boolean isNull(Object obj) {
            return obj == null;
        }

##### nonNull #####

public static boolean nonNull(Object o)//判断对象不为空
    
    
    //源码
    
     public static boolean nonNull(Object obj) {
            return obj != null;
        }

#### 包装类 ####

包装类就是把基本数据类型包装成对象

<table style="width:544px;"> 
 <tbody> 
  <tr> 
   <td> <p>基本数据类型</p> </td> 
   <td> <p>对应的包装类（引用数据类型）</p> </td> 
  </tr> 
  <tr> 
   <td> <p>byte</p> </td> 
   <td> <p>Byte</p> </td> 
  </tr> 
  <tr> 
   <td> <p>short</p> </td> 
   <td> <p>Short</p> </td> 
  </tr> 
  <tr> 
   <td> <p><span style="background-color:#38d8f0;">int</span></p> </td> 
   <td> <p><span style="background-color:#38d8f0;">Integer</span></p> </td> 
  </tr> 
  <tr> 
   <td> <p>long</p> </td> 
   <td> <p>Long</p> </td> 
  </tr> 
  <tr> 
   <td> <p><span style="background-color:#38d8f0;">char</span></p> </td> 
   <td> <p><span style="background-color:#38d8f0;">Character</span></p> </td> 
  </tr> 
  <tr> 
   <td> <p>float</p> </td> 
   <td> <p>Float</p> </td> 
  </tr> 
  <tr> 
   <td> <p>double</p> </td> 
   <td> <p>Double</p> </td> 
  </tr> 
  <tr> 
   <td> <p>boolean</p> </td> 
   <td> <p>Boolean</p> </td> 
  </tr> 
 </tbody> 
</table>

##### 自动装箱 #####

<table style="width:366px;"> 
 <tbody> 
  <tr> 
   <td> <p>基本类型的数据包装成对象的方案</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;Integer(int&nbsp;value)：已过时</p> </td> 
  </tr> 
  <tr> 
   <td> <p><span style="color:#fe2c24;">public&nbsp;static&nbsp;Integer&nbsp;valueOf(int&nbsp;i)</span></p> </td> 
  </tr> 
 </tbody> 
</table>

/*
    *返回表示指定int值的Integer实例。如果不需要新的Integer实例，则通常应该优先使用此方法，而不是构造函数Integer(int)，因为通过缓存频繁请求的值，该方法可能会产生更好的空间和时间性能。此方法将始终缓存-128到127(包括-128到127)范围内的值，并可能缓存此范围之外的其他值。**/
    
     @IntrinsicCandidate
        public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }

返回表示指定int值的Integer实例。如果不需要新的Integer实例，则通常应该优先使用此方法，而不是构造函数Integer(int)，因为通过缓存频繁请求的值，该方法可能会产生更好的空间和时间性能。此方法将始终缓存-128到127(包括-128到127)范围内的值，并可能缓存此范围之外的其他值。

Integer i = 10;
    
    //自动装箱，底层调用了valueOf()方法
    
    //反编译
    
    C:\Users\Administrator>javap -c "E:\javase base code\day04\src\com\itcast\dome07\demo01.class"
    Compiled from "demo01.java"
    public class com.itcast.dome07.demo01 {
      public com.itcast.dome07.demo01();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: bipush        10
           2: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
           5: astore_1
           6: return
    }

![98bf3a83ce74475fa9c2ddaab05faf86.png][]

##### 自动拆箱 #####

将引用数据类型转换自动转换为基本数据类型

public static void main(String[] args) {
            Integer integer = 10;
    
            int i = integer;
    
    
    
        }

反编译后可以看到底层自动调用了intValue（）方法。

![9cae3346a01e456ea3f092f47e83c5e2.png][]

##### 包装类的其他常见操作 #####

可以把基本类型的数据转换成字符串类型。

public static String toString(double d) 
    
    //基本类型数据 + “”

可以把字符串类型的数值转换成数值本身对应的数据类型。

//源码
    
    public static int parseInt(String s) throws NumberFormatException {
            return parseInt(s,10);
        }

**parseInt(String s)**

public static Integer valueOf(String s)//将字符串转换为Integer类型

##### StringBuilder #####

**作用：**StringBuilder代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的。

**好处：**StringBuilder比String更适合做字符串的修改操作，效率会更高，代码也会更简洁。

![0abbdd6b0efe4c3dae7859ceb97cc971.png][]

##### StringBuilder方法 #####

<table> 
 <tbody> 
  <tr> 
   <td> <p>方法名称</p> </td> 
   <td> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;StringBuilder&nbsp;append(任意类型)</p> </td> 
   <td> <p>添加数据并返回StringBuilder对象本身</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;StringBuilder&nbsp;reverse()</p> </td> 
   <td> <p>将对象的内容反转</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;int&nbsp;length()</p> </td> 
   <td> <p>返回对象内容长度</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;String&nbsp;toString()</p> </td> 
   <td> <p>通过toString()就可以实现把StringBuilder转换为String</p> </td> 
  </tr> 
 </tbody> 
</table>

###### append ######

添加数据并返回StringBuilder对象本身

###### reverse ######

将对象的内容反转

###### length ######

返回对象内容长度

###### toString ######

通过toString()就可以实现把StringBuilder转换为String

**为啥操作字符串建议使用StringBuilder，而不用原来学过的String??**

![2ff6fa2136a14f138931dd39d73f7b94.png][]

*  对于字符串相关的操作，如频繁的拼接、修改等，建议用StringBuidler，效率更高！
 *  注意：如果操作字符串较少，或者不需要操作，以及定义字符串变量，还是建议用String。

#### StringBuffer ####

StringBuffer的用法与StringBuilder是一模一样的 但 StringBuilder是线程不安全的 StringBuffer是线程安全的

![5b3065aa1ca645f1b92ec282de294f9b.png][]

public class demo01 {
        public static void main(String[] args) {
        //定义一个数组；
        int[] a = {1,2,3,4,5,6};
            //调myarray方法；
            System.out.println(myArray(a));
    
        }
        public static StringBuilder myArray(int[] arrays){
            //非空判断
            if(arrays == null)
                return null;
            // 创建StringBuilder对象
            StringBuilder builder = new StringBuilder();
            builder.append("[");
            for (int i = 0; i <= arrays.length - 1; i++) {
                builder.append(arrays[i]);
                  
                if(i == arrays.length - 1){
    
                    builder.append("]");
                }else {
    
                    builder.append(",");
                }
            }
            return builder;
        }
    
    }

#### StringJoiner ####

JDK8开始才有的，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的。

好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁

<table> 
 <tbody> 
  <tr> 
   <td> <p>构造器</p> </td> 
   <td> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;StringJoiner&nbsp;(间隔符号)</p> </td> 
   <td> <p>创建一个StringJoiner对象，指定拼接时的间隔符号</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;StringJoiner&nbsp;(间隔符号，开始符号，结束符号)</p> </td> 
   <td> <p>创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>方法名称</p> </td> 
   <td> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;StringJoiner&nbsp;add&nbsp;(添加的内容)</p> </td> 
   <td> <p>添加数据，并返回对象本身</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;int&nbsp;length()</p> </td> 
   <td> <p>返回长度&nbsp;(&nbsp;字符出现的个数)</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;String&nbsp;toString()</p> </td> 
   <td> <p>返回一个字符串（该字符串就是拼接之后的结果）</p> </td> 
  </tr> 
 </tbody> 
</table>

public class Test{
        public static void main(String[] args){
            StringJoiner s = new StringJoiner(",");
            s.add("java1");
            s.add("java2");
            s.add("java3");
            System.out.println(s); //结果为： java1,java2,java3
            
            //参数1：间隔符
            //参数2：开头
            //参数3：结尾
            StringJoiner s1 = new StringJoiner(",","[","]");
            s1.add("java1");
            s1.add("java2");
            s1.add("java3");
            System.out.println(s1); //结果为： [java1,java2,java3]
        }
    }

修改前面的案例

public class Test{
        public static void main(String[] args){
            String str = getArrayData( new int[]{11,22,33});
            System.out.println(str);
        }
        
        //方法作用：将int数组转换为指定格式的字符串
        public static String getArrayData(int[] arr){
            //1.判断数组是否为null
            if(arr==null){
                return null;
            }
            //2.如果数组不为null，再遍历，并拼接数组中的元素
            StringJoiner s = new StringJoiner(", ","[","]");
            for(int i=0; i<arr.length; i++){
                //加""是因为add方法的参数要的是String类型
                s.add(String.valueOf(arr[i]));
            }
            //3、把StringJoiner转换为String，并返回。
            return s.toString();
        }
    }

#### Math ####

代表数学，是一个工具类，里面提供的都是对数据进行操作的一些静态方法。

##### Math类提供的常见方法 #####

<table> 
 <tbody> 
  <tr> 
   <td> <p>方法名</p> </td> 
   <td> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;int&nbsp;abs(int&nbsp;a)</p> </td> 
   <td> <p>获取参数绝对值</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;double&nbsp;ceil(double&nbsp;a)</p> </td> 
   <td> <p>向上取整</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;double&nbsp;floor(double&nbsp;a)</p> </td> 
   <td> <p>向下取整</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;int&nbsp;round(float&nbsp;a)</p> </td> 
   <td> <p>四舍五入</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;int&nbsp;max(int&nbsp;a,int&nbsp;b)</p> </td> 
   <td> <p>获取两个int值中的较大值</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;double&nbsp;pow(double&nbsp;a,double&nbsp;b)</p> </td> 
   <td> <p>返回a的b次幂的值</p> <p></p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;double&nbsp;random()</p> </td> 
   <td> <p>返回值为double的随机值，范围[0.0,1.0)</p> <p></p> </td> 
  </tr> 
 </tbody> 
</table>

public class MathTest {
        public static void main(String[] args) {
            // 目标：了解下Math类提供的常见方法。
            // 1、public static int abs(int a)：取绝对值（拿到的结果一定是正数）
            //    public static double abs(double a)
            System.out.println(Math.abs(-12)); // 12
            System.out.println(Math.abs(123)); // 123
            System.out.println(Math.abs(-3.14)); // 3.14
    
            // 2、public static double ceil(double a): 向上取整
            System.out.println(Math.ceil(4.0000001)); // 5.0
            System.out.println(Math.ceil(4.0)); // 4.0
    
            // 3、public static double floor(double a): 向下取整
            System.out.println(Math.floor(4.999999)); // 4.0
            System.out.println(Math.floor(4.0)); // 4.0
    
            // 4、public static long round(double a)：四舍五入
            System.out.println(Math.round(3.4999)); // 3
            System.out.println(Math.round(3.50001)); // 4
    
            // 5、public static int max(int a, int b)：取较大值
            //   public static int min(int a, int b)：取较小值
            System.out.println(Math.max(10, 20)); // 20
            System.out.println(Math.min(10, 20)); // 10
    
            // 6、 public static double pow(double a, double b)：取次方
            System.out.println(Math.pow(2, 3)); // 2的3次方   8.0
            System.out.println(Math.pow(3, 2)); // 3的2次方   9.0
    
            // 7、public static double random()： 取随机数 [0.0 , 1.0) (包前不包后)
            System.out.println(Math.random());
        }
    }

### System类 ###

System代表程序所在的系统，也是一个工具类。

##### System类提供的常见方法 #####

<table> 
 <tbody> 
  <tr> 
   <td> <p>方法名</p> </td> 
   <td> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;void&nbsp;exit(int&nbsp;status)</p> </td> 
   <td> <p>终止当前运行的Java虚拟机。&nbsp;</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public&nbsp;static&nbsp;long&nbsp;currentTimeMillis()</p> </td> 
   <td> <p>返回当前系统的时间毫秒值形式</p> </td> 
  </tr> 
 </tbody> 
</table>

public class SystemTest {
        public static void main(String[] args) {
    
            // 1、public static void exit(int status):
            //   终止当前运行的Java虚拟机。
            //   该参数用作状态代码; 按照惯例，非零状态代码表示异常终止。
            System.exit(0); // 人为的终止虚拟机。(不要使用)
    
            // 2、public static long currentTimeMillis():
            //    获取当前系统的时间
            //    返回的是long类型的时间毫秒值：指的是从1970-1-1 0:0:0开始走到此刻的总的毫秒值，1s = 1000ms
            long time = System.currentTimeMillis();
            System.out.println(time);
    
            for (int i = 0; i < 1000000; i++) {
                System.out.println("输出了：" + i);
            }
    
            long time2 = System.currentTimeMillis();
            System.out.println((time2 - time) / 1000.0 + "s");
        }
    }

System.exit(0); // 人为的终止虚拟机。(不要使用)

### Runtime类 ###

Runtime类。这个类可以用来获取JVM的一些信息，也可以用这个类去执行其他的程序

**代表程序所在的运行环境。 Runtime是一个单例类。**

##### **Runtime类提供的常见方法** #####

<table> 
 <tbody> 
  <tr> 
   <td> <p>方法名</p> </td> 
   <td> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td> <p><strong>public&nbsp;static&nbsp;Runtime&nbsp;getRuntime()</strong></p> </td> 
   <td> <p>返回与当前Java应用程序关联的运行时对象</p> </td> 
  </tr> 
  <tr> 
   <td> <p><strong>public&nbsp;void&nbsp;exit(int&nbsp;status)</strong></p> </td> 
   <td> <p>终止当前运行的虚拟机</p> </td> 
  </tr> 
  <tr> 
   <td> <p><strong>public&nbsp;int&nbsp;availableProcessors()</strong></p> </td> 
   <td> <p>返回Java虚拟机可用的处理器数。</p> </td> 
  </tr> 
  <tr> 
   <td> <p><strong>public&nbsp;long&nbsp;totalMemory()</strong></p> </td> 
   <td> <p>返回Java虚拟机中的内存总量&nbsp;</p> </td> 
  </tr> 
  <tr> 
   <td> <p><strong>public&nbsp;long&nbsp;freeMemory()</strong></p> </td> 
   <td> <p>返回Java虚拟机中的可用内存</p> </td> 
  </tr> 
  <tr> 
   <td> <p><strong>public&nbsp;Process&nbsp;exec(String&nbsp;command)</strong></p> </td> 
   <td> <p>启动某个程序，并返回代表该程序的对象</p> </td> 
  </tr> 
 </tbody> 
</table>

public class RuntimeTest {
        public static void main(String[] args) throws IOException, InterruptedException {
    
            // 1、public static Runtime getRuntime() 返回与当前Java应用程序关联的运行时对象。
            Runtime r = Runtime.getRuntime();
    
            // 2、public void exit(int status) 终止当前运行的虚拟机,该参数用作状态代码; 按照惯例，非零状态代码表示异常终止。
            // r.exit(0);
    
            // 3、public int availableProcessors(): 获取虚拟机能够使用的处理器数。
            System.out.println(r.availableProcessors());
    
            // 4、public long totalMemory() 返回Java虚拟机中的内存总量。
            System.out.println(r.totalMemory()/1024.0/1024.0 + "MB"); // 1024 = 1K     1024 * 1024 = 1M
    
            // 5、public long freeMemory() 返回Java虚拟机中的可用内存量
            System.out.println(r.freeMemory()/1024.0/1024.0 + "MB");
    
            // 6、public Process exec(String command) 启动某个程序，并返回代表该程序的对象。
            // r.exec("D:\\soft\\XMind\\XMind.exe");
            Process p = r.exec("QQ");
            Thread.sleep(5000); // 让程序在这里暂停5s后继续往下走！！
            p.destroy(); // 销毁！关闭程序！
        }
    }

**Runtime runtime = Runtime.getRuntime();//使用这种方式创建对象**

#### BigDecimal ####

用于解决浮点型运算时，出现结果失真的问题。

##### 方法 #####

<table> 
 <tbody> 
  <tr> 
   <td style="width:354px;"> <p>构造器</p> </td> 
   <td style="width:494px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:354px;"> <p>public&nbsp;BigDecimal(double&nbsp;val)&nbsp;&nbsp;注意：不推荐使用这个</p> </td> 
   <td style="width:494px;"> <p>将&nbsp;double转换为&nbsp;BigDecimal&nbsp;</p> </td> 
  </tr> 
  <tr> 
   <td style="width:354px;"> <p>public&nbsp;BigDecimal(String&nbsp;val)&nbsp;&nbsp;</p> </td> 
   <td style="width:494px;"> <p>把String转成BigDecimal</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td style="width:474px;"> <p>方法名</p> </td> 
   <td style="width:374px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:474px;"> <p>public&nbsp;static&nbsp;BigDecimal&nbsp;valueOf(double&nbsp;val)</p> </td> 
   <td style="width:374px;"> <p>转换一个&nbsp;double成&nbsp;BigDecimal</p> </td> 
  </tr> 
  <tr> 
   <td style="width:474px;"> <p>public&nbsp;BigDecimal&nbsp;add(BigDecimal&nbsp;b)</p> </td> 
   <td style="width:374px;"> <p>加法</p> </td> 
  </tr> 
  <tr> 
   <td style="width:474px;"> <p>public&nbsp;BigDecimal&nbsp;subtract(BigDecimal&nbsp;b)</p> </td> 
   <td style="width:374px;"> <p>减法</p> </td> 
  </tr> 
  <tr> 
   <td style="width:474px;"> <p>public&nbsp;BigDecimal&nbsp;multiply(BigDecimal&nbsp;b)</p> </td> 
   <td style="width:374px;"> <p>乘法</p> </td> 
  </tr> 
  <tr> 
   <td style="width:474px;"> <p>public&nbsp;BigDecimal&nbsp;divide(BigDecimal&nbsp;b)</p> </td> 
   <td style="width:374px;"> <p>除法</p> </td> 
  </tr> 
  <tr> 
   <td style="width:474px;"> <p>public&nbsp;BigDecimal&nbsp;divide&nbsp;(另一个BigDecimal对象，精确几位，舍入模式)&nbsp;</p> </td> 
   <td style="width:374px;"> <p>除法、可以控制精确到小数几位</p> </td> 
  </tr> 
  <tr> 
   <td style="width:474px;"> <p>public&nbsp;double&nbsp;doubleValue()</p> </td> 
   <td style="width:374px;"> <p>将BigDecimal转换为double</p> </td> 
  </tr> 
 </tbody> 
</table>

public class Test {
        public static void main(String[] args) {
            System.out.println(0.1 + 0.2);
            System.out.println(1.0 - 0.32);
            System.out.println(1.015 * 100);
            System.out.println(1.301 / 100);
        }
    }

![1d1ab51d6e1b441a8fab072b3f5ce399.png][]

为了解决计算精度损失的问题，Java给我们提供了BigDecimal类，它提供了一些方法可以对数据进行四则运算，而且不丢失精度，同时还可以保留指定的小数位。下面看代码，演示一下

public class Test2 {
        public static void main(String[] args) {
            // 目标：掌握BigDecimal进行精确运算的方案。
            double a = 0.1;
            double b = 0.2;
    
            // 1、把浮点型数据封装成BigDecimal对象，再来参与运算。
            // a、public BigDecimal(double val) 得到的BigDecimal对象是无法精确计算浮点型数据的。 注意：不推荐使用这个，
            // b、public BigDecimal(String val)  得到的BigDecimal对象是可以精确计算浮点型数据的。 可以使用。
            // c、public static BigDecimal valueOf(double val): 通过这个静态方法得到的BigDecimal对象是可以精确运算的。是最好的方案。
            BigDecimal a1 = BigDecimal.valueOf(a);
            BigDecimal b1 = BigDecimal.valueOf(b);
    
            // 2、public BigDecimal add(BigDecimal augend): 加法
            BigDecimal c1 = a1.add(b1);
            System.out.println(c1);
    
            // 3、public BigDecimal subtract(BigDecimal augend): 减法
            BigDecimal c2 = a1.subtract(b1);
            System.out.println(c2);
    
            // 4、public BigDecimal multiply(BigDecimal augend): 乘法
            BigDecimal c3 = a1.multiply(b1);
            System.out.println(c3);
    
            // 5、public BigDecimal divide(BigDecimal b): 除法
            BigDecimal c4 = a1.divide(b1);
            System.out.println(c4);
    
    //        BigDecimal d1 = BigDecimal.valueOf(0.1);
    //        BigDecimal d2 = BigDecimal.valueOf(0.3);
    //        BigDecimal d3 = d1.divide(d2);
    //        System.out.println(d3);
    
            // 6、public BigDecimal divide(另一个BigDecimal对象，精确几位，舍入模式) : 除法，可以设置精确几位。
            BigDecimal d1 = BigDecimal.valueOf(0.1);
            BigDecimal d2 = BigDecimal.valueOf(0.3);
            BigDecimal d3 = d1.divide(d2,  2, RoundingMode.HALF_UP); // 0.33
            System.out.println(d3);
    
            // 7、public double doubleValue() : 把BigDecimal对象又转换成double类型的数据。
            //print(d3);
            //print(c1);
            double db1 = d3.doubleValue();
            double db2 = c1.doubleValue();
            print(db1);
            print(db2);
        }
    
        public static void print(double a){
            System.out.println(a);
        }
    }

### Date类 ###

Date类，Java中是由这个类的对象用来表示日期或者时间。

Date对象记录的时间是用毫秒值来表示的。Java语言规定，1970年1月1日0时0分0秒认为是时间的起点，此时记作0，那么1000（1秒=1000毫秒）就表示1970年1月1日0时0分1秒，依次内推。

![0b4edc45200442b8835881aff6348088.png][]

##### Date构造器和方法 #####

<table> 
 <tbody> 
  <tr> 
   <td style="width:179px;"> <p>构造器</p> </td> 
   <td style="width:616px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:179px;"> <p>public&nbsp;Date()</p> </td> 
   <td style="width:616px;"> <p>创建一个Date对象，代表的是系统当前此刻日期时间。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:179px;"> <p>public&nbsp;Date(long&nbsp;time)</p> </td> 
   <td style="width:616px;"> <p>把时间毫秒值转换成Date日期对象。</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td style="width:214px;"> <p>常见方法</p> </td> 
   <td style="width:581px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:214px;"> <p>public&nbsp;long&nbsp;getTime()</p> </td> 
   <td style="width:581px;"> <p>返回从1970年1月1日&nbsp;&nbsp;&nbsp;&nbsp;00:00:00走到此刻的总的毫秒数</p> </td> 
  </tr> 
  <tr> 
   <td style="width:214px;"> <p>public&nbsp;void&nbsp;setTime(long&nbsp;time)</p> </td> 
   <td style="width:581px;"> <p>设置日期对象的时间为当前时间毫秒值对应的时间</p> </td> 
  </tr> 
 </tbody> 
</table>

public class Test1Date {
        public static void main(String[] args) {
            // 目标：掌握Date日期类的使用。
            // 1、创建一个Date的对象：代表系统当前时间信息的。
            Date d = new Date();
            System.out.println(d);
    
            // 2、拿到时间毫秒值。
            long time = d.getTime();
            System.out.println(time);
    
            // 3、把时间毫秒值转换成日期对象： 2s之后的时间是多少。
            time += 2 * 1000;
            Date d2 = new Date(time);
            System.out.println(d2);
    
            // 4、直接把日期对象的时间通过setTime方法进行修改
            Date d3 = new Date();
            d3.setTime(time);
            System.out.println(d3);
        }
    }

#### SimpleDateFormat ####

代表简单日期格式化，可以用来把日期对象、时间毫秒值格式化成我们想要的形式。

##### 构造器和方法 #####

<table> 
 <tbody> 
  <tr> 
   <td style="width:279px;"> <p>常见构造器</p> </td> 
   <td style="width:569px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:279px;"> <p>public&nbsp;SimpleDateFormat(String&nbsp;pattern)</p> </td> 
   <td style="width:569px;"> <p>创建简单日期格式化对象，并封装时间的格式</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td style="width:277px;"> <p>格式化时间的方法</p> </td> 
   <td style="width:571px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:277px;"> <p>public&nbsp;final&nbsp;String&nbsp;format(Date&nbsp;date)</p> </td> 
   <td style="width:571px;"> <p>将日期格式化成日期/时间字符串</p> </td> 
  </tr> 
  <tr> 
   <td style="width:277px;"> <p>public&nbsp;final&nbsp;String&nbsp;format(Object&nbsp;time)</p> </td> 
   <td style="width:571px;"> <p>将时间毫秒值式化成日期/时间字符串</p> </td> 
  </tr> 
 </tbody> 
</table>

public class Test2SimpleDateFormat {
        public static void main(String[] args) throws ParseException {
            // 目标：掌握SimpleDateFormat的使用。
            // 1、准备一些时间
            Date d = new Date();
            System.out.println(d);
    
            long time = d.getTime();
            System.out.println(time);
    
            // 2、格式化日期对象，和时间 毫秒值。
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
    
            String rs = sdf.format(d);
            String rs2 = sdf.format(time);
            System.out.println(rs);
            System.out.println(rs2);
            System.out.println("----------------------------------------------");
    
            // 目标：掌握SimpleDateFormat解析字符串时间 成为日期对象。
            String dateStr = "2022-12-12 12:12:11";
            // 1、创建简单日期格式化对象 , 指定的时间格式必须与被解析的时间格式一模一样，否则程序会出bug.
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d2 = sdf2.parse(dateStr);
            System.out.println(d2);
        }
    }

##### 时间格式的常见符号： #####

![3ebe53ca40cd46daa8a15065d15915f5.png][]

##### SimpleDateFormat解析字符串时间成为日期对象 #####

<table> 
 <tbody> 
  <tr> 
   <td style="width:230px;"> <p>解析方法</p> </td> 
   <td style="width:541px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:230px;"> <p>&nbsp;public&nbsp;Date&nbsp;parse(String&nbsp;source)</p> </td> 
   <td style="width:541px;"> <p>把字符串时间解析成日期对象</p> </td> 
  </tr> 
 </tbody> 
</table>

##### 秒杀案例 #####

需求 小贾下单并付款的时间为：2023年11月11日 0:01:18 小皮下单并付款的时间为：2023年11月11日 0:10:51 请用代码说明这两位同学有没有参加上秒杀活动？

public class Test3 {
        public static void main(String[] args) throws ParseException {
            // 目标：完成秒杀案例。
            // 1、把开始时间、结束时间、小贾下单时间、小皮下单时间拿到程序中来。
            String start = "2023年11月11日 0:0:0";
            String end = "2023年11月11日 0:10:0";
            String xj = "2023年11月11日 0:01:18";
            String xp = "2023年11月11日 0:10:57";
    
            // 2、把字符串的时间解析成日期对象。
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            Date startDt = sdf.parse(start);
            Date endDt = sdf.parse(end);
            Date xjDt = sdf.parse(xj);
            Date xpDt = sdf.parse(xp);
    
            // 3、开始判断小皮和小贾是否秒杀成功了。
            // 把日期对象转换成时间毫秒值来判断
            long startTime = startDt.getTime();
            long endTime = endDt.getTime();
            long xjTime = xjDt.getTime();
            long xpTime = xpDt.getTime();
    
            if(xjTime >= startTime && xjTime <= endTime){
                System.out.println("小贾您秒杀成功了~~");
            }else {
                System.out.println("小贾您秒杀失败了~~");
            }
    
            if(xpTime >= startTime && xpTime <= endTime){
                System.out.println("小皮您秒杀成功了~~");
            }else {
                System.out.println("小皮您秒杀失败了~~");
            }
        }
    }

### Calendar类 ###

Calendar类。Calendar类表示日历，它提供了一些比Date类更好用的方法。

比如下面的案例，用Date类就不太好做，而用Calendar就特别方便。因为Calendar类提供了方法可以直接对日历中的年、月、日、时、分、秒等进行运算。

##### 方法 #####

<table> 
 <tbody> 
  <tr> 
   <td style="width:265px;"> <p>方法名</p> </td> 
   <td style="width:458px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:265px;"> <p>public&nbsp;static&nbsp;Calendar&nbsp;getInstance()</p> </td> 
   <td style="width:458px;"> <p>获取当前日历对象</p> </td> 
  </tr> 
  <tr> 
   <td style="width:265px;"> <p>public&nbsp;int&nbsp;get(int&nbsp;field)</p> </td> 
   <td style="width:458px;"> <p>获取日历中的某个信息。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:265px;"> <p>public&nbsp;final&nbsp;Date&nbsp;getTime()</p> </td> 
   <td style="width:458px;"> <p>获取日期对象。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:265px;"> <p>public&nbsp;long&nbsp;getTimeInMillis()</p> </td> 
   <td style="width:458px;"> <p>获取时间毫秒值</p> </td> 
  </tr> 
  <tr> 
   <td style="width:265px;"> <p>public&nbsp;void&nbsp;set(int&nbsp;field,int&nbsp;value)</p> </td> 
   <td style="width:458px;"> <p>修改日历的某个信息。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:265px;"> <p>public&nbsp;void&nbsp;add(int&nbsp;field,int&nbsp;amount)</p> </td> 
   <td style="width:458px;"> <p>为某个信息增加/减少指定的值</p> </td> 
  </tr> 
 </tbody> 
</table>

public class Test4Calendar {
        public static void main(String[] args) {
            // 目标：掌握Calendar的使用和特点。
            // 1、得到系统此刻时间对应的日历对象。
            Calendar now = Calendar.getInstance();
            System.out.println(now);
    
            // 2、获取日历中的某个信息
            int year = now.get(Calendar.YEAR);
            System.out.println(year);
    
            int days = now.get(Calendar.DAY_OF_YEAR);
            System.out.println(days);
    
            // 3、拿到日历中记录的日期对象。
            Date d = now.getTime();
            System.out.println(d);
    
            // 4、拿到时间毫秒值
            long time = now.getTimeInMillis();
            System.out.println(time);
    
            // 5、修改日历中的某个信息
            now.set(Calendar.MONTH, 9); // 修改月份成为10月份。
            now.set(Calendar.DAY_OF_YEAR, 125); // 修改成一年中的第125天。
            System.out.println(now);
    
            // 6、为某个信息增加或者减少多少
            now.add(Calendar.DAY_OF_YEAR, 100);
            now.add(Calendar.DAY_OF_YEAR, -10);
            now.add(Calendar.DAY_OF_MONTH, 6);
            now.add(Calendar.HOUR, 12);
            now.set(2026, 11, 22);
            System.out.println(now);
        }
    }

**需求：将2023年09月10日 增加一个月**

[98bf3a83ce74475fa9c2ddaab05faf86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/fe058455779347539f658f8b7181ccd9.png
[9cae3346a01e456ea3f092f47e83c5e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/391e8d71daf145a1b8b94568add41a8d.png
[0abbdd6b0efe4c3dae7859ceb97cc971.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/81c4232055274238840e00fdbf7f42c1.png
[2ff6fa2136a14f138931dd39d73f7b94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/d54abe8738124e979edda9e715e11152.png
[5b3065aa1ca645f1b92ec282de294f9b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/35ea3493a9794b7380a0f6e1bd0bedf7.png
[1d1ab51d6e1b441a8fab072b3f5ce399.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/7332197e845a40f2994de80934f376d2.png
[0b4edc45200442b8835881aff6348088.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/40b54e9d5ed645bab1d3aff12022622d.png
[3ebe53ca40cd46daa8a15065d15915f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/93656f53953346f28525477368a6caa8.png