java - 工具类 - 包装类，数字相关类， 日期相关类

工具类：java开发者写好的类

1.包装相关类

2.数字相关类

3.日期类

4.字符串

5.集合相关类

6.异常相关类

7.输入输出相关 IO（input/output）

8.线程

9.网络

10.注解

11.GUI

1.包装类：

为了将基本类型也面向对象，所以将他们分装进包装类中

1.byte -- Byte，short --Short，int -- Integer，long -- Long

2.float -- Float，double -- Double

3.char -- Character

4.boolean -- Boolean

6个数字相关的类都继承Number类

除了Character都有用String类型作为参数的构造方法, 也可以用 类名.valueOf();

package number_test;

public class NumberTest {

    public static void main(String[] args){
        //构造方法和valueOf
        //注意这类变量是包装类的类型，不是基本类型，基本类型是小写。
        Integer i1 = 111;
        Integer i2 = 111;
        Integer i3 = new Integer("111");
        Integer i4 = new Integer("111");
        Integer i5 = i3;

         //使用起来和 基本类型int 基本没区别，可以加减乘除打印等，但是储存方法不同，

        // == 比较基本类型比较的是值，比较引用类型则比较的是地址， equals比较的是值（所以也用来比较String这种引用类型）

        // Integer直接赋值时，值存在方法区的静态元素区，值一样时地址也一样。 java底层有一个静态数组，里面存了-127 - 128，直接赋值会把变量指向这个数组对应位置。
        //因为静态数组是-127 - 128，所以如果Integer的值大于这个范围，则会自动给他new一个对象存在堆内存中
        System.out.println("i1 == i2: " + (i1 == i2)); //定义时两个存在了方法区的静态元素区中
        i1 = 1111;
        i2 = 1111;
        System.out.println("i1 == i2: " + (i1 == i2)); //定义时两个存在了堆内存中

        System.out.println("i3 == i4: " + (i3 == i4)); //两个定义时用了new，存在了堆内存，所以地址不同
        System.out.println("i3 == i5: " + (i3 == i5));
        System.out.println("i1 .equals( i2 ): " + (i1.equals(i2)));
        System.out.println("i3 .equals( i4 ): " + (i3.equals(i4)));
//        i1 == i2: true
//        i1 == i2: false
//        i3 == i4: false
//        i3 == i5: true
//        i1 .equals( i2 ): true
//        i3 .equals( i4 ): true

        //String
        String s1 = i1.toString();
        String s2 = i2.toString();
        System.out.println("s1 == s2: " + (s1 == s2)); //值通过计算获得，两者地址不同
        System.out.println("s1.equali3;s(s2): " + (s1.equals(s2)));
        s1 = "abc";
        s2 = "abc";
        System.out.println("改为直接赋值：s1 == s2: " + (s1 == s2)); //如果是直接赋值，他们的值会相同 - -这里我有点没明白
        //查资料，说是java对String进行了优化，刚赋值时会存入缓存池，如果之后有相同的赋值操作，会指向同一个地址,不是直接赋值或者赋不同值才会new新对象。
        //所以测试一下：
        String s3 = "bcd";
        String s4 = "bc"; //这里应该是已经new了一个新对象，再改变他应该就不会相等了。
        s4 = s4 + "d";  //s4 = s4 + "d";是false，如果直接 s4  =  "bc" + "d";则下面s3 == s4依旧为true，稍微有点不太明白- -
        System.out.println("直接赋值测试:s1 == s2: " + (s1 == s2));
        System.out.println("直接赋值测试:s3 == s4: " + (s3 == s4));

//        s1 == s2: false
//        s1.equali3;s(s2): true
//        改为直接赋值：s1 == s2: true
//        直接赋值测试:s1 == s2: true
//        直接赋值测试:s3 == s4: false    

        Byte b = Byte.valueOf("111");
        int i = Integer.valueOf("111");
        Long l = Long.valueOf("222");
        Float f = new Float("1.1");
        Double d = Double.valueOf("2.2");
        boolean bt = new Boolean("true");
        Boolean bf = Boolean.valueOf("false");
        //可以直接使用
        System.out.println(i * 10);
        System.out.println(l * 10);
        System.out.println(f * 10);
        System.out.println(d * 10);
        if(bt){
            System.out.println(bt);
        }
        if(!bf){
            System.out.println(bf);
        }
//        1110
//        2220
//        11.0
//        22.0
//        true
//        false

        //intValue
        int intTest = i1.intValue(); //把包装类变成基本类型
        int doubleTest = d.intValue();//取整数部分
        int charTest = ‘a‘;//asc码转成数字，char和int可以直接转换
        int stringTest = Integer.parseInt("111");//直接把字符串转为int

        System.out.println(intTest);
        System.out.println(doubleTest);
        System.out.println(charTest);
        System.out.println(stringTest);
//        111
//        2
//        97
//        111

        //于是想测试一下。。。
        System.out.println("i3 == i4: " + (i3 == i4)); //两个定义时用了new所以地址不同
        int ii3 = i3.intValue();
        int ii4 = i4.intValue();
        System.out.println("ii3 == ii4: " + (ii3 == ii4)); //两个定义时用了new所以地址不同
        //i3 == i4: false
        //ii3 == ii4: true
        //int值存在常量区，所以只要值一样地址就一样，

        // Integer不是直接赋值时，如new赋值时，和引用类型一样

//        intValue()是把Integer对象类型变成int的基础数据类型；
//        parseInt()是把String 变成int的基础数据类型；
//        Valueof()是把给定的String参数转化成Integer对象类型；
        //不过现在java支持自动转换了，所以其实可以混着用。。。
    }

}

2.数学相关的类：

Math用来进行基本类型的运算相关

Random

BigInteger

BigDecimal

package Math_test;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Random;

public class MathTest {
    public static void main(String[] args){
        //Math构造方法为私有，方法都是static，所以可以直接调用（单例模式），Math有很多方法，只挑部分常用的

        //Math.random()，返回一个0-1之间的double类型的数字
        for(int i = 0; i < 5; i++){
            System.out.println(Math.random());//返回一个0-1之间的double类型的数字
        }
//        0.30222893423699926
//        0.37739767545532177
//        0.13927359803309325
//        0.9123839746760073
//        0.9768944004877123

        //Random,专门用来生成随机数的类
        for(int i = 0; i < 5; i++){
            System.out.println( new Random().nextInt(10) );//返回一个0-9之间的int类型的数字  ,还可以nextFloat，nextBoolean等
        }
//        8
//        5
//        3
//        3
//        0

        //Math.abs(); 变为正数
        int i = -111;
        System.out.println( Math.abs(i) );

        //取最近值
        System.out.println( Math.ceil(1.4) ); //向上取
        System.out.println( Math.ceil(1.5) ); //向上取
//        2.0
//        2.0

        System.out.println( Math.floor(1.8) );//向下取
        System.out.println( Math.floor(1.5) );//向下取
//        1.0
//        1.0

        System.out.println( Math.rint(1.4) ); //最近的整数，一样的话返回偶数
        System.out.println( Math.rint(1.5) ); //最近的整数，一样的话返回偶数
        System.out.println( Math.rint(2.5) ); //最近的整数，一样的话返回偶数
//        1.0
//        2.0
//        2.0

        System.out.println( Math.round(1.4) );//四舍五入返回int
        System.out.println( Math.round(1.5) );//四舍五入返回int
        System.out.println( Math.round(2.5) );//四舍五入返回int
//        1
//        2
//        3

        //负数测试：
        System.out.println( Math.ceil(-1.4) ); //向上取
        System.out.println( Math.ceil(-1.5) ); //向上取
//        -1.0
//        -1.0

        System.out.println( Math.floor(-1.8) );//向下取
        System.out.println( Math.floor(-1.5) );//向下取
//        -2.0
//        -2.0

        System.out.println( Math.rint(-1.4) ); //最近的整数，一样的话返回偶数
        System.out.println( Math.rint(-1.5) ); //最近的整数，一样的话返回偶数
        System.out.println( Math.rint(-2.5) ); //最近的整数，一样的话返回偶数
//        -1.0
//        -2.0
//        -2.0

        System.out.println( Math.round(-1.4) );//四舍五入返回int
        System.out.println( Math.round(-1.5) );//四舍五入返回int
        System.out.println( Math.round(-2.5) );//四舍五入返回int
//        -1
//        -1
//        -2

        //Math.max, Math.min
        System.out.println( Math.max(111,222) );//取最大值
        System.out.println( Math.min(111,222L) );//取最小值
//        222
//        111

        //Math.sqrt()  平方根
        System.out.println( Math.sqrt(1.21) ); //double类型返回
        System.out.println( Math.sqrt(9) ); //double类型返回
//        1.1
//        3.0

        //BigInteger,用来储存超大整数
        BigInteger bi = new BigInteger(                "5555555555555555555555555555555555555555555555555555555555555555");
        System.out.println(bi);
//        111111111111111111111111111111111111111111111111111111111111111111
        System.out.println(bi.add(new BigInteger(     "1111111122222222222222222233333333333333333333333333333444444444")));//加
        System.out.println(bi.subtract(new BigInteger("1111111122222222222222222233333333333333333333333333333444444444")));//减
        System.out.println(bi.multiply(new BigInteger("11111111")));//乘
        System.out.println(bi.divide(new BigInteger(  "1111111111111111111111111111111111111111111111111111111111111111")));//除
        //BigInteger的运算只能是BigInteger之间
//        5555555555555555555555555555555555555555555555555555555555555555
//        6666666677777777777777777788888888888888888888888888888999999999
//        4444444433333333333333333322222222222222222222222222222111111111
//        61728394444444444444444444444444444444444444444444444444444444438271605
//        5

          //BigDecimal,用来储存超大小数，加减乘除运算和NigInteger一致
        BigDecimal bd = new BigDecimal("55555555555555555555555555555555.555555555555555555555555555555555555555555555555555555");
        System.out.println(bd.add(new BigDecimal("55555555555555555555555555555555.555555555555555555555555555555555555555555555555555555")));
        System.out.println(bd.setScale(2,BigDecimal.ROUND_UP)); //setScale(int newScale, RoundingMode roundingMode)
        System.out.println(bd.setScale(2,BigDecimal.ROUND_DOWN));
//        111111111111111111111111111111111.111111111111111111111111111111111111111111111111111110
//        55555555555555555555555555555555.56
//        55555555555555555555555555555555.55
    }
}

3.日期：

Date

Calendar

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class TimeTest {
    public static void main(String[] args){
        System.out.println(System.currentTimeMillis());//计算机元年1970.1.1到现在的毫秒差
        try {
            Thread.sleep(3000); //尝试让这个线程睡眠3000毫秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis());

        //正好过了3000毫秒
//        1570000718473
//        1570000721473
        //这个方法也可以用来测试电脑或者程序运算性能

        //Date
        Date d = new Date(System.currentTimeMillis()); //构造方法中添加的是计算机元年1970.1.1到现在的毫秒差
        d = new Date();//直接new默认当前时间
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd KK:mm:ss");
        System.out.println(simpleDateFormat.format(d));
        //2019-10-02 03:23:22

        //Date现在很少使用了，日期处理采用calendar
        Calendar cal = Calendar.getInstance();  //创建当前时间的时间对象
        //public void set(int year,int month,int date,int hourofday,int minute,int second)

        cal.set(1990,5,26,2,15,16);
        cal.set(Calendar.DATE, 2);
        // 获取年
        int year = cal.get(Calendar.YEAR);
        // 获取月
        int month = cal.get(Calendar.MONTH);
        // 获取日
        int date = cal.get(Calendar.DATE);
        // 获取时
        int hour = cal.get(Calendar.HOUR);  //会自动 %12，所以上面就算hourOfDay设成25也是能存入 1 的= =

        //getTimeZoon();
        System.out.println("timeZoon = " + cal.getTimeZone().getDisplayName());

        System.out.println(simpleDateFormat.format(cal.getTime()));//simpleDateFormat一样可以处理cal,需要把calendar先转为date

    }
}

原文地址：https://www.cnblogs.com/clamp7724/p/11617563.html

时间： 2024-10-11 01:10:48

java - 工具类 - 包装类，数字相关类， 日期相关类的相关文章

Android随笔之——Android时间、日期相关类和方法

今天要讲的是Android里关于时间.日期相关类和方法.在Android中,跟时间.日期有关的类主要有Time.Calendar.Date三个类.而与日期格式化输出有关的DateFormat和SimpleDateFormat,今天会稍微提到关于这两个类的用法,下次会找个时间细讲. 一.Time类 在官方的API中,有建议说使用Time代替Calendar,原因不明,据说用Time对CPU的负荷比较小. 在Time中,年月日时分秒的转义字符分别对应%Y%m%d%H%M%S,切记,大小写千万不能写错

第2章 日期相关类

1.1 Date类Date: 表示特定的瞬间,精确到毫秒,他可以通过方法来设定自己所表示的时间,可以表示任意的时间1.1.1 Date类的构造方法Date() :创建的是一个表示当前系统时间的Date对象Date(long date) :根据"指定时间"创建Date对象1.1.2 案例代码五 package com.itheima_03; import java.util.Date; /* * Date: 表示特定的瞬间,精确到毫秒,他可以通过方法来设定自己所表示的时间,可以表示任意的

第二十二节（String，StringBuffer，基础类型对应的 8 个包装类，日期相关类、 Random 数字 ，Enum枚举）上

/* 获取当前的毫秒数 1S = 1000毫秒 */ public class DateTest01{ public static void main(String[] args){ long now = System.currentTimeMillis(); System.out.println(now); // 1418662206661 } } /////////////////////////////////////////////////////////////////////////

第二十三节（String，StringBuffer，基础类型对应的 8 个包装类，日期相关类、 Random 数字 ，Enum枚举）下

/* java.lang.String 是字符串类型 注意:只要采用双引号赋值字符串,那么在编译期将会放到方法区中的字符串的常量池里, 如果是运行时对字符串.加或相减会放到堆中(放之前会先验证方法区中是否含有 相同的字符串常量,如果存在,把地址返回,如果不存在,先将字符串常量放到池中,然 后再返回该对象的地址 */ public class StringTest01{ // java的入口 public static void main(String[] args){ // 创建一个“abc”字

Java面向对象_常用类库api——日期操作类

Data类 类Data表示特定的瞬间,精确到毫秒,也就是程序运行时的当前时间 Data data=new Data();//实例化Data对象,表示当前时间 Calendar类 日历类,使用此类可以将时间精确到毫秒显示. //两种实例化方式 Calendar c=Calendar.getInstance();//Calendar类是抽象类,不能直接new Calendar c=new GregorianCalendar(); DateFormat类及子类SimpleDateFormat 例: 1

日期相关类data，simpledataformat类

(1) (2) 原文地址:https://www.cnblogs.com/Yefudaling/p/12368643.html

Date类，时间和日期格式类

Date类:构造一个反应当前时间的实例.         Date s=new Date(); System.out.println(s); 打印变量s可得到计算机当前时间,可具体到时间单位'秒'. long starttime=System.currentTimeMillis(); long endtime=System.currentTimeMillis(); starttime与endtime会统计一段执行时间,这个时间段就是两个表达式之间的代码所执行的时间.这样可以计算当前代码执行的效率

Java知多少（77）日期和时间类

Java 的日期和时间类位于 java.util 包中.利用日期时间类提供的方法,可以获取当前的日期和时间,创建日期和时间参数,计算和比较时间. Date 类 Date 类是 Java 中的日期时间类,其构造方法比较多,下面是常用的两个: Date():使用当前的日期和时间初始化一个对象. Date(long millisec):从1970年01月01日00时(格林威治时间)开始以毫秒计算时间,计算 millisec 毫秒.如果运行 Java 程序的本地时区是北京时区(与格林威治时间相差 8 小

1、自学——Linux的学习进度与任务【时间日期管理类的命令】

时间日期管理类的命令 时间日期管理类的命令:  # date :显示 # date MMDDhhmm[CC]YY.ss :设定 # date [+FORMAT] %Y:4位年份 %y:  2位年份 %M:  分 %m:月 %d:  日 %H:  时 %S:  秒 %T: 时间(以冒号隔开) %D:日期 %F: 日期(以横杆隔开) unix元年:1970-01-01 00:00:00 %s:timestamp:从unix元年开始到此刻所经历的秒数 # cal   :    显示日历 # cal #