[Java][华为云Java编程创造营][学习笔记][第三阶段][07_Java常用类][02_常用类]

举报
John2021 发表于 2021/12/29 22:20:27 2021/12/29
【摘要】 2，Java常用类 2.1，System类System类代表系统，系统级的很多属性和控制方法都放置在该类的内部，该类位于java.lang包。由于该类的构造方法是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员方法和成员变量都是static的，可以通过类名呼叫。System中包含了in,out和err三个成员变量，分别代表标准输入流，标准输出流和标准错误输出流。...

2，Java常用类

2.1，System类

  • System类代表系统，系统级的很多属性和控制方法都放置在该类的内部，该类位于java.lang包。

  • 由于该类的构造方法是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员方法和成员变量都是static的，可以通过类名呼叫。

  • System中包含了in,out和err三个成员变量，分别代表标准输入流，标准输出流和标准错误输出流。

  • System中常用的方法：

    1. System.arraycopy(a,b,c,d,e)：其中a是被复制的数组，b是复制的起始位置，c是复制到的数组，d是复制到这个数组的起始位置，e是复制到这个数组的结束位置。
    2. System.currentTimeMillis()：返回毫秒数，这个就比较简单了，和Date类中的getTime方法一样。
    3. getProperty()：获取系统属性。

  • System类的案例：

import java.util.Scanner;

public class Test1
{
    public static void main(String[] args)
    {
        System.out.println("请输入：");
        Scanner scanner = new Scanner(System.in);
        String inputStr = scanner.next();
        System.out.println("输入的数据为：" + inputStr);
    }
    /*
    请输入：
    hello
    输入的数据为：hello
    * */
}

public class Test2
{
    public static void main(String[] args)
    {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++)
        {

        }
        long endTime = System.currentTimeMillis();
        System.out.println("时间差为：" + (endTime - startTime));
        /*
         * 输出结果
         * 时间差为：0
         * */
    }
}

public class Test3
{
    public static void main(String[] args)
    {
        String arch = System.getProperty("os.arch");
        System.out.println(arch);
        String version = System.getProperty("os.version");
        System.out.println(version);
        String home = System.getProperty("user.home");
        System.out.println(home);
    }
    /*
    * 输出结果
    *   amd64
        10.0
        C:\Users\John
    * */
}

2.2，charSequence类

  • CharSequence是一个接口，表示char值的一个可读序列，此接口对许多不同种类的char序列提供统一的自读访问。
  • CharSequence与String都能用于定义字符串，但CharSequence的值是可读可写序列，而String的值是只读序列。
public class Test1
{
    public static void main(String[] args)
    {
        CharSequence cs = "hello";
        System.out.println(cs.length());//5
        System.out.println(cs.charAt(0));//h
    }
}

public class Test2
{
    public static void main(String[] args)
    {
        //声明一个CharSequence类型的变量cs
        CharSequence cs = new StringBuffer("123");
        System.out.println(cs);//123
        cs = ((StringBuffer) cs).append("456");
        System.out.println(cs);//123456
    }
}

2.3，Runtime类

  • Runtime类封装了运行时的环境，每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。
  • Runtime类通过totalMemory()和freeMemory()方法可以知道对象的堆内存有多大，还剩多少。
public class Test
{
    public static void main(String[] args)
    {
        Runtime runtime = Runtime.getRuntime();
        System.out.println("处理器数量：" + runtime.availableProcessors());
    }
    /*
     * 输出结果
     * 处理器数量：2
     * */
}

public class Test1
{
    public static void main(String[] args)
    {
        Runtime runtime = Runtime.getRuntime();
        long mem1, mem2;
        Integer someints[] = new Integer[1000];
        System.out.println("Total memory is : " + runtime.totalMemory());//Total memory is : 62390272

        mem1 = runtime.freeMemory();
        System.out.println("Initial free is : " + mem1);//Initial free is : 59768416
        runtime.gc();
        mem1 = runtime.freeMemory();
        System.out.println("Free memory after garbage collection : " + mem1);//Free memory after garbage collection : 61738536
    }
}

2.4，cleaner类

  • Cleaner负责清理对象，替代finalize()方法，Cleaner是在JDK1.9之后才提供的一个对象清理操作。
class Member implements Runnable
{
    public Member()
    {
        System.out.println("【构造】在一个雷电交加的日子里，一个人诞生了");
    }

    @Override
    public void run()
    {
        System.out.println("【回收】最终你一定会死的");
    }
}

class MemberCleaning implements AutoCloseable
{
    //实现清除的处理
    private static final Cleaner cleaner = Cleaner.create();//创建一个清除处理
    private Member member;
    private Cleaner.Cleanable cleanable;

    public MemberCleaning()
    {
        this.member = new Member();//创建新对象
        this.cleanable = this.cleaner.register(this, this.member);//注册使用的对象
    }

    @Override
    public void close() throws Exception
    {
        this.cleanable.clean();//启动多线程
    }
}

public class Test
{
    public static void main(String[] args) throws Exception
    {
        try (MemberCleaning mc = new MemberCleaning())
        {
            //之间可以执行一些相关代码
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

2.5，深度克隆

  • 克隆和现实生活中的克隆一样，复制一个一摸一样的对象出来。
  • clone()这个方法是从Object继承下来的，一个对象要实现克隆，需要实现一个叫做Cloneable的接口，实现了这个接口就能实现克隆操作。
  • 克隆分深度克隆和浅度克隆。
  • 深度克隆：被克隆得到的对象基本类型的值修改了，原对象的值改变。
  • 深度克隆案例：
class Student implements Cloneable
{
    private String name;
    private Achievement achievement;//成绩

    public Student(String name, Achievement achievement)
    {
        this.name = name;
        this.achievement = achievement;
    }

    @Override
    protected Student clone() throws CloneNotSupportedException
    {
        Student student = (Student) super.clone();
        Achievement achievement = student.getAchievement().clone();
        student.setAchievement(achievement);
        return student;
    }

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

    public String getName()
    {
        return name;
    }

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

    public Achievement getAchievement()
    {
        return achievement;
    }

    public void setAchievement(Achievement achievement)
    {
        this.achievement = achievement;
    }
}

class Achievement implements Cloneable
{
    private float Chinese;
    private float math;
    private float English;

    public Achievement(float chinese, float math, float english)
    {
        Chinese = chinese;
        this.math = math;
        English = english;
    }

    @Override
    protected Achievement clone() throws CloneNotSupportedException
    {
        return (Achievement) super.clone();
    }

    @Override
    public String toString()
    {
        return "Achievement{" +
                "Chinese=" + Chinese +
                ", math=" + math +
                ", English=" + English +
                '}';
    }

    public float getChinese()
    {
        return Chinese;
    }

    public void setChinese(float chinese)
    {
        Chinese = chinese;
    }

    public float getMath()
    {
        return math;
    }

    public void setMath(float math)
    {
        this.math = math;
    }

    public float getEnglish()
    {
        return English;
    }

    public void setEnglish(float english)
    {
        English = english;
    }
}

public class Test
{
    /*
     * 深度克隆：复制对象本身的同时，也复制对象包含的引用指向的对象，即修改被克隆对象的任何属性都不会影响到克隆出来的对象。
     * */
    public static void main(String[] args) throws CloneNotSupportedException
    {
        Achievement achievement = new Achievement(100, 100, 100);
        Student student = new Student("张同学", achievement);
        //克隆出一个对象
        Student newStudent = student.clone();
        //修改原有对象的属性
        student.setName("李同学");
        student.getAchievement().setChinese(90);
        student.getAchievement().setEnglish(90);
        student.getAchievement().setMath(90);
        System.out.println(newStudent);
        System.out.println("---------------------");
        System.out.println(student);
    }
    /*
    * 输出结果
    *   Student{name='张同学', achievement=Achievement{Chinese=100.0, math=100.0, English=100.0}}
        Student{name='李同学', achievement=Achievement{Chinese=90.0, math=90.0, English=90.0}}
    * */
}

2.6，浅度克隆

  • 浅度克隆：被克隆得到的对象基本类型的值修改了，原对象的值不会改变。
  • 浅度克隆案例：
class Student implements Cloneable
{
    private String name;
    private Achievement achievement;//成绩

    public Student(String name, Achievement achievement)
    {
        this.name = name;
        this.achievement = achievement;
    }

    @Override
    protected Student clone() throws CloneNotSupportedException
    {
        return (Student) super.clone();
    }

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

    public String getName()
    {
        return name;
    }

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

    public Achievement getAchievement()
    {
        return achievement;
    }

    public void setAchievement(Achievement achievement)
    {
        this.achievement = achievement;
    }
}

class Achievement implements Cloneable
{
    private float Chinese;
    private float math;
    private float English;

    public Achievement(float chinese, float math, float english)
    {
        Chinese = chinese;
        this.math = math;
        English = english;
    }

    @Override
    protected Achievement clone() throws CloneNotSupportedException
    {
        return (Achievement) super.clone();
    }

    @Override
    public String toString()
    {
        return "Achievement{" +
                "Chinese=" + Chinese +
                ", math=" + math +
                ", English=" + English +
                '}';
    }

    public float getChinese()
    {
        return Chinese;
    }

    public void setChinese(float chinese)
    {
        Chinese = chinese;
    }

    public float getMath()
    {
        return math;
    }

    public void setMath(float math)
    {
        this.math = math;
    }

    public float getEnglish()
    {
        return English;
    }

    public void setEnglish(float english)
    {
        English = english;
    }
}

public class Test
{
    /*
     * 浅度克隆：复制对象时仅仅复制对象本身，包括基本属性，但该对象的属性引用其他对象时，
     * 该引用对象不会被复制，即拷贝出来的对象与被拷贝出来的对象中的属性引用的对象是同一个。
     * */
    public static void main(String[] args) throws CloneNotSupportedException
    {
        Achievement achievement = new Achievement(100, 100, 100);
        Student student = new Student("张同学", achievement);
        //克隆出一个对象
        Student newStudent = student.clone();
        //修改原有对象的属性
        student.setName("李同学");
        student.getAchievement().setChinese(90);
        student.getAchievement().setMath(90);
        student.getAchievement().setEnglish(90);
        System.out.println(newStudent);
        System.out.println(student);
    }
    /*
    * 输出结果
    *   Student{name='张同学', achievement=Achievement{Chinese=90.0, math=90.0, English=90.0}}
        Student{name='李同学', achievement=Achievement{Chinese=90.0, math=90.0, English=90.0}}
    * */
}

2.7，Math数学类

  • Math类中包含基本的数字操作，如指数、对数、平方根和三角函数。
  • Math类中包含E和PI两个静态变量，以及进行科学计算的类方法，可以直接通过类名调用。

public static final Double E = 2.7182818284590452354
public static final Double PI = 3.14159265358979323846
public static long abs(double x)：传回x的绝对值，x也可int long float
public static long sin(double x)：传回x经度的正弦函数值
public static long cos(double x)：传回x经度的余弦函数值
public static long tan(double x)：传回x经度的正切函数值
public static long asin(double x)：传回x值的反正弦函数值
public static long acos(double x)：传回x值的反余弦函数值
public static long atan(double x)：传回x值的反正切函数值
public static long atan2(double x,double y)：传回极坐标的θ值
public static long floor(double x)：传回不大于x的最大整数值

2.8，随机数类

  • Random类用于产生随机数。
  • Random.nextInt(int bound)：随机生成[0,bound)之间的整数。注意是左开右闭区间，可能取到0，不能取到bound的值。
import java.util.Random;

public class Test
{
    public static void main(String[] args)
    {
        Random random = new Random();
        for (int i = 0; i <= 10; i++)
        {
            int num = random.nextInt();
            System.out.println(num);
        }
    }
    /*
    * 输出结果
    *   1674278623
        472928102
        1151022259
        1561605962
        -1942861757
        -1681392491
        552006218
        1745546329
        -1873412215
        1577096860
        -1469750741
    * */
}

import java.util.Random;

public class Test1
{
    public static void main(String[] args)
    {
        Random random = new Random();
        for (int i = 0; i <= 10; i++)
        {
            int num = random.nextInt(10);
            System.out.println(num);
        }
    }
    /*
    * 输出结果
    *   7
        7
        4
        8
        2
        6
        1
        4
        3
        9
        5
    * */
}

2.9，科学精准计算类

  • BigDecimal是一个不变的、任意精度的有符号的十进制对象。
  • BigDecimal(double)是把一个double型十进制数构造为一个BigDecimal实例。
  • BigDecimal(String)是把一个以String表示的十进制数构造为BigDecimal实例。
  • BigDecimal(String)构造方法是被优先推荐使用的。
import java.math.BigDecimal;

public class Test
{
    public static void main(String[] args)
    {
        System.out.println(new BigDecimal(1.01));
        System.out.println(new BigDecimal("1.01"));
    }
    /*
    * 输出结果
    *   1.0100000000000000088817841970012523233890533447265625
        1.01
    * */
}

import java.math.BigDecimal;

public class Test1
{
    public static void main(String[] args)
    {
        double d1 = 1.01;
        double d2 = 2.13;
        double d3 = d1 + d2;
        System.out.println("d3=" + d3);//d3=3.1399999999999997

        BigDecimal b1 = new BigDecimal(String.valueOf(d1));
        BigDecimal b2 = new BigDecimal(String.valueOf(d2));

        double b3 = b1.add(b2).doubleValue();
        System.out.println("b3=" + b3);//b3=3.14
    }
}

2.10，日期处理类

  • Date类和Calendar类都是关于日期的类，都在java.util包中。
  • java.util.Date类的对象用来表示时间和日期，用得最多的是获取系统当前日期和时间，精确到毫秒。
  • java.util.Calender类是抽象类，无法实例化。
  • Java8新增java.time用于日期、时间处理。
  • Date类的案例
import java.util.Date;

public class Test
{
    public static void main(String[] args)
    {
        Date date = new Date();//获取当前系统日期和时间
        System.out.println("今天的日期是：" + date);//今天的日期是：Wed Dec 29 06:48:11 CST 2021

        Date dateL = new Date(0L);//带参版：参数是毫秒值
        System.out.println("Date(long date)的日期是：" + dateL);//Date(long date)的日期是：Thu Jan 01 08:00:00 CST 1970

        long time = date.getTime();//获取毫秒数
        System.out.println("自1970年1月1日起以毫秒为单位的时间(GMT)：" + time);
        //Deprecated，不赞成使用。建议使用Calendar代替。
        Date dateYMD = new Date(1999, 01, 02);
        Date dateYMDHMS = new Date(1999, 01, 02, 10, 10, 10);
    }
}
  • Calendar类的案例
import java.util.Calendar;

public class Test1
{
    public static void main(String[] args)
    {
        Calendar calendar = Calendar.getInstance();

        System.out.println(calendar.get(Calendar.YEAR) + "：年");//2021：年
        System.out.println(calendar.get(Calendar.MONTH) + "：月，从0开始算");//11：月，从0开始算
        System.out.println(calendar.get(Calendar.DATE) + "：当天 1-31");//29：当天 1-31
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH) + "：当天 1-31");//29：当天 1-31
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK) + "：星期，周日算第1天");//4：星期，周日算第1天
        System.out.println(calendar.get(Calendar.WEEK_OF_MONTH) + "：月的第n周");//5：月的第n周
        System.out.println(calendar.get(Calendar.WEEK_OF_YEAR) + "：年的第n周");//1：年的第n周
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR) + "：一年里的第n天");//363：一年里的第n天
        System.out.println(calendar.get(Calendar.HOUR) + "：12小时制");//7：12小时制
        System.out.println(calendar.get(Calendar.HOUR_OF_DAY) + "：24小时制");//7：24小时制
        System.out.println(calendar.get(Calendar.MINUTE) + "：分");//10：分
        System.out.println(calendar.get(Calendar.SECOND) + "：秒");//9：秒
        System.out.println(calendar.get(Calendar.MILLISECOND) + "：毫秒");//833：毫秒
        //闰年2月29号的一年之后
        calendar.set(2000, 2 - 1, 29);
        //把日历转为日期
        System.out.println(calendar.getTime());//Tue Feb 29 07:12:56 CST 2000
        calendar.add(Calendar.YEAR, 1);
        System.out.println(calendar.getTime());//Wed Feb 28 07:12:56 CST 2001
    }
}

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;

/*
 * Clock类：获取指定时区的日期时间
 * Duration类：一段持续的时间
 * Instant类：具体时刻，精确到纳秒
 * LocalDate类：不带时区的时间
 * */
public class Test2
{
    static void testClock()
    {
        System.out.println("---Clock类：获取指定时区的日期时间---");
        Clock clock = Clock.systemUTC();//世界统一时间
        System.out.println("当前时刻为：" + clock.instant());
        //millis()获取clock对应的毫秒数，与System.currentTimeMillis()输出相同
        System.out.println(clock.millis() + "：clock.millis()");
        System.out.println(System.currentTimeMillis() + "：System.currentTimeMillis()");
    }

    static void testDuration()
    {
        System.out.println("---Duration类：一段持续的时间---");
        int s = 60 * 59;//60秒*59=59分钟
        Duration d = Duration.ofSeconds(s);
        System.out.println(s + "秒相当于" + d.toMinutes() + "分");
        System.out.println(s + "秒相当于" + d.toHours() + "小时");
        System.out.println(s + "秒相当于" + d.toDays() + "天");
    }

    static void testInstant()
    {
        System.out.println("---Instant类：具体时刻，精确到纳秒---");
        Instant instant = Instant.now();//获取当前时间
        System.out.println(instant + "：Instant.now()");
        Instant instant1 = instant.plusSeconds(6000);
        System.out.println(instant1 + "：加时间plusSeconds()");
    }

    static void testLocalDate()
    {
        System.out.println("---LocalDate类：不带时区的时间---");
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate + "：LocalDate.now()");
        //获取某年的第几天
        int _someyear = 2017, _someday = 100;
        LocalDate localDate1 = LocalDate.ofYearDay(_someyear,_someday);
        System.out.println(localDate1 + "：" + _someyear + "年，"
                + "第" + _someday + "天LocalDate.ofYearDay()");
    }

    public static void main(String[] args)
    {
        testClock();
        testDuration();
        testInstant();
        testLocalDate();
    }
    /*
    * 输出结果
    *   ---Clock类：获取指定时区的日期时间---
        当前时刻为：2021-12-29T13:54:45.708Z
        1640786085775：clock.millis()
        1640786085775：System.currentTimeMillis()
        ---Duration类：一段持续的时间---
        3540秒相当于59分
        3540秒相当于0小时
        3540秒相当于0天
        ---Instant类：具体时刻，精确到纳秒---
        2021-12-29T13:54:45.775Z：Instant.now()
        2021-12-29T15:34:45.775Z：加时间plusSeconds()
        ---LocalDate类：不带时区的时间---
        2021-12-29：LocalDate.now()
        2017-04-10：2017年，第100天LocalDate.ofYearDay()
    * */
}

2.11，UUID类

  • UUID全称：Universally Unique Identifier缩写，即通用唯一识别码。
  • UUID产生的目的是让分布式系统中的所有元素，都能有唯一的辨识信息，而不需要通过中央控制端来做辨识信息的指定，每个人都可以创建不与其他人冲突的UUID。
import java.util.UUID;

public class Test
{
    public static void main(String[] args)
    {
        String uuid = UUID.randomUUID().toString().
                replaceAll("-", "");
        System.out.println(uuid);//ff9764b3638545ca92f8632e8432992a
    }
}

2.12，Hutool类

  • Hutool是一个小而全的Java工具类库，使Java拥有函数式语言的优雅，让Java语言也可以简单易用。
public class Test
{
    public static void main(String[] args)
    {
        //金额转换为人民币大写
        double a = 123.34;
        System.out.println(Convert.digitToChinese(a));//壹佰贰拾叁元叁角肆分
    }
}

import cn.hutool.crypto.SecureUtil;

public class Test1
{
    public static void main(String[] args)
    {
        //MD5加密
        String append = "123456";
        String sign = SecureUtil.md5(append);
        System.out.println(sign);//e10adc3949ba59abbe56e057f20f883e
    }
}

import cn.hutool.core.util.IdcardUtil;

public class Test2
{
    public static void main(String[] args)
    {
        String ID_18 = "321083197812162119";
        String ID_15 = "150102880730303";
        //身份证是否有效
        boolean valid = IdcardUtil.isValidCard(ID_18);
        boolean valid1 = IdcardUtil.isValidCard(ID_15);

        System.out.println(valid);//true
        System.out.println(valid1);//true
    }
}
【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入