Java基础知识整理（正则表达式，StringBuffer，StringBuilder，常用数据类，System类，RunTime类，Random类）

正则表达式

正则表达式是一个特殊的字符串，用于检测字符串是否符合要求

Pattern正则类

判断字符串是否满足正则表达式，可以使用mastches

判断邮箱正则

//字母数字_+@+字母数字.字母

//String reg = “^\\d\\w\\s$”;标准写法

String reg = “\\w+@\\w+(\\.+\\w){1,2}”;

手机号码判断

NSString Regex = “(13[0-9]|14[57]|15[0-9]|18[0-9]|17[015678])\\d{8}”;

StringBuffer和StringBuilder

都是可变字符串，这两个类可以叫做（字符串构建器），只要传人StringBuffer和StringBuilder任何一个字符串，在修改的时候都是对原有字符串的修改

StringBuffer和StringBuilder使用方式完全一样，API相同

StringBuffer是线程安全的，但是效率低

StringBuilder线程不安全，但是效率高

在没有多线程并发访问的前提下，建议使用StringBuilder来进行字符串的构建

stringBuffer

当用无参构造方法创建对象的时候，此时会初始化一个大小为16的字符数组

当大于16个字符的时候，会自动扩容，会创建一个更加大的数组将数据储存

StringBuffer bs = new StringBuffer();

StringBuffer bs = new StringBuffer(80); // 创建StringBuffer对象的时候同时指定字符数组的大小，可以减少底层扩容的次数

1.对字符串追加（多种重载函数涵盖了所有的数据类型）

b.append(各种数据类型);

bs.append(“d”).append(“e”);//链式编程方法多次调用方法

2，获取字符串长度 length();

3.删除指定位置的字符串(参数是下标)

第一个参数：开始位置（包含）；第二个参数：结束位置（不包含）

bs.delete(start,end);

bs.deleteCharAt(0); 删除指定位置字符

4.指定位置插入字符串（多种重载）

bs.insert(offset,b); 不能超出字符串范围插入

5.替换指定位置字符串

第一个参数：开始的位置；第二个参数；结束的位置；第三个位置：替换的字符串

bs.replace(start,end,str); //替换字符串的长度，不受范围限制

6.反转字符串

bs.reverse();

7.修改指定位置的字符

bs.setCharAt(index,str);

如何将StringBuffer或StringBuilder对象转换成String对象——>>bs.toString();

性能比较： StringBuilder>StringBuffer>String

在这方面运行速度快慢为：StringBuilder > StringBuffer > String

String最慢的原因：

String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的

String面试题

1.使用""创建字符串是常量，在编译时期就已经确定了当前的值，并且已经存到常量池中

java会进行一步优化，也就是说在确定是常量，所有+的拼接都会被认为一个字符串，即"ab"+“cd"就相当于"abcd”.系统自动优化

2.使用new创建是堆中的地址，应用的也还是堆中的地址

3.使用变量储存，或者使用方法返回值，在编译时期是无法确定其中的值的，只有在执行阶段才能确定，此时相当于调用了

字符串构建其中的append拼接，储存在堆中

public class StringFace{
    public static void main(String[] args){
         String  str1 = "ABCD";
         String  str2 = "A"+"B"+"C"+"D";
         String  str3 = "AB"+"CD";
         String  str4 = new String("ABCD");
         String  tmp = "AB";
         String  str5 = tmp+"CD";
         String  str6 = getString()+"CD";
//这里所有的比较equals 都是true 因为比较的是内容 System.out.println(str1 == str2);//true System.out.println(str1 == str3);//true System.out.println(str1 == str4);//false System.out.println(str1 == str5);//false System.out.println(str1 == str6);//false
    }
    public static String getString(){
         return "AB";
    }
}
通过反编译得到的结果:
public static void main(String args[])
    {
        String str1 = "ABCD";
        String str2 = "ABCD";
        String str3 = "ABCD";
        String str4 = new String("ABCD");
        String tmp = "AB";
        String str5 = (new StringBuilder(String.valueOf(tmp))).append("CD").toString();
        String str6 = (new
StringBuilder(String.valueOf(getString()))).append("CD").toString();
        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str1 == str4);
        System.out.println(str1 == str5);
        System.out.println(str1 == str6);
    }
    public static String getString()
    {
        return "AB";
    }

常用类

数据类：

1.Math数据类

Math.pow(2,31); 获取次方的值，返回值类型是double

Math.random(); 随机数，返回值double

Math.max(a,b);比较最大值最小值绝对值开平方 min、abs、sqrt

2.bigDecimal 小数

非常精确的小数，可以精确128位 double是一个不能精确储存的小数

这里要添加代码。。。。。。。

使用BigDecimal的时候不能直接给值，要给字符串才能精确的计算值

BigDecimal num1 = new BigDecimal(0.09);——>打印出来不是0.09，是0.0900000123440012什么的不能精确

BigDecimal num1 = new BigDecimal(“0.09”);这个可以精确

BigDecimal num2 = new BigDecimal(0.01);

num1.add(num2);

BigDecimal中封装了所有操作运算符的方法

3.bigInteger超大整数

BigInteger num = new BigInteger(“3333333567898376787678767767876567676767676”);

BigInteger num2 = new BigInteger(“7”);

这个超大整数可以计算，必须调用其内部的方法，不能使用运算符

例：求余 mod ——>num.mod(num2); 等到是一个BigInteger的对象

4.NumberFormat和DecimalFormat 数字格式化

有范围限制（16位以内可以精确）

NumberFormat nf = NumberFormat.getInstanse();

整数的储存范围是有限的，所以建议给小数

nf.format(12334444766788.0); 超过16位后就不精准了

System类和Runtime类

System是一个系统类，可以有一些常用的in和out的输入输出

System.arraycopy(src, srcPos, dest, destPos, length);

第一个参数是原数组

第二个参数 从原数组中那个位置开始复制

第三个参数是目标数组———要复制到的那个数组

第四个参数是目标数组的位置

第五个参数是数组要复制的长度

System.exit(status);

//终止虚拟机，整数包括0 负数；整数正常退出虚拟机，负数是异常退出虚拟机

尽量不要调用，虚拟机应该是正常退出不应该干预

System.gc();//手动调用GC，可以加快GC回收，但是需要注意这个只能是暗示GC加快（GC垃圾回收Garbage Collection）

//系统时间: 1000毫秒 == 1秒
System.out.println(System.currentTimeMillis()+“毫秒”);
System.out.println(System.nanoTime()+“纳秒”);

Runtime

可以获取JVM实例----虚拟机对象 可以用各种方法观察JVM，从而可以达到调优的目的
获取runtime对象

Runtime rt = Runtime.getRuntime();

System.out.println(“处理的核心数量”+rh.availableProcessors());

System.out.println(“获取空闲内存”+rt.freeMemory());

System.out.println(“获取总内存数”+rt.totalMemory());

System.out.println(“获取最大内存数”+rt.maxMemory()/1024/1024);

rt.gc();//垃圾回收

Random类

是一个随机数类，可以产生一个随机数，这个随机数是一个伪随机数

伪随机数有一个前提就是种子要相同

常用构建方法Random()——获取的种子是当前系统时间实现

指定种子Random(int seed) 种子不等于随机范围,种子相同的情况下才会出现伪随机，也就是随机出的数相同

//伪随机测试 --> 只有种子相同时才会出现伪随机 ，种子相同随机出来的都是同一个数

Random r1 = new Random(10);

System.out.println(r1.nextBoolean());

System.out.println(r1.nextDouble());

System.out.println(r1.nextInt());

System.out.println(r1.nextInt(100));

System.out.println("------------------------对比种子相同---------------------");

Random r2 = new Random(10);
System.out.println(r2.nextBoolean());
System.out.println(r2.nextDouble());
System.out.println(r2.nextInt());
System.out.println(r2.nextInt(100));

System.out.println("------------------------正常随机---------------------"); //创建随机数 --> 也遵守左闭杨右开区间
Random r3 = new Random();
//随机100以内的一个数 参数即是随机范围

int num = r3.nextInt(100);

System.out.println(num); //随机34~179之前的一个数值
int num2 = r3.nextInt(145)+34;