JavaSE---常用类

JAVAAPI概述

API(Application Programming Interface)应用程序编程接口

是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明.

API—>语言中提供的类,接口

API–>对类,接口功能的说明文档

基本数据类型包装类

基本类型：结构简单 int short long byte char boolean double float

每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类.

包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法。

基本数据类型	对应的类
byte	Byte
int	Integer
long	Long
shor	Short
double	Double
float	Float
char	Character
boolean	Boolean

对于包装类来说，这些类的用途主要包含两种：

作为和基本数据类型对应的类类型存在。

包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

以Integer为例

 public static void main(String[] args) {
        int num = 10;//只表示一个具体的值
        System.out.println(num);
        //构造方法
        Integer num1 = new Integer(10);//把10包装在Integer这个类的对象中
        Integer num2 = new Integer("10");//把String类型转为int，只能传入String类型的数字，否则会报错
        //Integer类包装一个对象中的原始类型int的值。 类型为Integer的对象包含一个单一字段，其类型为int 。
        //Integer类提供了方法来对int类型进行操作
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);//获取最大值和最小值
        System.out.println(Integer.BYTES);
        System.out.println(Integer.SIZE);
        System.out.println(Integer.toBinaryString(4));//二进制
        System.out.println(Integer.toHexString(100));//十六进制
        System.out.println(Integer.toOctalString(78));//八进制

        System.out.println(num1.compareTo(num2));//比较，-1(前面的num1小)0(相等)1(前面的num1大)
        System.out.println(Integer.max(10,50));
        System.out.println(num1.equals(num2));//true，equals()比较的是两个对象的值
        System.out.println(num1==num2);//false,==比较的是两个对象在内存中的地址

        Integer num3 = new Integer(10);
        int num4 = num3.intValue();//取出对象中包含的具体的值
        long num5 = num3.longValue();//转换为long类型
        int num6 = Integer.parseInt("11");//把字符串类型转为int型

        Integer num7 = Integer.valueOf(12);//把基本类型的10封装成引用类型Integer
        Integer num8 = Integer.valueOf(12);

        //把数值转为字符串类型
        System.out.println(num8.toString());
        System.out.println(Integer.toString(10));

自动装箱和自动拆箱

自动装箱：把基本类型转为引用类型，自动调用valueOf()

自动拆箱：引用类型转为基本类型，自动调用intValue()方法

  /*
        自动装箱：把基本类型转为引用类型
        */
        int n = 10;
        Integer n1 = n;//自动调用valueOf()
        /*
        自动拆箱：引用类型转为基本类型
         */
        int n2 = n1;//自动调用intValue()方法
  public static void main(String[] args) {

        Integer num0 = new Integer(10);
        Integer num1 = new Integer(10);
        System.out.println(num0.equals(num1));//true
        System.out.println(num0 == num1);//false

        Integer num2 = Integer.valueOf(10);
        Integer num3 = Integer.valueOf(10);
        System.out.println(num2.equals(num3));//true
        System.out.println(num2 == num3);//true
        /*
        使用装箱(valueOf)在创建对象时，值如果在-128---127之间，如果多个值相同，指向的是内存中同一个地址
        使用new+构造方法()方式，不管值是否在此区间相同，都会创建新的对象
        */
        Integer num4 = Integer.valueOf(128);
        Integer num5 = Integer.valueOf(128);
        System.out.println(num4 == num5);//false
    }

Object类

Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都实现这个类的方法。

如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

public class Person {	...	}
/*等价于：
        public class Person extends Object {
	...
}*/

1-toString方法

Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。

在进行String与其它类型数据的连接操作时（如：System.out.println(“info”+person）），

将自动调用该对象类的 toString()方法

可以根据需要在用户自定义类型中重写toString()方法。

public class ObjectDemo {
    public static void main(String[] args) {
        Person p = new Person("admin",18);
        /*
        将对象输出时，就会调用toString()
        当类中没有定义toString()时，会默认调用父类(Object)中的toString()
        public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        本地方法，java语言不实现，调用操作系统实现
        public native int hashCode();
        Object类中toString()将对象地址转为16进制的字符串输出，

        在类中重写toString()
         */
        System.out.println(p);//day08.Person@1540e19d
        //重写后：Person{姓名='admin'年龄=18}
    }
}
public class Person {
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "姓名='" + name + '\'' +
                "年龄=" + age +
                '}';
    }
}

2-equals方法

public boolean equals(Object obj)方法

提供定义对象是否“相等”的逻辑。

Object 的 equals 方法 定义为：x.equals ( y ) ，当 x 和 y是同一个对象的引用时返回 true 否则返回 false

JDK提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ,

x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回 true 否则返回 false。

public class ObjectDemo2 {
    public static void main(String[] args) {
        Person p1 = new Person("admin",18);
        Person p2 = new Person("admin",18);
        //Object中equal方法比较的是创建的对象在内存中的地址是否相等，等同于==
        //其他类都重写了equal方法，比较的是内容是否相等
        System.out.println(p1.equals(p2));//false，重写后输出false，比较的是对象中包含的内容
        System.out.println(p1==p2);//false
    }
}

public class Person {
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
  @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

String类

字符串是由多个字符组成的一串数据(字符序列)的字符串常量(值不能改变),java中所有字符串都是String类的实例.

String s = “abc”;

有两种创建形式：
第一种:

​ String s = “abc”;
先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中

添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向该地址即可,不用重新创建.

  String s = "abc";
        String s1 = "abc";
        System.out.println(s.equals(s1));//true
        System.out.println(s==s1);//true

第二种:

​ 使用new+构造方法()

​ 一概在堆中创建新对象，值存储在堆内存的对象中。

​ String s = new String(“abc”);

   /*
        只要是new出来的对象，在内存中一定是一个独一无二的对象空间
         */
        String s2 = new String("abc");
        String s3 = new String("abc");
        System.out.println(s2.equals(s3));//true
        System.out.println(s2==s3);//false

字符串特点

public class StringDemo2 {
    public static void main(String[] args) {
        /*
        字符串值是常量，不能改变，一旦改变是在内存中重新创建了一个对象
        字符串底层是数组存储(单个字符存储)，final修饰，值不能改变吧
         */
        String s = "abc";
        s += "def";
        s += "aaa";
        System.out.println(s);
    }
}

构造方法

   /*
        String类中常用方法
        构造方法：
        String();
        String(String s);
         */
        //创建一个String对象，值为""
        String s = new String();

判断功能

//判断功能
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.equals(s2));//true
        System.out.println(s1.equalsIgnoreCase("aBc"));//true,不区分大小写比较内容1是否相等
        System.out.println(s1.contains("ab"));//true,包含
        System.out.println(s1.isEmpty());//false,是否为空(" ")
        System.out.println(s1.startsWith("a"));//true,以  开头
        System.out.println(s1.endsWith("c"));//true,以  结尾
        System.out.println("a".compareTo("b"));//-1,a对应97，b对应98，返回-1，a与c则返回-2，比较大小，用于排序

获取功能

 //获取功能
        System.out.println(s1.length());//获取字符串长度
        System.out.println(s.charAt(2));//把字符串当作数组，返回2对应位置的字符c(abc---012)
        System.out.println(s.indexOf("c"));//找到对应的位置2，只能找到第一个c对应的位置
        System.out.println(s.indexOf("c",3));//给指定位置开始找字符首次出现的位置
        System.out.println(s.lastIndexOf("c"));//从后往前找字符首次出现的位置
        System.out.println(s.lastIndexOf("c",10));//从指定位置开始从后往前找字符首次出现的位置
        //若字符不存在则返回-1
        System.out.println(s.substring(2));//从指定位置截取字符串到结束，返回一个新的字符串，原字符串不变
        System.out.println(s.substring(2,6));//区间截取，包含开始的字符，不包含结束的那个字符

替换功能

 //替换功能
		String s = new String(" abcde ");
        System.out.println(s.replace('c','C'));//原来的字符串不会变，替换后会返回一个新的字符串
        System.out.println(s.replace("ab","AB"));
        System.out.println(s.replaceAll("ab","AB"));//把所有的ab替换为AB，返回新的字符串
        System.out.println(s.replaceFirst("ab","ABC"));//用ABC替换ab中的第一个字符a，返回新的字符串
        System.out.println(s.trim());//去掉前后的空格，不能消除中间的空格

转换功能

   /*
        构造方法
        public String(byte[] bytes)
        public String(char[] value)
         */

        //转换功能
        //byte[] getBytes()
       // char[] toCharArray()
        String s = "abc";
        byte [] b = s.getBytes();//编码：字符转为字节
        System.out.println(Arrays.toString(b));//[97, 98, 99]
        String s1 = new String(b);//解码：字节转为字符
        System.out.println(s1);//abc
		String s2 = "中文";
        byte [] b2 = s2.getBytes("utf-8");
        System.out.println(Arrays.toString(b2));//[-28, -72, -83, -26, -106, -121]
		String s3 = new String(b2,"utf-8");
        System.out.println(s3);//中文
		String s4 = new String(b2,3,3,"utf-8");
        System.out.println(s4);//文
        String s5 = "abc";
        char [] c = s5.toCharArray();//转为char数组
        System.out.println(Arrays.toString(c));//[a, b, c]
        String s6 = new String(c);
        String s7 = String.valueOf(c);//char转为String
        String s8 = "abcdEFG";
        System.out.println(s8.toLowerCase());//全部小写abcdefg
        System.out.println(s8.toUpperCase());//全部大写ABCDEFG
        //contact()效率高于"+"
        String s9 = s8.concat("xxxx");//拼接，返回新的字符串
        System.out.println(s9);//abcdEFGxxxx
        String s10 = s8+"xxxx";//效率最低的字符串拼接
        String s11 = "ab:cd:ef:g";//分割
        String [] arr = s11.split(":");
        System.out.println(Arrays.toString(arr));//[ab, cd, ef, g]

StringBuffer类和StringBuilder类

线程安全的可变字符序列

只能通过new+构造方法（）创建

  //无参的构造方法，默认底层创建一个长度为16的char数组  char[] value
        StringBuffer s = new StringBuffer();
        StringBuffer s1 = new StringBuffer(10);//创建一个容量为10的数组
        StringBuffer s2 = new StringBuffer("abc");//在abc的基础上容量加16
        s2.append("def");
        s2.append("hijk");
        System.out.println(s2);//直接添加在原来的数组里，不创建新的对象
        /*
        大量的字符串拼接，使用StringBuffer,不会创建新的对象
         */
        s2.insert(1,"xxx");//从指定位置插入字符串
        s2.delete(0,5);//删除指定区间，包含0，不包含5
        s2.deleteCharAt(3);//删除指定位置的字符，从0开始数
        s2.replace(0,3,"B");//把指定区间的字符替换，包含0不3
        s2.reverse();//逆序输出
        s2.substring(3);
        s2.substring(0,3);//截取
/*
除截取返回值类型为String，其余返回值均为StringBuffer
*/

StringBuffer类StringBuilder类String类区别

  public static void main(String[] args) {

    /*
    StringBuilder 适用于单线程下在字符缓冲区进行大量操作，内容可变
    StringBuffer 适用于多线程在字符缓冲区下进行大量操作线程安全，内容可变
    String  字符常量，适用于少量字符串的操作，内容不可变
     */
        StringBuilder s = new StringBuilder();
        s.append("aaa");
    }

Arrays类

java.util.Arrays;

用于操作数组工具类，里面定义了常见操作数组的静态方法。

equals()方法

比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。
声明：public static boolean equals(type[]a,type[]a2)
参数的类型可以是原生数据类型和引用类型的任意一种类型。
返回：如果两个相等，则返回true，否则返回false

  public static void main(String[] args) {
        int [] a = {1,2,3,4,5};
        int [] b = {1,2,3,4,5};

        System.out.println(Arrays.equals(a,b));//比较两个数组包含元素是否一致

sort排序

作用于数组的所有元素public static void sort(type[] a)
作用于数组指定范围内的元素public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))将指定的类型（除boolean以外的任意原生数据类型）数组所有元素（或指定范围内的元素）按数字升序进行排序。object型数组，根据元素的自然顺序，对指定对象数组进行升序排序。（fromIndex==toIndex，则排序范围为空）
自定义对象排序
自定义类实现Comparable接口

 public static void main(String[] args) {
        int [] a = {2,3,1,42,6,8};
        Arrays.sort(a);//排序
        Arrays.sort(a,0,3);//指定区间排序，包含0不包含5
        System.out.println(Arrays.toString(a));

        //对引用类型数组排序，
        Student s1 = new Student("bim",70,50,120);
        Student s2 = new Student("cim",80,60,140);
        Student s3 = new Student("aim",60,50,110);
        Student [] students = new Student[3];
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
        Arrays.sort(students);//对学生数组排序
        System.out.println(Arrays.toString(students));

//排序接口，要重写CompareTo()方法
public class Student<CompareTo> implements Comparable<Student>{
    String name;
    int bs;
    int sj;
    int sum;
   /*
        用于排序比较的方法，在sort()方法中调用
        */

    @Override
    public int compareTo(Student o) {
        return this.sum-o.sum;//自定义排序规则，用哪个属性比较，用哪个属性排序
        //return this.name.compareTo(o.name);
    }

toString() 方法
声明：public static String toString(type[] a)
描述：返回指定数组内容的字符串表示形式。
基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素用“, ”(逗号加空格)分隔。

System.out.println(Arrays.toString(a));

泛型

    /*
        泛型：参数化类型
        类型不确定，传参时可以将类型作为参数传入，只能传入引用类型，如果不传，默认是Object
         */
public class TypeDemo<T,M> {
    T p;
    M x;
    public String test(String a){
        return null;

    }

            public static void main(String[] args) {
                //TypeDemo<String> t = new TypeDemo<>();
               //t.p;
                TypeDemo<Integer,String> t,x = new TypeDemo<>();


            }
}

二分查找

声明：

public static int binarySearch(type[] a, type key)

public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)

描述：使用二分搜索算法搜索指定的type型数组，以获得指定的值。

参数：a - 要搜索的数组。

key - 要搜索的值。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex -

要排序的最后一个元素的索引（不包括）。

type -byte、double、float、object、long、int、short、char

如果key在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)

 public static void main(String[] args) {
        int [] a = {5,2,3,1,1};
        //二分折半，前提是排序后的数组
        Arrays.sort(a);
        int index = Arrays.binarySearch(a,1);//折半，要找的值小于中间值在前一部分找，大于中间值在后半部分找，找到返回0，没找到返回1
        int index1 = Arrays.binarySearch(a,0,3,1);//指定区间查找
        System.out.println(index);
    }

数组复制

      int [] a = {1,2,3,4,5};
      int [] b = Arrays.copyOf(a,10);//会创建一个新的数组,复制原来的数组，后面值为初始化的默认值
    

Math类

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

abs 绝对值

sqrt 平方根

pow(double a, double b) a的b次幂

max(double a, double b)

min(double a, double b)

random() 返回 0.0 到 1.0 的随机数

long round(double a) double型的数据a转换为long型（四舍五入）

 public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.abs(-98));//绝对值
        System.out.println(Math.sqrt(9));
        System.out.println(Math.pow(2,3));//2的3次方
        System.out.println(2<<2);

        System.out.println(Math.ceil(11.2));//12，向上取整
        System.out.println(Math.floor(11.6));//11向下取整
        System.out.println(Math.round(11.2));//四舍五入取整
        System.out.println(Math.random());//返回0-1之间的随机数，可能为0但不会为1
    }

Random类

Random类

此类用于产生随机数

构造方法

public Random()

成员方法

public int nextInt()

public int nextInt(int n)

import java.util.Arrays;
import java.util.Random;

public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextBoolean());//true或false随机返回
        System.out.println(r.nextInt());//在int取值范围内随机返回
        System.out.println(r.nextInt(10));//在0-10之间随机返回，不包含10

        byte [] b = new byte[5];
        r.nextBytes(b);//括号里面要传byte数组，向里面装入数组.length个byte随机数
        System.out.println(Arrays.toString(b));
    }

System类

System类

System 类包含一些有用的类字段和方法。它不能被实例化。

成员方法

public static void exit(int status)

public static long currentTimeMillis()

 public static void main(String[] args) {
        //public final static PritStream out = null
        //println()是PritStream中的方法
        System.out.println();
        System.out.println(System.getenv());//环境
        System.out.println(System.getenv("Path"));//环境里面path的值
        System.out.println(System.getProperties());//属性
        System.out.println(System.getProperty("jav.runtime.version"));

       // System.exit(0);//关闭程序
        System.out.println("aaaaaa");//关闭后这句不执行
       long s =  System.currentTimeMillis();//1970 1.1 0.0.0--到今天的毫秒差，在1970年1月1日UTC之间的当前时间和午夜之间的差异，以毫秒为单位。//1608206306537
        for (int i = 0; i < 100000; i++) {
            System.out.println(i);
        }
        System.out.println(System.currentTimeMillis()-s);
//        int a[] = {1,2,3,4,5};
//        int []b = Arrays.copyOf(a,10);
        int a[] = {1,2,3,4,5};
        int b[] = new int[10];
        System.arraycopy(a,0,b,0,a.length);
        System.out.println(Arrays.toString(b));
    

Date类/Calendar类/ SimpleDateFormat类

Date类

使用Date类代表当前系统时间

​ Date d = new Date();

​ Date d = new Date(long d);

   //构造方法
        Date date = new Date();//获得当前运行时间
        System.out.println(date);
        Date date0 = new Date(1608206306537L);
       // date.setTime(1608206306537L);//括号里面要传long类型的时间
        Date date1 = new Date();
        System.out.println(date1.getYear()+1900);//过期方法不建议使用@Deprecate
        System.out.println(date1.getMonth()+1);
        System.out.println(date1.getDate());
        System.out.println(date1.getDay());//0 星期天 1 2 3 4 5 6
        System.out.println(date1.getHours());
        System.out.println(date1.getTime());//==System.currentTimeMillis()

Calendar类

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需

要使用getInstance方法创建即可。

Calendar c1 = Calendar.getInstance();

c1.get(Calendar. YEAR);

   //Calendar类是一个抽象类,在实际使用时实现特定的子类的对象，
        // 创建对象的过程对程序员来说是透明的，
        // 只需要使用getInstance方法创建即可。
        //Calendar rightNow = Calendar.getInstance();
        Calendar rightNow = new GregorianCalendar();
        rightNow.set(2022,5,1);
        System.out.println(rightNow.get(Calendar.DAY_OF_YEAR));//日历字段
        System.out.println(rightNow.get(Calendar.YEAR));
        System.out.println(rightNow.get(Calendar.MONTH)+1);
        System.out.println(rightNow.getTime());
        System.out.println(rightNow.getTimeInMillis());

SimpleDateFormat 日期格式化类
构造方法

​ SimpleDateFormat(格式); // yyyy-MM-dd

日期转字符串

​ Date now=new Date();

​ myFmt.format(now);

字符串转日期

​ myFmt.parse(“2018-02-10”);

​ 字符串日期格式与 指定格式必须一致

​ 例如:String s = “2018-03-15”;

​ new SimpleDateFormat(“yyyy-MM-dd”)

public static void main(String[] args) {
        //1.日期对象转为指定格式的字符串
        Date date = new Date();
        System.out.println(date);

        SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月ddd日 HH:mm:ss E", Locale.FRANCE);
        String str  = sdf.format(date);
        System.out.println(str);
        //2.字符串转为日期对象
        String birthday = "1999-12-17";
        SimpleDateFormat sdf1 = new SimpleDateFormat("YYYY-MM-dd");
        try {
            Date date1 = sdf1.parse(birthday);
            System.out.println(date1);
        } catch (ParseException e) {
            e.printStackTrace();
        }

    }

BigInteger类

在 Java 中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。

我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类

型就无法实现了，所以Java中提供了BigInteger 类。

BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算

中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。

BigInteger类位于java.math包中

构造方法

​ BigInteger(String val) /BigInteger(byte[] val) …

​ 基本运算方法

​ add()，subtract()，multiply()，divide()

	    BigInteger b1 = new BigInteger("1608206306537456789023456789");
        BigInteger b2 = new BigInteger("1608206306537456789023456789");
        BigInteger b3 = b1.add(b2);//新创建一个对象
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b1.subtract(b2));//减，可以得到负数
        System.out.println(b1.multiply(b2));//乘
        System.out.println(b1.divide(b2));//除

BigDecimal类

在计算机中不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去一定的精确度。

根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近

于那个值.

​ double a = 1.0-0.9;

​ double b = 0.8-0.7;

​ System.out.println(a==b); // 结果?

但是，在项目中，我们不可能让这种情况出现，特别是金融项目，因为涉及金额的计算都必须十分精确，你想想，

如果你的支付宝账户余额显示193.99999999999998，那是一种怎么样的体验？

Java在java.math包中提供的API类BigDecimal

构造方法

​ BigDecimal(String val)

基本运算方法

​ add()，subtract()，multiply()，divide()

        System.out.println(12-11.9==0.1);//false
        System.out.println(12-11.9);//0.09999999999999964
        BigDecimal b1 = new BigDecimal("11.9");
        BigDecimal b2 = new BigDecimal("11.8");
        System.out.println(b1.subtract(b2));//0.1

        BigDecimal b3 = new BigDecimal("10");
        BigDecimal b4 = new BigDecimal("3");
        //System.out.println(b3.divide(b4));//会报错，出现无限循环小数时就会报错
        //如果不能表示确切的商（因为它具有非终止的十进制扩展），则抛出一个ArithmeticException 。
        System.out.println(b3.divide(b4,4,BigDecimal.ROUND_CEILING));//4表示保留4位小数,ROUND_CEILING表示向上进一位

        System.out.println(b3.divide(b4,5,BigDecimal.ROUND_FLOOR));//ROUND_FLOOR表示直接剪掉后面的小数

正则表达式

 /*
    正则表达式 regular-expression 简称：regex
    是一种模式匹配语法，由许多特定字符组成，每种字符匹配一种规则
    使用这些特定字符匹配某一个字符串，判断字符串是否满足规则需求
    从各终端向程序中输入数据时，需要对象输入的数据格式进行验证（长度，格式（手机格式，邮箱格式，qq格式，网址，数字....）)
     */
    public static void main(String[] args) {
        String s = "wsY hdh@# %$";
        if(s.length()>10||s.length()<3){
//            for (int i = 0; i < s.toCharArray().length; i++) {
//                if(i==0){
//                    s.toCharArray()[0]!=1;
//                }
//            }
            boolean res;
            res = s.matches("\\d");//\\d-是否都是数字，只能匹配一个数字，最终的返回值是布尔类型
            res = s.matches("\\d?");//？-数量词，一次或一次也没有，控制数量。
            res = s.matches("\\d*");//*-零次或多次
            res = s.matches("\\d+");//+-一次或多次
            res = s.matches("\\d{11}");//{n}-固定n次
            res = s.matches("\\d{3,}");//至少3次，上不封顶
            res = s.matches("\\d{3,6}");//3-6位，包含3和6
            res = s.matches("\\D");//\\D-非数字
            res = s.matches("[0-9]{3,6}");//[0-9]-0-9的数字，3-6位
            res = s.matches("[1357]{3,6}");//只包含1357，3-6位
            res = s.matches("[^1357]{3,6}");//非1357，3-6位
            res = s.matches("\\w*");//\\w-单词字符，大小写字母，0-9数字
            res = s.matches("[a-z]*");//小写字母
            res = s.matches("[A-Za-z]*");//大小写字母
            res = s.matches("[A-z]*");//大小写字母
            res = s.matches("[A-z0-9]*");//大小写字母，0-9数字
            System.out.println(res);//false
        }
    }