Java-_- API，基础常用类

Wooo_e

已于 2024-03-23 20:02:59 修改

阅读量985

点赞数 29

文章标签： java 开发语言

于 2024-03-23 20:02:34 首次发布

本文链接：https://blog.csdn.net/Wooo_e/article/details/136569629

版权

7、String类与StringBuffer类与StringBuilder类区别

3、SimpleDateFormat类（日期格式化）

1、Java API

API（Application Programming Interface）应用程序编程接口

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

2、常用类

1、Object类

Object:是Java体系结构中最顶层的类
       可以表示Java中任意的类

1、toString

输出一个对象，但是对象是在内存中存储，不能输出的。
当输出一个对象时，会默认调用此对象的toString()

如果类中没有定义toString( )，会源用Object类中的toString( )。

Obejct类中toString()，是把对象在内存的哈希值(以16进制)返回。如下

那么如何把信息以字符串的形式输出？

我们可以在类中对定义Object类中的toString()进行重写，后面调用时，就调用我们自己类中的toString()了

public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());

//在类中重写toString方法
public class Person1 extends Object{
    private String name;
    private int age;

    public Person1(){

    }
    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ",age=" + age + '}';
    }
}


public class TestPerson {
    public static void main(String[] args) {
        new Person1().hashCode();
        new int[10].hashCode();
        Person1 p1 = new Person1("张三", 16);
       
        System.out.println(p1);//结果：person{name='张三',age=16}
    }
}

2、equals方法

Object类中的equals:判断两个对象是否相等

他默认比较的是两个对象的地址是否相等，在比较地址时我们就可以使用==代替它。

这里说明一下==的用法：
==:比较等号两边是否相等
当==用于比较基本类型时，比较的是常量值是否相等
当==用于比较引用类型时，比较的是对象的地址是否相等

所以在其他类中，一般都重写了equals()，把它改造为比较对象中的内容是否相等。

即在其他类中，重写equals()，比较的是对象中的内容。

public boolean equals(Object obj) {

return (this == obj);

}

public class Person {
    private String name;
    private int age;

    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object a) {
        if(a instanceof Person){//父类类型中持有的实际类型是否是指定的类型
            Person other=(Person)a;
            return name.equals(other.name)&&age==other.age;
        }
        return false;
    }
}

public class TestPerson {
    public static void main(String[] args) {
        int a=10;
        int b=10;
        System.out.println(a==b);//true

        Person p1=new Person("张三",12);
        Person p2=new Person("张三",12);
        System.out.println(p1.equals(p2));//没重写equals之前是false,重写之后是true
       
    }
}

2、Arrays类

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

1、基本类型数组

1、equals

比较两个数组的内容是否相等

public class A_equals {
    public static void main(String[] args) {
        /*
          比较两个数组的内容是否相等。
         */
        int[] a={1,2,3,4};
        int[] b={1,2,3,4};
        System.out.println(Arrays.equals(a,b));
    }
}

2、copyOf

数组扩容。讲原数组的内容，复制到一个指定长度的新数组中。

import java.util.Arrays;

/*
copyOf 数组扩容
       将原数组内容，复制到一个指定长度的新数组中
 */
public class B_copyOf {
    public static void main(String[] args) {
        int[] c=new int[5];
        c[0]=1;
        c[1]=2;
        c[2]=3;
        c[3]=4;
        c[4]=5;
        System.out.println(Arrays.copyOf(c,10));

    }

}

3、fill

用指定的值，将指定的数组中的每个元素填充。

import java.util.Arrays;

/*
fill()  用指定的值，将指定数组中的每个元素填充
 */
public class C_fill {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4};
        int[] b = {1, 2, 3, 4};
        Arrays.fill(a, 0);//将数组中的值指定为0
        System.out.println(Arrays.toString(a));
    }
}

4、toString

将数组中的元素内容拼接为一个字符串输出

import java.util.Arrays;

/*
toString 将数组中的元素内容拼接为一个字符串输出
 */
public class D_toString {
    public static void main(String[] args) {
        int[] a={1,2,3,4};
        int[] b={1,2,3,4};
        System.out.println(Arrays.toString(a));
    }
}

5、sort

对指定的数组进行升序排序

1、Arrays.sort(a);//从0—length-1升序排序
2、Arrays.sort(a,0,3);开始排序的位置0，结束排序的位置3（不包含3）

import java.util.Arrays;
/*
    sort():对指定的数组进行升序排序
 */
public class E_Sort_BinarySearch {
    public static void main(String[] args) {
        long[] a = {3, 5, 6, 2, 1, 9};
        Arrays.sort(a);//0-length-1
        System.out.println(Arrays.toString(a));//[1, 2, 3, 5, 6, 9] 
    }
}

import java.util.Arrays;

public class E_Sort_BinarySearch {
    public static void main(String[] args) {
        long[] a = {3, 5, 6, 2, 1, 9};
       
        //Arrays.sort(a,0,3);索引：开始排序的位置0，结束排序的位置3（不包含3）
        Arrays.sort(a,0,4);
        System.out.println(Arrays.toString(a));//[2, 3, 5, 6, 1, 9]
   }
}

6、binarySearch

二分搜索算法查找指定的元素位置，如果未找到返回负数，二分查找前提是数组必须有序。

1、Arrays.binarySearch(b,3);//查找数组b,是否有3，返回其下标
2、Arrays.binarySearch(b,0,4,2);//开始查找的位置索引0，结束查找的位置索引4，找对象2，返回下标。

import java.util.Arrays;

public class E_Sort_BinarySearch {
    public static void main(String[] args) {
        int[] b={2,3,4,9,5};
        Arrays.sort(b);
        int index=Arrays.binarySearch(b,3);
        System.out.println(index);//返回下标

        //开始查找的位置索引0，结束查找的位置索引4，找对象2
        int index2=Arrays.binarySearch(b,0,4,2);
        System.out.println(index2);
    }
}

2、引用类型数组

1、toString

2、sort

在对类排序时，要实现Comparable接口,指定一个排序的方法。

import java.util.Arrays;

public class TestStudent {
    public static void main(String[] args) {
        //创建对象
        Student s1=new Student("张1",12);
        Student s2=new Student("张2",13);
        Student s3=new Student("张3",16);
        Student s4=new Student("张4",11);

        //定义一个Student类型的数组
        Student[] students=new Student[4];
        //将创建的对象存入数组中
        students[0]=s2;
        students[1]=s4;
        students[2]=s1;
        students[3]=s3;

        //对其进行排序
        //一个类进行排序，那么这个类必须实现Comparable接口，指定一个排序的方法
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }


}
//类实现Comparable接口
public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //方法重写
     @Override
    public String toString() {
        return "Student{"+
                "name='"+name+'\''+
                ",age="+age+'}';
    }
    /*
    重写： compareTo( )用来指定排序规则，
         可以执行用类中的哪个属性作为排序的项
         这个方法在sort()方法的底层调用，来判断大小,不需要用对象调用,sort会自动调用它。
   */
    @Override
    public int compareTo(Student o){
        //return this.age-o.age;
        return o.name.compareTo(this.name);
    }

}

3、BaseType基本数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进表示，这样八个和基本数据类型对应的类统称为包装类。

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

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

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

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

以java.lang.Integer类为例，

1、Integer

1、基本方法

最大int型数值
最小int型数值
int类型字节大小

public class IntegerDemo {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);//最大值2147483647
        System.out.println(Integer.MIN_VALUE);//最小值-2147483648
        System.out.println(Integer.SIZE);//32
        System.out.println(Integer.BYTES);//4
   }
}

2、构造方法

构造方法:
构造Integer对象，里面包装了一个基本类型的值(字符串)，用该对象来表示一个int值
Integer a = new Integer(8);
（可以是字符串类型的int值）
Integer b = new Integer("4");

public class IntegerDemo {
    public static void main(String[] args) {
       
        //构造Integer对象，里面包装了一个基本类型的值，用该对象表示一个int值
        Integer a = new Integer(8);
        Integer b = new Integer("4");

        System.out.println(a);
        System.out.println(b);

3、静态方法

静态方法

拿Integer包装类型直接使用

Integer.toHexString(17)//将17转为16进制
Integer.toOctalString(22)//将22转为8进制
Integer.toBinaryString(23)//将23转为二进制

Integer.max(a, b)//比较大小，返回较大的数的值
Integer.compare(a, b)//比较大小，如果a>b,返回1；a<b,返回-1；a=b,返回0；

public class IntegerDemo {
    public static void main(String[] args) {
        //构造Integer对象，里面包装了一个基本类型的值，用该对象表示一个int值
        Integer a = new Integer(8);
        Integer b = new Integer("4");

        System.out.println(a);
        System.out.println(b);

        //一类是静态方法：（拿Integer包装类型直接）
        System.out.println(Integer.toHexString(17));
        System.out.println(Integer.toOctalString(22));
        System.out.println(Integer.toBinaryString(23));
        System.out.println(Integer.max(a, b));
        System.out.println(Integer.compare(a, b));//1,0,-1
    }
}

4、非静态方法

非静态方法
用new关键字创建出来的对象，实例化。
a.equals(b)//判断a和b的内容是否相等
b.compareTo(a)//比较大小，b>a,返回1;b<a,返回-1;b=a,返回0;

public class IntegerDemo {
    public static void main(String[] args) {

        //构造Integer对象，里面包装了一个基本类型的值，用该对象表示一个int值
        Integer a = new Integer(8);
        Integer b = new Integer("4");

        //二类是非静态方法（拿new出来的对象来实例化)
        System.out.println(a.equals(b));//是否相等 false
        System.out.println(b.compareTo(a));//比较大小，小：-1，大：1，相等：0
   }
}

5、装箱

将基本类型转换成包装类型---->装箱

自动装箱：把基本数据类型自动转为引用类型时，装箱的时候会自动调用valueOf( )方法。那把这称之为自动装箱。

如果基本类型的值在（-128~127）之间，java会首先从缓存数组中直接抽取一个Inteder对象，不会创建新对象，这样就减少了对象的创建次数。

如果两个值相同，那么我们说获取的是同一个数。

如果不在（-128~127）范围之间，那么就比较麻烦了，每次都会创建一个新的Inteder对象返回。

我们来看看java底层对于valuOf方法的使用：
 public static Integer valueOf(int i) {
           if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
               return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
            return new Integer(i);
}

public class IntegerDemo {
    public static void main(String[] args) {
        
        int e=10;//如过换成是140
        ///Integer x=Integer.valueOf(e);
        Integer x=e;//自动装箱，会默认自动调用ValueOf()方法。
        Integer z=e;
     
        System.out.println(x==z);//比较的是两个数的地址。返回的是true
        //如果e不在基本类型范围-128~127，Java会创建一个Integer对象。用==比较的时候自然返回的是false
        System.out.println(x.equals(e));//比较的是两个数的内容。

    }
}

6、拆箱

将引用（包装）类型转为基本类型方法---->拆箱

自动拆箱：将引用类型转为基本类型时，会自动调用intValue方法，被称之为自动拆箱。

引用类型转基本类型转换的方法: 拆箱
     //int c=a.intValue();//使用intValue()方法来拆箱
     Integer a = new Integer(8);
     int y=a;//就是自动拆箱，会默认自动调用intValue方法，

4、String类

String类在java中，路径："java.lang.String"，是由多个字符组成的一串数据（字符序列）的字符串常量。

java中所有字符串都是此类的实例。

String类中有许多方法，我在这里对其进行分类记忆。

1、创建对象

1、String s="abc";

先在栈中创建一个String类的对象引用变量s,创建时，先去字符串常量池中查找有没有相同的对象。如果有，说明字符串常量池中已经存储，就使用字符串常量池的对象，不需要创建新的，直接返回已存在的对象的地址。（字符串常量池在java中是一个独立的内存管理空间）

如果没有，就创建一个新的字符串对象，并返回其地址。

2、String s=new String("abc");

使用new关键字，每次都创建一个新的对象，值存储在堆内存的对象中。

public class String1 {
    public static void main(String[] args) {
        String s = "ddd";
  
        String s1 = "ddd";
        System.out.println(s == s1);//在字符串常量池中，所以地址相同，true

        String a = new String("ddd");
        String b = new String("ddd");
        System.out.println(a == b);//重新创建的对象，false
        System.out.println(a.equals(b));//true
        System.out.println(s1 == a);//false
        System.out.println(s1.equals(a));//true

    }
}

注意： 创建一个新的字符串对象后，字符串就不变了，它们的值在创建后不能被更改。如果更改他们的值，相当于重新创建了一个新的对象。

public class String2 {
    public static void main(String[] args) {
        //字符串不变，它们的值在创建后不能被更改
        String s="abc";//对象1：abc
               s+="ef";//对象2：abcef
               s+="ggg";//对象3：abcefggg
        System.out.println(s);//进行运算时，创建了三个对象。abcefggg
    }
}

2、String类中的构造方法

String() //无参的构造方法
String(String b)  //有参的构造方法
String(byte[] bytes)  把字节数组-转为-字符串   s3.getBytes();
String(char[] chars)  把char数组-转为-字符串   s5.toCharArray();

public class String3 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //1、无参
        String s1 = new String();
        //2、有参
        String s2 = new String("acb");
        //3、字节数组---与---字符串
        String s3 = "你好";
        byte[] bytes = s3.getBytes();//编码：把字符串"你好"转为：字节数组（一串数字）
        System.out.println(Arrays.toString(bytes));//输出：[-28, -67, -96, -27, -91, -67]

        String s4=new String(bytes);//解码：把字节数组转为：字符串"你好"
        System.out.println(s4);//输出：你好

        //4、char数组---与--字符串
        String s5="cba";
        char[] chars=s5.toCharArray();//把字符串转为字符数组
        Arrays.sort(chars);//以数组的形式进行排序

        String s6=new String(chars);//把排序好的数组转为字符串
        System.out.println(s6);//输出：abc

    }
}

3、判断功能

boolean equals ( Object anObject ) --------> 比较字符串对象中的内容是否相等。

boolean equalsIgnoreCase ( String anotherString ) ---------> 比较字符串对象中的内容是否相等（忽略大小写）。

boolean contains ( CharSequence s ) ----------> 判断字符串中是否包含指定的字符串（连续的或单独的）。

boolean isEmpty () --------> 判断字符串是否为空串。

boolean startsWith ( String prefix ) ---------> 判断是否以指定的字符串开头。

boolean endsWith ( String suffix ) ----------> 判断是否以指定的字符串结尾。

public class String4 {
    public static void main(String[] args) {
        String s1=new String("abcd");
        String s2=new String("abcD");

        System.out.println(s1.equals(s2));//false比较字符串对象中内容是否相等
        System.out.println(s1.equalsIgnoreCase(s2));//true比较字符串对象中的内容是否相等（忽略大小写）
        System.out.println(s1.contains("bc"));//true判断字符串中是否包含指定的字串 （连续的或单独的）
        System.out.println(s1.isEmpty());//false判断字符串是否为空串
        System.out.println(s1.startsWith("ac"));//false判断是否以指定的字符串开头
        System.out.println(s1.endsWith("cd"));//true判断是否以指定的字符串结尾

    }
}

4、获取功能

int length () --------> 获取字符串的长度。

char charAt ( int index ) --------> 获取字符串指定位置上的字符。

int indexOf ( String str ) --------> 返回指定字符串首次出现的位置。

int indexOf ( String str , int fromIndex ) --------> 返回指定字符串首此出现的位置，从指定位置开始查找。

int lastIndexOf ( String str ) --------> 从后向前查找，返回指定字符串首次出现的位置。

String substring ( int beginIndex ) ---------> 从指定位置截取一个字符串的副本到结束。

String substring ( int beginIndex , int endIndex ) --------> 从指定位置开始截取一个字符串的副本到指定位置（不包含结束位置）。

public class String5 {
    public static void main(String[] args) {
        String s1 = new String("abcdefcefg");
                        //下标：0123456789
        System.out.println(s1.charAt(4));//结果：e，获取字符串指定位置上的字符
        System.out.println(s1.indexOf("ef"));//结果：4，返回字符串首次出现的位置
        System.out.println(s1.indexOf("c",4));//结果：6，从指定位置查找，返回字符串首次出现的位置
        System.out.println(s1.lastIndexOf("d"));//结果：3，从后向前查找，返回字符串首次出现的位置
        System.out.println(s1.substring(4));//结果：efcefg，从指定位置开始截取一个字符串的副本到完
        System.out.println(s1.substring(4,7));//结果：fc，从指定位置开始截取一个字符串的副本到指定的位置结束（不包含指定位置）
        s1.length();//获取字符串的长度
    }
}

5、转换功能

byte [ ] getBytes () -------> 把字符串转为字节数组。

char [ ] toCharArray () -------> 把字符串转为字符数组。

static String valueOf ( int i ) --------> 将传入的参数转为字符串类型。

static String valueOf ( char data [ ]) -------> 将传入的字符数组转为字符串类型。

char charAt ( int index ) -------> 将返回传入的参数（作为字符串下标的）字符

String toLowerCase () --------> 将英文字母转为小写

String toUpperCase () --------> 将英文字母转为大写。

String concat ( String str ) ---------> 拼接指定的字符串内容到原来的字符串末尾，返回一个新的字符串的对象。

String [] split ( String regex ) （分割符） --------> 将一个字符串用指定的分隔符，拆成一个个的字符串存入字符串数组中

public class String6 {
    public static void main(String[] args) {
        String s1=new String("abcddfgs");
        System.out.println(Arrays.toString(s1.getBytes()));//结果：[97, 98, 99, 100, 100, 102, 103, 115]，将字符串转为字节数组
        System.out.println(Arrays.toString(s1.toCharArray()));//结果：[a, b, c, d, d, f, g, s]，将字符串转为字符数组

        String s2=String.valueOf(1234);
        System.out.println(s2);//结果：1234，将传入的参数转为字符串类型
        System.out.println(s2.charAt(3));//结果：4，将返回传入的参数作为下标的字符

        String s3=String.valueOf("abc2".toCharArray());
        System.out.println(s3);//结果：abc2，将传入的字符串用toCharArray转为字符数组，然后将字符数组转为字符串类型

        String s4="abcEDF";
        System.out.println(s4.toLowerCase());//结果：abcedf，将字符串中的英文字母全部改成小写
        System.out.println(s4.toUpperCase());//结果：ABCEDF，将字符串中的英文字母全部改成大写

        String s5="a3;b2;c4";
        System.out.println(s5.concat(";"));//结果a3;b2;c4;，拼接指定的字符串内容到原来的字符串末尾，返回一个新的字符串

        String[] strings=s5.split(";");//分隔符，将字符串用指定的分隔符，拆分成一个个字符串存入一个新的字符串数组中并返回
        System.out.println(Arrays.toString(strings));//结果：[a3, b2, c4]
    }

}

6、替换功能

String replace ( char oldChar , char newChar ) ------> 将内容替换字符串中指定的字符数组。

String replace ( CharSequence target , CharSequence replacement ) -------> 将新内容替换字符串中指定的字符串。

String replaceAll ( String regex , String replacement ) --------> 用新内容替换字符串中正则表达式匹配的字符串。

String replaceFirst ( String regex , String replacement ) --------> 用新内容替换字符串中正则表达式匹配的字符串，只能替换第一个。

String trim () -------> 去除字符串两端的空格 .

public class String7 {
    public static void main(String[] args) {
        String s1=new String(" a4b3c5ed4 ");

        System.out.println(s1.replace('a','b'));//结果：b4b3c5ed4 ，用新内容替换字符串中指定的字符串
        System.out.println(s1.replace("3","4"));//结果：a4b4c5ed4

        System.out.println(s1.replaceAll("4","1"));//结果：a1b3c5ed1 ，用新内容替换字符串中正则表达式匹配的字符串
        System.out.println(s1.replaceAll("\\d","t"));//结果：atbtctedt ，用新内容替换字符串中正则表达式匹配的字符串（所有数字）。
        System.out.println(s1.replaceFirst("4","0"));//结果：a0b3c5ed4 ，用新内容替换字符串中正则表达式匹配的字符串，只能替换第一个
        System.out.println(s1.replaceFirst("\\d","c"));//结果：acb3c5ed4 ，用新内容替换字符串中正则表达式匹配的字符串（\d指数字），只能替换第一个

        System.out.println(s1.length());//11，获取字符串的长度
        System.out.println(s1.trim().length());//结果：9，去除字符串两端的空格

    }
}

5、StringBuffer类

String声明的字符串对象值一旦给定就不能被改变了。那我们在每次拼接的时候都会创建新的字符串对象，既耗时又占用空间。这里Java就创建了一个新的类：StringBuffer。线程安全的可变字符序列‘

1、特点

StringBuffer是内容可以改变的字符串。底层实现是：char[] value; 并且没有使用final修饰，每次添加内容都是对此数组进行操作，不会创建新的字符串对象。

2、创建对象

构造方法

public StringBuffer( ) //空参

public StringBuffer(String str) //有参

//空参的构造方法中默认指定：底层数组的长度是16
StringBuffer s = new StringBuffer();
//当然我们也可以指定数组的容量
StringBuffer s2 = new StringBuffer(10);

//有参的构造方法中默认数组长度：内容长度+16
StringBuffer s=new StringBuffer("abcdefg");

public class StringBuffer1 {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();//空参的构造方法 指定底层数组的长度是16
        StringBuffer s=new StringBuffer("abcdefg");//创建 内容长度+16的char数组
        StringBuffer s2 = new StringBuffer(10);//指定数组的容量
        
        System.out.println(s);
    }
}

3、添加功能

public StringBuffer append(String str)//在原字符串后添加字符串

public StringBuffer insert(int offset,String str)//向指定位置上插入指定的字符串

4、删除功能

public StringBuffer deleteCharAt(int index)//删除指定位置上的字符

public StringBuffer delete(int start,int end)//删除指定区间上的字符，包含开始位置，不包含结束位置

5、替换功能

public StringBuffer replace(int start,int end,String str)//替换指定区间上的字符串，包含开始位置，不包含结束位置。

6、反转功能

public StringBuffer reverse()//反转字符

7、截取功能

public String substring(int start)//从当前位置截取字符

public String substring(int start,int end)//从当前位置截取字符串，包含开始，不包含结尾。

注意：截取字符串时，从StringBuffer中截取一个字符串副本，返回一个新的String类型对象，StringBuffer本身的对象不变。

public class StringBuffer1 {
    public static void main(String[] args) {
        //创建对象
        StringBuffer s1 = new StringBuffer();//空参的构造方法16 指定底层数组的长度是16
        StringBuffer s=new StringBuffer("abcdefg");//创建 内容长度+16的char数
组
        System.out.println(s);
        StringBuffer s2 = new StringBuffer(10);//指定数组的容量

        //添加元素
        s1.append("efd");
        System.out.println(s1);

        s2.append("erty");
        s2.append("uuuu");
        System.out.println(s2);


        System.out.println(s2.insert(1,"g"));//向指定位置上插入指定的字符串
        System.out.println(s2.delete(0,3));//删除指定区间上的字符，包含开始位置，不包含结尾
        System.out.println(s2.deleteCharAt(1));//删除指定位置上的字符
        System.out.println(s2.replace(0,2,"AAA"));//替换指定区间字符串
        System.out.println(s2.reverse());//反转字符

        System.out.println(s2.substring(0,4));//截取字符串，从StringBuffer中截取一个字符串副本，返回给一个新的String对象，StringBuffer对象不变

    }

}

6、StringBuilder类

StringBuilder类功能和StringBuffer功能完全一致，但是区别是：StringBuffer是线程安全的。

7、String类与StringBuffer类与StringBuilder类区别

String: 是字符常量，适用于少量的字符串操作的情况。是一个值不可以改变的字符串
StringBuffer: 值可以改变且不需要创建对象，方法上都加了锁，是在多线程（任务）执行时线程是安全的
StringBuilder: 值可以改变且不需要创建对象，由于方法上没有加锁，在多线程（任务）执行时线程是不安全的，适合单线程

8、正则表达式

1、概念

正则表达式：Regular Expression 简称：regex。是一种规格（模式）匹配语法，是用于文本处理，他允许用户创建一个模式，用于在字符串中匹配特定的文本或字符序列。
可以使一些正则表达式中定义的特殊符号来定义一种规则，然后用此规则去匹配某个字符串。

他是个boolean类型，如果字符串与规则相匹配返回true，否则返回false

2、特殊字符

字符	含义
*	允许重复0次或更多次
+	允许重复1次或更多次
？	允许重复0次或1次
{n}	允许重复出现n次
{n，}	允许至少重复出现n次
{n，m}	允许重复至少n次不大于m次
\d	匹配数字
\D	匹配任意非数字的字符
[0-9]	字符串中只有0-9的数字，且默认只允许出现一次
[a-z]	小写字母，且默认只允许出现一次
[A-z]	任意字母，且默认只允许出现一次
[357]	只允许出现3或5或7，且默认只允许出现一次
[0-9A-z]	匹配数字或字母或下划线
\w	匹配数字或字母或下划线
\W	匹配非数字或非字母或非下划线
\s	匹配空格字符
\S	匹配非空格字符
\|	逻辑或
.	匹配除换行符以外的任意字符

3、案例

验证一个字符串是否是大陆地区的手机号格式？（利用正则表达式去定义一种规则）

matches()方法---->里面写一个规则，进行匹配，判断字符串是否符合要求。

public class Regex1 {
    //验证一个字符串是否是中国大陆地区手机号？
    public static void main(String[] args) {
        String s = "17789876754";
        System.out.println(s.matches("1[35789]\\d{9}"));//true

        //验证一个字符串是否是邮箱？
        String s1="3485083973@qq.com";
        System.out.println(s1.matches("\\w{6,10}@[0-9a-z]{2,5}\\.com|com\\.cn"));//true
        
        //验证一个字符串是否是中文字符？
        String s2="中国";
        System.out.println(s2.matches("[\u4e00-\u9fa5]+"));//true

    }
}

9、Math类

Math.PI;//Π
Math.max(int a, int b);//求两数最大值
Math.abs(int a);//求绝对值
Math.sqrt(double a);//求平方根
Math.floor(double a);//向下取整
Math.ceil(double a);//向上取整
Math.round(double a);//正常取整，四舍五入
Math.random();//求随机数（大于0，小于1）

public class Dame {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.max(12,23));
        System.out.println(Math.abs(-3));//int 绝对值
        System.out.println(Math.sqrt(9));//double 平方根
        System.out.println(Math.floor(9.1));//向下取整
        System.out.println(Math.ceil(9.1));//向上取整
        System.out.println(Math.round(9.5));//正常取整。四舍五入
        System.out.println(Math.random());//double 小于1，大于0，随机数
    }
}

10、Random类

nextBoolean();//随机返回Boolean值
nextDouble();//随机返回double值
nextInt();//随机返回int值
nextFloat();//随机返回float值
nextInt(int bound);//随机返回指定区间值


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

public class Reandom1 {
    public static void main(String[] args) {
        Random random=new Random();
        System.out.println(random.nextBoolean());//boolean nextBoolean(),随机返回Boolean值
        System.out.println(random.nextDouble());//double范围内
        System.out.println(random.nextInt());//int范围内
        System.out.println(random.nextFloat());//float范围内
        System.out.println(random.nextInt(2)+1);//随机返回（0+1）~2范围内的值

        byte[] bytes=new byte[5];
        random.nextBytes(bytes);//随机取出[数组长度]个byte类型的随机数
        System.out.println(Arrays.toString(bytes));
    }
}

11、时间类

1、Date类

1、构造方法

Date d=new Date();

Date d=new Date(long d);

2、创建对象

Date date=new Date();
System.out.println(date);
//得到的是一串字符串格式的日期Sat Mar 16 16:55:54 CST 2024

3、方法调用

//方法上有删除线，表示此方法已弃用，有新的替代，但是也可以使用

import java.util.Date;

public class Date1 {
    public static void main(String[] args) {
        Date date=new Date();
        System.out.println(date);
         
        //方法上有删除线，表示此方法已弃用，有新的替代，但是也可以使用
        System.out.println(date.getDay());//这一星期的第几天
        System.out.println(date.getHours());//现在是一天中的几点
        System.out.println(date.getDate());//今天是一个月中的第几天
        System.out.println(date.getMinutes());//现在是几分钟
        System.out.println(date.getMonth()+1);//现在是几月（美国从12月开始）
        System.out.println(date.getSeconds());//现在是几秒
        System.out.println(date.getYear()+1900);//今年是第几年（从1900开始）

import java.util.Date;

public class Date1 {
    public static void main(String[] args) {
        Date date=new Date();
        //时间戳 例如：1709035404026  long类型
        //目的是获取自1970 1.1 0:0:0 至程序运行时刻的毫秒值
        System.out.println(date.getTime());
        
        //将指定的long类型的时间戳构造出一个时间对象
        Date date2=new Date(1709035404026L);
        System.out.println(date2);

        Date date1=new Date();//可以用来计算效率
        System.out.println(date1.getTime() - date.getTime());
    }
}

2、Calender类（日历）

它是一个抽象类

1、获取一个实例

Calendar.getInstance();//他的子类其实就是公历。

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar>
        Calendar calendar=Calendar.getInstance();//获取日期
        System.out.println(calendar);//获取一个公历
    }
}

2、方法调用

calendar.get(Calendar.YEAR);//获取今年是多少年
calendar.get(Calendar.MONTH)+1;//现在几月
calendar.get(Calendar.DATE);//第几日
calendar.get(Calendar.DAY_OF_WEEK);//一周第几天（美国从周日开始）
calendar.get(Calendar.DAY_OF_MONTH);//一月第几天
calendar.get(Calendar.DAY_OF_YEAR);//一年第几天

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar>
        Calendar calendar=Calendar.getInstance();//获取日期  

  
        System.out.println(calendar.get(Calendar.YEAR));//获取今年是多少年
        System.out.println(calendar.get(Calendar.MONTH)+1);//获取现在是几月
        System.out.println(calendar.get(Calendar.DATE));//获取今天是第几天
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));// 一周里面的第几天（美国从周日开始计算）
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//一个月里的第多少天
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//一年里面的多少天


        System.out.println(calendar.getTimeInMillis());//结果例如：1710581624654，获取时间戳
    }
}

3、创建一个日期

calendar.set(2024,2,27);//可以自己创建一个日期，进行方法的调用。

3、SimpleDateFormat类（日期格式化）

通常在我们的网页中，输入一个日期，拿到的是他的字符串类型。如何把字符串转为日期类型呢？

1、将字符串日期转为Date对象

Date date=simpleDateFormat1.parse(String s);//利用parse方法将字符串转为Date类型

2、将一个日期对象转为字符串日期

String s=simpleDateFormat.format(Date date);//利用format方法将Date类型转为String类型

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

/*
日期格式化
 */
public class SimpleDateFormat1 {
    public static void main(String[] args) throws ParseException {
        //将字符串日期（标准用-隔开） 转为 Date对象
        String s="2022-02-12";
        SimpleDateFormat simpleDateFormat1=new SimpleDateFormat("yyyy-MM-dd");//构造方法传入的是有参的
        Date date=simpleDateFormat1.parse(s);
        System.out.println(date.getYear()+1900);
        //将日期对象 转为 指定格式字符串日期
        Date date1=new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");//构造方法格式化 2024年02月27日 21:37:48 星期二
        String s1=simpleDateFormat.format(date1);
        System.out.println(s1);

    }
}

12、BigInteger类

BigInteger类位于java.math包中。

在java中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。

BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。

import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {
        BigInteger bigInteger=new BigInteger("111111111111111111111111111111111111111111");
        BigInteger bigInteger1=new BigInteger("2222222222222222222222222222222222222222222");

        BigInteger b3=bigInteger.add(bigInteger1);
        BigInteger b4=bigInteger1.divide(bigInteger);
        BigInteger b5=bigInteger.multiply(bigInteger1);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
   }
}

13、BigDecimal类

java.math包中提供的API类BigDecimal类。

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

根本原因是:十进制浮点值没有完全相同的二进制表示形式;十进制浮点值的二进制表示形式不精确,只能无限接近于那个值。

但是，在项目中，我们不可能让这种情况出现，使用BigDecimal类解决问题。

注意除法：除法需要注意可能无限循环，需要给定保留的位数，以及舍入模式。

BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
在除法中，常常会遇到死循环。
通过传入参数来解决此类问题scale保留小数的位置，roundingMode取整模式
roundingMode如果为1：向下舍入，如果为二2：向上舍入

import java.math.BigDecimal;

public class BigIntegerDemo {
    public static void main(String[] args) {

        //bigDecimal参数以字符串的形式传入
        System.out.println(0.3+0.36);//结果：0.6599999999999999
        //使用bigDecimal类，达到准确精度
        BigDecimal bigDecimal2=new BigDecimal("0.3");
        BigDecimal bigDecimal3=new BigDecimal("0.36");
        System.out.println(bigDecimal2.add(bigDecimal3));//0.66

        //在除法中，常常会遇到死循环。
        //通过传入参数来解决此类问题scale保留小数的位置，roundingMode取整模式
        BigDecimal bigDecimal4=new BigDecimal("10");
        BigDecimal bigDecimal5=new BigDecimal("3");
        System.out.println(bigDecimal4.divide(bigDecimal5,2,2));//roundingMode如果为1：向下舍入，如果为二2：向上舍入
        //除法需要注意可能无限循环，需要给定保留的位数，以及舍入模式。
    }
}

持续更.......

Wooo_e

关注

29
点赞
踩
17

收藏

觉得还不错? 一键收藏
1
评论
Java-_- API，基础常用类

API（Application Programming Interface）应用程序编程接口是对Java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明。
复制链接

扫一扫