Java常用类库API

Posted 2020-12-12 sawye-sxy

目录

• 字符串操作
  • String类
    • String两种赋值方式
    • String类中的构造函数
      • String()方法
      • String(byte[] bytes)方法
      • String(byte[] bytes,int offset,int length)方法
      • String(char[] value)方法
      • String(byte[] char,int offset,int length)方法
    • String类的常用方法
      • isEmpty()方法
      • length()方法
      • toUpperCase()转大写
      • toLowerCase()转小写
      • trim()方法
      • concat(String str)方法
      • charAt(int index)方法
      • contains(String str)方法
      • getBytes( )将字符串转换为字节数组
      • toCharArray( )将字符串转换为字符数组
      • compareTo()
      • compareToIgnoreCase( )
      • indexOf(int ch)
      • indexOf(int ch，int fromIndex)
      • indexOf(String str)
      • indexOf(String str，int fromIndex)】
      • lastIndexOf(string str)
      • startsWith(String str)
      • startsWith(String str，int toffset)
      • endsWith(String str )
      • replace(char oldChar，char newChar)替换指定字符
      • replace(CharSequence target，CharSequence replacement)替换指定字符串
      • replaceAll(String regex，String replacement)替换指定的字符串
      • repalceFirst(String regex，String replacement)
      • substring(int beginIndex)
      • substring(int beginIndex, int endIndex)
      • split(String regex)
      • split(String regex，int limit)
      • valueOf()
  • StringBuffer类
    • StringBuffer常用的方法
      • StringBuffer()
      • StringBuffer(String str)
      • StringBuffer(CharSequence seq)
      • append(数据类型 b)
      • delete(int start，int end)
      • indexOf(String str)
      • insert(int offset，数据类型 b)
      • replace(int start，int end，String str)
      • substring(int start, int end)
      • substring(int start)
      • reverse()
  • StringBuilder类
• 程序国际化
  • Locale类
  • ResourceBundle类
    • getBundle(String baseName)方法
    • getString(String key)方法
  • MessageFormat类
• Math与Random类
  • Math类
    • PI
    • abs(double a)方法
    • random()方法
    • round(double a)方法
    • sqrt(double a)方法
    • floor()方法
  • Random类
    • nextLong()方法
    • nextBoolean()方法
    • nextDouble()方法
    • nextInt()方法
    • nextInt(int n)方法
• 日期操作类
  • Date类
    • Date()方法
    • Date(long date)方法
  • Calendar类
  • DateFormat类及子类SimpleDateFormat
• 对象比较器
  • Comparable接口
  • Comparator接口
• 对象的克隆
  • Clone()方法
• System与Runtime类
  • System类
    • arraycopy()方法
    • currentTimeMillis()方法
    • exit(int status)方法
    • gc()方法
    • getProperty(String key)方法
    • loadLibrary(string libname)
  • Runtime类
• 数字处理工具类
  • BigInteger类
    • 构造方法
      • BigInteger(String val)
    • 常用方法
      • add(BigInteger val)
      • subtract(BigInteger val)
      • multiply(BigInteger val)
      • divide(BigInteger val)
      • remainder(BigInteger val)
      • divideAndRemainder(BigInteger val)
  • BigDecimal类
    • 构造方法
      • BigDecimal(String val)
    • 常用方法
      • add(BigDecimal val)
      • substract(BigDecimal val)
      • multiply(BigDecimal val)
      • divide(BigDecimal val)
  • DecimalFormat类
• MD5工具类

字符串操作

String类

• String可以表示一个字符串
• String类实际是使用字符数组存储的

String两种赋值方式

1. 直接赋值:java推荐使用

   String name = "xiaoyu";//对象生成在常量池中
   

2. 通过关键字new调用String的构造方法赋值

   String name = new String("xiaoyu");//创建了两个对象 new：表示申请内存空间
   

String表示一个字符串，内部使用字符数组实现，不能被继承（它是最终类），不可变

package com.API.demo01;

public class Demo01{
    public static void main(String[] args) {
        //直接赋值字符串连接时，考虑编译器和运行期
        //如果在编译器值可以被确定，那么使用已有的对象，否则会创建新的对象
        String a = "a";
        String a1 = a+1;//在堆中创建一个“a1”
        String a2 = "a1";//这个a1是在常量池中
        System.out.println(a1==a2);//false


        final String b = "b";//final是常量
        String b1=b+1;//常量相加
        String b2="b1";
        System.out.println(b1==b2);//true

        String c = getC();
        String c1=c+1;
        String c2="c1";
        System.out.println(c1==c2);//false

        final String d = getD();
        String d1=d+1;
        String d2="d1";
        System.out.println(d1==d2);//false

    }

    private static String getC(){
        return "c";
    }

    private static String getD(){
        return "d";
    }
}

String类中的构造函数

String()方法

构造一个空字符串对象

String s = new String();

String(byte[] bytes)方法

通过byte数组构造字符串对象

String(byte[] bytes,int offset,int length)方法

通过byte数组，从offset开始，总共length长的字节构造字符串对象

String(char[] value)方法

通过char数组构造字符串对象

char[] cs ={‘a‘,‘b‘,‘c‘};
String s1 = new String(cs);//将数组变成字符串

String(byte[] char,int offset,int length)方法

通过char数组，从offset开始，总共length长的字节构造字符串对象

char[] cs ={‘a‘,‘b‘,‘c‘};
String s2 = new String(cs,0,2);
System.out.println(s2);//a

String类的常用方法

isEmpty()方法

判断是否为空，指的是内容为空

String str1="";
System.out.println(str1.isEmpty());//true

length()方法

查看字符串长度

String str = "sads1231sad";
System.out.println(str.length());//11

toUpperCase()转大写

String str = "sads1231sad";
System.out.println(str.toUpperCase());//SADS1231SAD

toLowerCase()转小写

String str1= "WEDVCSDFZZVC";
System.out.println(str1.toLowerCase());//wedvcsdfzzvc

trim()方法

用户数据后台校验前的过滤，返回字符串的副本，忽略前部空白和尾部空白

String str1= " WEDVCS DFZZVC ";
System.out.println(str1.trim());//WEDVCS DFZZVC

concat(String str)方法

字符号连接操作

String str = "sads1231sad";
System.out.println(str.concat("***8*"));//sads1231sad***8*

charAt(int index)方法

获取字符串中的某个值

String str = "sads1231sad";
char c=str.charAt(1);
System.out.println(c);//a

contains(String str)方法

判断一个字符串是否包含另一个字符串

String str = "sads1231sad";
System.out.println(str.contains("a"));//true

getBytes( )将字符串转换为字节数组

String str = "sads1231sad";
System.out.println(Arrays.toString(str.getBytes()));//[115, 97, 100, 115, 49, 50, 51, 49, 115, 97, 100]

toCharArray( )将字符串转换为字符数组

String str = "sads1231sad";
System.out.println(str.toCharArray());//sads1231sad

compareTo()

比较两个字符串的大小，相等返回0，大于返回正数，小于返回负数

String str = "sads1231sad";
String str1= "WEDVCSDFZZVC";
System.out.println(str.compareTo(str1));//28

compareToIgnoreCase( )

比较两个字符串的大小，不考虑大小写

String str = "sads1231sad";
String str1 = "SADS1231SAD"
System.out.println(str.compareToIgnoreCase(str1));//0

indexOf(int ch)

从头查找指定字符是否存在，char→int，如果存在则返回第一个出现的位置，如果不存在则返回-1 ch是阿斯克码

String str = "sads1231sad";
System.out.println(str.indexOf(97));//1

indexOf(int ch，int fromIndex)

从头指定位置查找指定的字符是否存在，char→int，如果存在则返回位置，如果不存在则返回-1

String str = "sads1231sad";
System.out.println(str.indexOf(97,2));//9

indexOf(String str)

从头查找指定字符串是否存在，如果存在则返回第一个出现的位置，如果不存在则返回-1

String str = "sads1231sad";
System.out.println(str.indexOf("a"));//1

indexOf(String str，int fromIndex)】

从头指定位置查找字符串是否存在，如果存在则返回位置，如果不存在则返回-1

String str = "sads1231sad";
System.out.println(str.indexOf("a",2));//9

lastIndexOf(string str)

从后查找指定字符串是否存在，如果存在则返回第一个出现的位置，如果不存在则返回-1

String str = "sads1231sad";
System.out.println(str.lastIndexOf("a"));//9

startsWith(String str)

从第一个位置开始判断是否以指定的内容开头

String str = "sads1231sad";
System.out.println(str.startsWith("s"));//true

startsWith(String str，int toffset)

从指定的位置开始判断是否以指定的内容开头

String str = "sads1231sad";
System.out.println(str.startsWith("s",4));//false

endsWith(String str )

判断是否以指定的内容结尾 可以用于判断文件以什么格式结束

String str = "sads1231sad";
System.out.println(str.endsWith("d"));//true

replace(char oldChar，char newChar)替换指定字符

String str = "sads1231sad";
System.out.println(str.replace(‘s‘,‘*‘));//*ad*1231*ad

replace(CharSequence target，CharSequence replacement)替换指定字符串

String str = "sads1231sad";
System.out.println(str.replace("12","DD"));//sadsDD31sad

replaceAll(String regex，String replacement)替换指定的字符串

regex是正则表达式的意思

String str = "sads1231sad";
System.out.println(str.replaceAll("[0-9]","*"));//sads****sad
//System.out.println(str.replaceAll("\d","*"));//sads****sad

repalceFirst(String regex，String replacement)

替换第一个满足条件的字符串

String str = "sads1231sad";
System.out.println(str.replaceFirst("[0-9]","*"));//sads*231sad

substring(int beginIndex)

从指定位置开始一直截取到末尾

String str = "sads1231sad";
System.out.println(str.substring(4));//1231sad

substring(int beginIndex, int endIndex)

截取指定范围的字符串

String str = "sads1231sad";
System.out.println(str.substring(0,4));//sads

split(String regex)

根据给定正则表达式的匹配拆分此字符串。

String str = "sads1231sad";
System.out.println(Arrays.toString(str.split("s")));//[, ad, 1231, ad]

split(String regex，int limit)

根据给定正则表达式的匹配拆分此字符串，并指定拆分的个数。

String str = "sads1231sad";
System.out.println(Arrays.toString(str.split("1",2)));//[sads, 231sad]

valueOf()

把各种类型转换成字符串

System.out.println(String.valueOf(true));//true

StringBuffer类

在实际开发当中，我们经常会使用到字符串连接的操作，如果String来操作，则使用"+"号完成字符串的连接操作

使用String连接字符串，代码性能会非常低，因为String的内容不可改变，解决这个问题的方法是使用StringBuffer

package com.API.demo01;

public class Demo03 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String c = a+b+1;//变量和常量相加产生三个对象
        String d = "a"+"b"+1;//常量相加产生1个对象 没有性能问题，因为在编译器就进行了优化
        //System.out.println(c);//ab1 产生五个对象
        
        //StringBuffer目的是来解决字符串相加时带来的性能问题（常量与变量相加）
        //StringBuffer的内部实现采用字符数组，默认数组的长度为16，超过数组大小时，动态扩充的算法是原来长度*2+2
        //所以当我们预知要添加的数据长度时，建议使用带初始化容量的构造方法，来避免动态扩充的次数，从而提高效率
        //线程安全的，会影响性能
        StringBuffer sb = new StringBuffer();
        sb.append(a).append(b).append(1);
        System.out.println(sb.toString());//ab1 产生一个对象
    }
}

StringBuffer常用的方法

StringBuffer()

构造一个空的StringBuffer对象

StringBuffer s = new StringBuffer();
StringBuffer s1 = new StringBuffer(32);//带容量的构造（推荐）

StringBuffer(String str)

将制定的String变为StringBuffer的内容

StringBuffer s = new StringBuffer("ABC");

StringBuffer(CharSequence seq)

接收CharSequence接口的实例

append(数据类型 b)

提供了很多append()方法，用于进行字符串连接

delete(int start，int end)

删除指定位置的内容

StringBuffer s = new StringBuffer("ABC");
System.out.println(s.delete(0,1));//BC

indexOf(String str)

字符串的查询功能

insert(int offset，数据类型 b)

在指定位置上增加一个内容

StringBuffer s = new StringBuffer("ABC");
System.out.println(s.insert(1,"f"));//AfBC

replace(int start，int end，String str)

将指定范围的内容替换成其他内容

substring(int start, int end)

截取指定范围的字符串

substring(int start)

字符串截取

reverse()

字符串反转

StringBuffer s = new StringBuffer("ABC");
System.out.println(s.reverse());//CBA

StringBuilder类

一个可变的字符序列。此类提同一个与StringBuffer兼容的API，但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议先采用该类，因为在大多数实现中，它比StringBuffer要快

public class Demo04 {
    public static void main(String[] args) {
        //StringBuffery与StringBuilder的区别？
        //StringBuffer是线程安全的，性能低，适合在多线程中使用,JDK1.0
        //StringBuilder是线程不安全的，性能高，适合在单线程中使用，这种情况占大多数，在JDK1.5后使用
        StringBuilder s = new StringBuilder();

        //字符串相加操作
        //1.多个常量相加没有性能问题
        //2.变量与常量相加，会产生多个垃圾对象、

        String a = "a"+1;
        //字符串相加，在编译后，会使用StringBuilder相优化代码，实现拼接
    }
}

程序国际化

Locale类

Locale对象表示特定的地理、政治和文化地区。需要locale来执行其任务的操作称为语言环境敏感的操作，它使用Locale为用户量身定制信息。例如，显示一个数值就是语言环境敏感的操作，应该根据用户的国家、地区或文化的风俗/传统来格式化该数值

Locale(String language)

Locale(String language，String country)

通过静态方法创建Locale：getDefault()

package com.API.demo02;

import java.util.Locale;

public class I18Demo {
    public static void main(String[] args) {
        //创建一个本地语言环境对象，该对象会根据参数设置来自动选择与之相关的语言环境
        //参数：语言，地区
        Locale locale_CN = new Locale("zh","CN");
        Locale locale_US = new Locale("en","US");
        //获取当前系统默认的语言环境
        Locale locale_default = Locale.getDefault();
        
    }
}

ResourceBundle类

国际化的实现核心在于显示的语言上，通常的做法是将其定义成若干个属性文件（文件后缀是*.properties），属性文件中的格式采用“key=value”的格式来进行操作。Properties文件：属性文件（配置文件），内容以键值对的形式存放（key-value）

ResourceBundle类表示的是一个资源文件的读取操作，所有的资源文件需要使用ResourceBundle进行读取，读取的时候不需要加上文件的后缀。ResourceBundle工具类，来绑定属性文件，并指定Locale对象，来自动选择使用哪个属性文件，默认将使用与操作系统相同的语言环境

package com.API.demo02;

import java.util.Locale;
import java.util.ResourceBundle;
import java.util.Scanner;

public class I18Demo {
    public static void main(String[] args) {
        //创建一个本地语言环境对象，该对象会根据参数设置来自动选择与之相关的语言环境
        //参数：语言，地区
        Locale locale_CN = new Locale("zh","CN");
        Locale locale_US = new Locale("en","US");
        //获取当前系统默认的语言环境
        Locale locale_default = Locale.getDefault();
        Scanner input = new Scanner(System.in);
        //用于绑定属性文件的工具类（参数：属性文件的基本名，就是前缀）
        ResourceBundle r = ResourceBundle.getBundle("com.API.demo02.info",locale_CN);//中文
        //ResourceBundle r = ResourceBundle.getBundle("com.API.demo02.info",locale_US);英文
        System.out.println(r.getString("system.name"));
        System.out.println(r.getString("input.username"));
        String username = input.nextLine();
        System.out.println(r.getString("input.password"));
        String password = input.nextLine();
        if("admin".equals(username) && "123".equals(password)){
            System.out.println(r.getString("login.success"));
        }else{
            System.out.println(r.getString("login.error"));
        }
    }
}

结果：中文

英文

getBundle(String baseName)方法

用于绑定属性文件的工具类（参数：属性文件的基本名（就是前缀））

getBundle(String baseName，Locale locale)

getString(String key)方法

从属性文件中使用key来获取value

注：ResourceBundle工具类是只读的

MessageFormat类

用来处理动态文本

package com.API.demo02;

import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;
import java.util.Scanner;

public class I18Demo {
    public static void main(String[] args) {
        //创建一个本地语言环境对象，该对象会根据参数设置来自动选择与之相关的语言环境
        //参数：语言，地区
        Locale locale_CN = new Locale("zh","CN");
        Locale locale_US = new Locale("en","US");
        //获取当前系统默认的语言环境
        Locale locale_default = Locale.getDefault();
        Scanner input = new Scanner(System.in);
        //用于绑定属性文件的工具类（参数：属性文件的基本名，就是前缀）
        ResourceBundle r = ResourceBundle.getBundle("com.API.demo02.info",locale_CN);
        System.out.println(r.getString("system.name"));
        System.out.println(r.getString("input.username"));
        String username = input.nextLine();
        System.out.println(r.getString("input.password"));
        String password = input.nextLine();
        if("admin".equals(username) && "123".equals(password)){
            System.out.println(r.getString("login.success"));
            String welcome = r.getString("welcome");
            //动态文本格式化
            welcome =MessageFormat.format(welcome,username);
            System.out.println(welcome);
        }else{
            System.out.println(r.getString("login.error"));
            String sorry = r.getString("sorry");
            //动态文本格式化
            sorry =MessageFormat.format(sorry,username);
            System.out.println(sorry);
        }
    }
}

结果：

Math与Random类

Math类

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

使用Math类可以有两种方式：

1. 直接使用（Math所在的包java.lang为默认引入的包）
2. 使用import static java.lang.Math.abs;静态导入

PI

比任何其他值都更接近pi的double值

System.out.println(Math.PI);//3.141592653589793

abs(double a)方法

返回double值的绝对值

System.out.println(Math.abs(-10));//10

random()方法

返回带正号的double值，该值大于等于0.0且小于1.0

System.out.println(Math.random());//随机0-1之间的小数

round(double a)方法

返回最接近参数并等于某一整数的double值

System.out.println(Math.round(Math.random()*10));//5 随机数扩大十倍再取整
System.out.println(Math.round(Math.random()*100)/100.0);//0.92随机数保留两位小数

sqrt(double a)方法

返回正确舍入的double值的正平方根

System.out.println(Math.sqrt(2));//1.4142135623730951

floor()方法

返回一个四舍五入的近似值

package com.API.demo03;
import static java.lang.Math.floor;
public class MathDemo {
    public static void main(String[] args) {
        System.out.println(floor(1.23235341));//1.0
    }
}

Random类

此类的实例用于生成伪随机数流

nextLong()方法

返回下一个伪随机数的long值

package com.API.demo03;

import java.util.Random;

public class MathRandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextLong());//-2965780218345956466
    }
}

nextBoolean()方法

返回下一个伪随机数的boolean值

nextDouble()方法

返回下一个伪随机数，在0.0和1.0之间的double值

nextInt()方法

返回下一个伪随机数，int值

nextInt(int n)方法

返回一个伪随机数，在0（包括）和指定值分布的int值

Random r = new Random();
System.out.println(r.nextInt(20));//11 随机20以内的整数

日期操作类

Date类

表示特定的瞬间，精确到毫秒，也就是程序运行时的当前时间

Date date = new Date();//实例化Date对象，表示当前时间

Date()方法

分配Date对象并初始化此对象，以表示分配它的时间

import java.util.Date;
public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);//Wed May 27 22:43:36 CST 2020
    }
}

Date(long date)方法

分配一个毫秒来获取时间 参数是毫秒

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        Date d1 = new Date(520000);
        System.out.println(d1);//Thu Jan 01 08:08:40 CST 1970
    }
}

Calendar类

日历类，使用此类可以将时间精确到毫秒显示

两种实例化方式：

1. Calendar c1 = Calendar.getInstance();
2. Calendar c2 = new GregorianCalendar();

package com.API.demo04;

import java.util.Calendar;
import java.util.GregorianCalendar;
public class DateDemo {
    public static void main(String[] args) {

        Calendar c1 = Calendar.getInstance();
        Calendar c2 = new GregorianCalendar();

        int year = c1.get(Calendar.YEAR);
        int month = c1.get(Calendar.MONTH);
        int day = c1.get(Calendar.DAY_OF_MONTH);
        int hour = c1.get(Calendar.HOUR_OF_DAY);
        int minute = c1.get(Calendar.MINUTE);
        int second = c1.get(Calendar.SECOND);
        int millisecond = c1.get(Calendar.MILLISECOND);
        StringBuilder sb = new StringBuilder(50);
        sb.append(year).append("年").append(month).append("月").append(day).append("日")
                .append(hour).append(":").append(minute)
            .append(":").append(second).append(" ").append(millisecond);
        System.out.println(sb.toString());//2020年4月27日23:7:7 361
    }
}

DateFormat类及子类SimpleDateFormat

package com.API.demo04;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
        String nowDate = df.format(new Date());
        System.out.println(nowDate);//2020年05月27日 23:13:36 809
    }
}

对象比较器

对两个或多个数据项进行比较，以确定它们是否相等，或确定它们之间的大小关系及排列顺序称为比较。

前面我们学习的Arrays.sorts方法可以实现对象的排序操作

Comparable接口

此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。

测试类：

package com.API.demo05;
import java.util.Arrays;

public class ComDemo {
    public static void main(String[] args) {
        Cat[] cats = {new Cat("鱼鱼",1),new Cat("付付",4),new Cat("tom",2)};
        Arrays.sort(cats);
        System.out.println(Arrays.toString(cats));//[Cat{name=‘鱼鱼‘, age=1}, Cat{name=‘tom‘, age=2}, Cat{name=‘付付‘, age=4}]
    }

Cat类：

package com.API.demo05;
//<>里写的是比较对象
public class Cat implements Comparable<Cat>{
    private String name;
    private int age;

    public Cat() {
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name=‘" + name + ‘‘‘ +
                ", age=" + age +
                ‘}‘;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Cat o) {
        //if(this.age<o.age)return -1;
        //if(this.age>o.age)return 1;
        //return 0;
        return this.age-o.age;
    }
}

Comparator接口

Comparable接口是要求自定义类去实现，按照OO原则：对修改关闭，对扩展开放。（在类里直接加接口）

Comparator接口是强行对某个对象collection进行整体排序的比较。（新建一个接口类）

测试类：

package com.API.demo05;
import java.util.Arrays;

public class ComDemo {
    public static void main(String[] args) {
        Dog[] dogs = {new Dog("鱼鱼",1),new Dog("付付",4),new Dog("tom",2)};
        Arrays.sort(dogs,new DogComparator());//选择比较器
        System.out.println(Arrays.toString(dogs));//[Dog{names=‘鱼鱼‘, age=1}, Dog{names=‘tom‘, age=2}, Dog{names=‘付付‘, age=4}]
    }
}

在Dog类里如果没有toString方法则输出结果，会变成[com.API.demo05.Dog@1b6d3586, com.API.demo05.Dog@4554617c, com.API.demo05.Dog@74a14482]，就和直接System.out.println()数组不能直接输出数组必须借助Arrays.toString()一个道理。

Dog类：

package com.API.demo05;

public class Dog {
    private String names;
    private int age;

    public Dog() {
        super();
    }

    public Dog(String names, int age) {
        this.names = names;
        this.age = age;
    }

    public String getNames() {
        return names;
    }

    public void setNames(String names) {
        this.names = names;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override//如果没有这个就会出现乱码
    public String toString() {
        return "Dog{" +
                "names=‘" + names + ‘‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

接口类DogComparator：

package com.API.demo05;

import java.util.Comparator;

public class DogComparator implements Comparator<Dog> {

    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.getAge()-o2.getAge();
    }
}

对象的克隆

Clone()方法

如果某个类的对象要想被克隆，则对象所在的类必须实现Cloneable接口。此接口没有定义任何方法，是一个标记接口

测试类：

package com.API.Demo06;

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("付付",2);
        try {
            Cat newCat = (Cat) cat.clone();
            System.out.println("cat="+cat);//cat=Cat{name=‘付付‘, age=2}
            System.out.println("new cat="+newCat);//new cat=Cat{name=‘付付‘, age=2}地址不一样
            System.out.println(cat==newCat);//false
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Cat类：

package com.API.Demo06;

/**
 * 对象需要具备克隆功能：
 * 1.实现Cloneable接口（标记接口）
 * 2.重写Object类中的Clone方法
 * @Author 油炸蘑菇鱼
 */
public class Cat implements Cloneable{
    private String name;
    private int age;

    public Cat() {
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name=‘" + name + ‘‘‘ +
                ", age=" + age +
                ‘}‘;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重写Object中的clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

System与Runtime类

System类

• System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包
• System类内包含三个成员变量，in标准输入流（键盘输入），out标准输出流（显示器）和err标准错误流

System.out.println("向控制台输出");//向控制台输出
System.err.println("出错啦");//出错啦(红色字体)

arraycopy()方法

该方法是数组拷贝，也就是将一个数组中的内容复制到另外一个数组的指定位置，由于该方法是native本地方法，所以性能上比使用循环高效

int[] num1 = {1,2,3,4,5,6,7,8};
int[] num2 = new int[num1.length];
//参数（原数组，原数组的起始位置，目标数组，目标数组的起始位置，长度）
System.arraycopy(num1,0,num2,0,num1.length);
System.out.println(Arrays.toString(num2));//[1, 2, 3, 4, 5, 6, 7, 8]

currentTimeMillis()方法

该方法的作用是返回当前的计算机的时间，时间的表达式为当前计算机时间和GMT时间（格林威治时间）1970年1月1日0时0分0秒所差的毫秒差

System.out.println(System.currentTimeMillis());//1592743150979

Date nowDate = new Date(System.currentTimeMillis());
DateFormat DF = new SimpleDateFormat("HH:MM:SS");
String now  = DF.format(nowDate);
System.out.println(now);//20:06:523

exit(int status)方法

该方法作用是退出程序。其中status的值为0表示正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等

System.exit(0);//退出JVM

gc()方法

该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况

getProperty(String key)方法

该方法的作用是获得系统中属性名为key的属性对应的值

• java.version java运行时环境版本
• java.home java安装目录
• os.name 操作系统的名称
• os.version 操作系统的版本
• user.name 用户的账户名称
• user.home 用户的主目录
• user.dir 用户当前的工作目录

System.out.println(System.getProperty("java.version"));//1.8.0_251
System.out.println(System.getProperty("java.home"));//C:Program FilesJavaxxxxxxx
System.out.println(System.getProperty("os.name"));//Windows 10
System.out.println(System.getProperty("user.name"));//10260
System.out.println(System.getProperty("os.version"));//10.0

loadLibrary(string libname)

用于加载第三方类库，例如加载C，C++编写的类库

Runtime类

每个java应用程序都有一个Runtime类实例，使应用程序能够与其运行环境相连接

Runtime rt = Runtime.getRuntime();
System.out.println("处理器数量:"+rt.availableProcessors());//处理器数量:4
System.out.println("JVM总内存数:"+rt.totalMemory()+"byte");//JVM总内存数:124780544byte
System.out.println("JVM空闲内存数:"+rt.freeMemory()+"byte");//JVM空闲内存数:120840808byte
System.out.println("JVM可用最大内存数:"+rt.maxMemory()+"byte");//JVM可用最大内存数:1836580864byte
//在单独的进程中执行指定的字符串命令
try {
    rt.exec("notepad");//打开笔记本
} catch (IOException e) {
    e.printStackTrace();
}

数字处理工具类

BigInteger类

可以让超出integer范围内的数据进行运算

构造方法

BigInteger(String val)

//大整数运算
String val1="122313142342342";
String val2="858938563422344";
BigInteger b1 = new BigInteger(val1);
BigInteger b2 = new BigInteger(val2);

常用方法

add(BigInteger val)

加

System.out.println(b1.add(b2));//981251705764686

subtract(BigInteger val)

减

System.out.println(b1.subtract(b2));//-736625421080002

multiply(BigInteger val)

乘

System.out.println(b1.multiply(b2));//105059474771203913323980089648

divide(BigInteger val)

除

System.out.println(b1.divide(b2));//0

remainder(BigInteger val)

取模

System.out.println(b1.remainder(b2));//122313142342342

divideAndRemainder(BigInteger val)

除加取余

System.out.println(Arrays.toString(b1.divideAndRemainder(b2)));//[0, 122313142342342]

BigDecimal类

用于运算的时候，float类型和double类型很容易丢失精度，为了能精确的表示、计算浮点数，java提供了BigDecimal，不可变的、任意精度的有符号十进制数

构造方法

BigDecimal(String val)

String val3 = "5679.97979080728929";
String val4 = "398.2192381964231419129";
BigDecimal b3 = new BigDecimal(val3);
BigDecimal b4 = new BigDecimal(val4);

常用方法

add(BigDecimal val)

System.out.println(b3.add(b4));//6078.1990290037124319129

substract(BigDecimal val)

System.out.println(b3.subtract(b4));//5281.7605526108661480871

multiply(BigDecimal val)

System.out.println(b3.multiply(b4));//2261877.225266357622421505259065434282841

divide(BigDecimal val)

System.out.println(b3.divide(b4));//出错

DecimalFormat类

用于小数处理的问题

double pi = 3.14159265358;
//取一位整数
System.out.println(new DecimalFormat("0").format(pi));//3
//取一位整数和两位小数
System.out.println(new DecimalFormat("0.00").format(pi));//3.14
//取两位整数和三位小数
System.out.println(new DecimalFormat("00.000").format(pi));//03.142
//取所有整数部分
System.out.println(new DecimalFormat("#").format(pi));//3
//以百分比方式计数
System.out.println(new DecimalFormat("#.##%").format(pi));//314.16%

long num = 683892097;
System.out.println(new DecimalFormat("###,###").format(num));//683,892,097

MD5工具类

Message-Digest Algorithm 5 (信息摘要算法)

关于密码存储

package com.API.Demo09;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;


public class MDA5Demo {
    private static String savePassword = "pmq7VoTEWWLYh1ZPCDRujQ==";//存储的密文
    public static void main(String[] args) {
        //test();
        System.out.println(login("admin112ss"));//false
        System.out.println(login("admin123456"));//true
    }
    private static boolean login(String password){
        if(savePassword.equals(md5(password))){
            return true;
        }else{
            return false;
        }
    }

    //计算md5的工具方法
    private static String md5(String password){
        try {
            MessageDigest md = MessageDigest.getInstance("md5");
            byte[]  bytes = md.digest(password.getBytes("UTF-8"));//通过MD5计算摘要
            String str = Base64.getEncoder().encodeToString(bytes);
            return str;
        } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }
    private static void test() {
        String password = "admin123456";//原文
        String savePassword = "pmq7VoTEWWLYh1ZPCDRujQ==";//存储的密文
        try {
            MessageDigest md = MessageDigest.getInstance("md5");
            byte[]  bytes = md.digest(password.getBytes("UTF-8"));//通过MD5计算摘要
            System.out.println(Arrays.toString(bytes));//[-90, 106, -69, 86, -124, -60, 89, 98, -40, -121, 86, 79, 8, 52, 110, -115]
            //String mdStr = new String(bytes);
            //System.out.println(mdStr);//?j?V??Yb?V4n?
            //a-z  A-Z 0-9 / *  BASE64编码算法
            String str = Base64.getEncoder().encodeToString(bytes);//编码
            System.out.println(str);//pmq7VoTEWWLYh1ZPCDRujQ==
            byte[] bs = Base64.getDecoder().decode(str);//解码
            System.out.println(Arrays.toString(bs));//[-90, 106, -69, 86, -124, -60, 89, 98, -40, -121, 86, 79, 8, 52, 110, -115]
        } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}