Java 常用类-CSDN博客

本文链接：https://blog.csdn.net/2301_77687181/article/details/137398466

Object
Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类( 父类）。所有对象（包括数组）都继承实现这个类的方法。
● 如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类
public class Person { ...
}
等价于：
public class Person extends Object {
...
}
● toString方法
● Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。
● 当需要通过输出语句输出一个对象时,如System.out.println(person），将自动调用该对象类的toString()方法,如果该类中没有重写toString(),那么默认调用Object类中的toString(),默认输出对象hashCode值.
● 可以根据需要在用户自定义类型中重写toString()方法。
● equals方法
● Object类中定义有：
● public boolean equals(Object obj)方法,判断对象是否相等的逻辑。
public boolean equals(Object obj) {
return (this == obj);
}
● Object 中的 equals 方法默认使用==比较,比较的是对象地址,这点需要注意.
package day09常用类.tostringdemo;

public class Person{
    private String name;
    private int age;
    private int num;
 
    public Person(String name, int age,int num) {
        this.name = name;
        this.age = age;
        this.num=num;
    }
 
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", num=" + num +
                '}';
    }
 
    @Override
    public boolean equals(Object obj) {
        if(obj==null){
            return false;
        }
        if(this==obj){
            return true;
        }
        if(obj instanceof Person){
            Person person=(Person)obj;
            return this.name.equals(person.name)&&this.age==person.age&&this.num==person.num;
        }
        return false;
    }
}
package day09常用类.tostringdemo;
 
public class TestEquals {
    public static void main(String[] args) {
        /*
        == 用于基本类型比较时,比较的是值是否相等
           用于引用类型比较时,比较的是两个引用的地址是否相等
        equals()方法用来比较对象中的内容
         */
        Person person=new Person("zhang",23,23);
        Person person1=new Person("zhang",23,23);
 
        System.out.println(person.equals(person1));
 
        //Object类中的equal()方法比较的是地址
        //所以其他的类为了比较两个对象中包含的内容是否相等,都对Object类中的equal()方法重写,改为判断对象内容
 
        //以后如果比较两个对象的地址是否相等时,直接使用==比较即可
        System.out.println(person1==person);
    }
}
package day09常用类.tostringdemo;
 
 
public class ToStringDemo {
    /*
    Object
        java.lang.Object  是java类体系中最顶级的,万类之祖
        toString()
        当输出一个对象时,回默认调用类中toString()方法,把对象以字符串形式输出
        类中如果没有toString()方法,会调用父类(Object)中的toString()方法
     */
    public static void main(String[] args) {
        Person person=new Person("张三",24,1001);
        System.out.println(person);
    }
}

Arrays类
equals 方法
比较两个数组对象中元素是否相等. 而数组对象中的equals用来判断与另一个数组对象是否相等。
声明：public static boolean equals(type[]a,type[]a2)
参数的类型可以是原生数据类型和引用类型的任意一种类型
返回：如果两个相等，则返回true，否则返回false

package day09常用类.arraysdemo;
 
import java.util.Arrays;
 
public class ArraysEqualsDemo {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5,6};
        int[] b={1,2,3,4,5,6};
        System.out.println(a==b);//false  比较的是两个数组对象的地址
        System.out.println(a.equals(b));  //false  数组也是对象,也继承了Object类,数组名.equals(),调用的是Object类中的equals
        System.out.println(Arrays.equals(a,b));//true  比较的是两个数组中的元素是否相等
    }
}

sort －排序
● 作用于数组的所有元素
public static void sort(type[] a)
● 作用于数组指定范围内的元素
public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))
将指定的类型数组所有元素按数字升序进行排序。
●自定义对象排序
自定义类实现Comparable接口 , 重写compareTo方法

package day09常用类.arraysdemo;
 
import java.util.Arrays;
 
public class ArraysSort {
    public static void main(String[] args) {
        int[] a={32,5,7,6,9,8};
        //Arrays.sort(a);对数组默认进行升序排序
        Arrays.sort(a,0,4);//指定区间进行排序 ,包含开始,不包含结束
        System.out.println(Arrays.toString(a));
 
 
 
        String[] s={"b","a","c","d"};
        Arrays.sort(s);
        System.out.println(Arrays.toString(s));
 
    }
}

package day09常用类.arraysdemo;
 
public class Student implements Comparable<Student>{
    private int num;
    private String name;
 
    public Student(int num, String name) {
        this.num = num;
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
 
    //此方法用来指定排序规则
    //此方法会在sort()进行调用
    @Override
    public int compareTo(Student o) {
        return this.num-o.num;
        //return this.name.compareTo(o.name);
    }
}
package day09常用类.arraysdemo;
 
import java.util.Arrays;
 
public class TestStudent {
    public static void main(String[] args) {
        Student s1=new Student(1001,"张三1");
        Student s2=new Student(1002,"张三2");
        Student s3=new Student(1003,"张三3");
        Student s4=new Student(1004,"张三4");
        Student[] students=new Student[4];
        students[0]=s2;
        students[1]=s1;
        students[2]=s4;
        students[3]=s3;
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
 
        //字符串比大小,返回int值
        //System.out.println("a".compareTo("b"));
 
 
    }
}

binarySearch -使用二分搜索算法搜索指定数组
public static int binarySearch(type[] a, type key)
public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)
● 参数：
a - 要搜索的数组。
key - 要搜索的值。
fromIndex - 要排序的第一个元素的索引（包括）。
toIndex - 要排序的最后一个元素的索引（不包括）。
● 如果key在数组中，则返回搜索值的索引；否则返回负数,表示不存在

package day09常用类.arraysdemo;
 
 
import java.util.Arrays;
 
public class ArraysBinarySearch {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5, 6, 7};
 
        //二分查找法,数组必须有序,不存在,返回负数,若存在,返回元素的索引
        int index=Arrays.binarySearch(a, 7);
        System.out.println(index);
 
        //指定区间查找,包含开始索引,到结束索引-1
        int index1=Arrays.binarySearch(a,0,4,5);
        System.out.println(index1);
    }
}

● copyOf方法
数组复制,将指定数组中的元素复制到一个指定长度的新数组中,并返回新数组.
static int[] copyOf(int[] a, int newLength)
fill方法
将指定的int值分配给指定的int数组的每个元素。
fill(int[] a, int val)

package day09常用类.arraysdemo;
 
import java.util.Arrays;
 
public class ArraysCopy {
    public static void main(String[] args) {
        /*
        数组复制:
           java数组在创建时,指定长度,一旦指定长度不能改变
           将原数组中的内容复制到指定长度的新数组中
         */
        int[] a={1,2,3,4,5};
        int[] b= Arrays.copyOf(a,10);
        System.out.println(Arrays.toString(b));
 
    }
}

基本数据类型包装类
基本数据类型   包装类
byte   Byte
short   Short
char   Character
int   Integer
long   Long
float   Float
double   Double
boolean   Boolean
对于包装类来说，这些类的用途主要包含两种：
● 作为和基本数据类型对应的类类型存在。
● 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法

package day09常用类.datetype;
 
public class MyInt {
    int value;
 
    public MyInt(int value) {
        this.value = value;
    }
 
    public int maxint(){
        return Integer.MAX_VALUE;
    }
    public int minint(){
        return Integer.MIN_VALUE;
    }
 
    public static void main(String[] args) {
        int a=10;
        MyInt b=new MyInt(10);
        System.out.println(b.maxint());
        System.out.println(b.minint());
        System.out.println(Integer.toBinaryString(3));
        /*
        java中基本数据类型,由8种关键字声明的,不是面向对象的设计
        为了对基本类型更加方便的操作,java为每一种基本类型创建了一个类来进行表示.
        核心是类中还是包含了一个基本数据类型,还包含了很多关于基本类型操作方法
        这样使用包装类型,符合面向对象思想
         */
    }
}

package day09常用类.datetype;
 
public class IntegerDemo {
    public static void main(String[] args) {
        int x=10;
        Integer a=new Integer(x);
        System.out.println(Integer.SIZE);
        System.out.println(Integer.BYTES);
 
        System.out.println(Integer.toBinaryString(342));
        System.out.println(Integer.toHexString(349));
 
        //如何获得int类型的包装类型对象
        Integer b =new Integer(10);
        Integer c=Integer.valueOf(12);
 
 
        //非静态方法直接对包装类的值进行操作
        System.out.println(Integer.compare(2, 2));
        System.out.println(Integer.valueOf(1));
        System.out.println( Integer.toString(2123));
        System.out.println(Integer.sum(1, 2));
        System.out.println(Integer.parseInt("2341"));
    }
}

● 装箱和拆箱Auto-boxing/unboxing
● 装箱
自动将基本数据类型转换为包装器类型
装箱的时候自动调用的是Integer的valueOf(int)方法
● 拆箱
自动将包装器类型转换为基本数据类型
拆箱的时候自动调用的是Integer的intValue方法

package day10常用类;
 
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
 
public class InterDemo2 {
    public static void main(String[] args) {
 
        /*
        public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

          当自动装箱时,默认调用Integer类中的valueOf()
          这个方法内部对  -128--127之间进行缓存(数组),在此区间自动的撞见过,不会创建新的Integer,直接从数组获取
          超出此区间后,每次都会new  新的Integer对象
         */
        Integer a=10;
        Integer b=10;
        System.out.println(a==b);  //true
        System.out.println(a.equals(b));//true
 
        //equals(比较的是内容)
        Integer c=128;
        Integer d=128;
        System.out.println(c==d);  //false
        System.out.println(c.equals(d));//true
 
        Integer e=Integer.valueOf(-128);
        Integer f=Integer.valueOf(-128);
        System.out.println(e==f);
    }
}

String类/StringBuffer类/StringBuilder类
String类概述
字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例.
● 有两种创建形式：
● 第一种:
String s = "abc";
先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建.
● 第二种:
一概在堆中创建新对象，值存储在堆内存的对象中。

String s = new String("abc");
package day10常用类.stringdemo;
 
public class StringDemo1 {
    /*
         字符串的值不可改变,一旦字符串对象被创建,值就不能改变了
         底层存储字符串的数组,是被final修饰的,必须在对象创建之后由构造方法对其赋值
         public final char value[]
         java中字符串创建的两种方式
         方式1:
             String s1="abc";
             String s2="abc";
             在第一次创建s1变量时,会去内存中有一个叫字符串常量池的空间,检索,有没有次内容的一个字符串对象
             如果没有,就会在字符串常量池中创建一个字符对象,把对象的地址给s1,
             在第二次创建s2变量时,会去字符串常量池中查找,如果有,直接将之前创建的字符对象赋给s2
             一旦出现要创建的字符串对象内容一致,返回拿到的是同一个字符串对象的地址
         方式2:
             String s3=new String("abc");
             无论是否存在相同内容的字符串对象,都会创建一个新的字符串对象
     */
    public static void main(String[] args) {
        String s="abc";
        s+="aaa";
 
        String s1="abc";
        String s2="abc";
        System.out.println(s1==s2);//true
        System.out.println(s1.equals(s2));//true
 
        String s3=new String("abc");
        String s4=new String("abc");
        System.out.println(s3==s4);//false
        System.out.println(s3.equals(s4));//true
    }
}

构造方法

public String()
public String(String str)
public String(byte[] bytes)
public String(char[] value)
package day10常用类.stringdemo;
 
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
 
public class StringDemo2 {
    /*
    String 构造方法
    String();
    String("abc");
    String(byte[]  bytes);
    String(char[]  value);
     */
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s1=new String();
        String s2=new String("abc");
 
        String s3="abc你好";
        byte[] bytes=s3.getBytes();//把字符串转为byte类型
        System.out.println(Arrays.toString(bytes));
 
 
        String s4=new String(bytes,"utf-8");
        System.out.println(s4);
 
        String s5="bced";
        char[] chars=s5.toCharArray();//字符串---->char数组
        System.out.println(Arrays.toString(chars));
        Arrays.sort(chars);
        String s6=new String(chars);//char数组---->字符串
        System.out.println(s6);
 
    }
}

判断功能
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean isEmpty()
boolean startsWith(String prefix)
boolean endsWith(String suffix)

package day10常用类.stringdemo;
 
public class StringDemo3 {
    /*
    判断功能:
        boolean equals(Object obj)
        boolean equalsIgnoreCase(String str)
        boolean contains(String str)
        boolean isEmpty()
        boolean startsWith(String prefix)
        boolean endsWith(String suffix)
     */
    public static void main(String[] args) {
        String s="abcd";
        System.out.println(s.equals("abcD"));//false
        System.out.println(s.equalsIgnoreCase("abcD"));//true
        System.out.println(s.contains("ab"));//判断是否包含子串,子串必须连续
        System.out.println(s.contains("ac"));//false
        System.out.println(s.isEmpty());//判断是否是空串  null关键字不是空串
        System.out.println(s.startsWith("a"));//判断是否以指定的子串开头
        System.out.println(s.endsWith("d"));//判断是否以指定的子串结尾
    }
}

获取功能
int length()
char charAt(int index)
int indexOf(String str)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)
package day10常用类.stringdemo;
 
public class StringDemo4 {
    /*
    获取功能
        length()
        char charAt(int index)
        int indexOf(String str)
        int indexOf(String str,int fromIndex)
        String substring(int start)
        String substring(int start,int end)
     */
    public static void main(String[] args) {
        String s="abcdcd";
        System.out.println(s.length());//获取长度
        System.out.println(s.charAt(2));//返回对应索引的字符
        System.out.println(s.indexOf("c"));//获取指定字符首次出现的位置
        System.out.println(s.indexOf("cd"));//获取指定字符首字母首次出现的位置
        System.out.println(s.indexOf("c",s.indexOf("c")+1));//从指定位置查找
        System.out.println(s.lastIndexOf("c"));//从后向前查找
 
        String s1=s.substring(3);//从指定位置开始截取字符串,返回一个新的子字符串
        String s2=s.substring(0,1);//从指定位置开始到指定位置结束(不包含结束)截取字符串,返回一个新的子字符串
        System.out.println(s1);
        System.out.println(s);
        System.out.println(s2);
    }
}

转换功能
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
String toLowerCase()
String toUpperCase()
String concat(String str)
Stirng[] split(分割符)
package day10常用类.stringdemo;
 
import java.util.Arrays;
 
public class StringDemo5 {
    /*
    转换功能
        byte[] getBytes()
        char[] toCharArray()
        static String valueOf(char[] chs)
        String toLowerCase()
        String toUpperCase()
        String concat(String str)
        Stirng[] split(分割符);
     */
    public static void main(String[] args) {
        Integer a = null;
        //System.out.println(a.toString());
        String s = String.valueOf(a);//把替他类型转为字符串,建议使用,避免出现空指针异常
        System.out.println(s);
 
        char[] c = {'a', 'b', 'c'};
        String s1 = String.valueOf(c);
 
        String s2="abcDEF";
        System.out.println(s2.toLowerCase());
        System.out.println(s2.toUpperCase());
        System.out.println(s2.concat("www"));//将指定字符串拼接到字符串末尾,返回一个新字符串
        System.out.println(s2);
 
        String s4="ab;cde;fg";
        String[] strings=s4.split(";");//使用指定的字符将字符串分割为数组   正则表达式
        System.out.println(Arrays.toString(strings));
    }
}

替换功能
String replace(char old,char new)
String replace(String old,String new)
replaceAll(String regex, String replacement)
replaceFirst(String regex, String replacement)
去除字符串两空格      String trim()
package day10常用类.stringdemo;
 
public class StringDemo6 {
    /*
    替换功能
       String replace(char old,char new)
       String replace(String old,String new)
       replaceAll(String regex, String replacement)
       replaceFirst(String regex, String replacement)
     去除字符串两空格
       String trim()
     */
    public static void main(String[] args) {
        String s=" abc defg ";
        System.out.println(s.replace('c', 'C'));
        System.out.println(s.replace("cd", "CC"));
 
        //replaceAll()使用正则表达式匹配需要替换的内容
        System.out.println(s.replaceAll("c", "CC"));
        System.out.println(s.replaceFirst("a", "CC"));
 
        System.out.println(s.length());
        System.out.println(s.trim().length());
        System.out.println(s.replace(" ", ""));
    }
}

StringBuffer类
● 添加功能
public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)
● 删除功能
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)
● 替换功能
public StringBuffer replace(int start,int end,String str)
● 反转功能
public StringBuffer reverse()StringBuffer类
● 截取功能
public String substring(int start)
public String substring(int start,int end)
● 截取功能和前面几个功能的不同
返回值类型是String类型，本身没有发生改变

package day10常用类.stringdemo;
 
public class StringBufferDemo2 {
    public static void main(String[] args) {
        StringBuffer s=new StringBuffer(20);
        s.append("abc");
        s.append("efg");
        //向指定位置插入字符串
        s.insert(2, "xxx");//abxxxcefg
        //删除
        s.deleteCharAt(2);//abxxcefg
        s.delete(2, 4);//abcefg   删除指定区间的内容  包含开始位置   不包含结束位置
        //替换
        s.replace(2, 4, "XXX");  //用心内容替换指定区间的内容  包括开始位置,不包含结束位置
        s.reverse();
        System.out.println(s);
    }
}

StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程安全的
StringBuilder 也是一个字符串缓冲区,与StringBuffer功能基本一样
区别:
StringBuffer 中的方法被synchronized修饰,一次只允许一个请求进入操作,在多用户访问下是安全的
StringBuilder 中没有被synchronized修饰,在多用户访问下是不安全的,只适用于单用户

String:值不可以改变,一旦改变就创建新对象
StringBuffer,StringBuilder:值可以改变,不会创建新对象,变得只是底层的数组
StringBuffer:多线程是加锁的,是安全的
StringBuilder:,没有加锁,多线程不安全,单线程安全
Math类/Random类
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型（四舍五入）
Random类概述
此类用于产生随机数
● 构造方法
public Random()
成员方法
public int nextInt()
public int nextInt(int n)

package day10常用类;
 
import java.util.Arrays;
import java.util.Random;
 
public class RandomDemo {
    public static void main(String[] args) {
        Random random=new Random();
        //随机返回
        System.out.println(random.nextBoolean());
        System.out.println(random.nextInt());//在int取值范围内随机返回一个结果
        System.out.println(random.nextInt(3));//在指定的范围内返回一个随机数,大于等于0 小于给定的值
 
 
        byte[] bytes=new byte[5];
        random.nextBytes(bytes);
        System.out.println(Arrays.toString(bytes));
 
    }
}

Date类/Calendar类/ SimpleDateFormat类
● Date类
● 使用Date类代表当前系统时间
Date d = new Date();
Date d = new Date(long d);

package day11;
 
import java.util.Date;
 
public class DateDemo {
    /*
    new Date();  对象,得到一个系统的当前时间
    getYear();上面有个删除线,表示此方法是弃用的方法,不建议用,但是也是可以调用的
     */
    public static void main(String[] args) {
        /*Date date=new Date();
        System.out.println(date.getYear()+1900);
        System.out.println(date.getMonth()+1);//月份从0开始
        System.out.println(date.getDate());//月中的第几天
        System.out.println(date.getDay());
        System.out.println(date.getHours());
        System.out.println(date.getTime());//1694445406342  毫秒值  从1970  1,1  0.0 到程序运行那一刻的时间差
        //测试程序运行的时间,程序运行前 new Date().getTime()  程序运行后  new Date().getTime()
        System.out.println(date);
        Date d=new Date(1694445406342l);
        System.out.println(d);*/
 
 
        Date date=new Date();
        System.out.println(date);
    }
 
 
}

● Calendar类
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
Calendar c1 = Calendar.getInstance();
c1.get(Calendar. YEAR);

package day11;
 
import java.util.Calendar;
import java.util.GregorianCalendar;
 
public class CalendarDemo {
    public static void main(String[] args) {
        /*
        Calendar   抽象类  定义日历功能  具体实现可以交给子类实现
        GregorianCalendar  公历  Calendar抽象类的具体子类
         */
        //两种方式
        Calendar c=new GregorianCalendar();
        //Calendar c=Calendar.getInstance();
        System.out.println(c.get(Calendar.YEAR));//get(具体日历的属性)
        System.out.println(c.get(Calendar.DAY_OF_MONTH));//日
        System.out.println(c.get(Calendar.HOUR_OF_DAY));
 
 
        System.out.println(c.getTimeInMillis());
    }
}

● SimpleDateFormat 日期格式化类
● 构造方法
SimpleDateFormat(格式); // yyyy-MM-dd
● 日期转字符串
Date now=new Date();
myFmt.format(now);
● 字符串转日期
myFmt.parse(“2018-02-10”);
字符串日期格式与指定格式必须一致

package day11;
 
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        /*
            将Date类型格式化为指定字符串
         */
        Date date=new Date();
        String s="张三";
 
        /*
        yyyy 4位年
        MM    月
        dd    月中的天
        HH    24小时
        mm    分钟
        ss    秒
        E     星期
         */
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日HH-mm-ss   E");
          String dat=sdf.format(date);
        System.out.println(dat);
 
        /*
        把字符串日期转换为Date类型
         */
 
        String str="2002-3-2";
        SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd");
            Date d=sdf1.parse(str);
        System.out.println(d);
 
    }
}

BigInteger/BigDecimal
BigInteger
● BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。
● BigInteger类位于java.math包中
● 构造方法
BigInteger(String val) /BigInteger(byte[] val) ...
基本运算方法

   add()，subtract()，multiply()，divide()
package day11;
 
import java.math.BigInteger;
 
public class BigIntegerDemo {
    /*
    计算超大整数
     */
    public static void main(String[] args) {
        BigInteger a=new BigInteger("111111111111111111111111111111111");
        BigInteger b=new BigInteger("111111111111111111111111111111111");
        BigInteger c=a.add(b);
        System.out.println(c);
    }
}

BigDecimal
● 在计算机中float 还是double都是浮点数，而计算机是二进制的，浮点数会失去一定的精确度。
● 根本原因是:十进制浮点值没有完全相同的二进制表示形式;十进制浮点值的二进制表示形式不精确,只能无限接近于那个值.

package day11;
 
import java.math.BigDecimal;
 
public class BigDecimalDemo {
    public static void main(String[] args) {
        /*
        传进去的数值精确计算  传字符串类型
         */
        BigDecimal a=new BigDecimal("0.1");
        BigDecimal b=new BigDecimal("0.2");
        BigDecimal c=a.add(b);
        BigDecimal d=a.divide(b);
        System.out.println(c);
        System.out.println(d);
    }
}

正则表达式
规则
是一种模式匹配语法,可以使用一些符号来定义一个规则,然后用规则与字符串进行匹配
正则表达式的符号:
\d 匹配的是0-9之间的数字
\d* 匹配任意长度
[a-z]
[A-z]
\\w==[A-z0-9-]
. 匹配任意字符 \\.进行转义,只能匹配.
| X|Y 或

package day10常用类.stringdemo;
 
import java.util.Arrays;
 
public class StringDemo7 {
    public static void main(String[] args) {
        String name="张三";
        String s="ab:cd:efg";
        String[] arr=s.split(":");
        System.out.println(Arrays.toString(arr));
        /*
           验证输入的内容必须是手机号格式
             第一位是1
             第二位是3  5  7  8  9
             第三位是任意数字
           拿到字符串每一位进行判断
         */
        String s1="13456789108";
        //boolean b= s1.matches("\\d");   匹配一位数字
        //boolean b= s1.matches("\\d*"); 匹配任意数字
        //boolean b= s1.matches("\\d{9}");  只能是n次
        //boolean b= s1.matches("\\d{3,}");  至少n次
        //boolean b= s1.matches("\\d{3,6}");  //至少n次  不超过m次
        //boolean b= s1.matches("[3578]*");
        boolean b=s1.matches("1[35789]\\d{9}");
        System.out.println(b);
 
 
        //验证qq号   数字  6-12位,0不能开头
        String p="2113454";
        boolean d=p.matches("[1-9]\\d{5,11}");
    }
 
}