java高级特性(四) Java基础类库

String与StringBuffer

是一个功能类，这个类具有以下特点
1.每个字符串的常量都属于一个string类的匿名对象，并且不可更改
2.string有静态常量池和运行时常量池
3.string类对象实例化建议使用直接赋值的形式完成，，这样可以直接将对象保存在对象池中，以方便下次重用，
弊端就是内容不允许修改，
为了解决这样的问题，专门提供了一个string buffer类可以实现字符串内容的修改处理，

stringbuffer不像string那样有两种实例化方式，stringbuffer必须像普通类那样首先进行实例化，才能调用方法进行处理

范例：观察string和stringbuffer对比

string类对象引用传递	stringbuffer类引用传递

stringbuffer
构造方法：public stringbuffer();
数据追加：public stringbuffer append(数据类型 变量)

package package01;
public class demo {
    public static void main(String[] args) {
        String str="hello";
        change(str);
        System.out.println(str);
    }
    public static void change(String temp){
        temp+="world";
    }
}

运行结果是
hello

package package01;
public class demo {
    public static void main(String[] args) {
        StringBuffer buf=new StringBuffer();
        buf.append("hello");
        change(buf);
        System.out.println(buf);
    }
    public static void change(StringBuffer temp){
        temp.append("world");
    }
}

返回
helloworld

问题字符串相加，在程序内部运行时是转换为了string buffer类型了，string类型可以通过依靠stringbuffer类的构造方式实现，所有类对象都可以通过tostring方法将其变成string类型，

string buffer具备许多string不具有的方法，
例如append（）追加
insert（） 插入
delete（） 范围删除
reverse（）字符串反转，hello变成olleh

stringbuffer与stringbuilder在方法上相似，
区别在于stringbuilder是非线程安全的，stringbuffer线程安全

charSequence

一个描述字符串结构的接口，string类，stringbuffer类，stringbuilder类都继承了charsequence接口，
现在只要有字符串就可以charsequence接口实例化，称为子类实列向父接口转型，
该接口还定义了以下操作方法
获取指定索引字符：public char charAt(int index)
获取字符串的长度：public int length()
截取部分字符串：public charSequence subSequence(int start,int end)

autoCloseable

主要用在资源开发处理上，实现资源的自动关闭，或者是释放，

jdk1.7以后提供，只有一个close（）方法

要想实现自动关闭处理，除了要使用AutoCloseable之外，还需要结合异常处理语句才可以正常调用

当方法发生异常时才会自动调用该方法的close方法

Runtime类

RunTime描述的时运行时的状态，也就是说，runtime类在jvm中是为一个与jvm运行状态有关的类，并且都会默认提供一个该类的实例化对象，
由于在每一个jvm进程里面只允许提供有一个RunTime类的对象，所以这个类的构造方法被默认私有化，证明该类使用的是单例设计模式，并且一定会有一个static方法获取该类的实例，

由于runtime类属于单例设计模式，如果想要获取实例化对象，那么就要依靠getRunTime（）获取实例化对象
获取实例化对象：public static RunTime getRuntime()

范例：获取runtime类对象

public class demo {
    public static void main(String[] args) {
        Runtime run=Runtime.getRuntime();
        //获取本机的cpu的内核数量
        System.out.println(run.availableProcessors());
    }
}

核心操作方法

public class demo {
    public static void main(String[] args) {
        Runtime run=Runtime.getRuntime();
        //获取本机的cpu的内核数量 单位 :B 默认的配置为本机系统内存的四分之一
        System.out.println(run.availableProcessors());
        //获取最大可用内存空间 单位 :B 默认的配置为本机系统内存的六十四分之一
        System.out.println(run.maxMemory());
        //获取可用内存空间
        System.out.println(run.totalMemory());
        //获取空闲内存空间
        System.out.println(run.freeMemory());
        //手工GC处理
        System.out.println(run.gc());
    }
}

面试题
什么是GC？如何处理
GC（garbage collector）垃圾收集器，是可以由系统自动调用的垃圾释放功能，或者使用runtime类中的GC手工调用，

stream类

程序类，系统输出就是system类中的方法，也定义了一些其他的方法，
数组拷贝方法 ：public static voidarraycopy（）；
获取当前日期时间数值：public static long currenttimemillis(),
进行垃圾回收：public static void GC(); 该方法是继承了runtime类中的GC操作，

public class demo {
    public static void main(String[] args) {
        Runtime run=Runtime.getRuntime();
        String str="";
        long start=System.currentTimeMillis();
        for (int X=0;X<10000;X++){
            str+=X; //产生大量垃圾空间
        }
        long end=System.currentTimeMillis();
        System.out.println("使用时间："+(end-start));
    }
}

Cleaner类

jdk1.9之后提供的一个对象清理操作，主要功能是进行finalize（）方法的代替，在C++中有两种特殊的函数：构造函数，析构函数，（对象手工回收），Java里面的所有垃圾都是通过GC自动回收的，大多数情况下，不需要析构函数，
但Java本身依然提供了用户收尾操作，每个实例化对象在收尾之前给他一个喘息的机会，最初是object类中提供的finallize方法，

现在已经不建议使用了，现在使用autocloseable（）方法，
在新一代的清除回收处理工程之中，更多的情况下考虑更多的是多线程的使用，即：为了防止有可能造成的延迟处理，许多对象回收前的处理都是单独通过一个线程完成的，

对象克隆

指的是对象的复制，而且属于全新的复制，使用已有对象内容创建一个新的对象，对象克隆需要使用object类中的clone（）方法，
protected object clone（）thows CloneNotSupportedException；
是一个私有的方法，所有的类都会继承object类，所以所有类都一定会有clone方法，但是不是所有的对象都需要克隆，那么对象所在类需要实现一个cloneable接口，此接口没有一个任何方法提供，只是表示一种可以克隆的能力，
自定义类不能直接调用clone方法，必须复写clone方法调用父类中的clone方法，

math数学计算类

math类，主要进行数学计算，提供有基础的计算公式，

public class demo {
    public static void main(String[] args) {
        System.out.println(Math.abs(-15));
        System.out.println(Math.max(12,15));
        System.out.println(Math.log(5));
        System.out.println(Math.round(15.2));
        System.out.println(Math.round(-15.2));
        System.out.println(Math.pow(9,2));
    }
}

math类里面提供有四舍五入的处理方法，但是这个四舍五入在进行处理的时候直接将小数点后的所有位进行进位处理了，最方便的做法是可以指定位数的保留，

范例实现自定义的四舍五入

package package01;
import java.lang.Math;

class Mathutil{
    private Mathutil(){};

    /**
     * 实现数据的四舍五入操作
     * num 要进行四舍五入操作的数字
     * scale 四舍五入小数点的位置
     * return 四舍五入小数点的结果
     */
public static double round(double num,int scale){
    return Math.round(num*Math.pow(10,scale))/Math.pow(10,scale);
}
}
public class demo {
    public static void main(String[] args) {
       System.out.println(Mathutil.round(19.86273,2));
    }
}

Random随机数生成类

java.util.Random类主要功能是产生随机数，这个类主要依靠内部提供的方法来完成，

产生一个不大于边界的随机正整数数（包含0）：public int nextInt(int bound);

大数字操作类

在进行数学计算的过程中还有一个大数字的操作类，可以实现海量数字的计算（能提供的也只是基础计算），数字很大，超过了double类型，
于是我们提供有两个大数字的操作类：BigInteger，BigDecimal。

package package01;
import java.math.BigInteger;
public class demo {
    public static void main(String[] args)throws Exception {
        BigInteger bigA=new BigInteger("123456789987456321");
        BigInteger bigB=new BigInteger("8745321336262");
        System.out.println("加法操作"+bigA.add(bigB));
        System.out.println("减法操作"+bigA.subtract(bigB));
        System.out.println("乘法操作"+bigA.multiply(bigB));
        System.out.println("除法操作"+bigA.divide(bigB));
    }
}

大数的计算是非常慢的，math的处理都是基本数据类型，性能由于大数字计算

date日期处理类

简单Java类的主要设计来自于数据表的结构，那么在数据表的结构里面常用的类型有数字，字符串，日期，

在Java中有一个java.util.Date的类，那么这个类如果实例化就可以获取当前日期时间

import java.util.Date;
public class demo {
    public static void main(String[] args)throws Exception {
        Date date=new Date();
        System.out.println(date);
    }
}
//Sun Mar 06 13:38:27 CST 2022

此时进一步观察date类中构造方法，得出date类中只是对long数据的一种包装，
所以date类中一定提供了所谓日期与long数据类型转换的方法，
将long转换为Date：public Date（long）；
将Date转换为long：public long getTime();

import java.util.Date;
public class demo {
public static void main(String[] args)throws Exception {
Date date=new Date();
long current=date.getTime();
current +=864000*1000;
System.out.println(new Date(current));
}

}
日期格式化，默认输出的Date时间结构不能够满足要求，格式化处理在java.text类中提供了格式化方法，simplDateformat程序类，该类是DateFormat的子类，该类中提供了如下的方法，
将日期格式化：public final stringformat（Date date）
将字符串转换为日期：public Date parse（stringsource）throws parseException
构造方法：public simpleDateFormat（string pattern）
日期格式描述：年（yyyy）月（MM）日（dd）时（HH）分（mm）秒（ss）毫秒（SSS）,区分大小写

package package01;

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

public class demo {
    public static void main(String[] args)throws Exception {
        Date date=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        String str=sdf.format(date);
        System.out.println(str);
    }
}

//2022-03-06 14:03:57.905

除了可以将日期格式化为字符串，也可以实现字符串与日期之间的转换，

import java.text.SimpleDateFormat;
import java.util.Date;
public class demo {
    public static void main(String[] args)throws Exception {
        String birthday="1984-11-11 11:11:11.111"; //字符串
       SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date date=sdf.parse(birthday);
        System.out.println(date);
    }
}

当日期值大于该时间值会自动进位，例如20月会自动变成一年八个月，年数回自动多一，

数字格式化

package package01;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class demo {
    public static void main(String[] args)throws Exception {
       double money=2323121223.12;
       String str= NumberFormat.getInstance().format(money);
        System.out.println(str);
    }
}

正则表达式

string貌似是一个万能的类型，可以支持许多操作，用户输入的信息，基本上都可以用字符串表示，转换的时候为了保证转换的正确性，往往需要进行一些复杂的验证处理，单纯依靠string中的方法是非常麻烦的，这时候就需要用到正则表达式了，

jdk1.4以后在java.util.regex开发包，同时针对于string类进行了一些修改，可以支持正则处理，

使用正则表达式特点：方便验证处理，以及进行字符串的修改处理，

正则标记（掌握）

java.util.regex这个包提供一个pattern程序类，在这个程序类里面定义有所有支持的正则标记。
使用方法

public class demo {
    public static void main(String[] args)throws Exception {
       String str="a";
       String regex="[a-zA-Z]";
        System.out.println(str.matches(regex));
    }

}

1.单个字符匹配
任意字符：表示由任意字符组成
\ : 匹配 “”
\n:匹配换行
\t ：匹配制表符

2.字符集匹配（从中任选一个字符）
[abc]:表示可能是字母a b c之中的任意一个
[^ abc]:表示不是由字母a b c中的任意一个
[a-zA-Z]:表示由任意一个字母组成，不区分大小写；
[0-9]:表示可能是0-9之中任意一个z

3.简化字符集
点 . ：表示任意一个字符
\d :等价于[0-9]
\D:等价于[^ 0-9]
\s:匹配任意一位空格，可能是空格，换行，制表符，
\S：匹配任意的非空数据
\w:匹配字母，数字，下划线_,等价于[a-zA-Z0-9]
\W:匹配字母，数字，下划线_,等价于[^ a-zA-Z0-9]

4.边界匹配
^:匹配边界开始
$：匹配结束
5.数量表达，默认情况下只有添加上了数量单位才可以匹配多位字符，
表达式 ？：表示该正则可以出现0次或1次
表达式* ：表示该正则可以出现0次，1次或多次
表达式+：表示该正则可以出现1次或多次；
表达式{n}:表示表达式长度正好为n;
表达式{n,m}: 表示表达式的长度在n-m次
6.逻辑表达式：可以连接多个正则
表达式X表达式Y：表达式X之后紧跟上Y
表达式X|表达式Y:有一个表达式满足即可
（表达式）：为表达式设置一个整体描述，可以为整体描述设置数量单位，

在进行正则表达式大部分处理的情况下都是基于string类来完成，并且提供了以下方法

正则表达式只能判断格式是否正确，不能判断内容是否正确，

例题



正则处理类，这个包里面一个定义有两个类：pattern(正则表达式编译类)，Matcher（正则匹配），
1.pattern类提供有正则表达式的编译处理支持：public static pattern compile（string regex）;同时也提供一个字符串的拆分操作：public string [] split(charSquence input);

如果纯粹的是以拆分，替换，匹配三种操作为例，根本用不到java.util.regex开发包，只依靠string类就可以完全实现，但是matcher类里面提供一种分组的功能，而这种分组的功能是string不具备的，

如果不是很难的正则处理，matchar是很难使用到的，

goodgoodstudent

如果有用点点赞呦，小东西。