Java 常用类

最新推荐文章于 2024-08-12 16:47:32 发布

@Penjay

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量50

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_76628168/article/details/133936183

版权

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}");
    }

}

@Penjay

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 常用类

StringBuffer 中的方法被synchronized修饰,一次只允许一个请求进入操作,在多用户访问下是安全的。StringBuilder 中没有被synchronized修饰,在多用户访问下是不安全的,只适用于单用户。将自动调用该对象类的toString()方法,如果该类中没有重写toString(),那。么默认调用Object类中的toString(),默认输出对象hashCode值.字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字。
复制链接

扫一扫