【JAVA基础】16 常见类

1. Math类概述和方法使用

Math类概述
- Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
成员方法
- public static int abs(int a)
- public static double ceil(double a)
- public static double floor(double a)
- public static int max(int a,int b)
- public static double pow(double a,double b)
- public static double random()
- public static int round(float a)
- public static double sqrt(double a)

package com.heima.otherclass;

public class Demo1_Math {

    /**
    Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。 

    与 StrictMath 类的某些数学方法不同，并非 Math 类所有等价函数的实现都定义为返回逐位相同的结果。此类在不需要严格重复的地方可以得到更好的执行。

     */
    public static void main(String[] args) {
        // 常量π和指数e
        System.out.println(Math.PI);
        System.out.println(Math.E);
        
        // 常见方法
        System.out.println(Math.abs(-10));
        System.out.println(Math.ceil(12.3));
        System.out.println(Math.floor(12.3));
        System.out.println(Math.max(2,3));
        System.out.println(Math.min(1,-1));
        System.out.println(Math.pow(2,3));
        System.out.println(Math.random());
        System.out.println(Math.round(4.49f));
        System.out.println(Math.round(780999.99144));
        System.out.println(Math.sqrt(2));
        
    }

}

View Code

2. Random类的概述和方法使用

Random类的概述
- 此类的实例用于生成伪随机数流。
- 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
- 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
构造方法
- public Random()
- public Random(long seed)
成员方法
- public int nextInt()
- public int nextInt(int n) 生成 [0, n-1]的随机整数

package com.heima.otherclass;

import java.util.Random;

public class Demo2_Random {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextInt());
        System.out.println(r.nextInt(12));
        System.out.println(r.nextLong());
        System.out.println(r.nextFloat());
        System.out.println(r.nextBoolean());
        System.out.println(r.nextDouble());
        System.out.println(r.nextGaussian());
        
    }

}

View Code

3. System类的概述和方法使用

System类的概述
- System 类包含一些有用的类字段和方法。它不能被实例化。
- 在System类提供的设施中，有标准输入，标准输出，错误输出流。
- 对外部定义的属性和环境变量的访问
- 加载文件和库的方法
- 快速复制数组的一部分的实用方法。
成员方法
- public static void gc() 运行垃圾回收器
- public static void exit(int status) 终止当前正在运行的 Java 虚拟机。
- public static long currentTimeMillis() 返回以毫秒为单位的当前时间。
- pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

案例演示

System类的成员方法使用

package com.heima.otherclass;

public class Demo3_System {

    /**
    public static void gc()  运行垃圾回收器

    public static void exit(int status)   终止当前正在运行的 Java 虚拟机。

    public static long currentTimeMillis()   返回以毫秒为单位的当前时间。

    pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)    从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
     */
    public static void main(String[] args) {
//        demo1();
        
//        demo2();
        
//        demo3();
        demo4();
        
    }

    public static void demo4() {
        int[] src = {11,22,33,44,55};
        int[] dest = new int[8];
        System.arraycopy(src, 2, dest, 2, 3); // 将数组内容拷贝
        for(int i = 0; i < dest.length; i++) {
            System.out.println(i + " " + dest[i]);
        }
    }

    public static void demo3() {
        //System.out.println(System.currentTimeMillis());  // 当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。

        long start = System.currentTimeMillis();
        demo1();
        long end = System.currentTimeMillis();
        long diff = end - start;  // 可以用来测试程序运行需要的毫秒值
        System.out.println(diff);
    }

    public static void demo2() {
        System.exit(0); // 非0状态是异常终止；exit表示退出jvm
        System.out.println("这行信息由于已经退出了jvm，是不会执行的");
    }

    public static void demo1() {
        for(int i = 0; i < 9; i++) {
            new Demo();
            System.gc();   // 运行垃圾回收器，相当于呼喊保洁阿姨
        }
    }

}

class Demo {          // 在一个源文件中不允许定义两个用public修饰的类
    
    @Override 
    public void finalize() {
        System.out.println("垃圾被清扫了");
    }
}

View Code

4. BigInteger类的概述和方法使用

BigInteger的概述
- 可以让超过Integer范围内的数据进行运算
- 不可变的任意精度的整数。
- 所有操作中，都以二进制补码形式表示 BigInteger（如 Java 的基本整数类型）。
- BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。
- 另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。
构造方法
- public BigInteger(String val)
成员方法
- public BigInteger add(BigInteger val)
- public BigInteger subtract(BigInteger val)
- public BigInteger multiply(BigInteger val)
- public BigInteger divide(BigInteger val)
- public BigInteger[] divideAndRemainder(BigInteger val)

package com.heima.otherclass;

import java.math.BigInteger;
import java.util.Arrays;

public class Demo4_BigInteger {

    /**
    
     */
    public static void main(String[] args) {
        int a = 1234466666;  // int表示的数的长度有限
        long b = 9099999999999999999L;   // long表示的数的长度比int大，但也有限
        String s = "12426272727272727272727272727272";  
        BigInteger big = new BigInteger(s);
        System.out.println(big);
        
        
        BigInteger bi1 = new BigInteger("100");
        BigInteger bi2 = new BigInteger("2");
        
        //加减乘除，divideAndRemainder 输出{商，取模}的数组结果
        System.out.println(bi1.add(bi2));
        System.out.println(bi1.subtract(bi2));
        System.out.println(bi1.multiply(bi2));
        System.out.println(bi1.divide(bi2));
        System.out.println(Arrays.toString(bi1.divideAndRemainder(bi2)));
        
    }

}

View Code

5. BigDecimal类的概述和方法使用

BigDecimal的概述

不可变的、任意精度的有符号十进制数。
BigDecimal 由任意精度的整数非标度值和 32位的整数标度（scale）组成。
- 如果为0或正数，则标度是小数点后的位数。
- 如果为负数，则将该数的非标度值乘以10的负scale次幂。
- BigDecimal表示的数值是（unscaledValue × 10^-scale）
由于在运算的时候，float类型和double类型很容易丢失精度，演示案例。
所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
BigDecimal 类提供以下操作：
- 算数
- 标度操作
- 舍入
- 哈希算法
- 格式转换
- toString() 方法提供BigDecimal 的规范表示形式。

构造方法
- public BigDecimal(String val)
成员方法
- public BigDecimal add(BigDecimal augend)
- public BigDecimal subtract(BigDecimal subtrahend)
- public BigDecimal multiply(BigDecimal multiplicand)
- public BigDecimal divide(BigDecimal divisor)

案例演示

BigDecimal类的构造方法和成员方法使用

package com.heima.otherclass;

import java.math.BigDecimal;
import java.util.Arrays;

public class Demo5_BigDecimal {

    /**
    构造方法
        public BigDecimal(String val)
    
    成员方法
        public BigDecimal add(BigDecimal augend)
        
        public BigDecimal subtract(BigDecimal subtrahend)
        
        public BigDecimal multiply(BigDecimal multiplicand)
        
        public BigDecimal divide(BigDecimal divisor)
     */
    public static void main(String[] args) {
        // 第一种：精准获得小数计算的结果
        BigDecimal bd1 = new BigDecimal("2.99");  
        BigDecimal bd2 = new BigDecimal("2.1");
        System.out.println(bd1.add(bd2));
        System.out.println(bd1.subtract(bd2));
        System.out.println(bd1.multiply(bd2));
        // 两个数相除，保留两位小数（示例是四舍五入）
        System.out.println(bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP));
        

        
        // 第二种：精准获得小数计算的结果
        System.out.println("-------");
        BigDecimal bd3 = BigDecimal.valueOf(2.99);
        BigDecimal bd4 = BigDecimal.valueOf(2.1);
        System.out.println(bd3.add(bd4));
        System.out.println(bd3.subtract(bd4));
        System.out.println(bd3.multiply(bd4));
        System.out.println(bd3.divide(bd4,2,BigDecimal.ROUND_HALF_UP));
        
        
        
    }

}

View Code

6. Date类的概述和方法使用

Date类的概述
- 类 Date 表示特定的瞬间，精确到毫秒。
构造方法
- public Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
- public Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
成员方法
- public long getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
- public void setTime(long time) 设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。

package com.heima.otherclass;

import java.util.Date;


public class Demo6_Date {

    /**
    构造方法
        public Date()   分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
        public Date(long date)    分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

    成员方法
        public long getTime()    返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
        public void setTime(long time)   设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
     */
    public static void main(String[] args) {
        Date d1 = new Date(); 
        System.out.println(d1);
        
        Date d2 = new Date(0);
        System.out.println(d2);
        
        System.out.println(System.currentTimeMillis());
        System.out.println(new Date(System.currentTimeMillis()));
        
        // 获取当前时间从1970年到现在的毫秒数
        System.out.println(d1.getTime());
        
        // 设置从1970年开始的毫秒数
        d1.setTime(353656840);
        System.out.println(d1.getTime());
        
        System.out.println(d1);
        
    }

}

View Code

7. SimpleDateFormat类实现日期和字符串的相互转换

DateFormat类的概述
- DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
SimpleDateFormat类的概述
- SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
  
  SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来创建日期-时间格式器。每一个这样的类方法都能够返回一个以默认格式模式初始化的日期/时间格式器。
SimpleDateFormat构造方法
- public SimpleDateFormat()
- public SimpleDateFormat(String pattern)
成员方法
- public final String format(Date date)
- public Date parse(String source)

package com.heima.otherclass;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo7_SimpeDateFormat {

    /**
     */
    public static void main(String[] args) throws ParseException {
//        demo1();
        
        demo2();
        
        // 将字符串格式时间转换格式
        String str = "2008年1月1日 00:11:59";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        try {
            Date d = sdf.parse(str);
            System.out.println(d);
        } catch (ParseException e) {
            System.out.println("wrong");
        }
        
    }

    public static void demo2() {
        Date d = new Date(); // 获取当前时间对象
        System.out.println(d.getTime());
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年mm月dd日 HH时MM分SS秒");  // 创建日期格式化类对象
        System.out.println(sdf.format(d));
    }

    public static void demo1() {
        // DateFormat类是抽象类，不能实例化
        // 下面的用getDateInstance方法，相当于父类引用指向子类对象，返回一个SimpleDateFormat子类对象
        DateFormat df = DateFormat.getDateInstance();
    }

}

View Code

8. 你来到这个世界多少天案例

案例演示

需求：算一下你来到这个世界多少天?

package com.heima.test;

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

public class Test3 {

    /**
    需求：算一下你来到这个世界多少天?
    分析：
    1. 将生日字符串和今天字符串在String类型的变量中
    2. 定义日期格式化对象
    3. 将日期字符串转换成日期对象
    4. 通过日期对象获取时间毫秒值
    5. 将两个时间毫秒值相减，再除以1000得到秒，再除以60得到分钟，再除以60得到小时，再除以24得到天
     */
    public static void main(String[] args) {
        // 出生日期
        String birthday = "1993年02月19日 08:00:00";
        String today = "2020年5月14日 08:00:00";
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:SS");
        try {
            Date d1 = sdf.parse(birthday);
            Date d2 = sdf.parse(today);
            
            long time = d2.getTime() - d1.getTime();
            System.out.println(time / 1000 / 60 / 60 / 24 + "天");
        } catch (ParseException e) {
            System.out.println("wrong");
        }
        
        
        
    }

}

View Code

9. Calendar类的概述和获取日期的方法

Calendar类的概述
- Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
- 瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。
- 该类还为实现包范围外的具体日历系统提供了其他字段和方法。这些字段和方法被定义为protected
成员方法
- public static Calendar getInstance()
- public int get(int field)

注意事项：

指示月份的 get 和 set 的字段数字。这是一个特定于日历的值。在格里高利历和罗马儒略历中一年中的第一个月是 JANUARY，它为 0；最后一个月取决于一年中的月份数。

package com.heima.otherclass;

import java.util.Calendar;

public class Demo9_Calendar {
    public static void main(String[] args) {
         Calendar rightNow = Calendar.getInstance();  // 父类引用指向子类对象，Calendar是抽象类
         System.out.println(rightNow);
         System.out.println(rightNow.get(Calendar.YEAR));
         System.out.println(rightNow.get(Calendar.MONTH));
         System.out.println(rightNow.get(Calendar.DATE));
         System.out.println(rightNow.get(Calendar.ZONE_OFFSET));
         System.out.println(rightNow.get(Calendar.HOUR));
         System.out.println(rightNow.get(Calendar.HOUR_OF_DAY));
         System.out.println(rightNow.get(Calendar.MINUTE));
    }
}

View Code

10. Calendar类的add()和set()方法

成员方法
- public void add(int field,int amount)
- public final void set(int year,int month,int date)

案例演示

Calendar类的成员方法使用

package com.heima.otherclass;

import java.util.Calendar;

public class Demo9_Calendar {
    public static void main(String[] args) {
         Calendar c = Calendar.getInstance();  // 父类引用指向子类对象，Calendar是抽象类
         
         
         c.add(Calendar.YEAR, 1);   // 对指定的字段进行加减
         c.add(Calendar.YEAR, -10);    
         c.set(Calendar.DATE,1);   // 修改指定字段
         c.set(2008,8,8);
         
         String s = c.get(Calendar.YEAR) + "年" + 
                 getNum(c.get(Calendar.MONTH) + 1) + "月" + getNum(c.get(Calendar.DATE)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK));
         System.out.println(s);
        
    }
    
    public static String getWeek(int week) {
        String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        return arr[week];
    }
    
    public static String getNum(int day) {
        return (day > 9) ? "" + day: "0" + day;
    }
}

View Code

11. 如何获取任意年份是平年还是闰年

案例演示

需求：键盘录入任意一个年份，判断该年是闰年还是平年

package com.heima.test;

import java.util.Calendar;
import java.util.Scanner;

public class Test4 {
    /**
    需求：键盘录入任意一个年份，判断该年是闰年还是平年
    分析：
    1. 从键盘读取流，获取年份，判断输入是否合法
    2. 通过Calendar类获取年份是否为闰年还是平年
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份，用于判断年份是否是闰年：");
        String line = sc.nextLine();
        int year = Integer.parseInt(line);
        //int year = sc.nextInt();
        
        
        System.out.println(judge(year));
        
    }

    public static boolean judge(int year) {
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);  // 设置为3月1日，注意月份是从0开始到11结束，3月是数字2指代
            
        c.add(Calendar.DATE,-1);
    
        int day = c.get(Calendar.DAY_OF_MONTH);
        return (day < 29) ? false : true;
    }
}

View Code

posted on 2020-05-14 11:28 Zoe233 阅读(186) 评论(0) 编辑收藏举报