javaSE-常用API（全）

最新推荐文章于 2024-04-24 09:17:11 发布

发自己的光就好

最新推荐文章于 2024-04-24 09:17:11 发布

阅读量1.5k

点赞数 3

分类专栏： java API 文章标签： java

本文链接：https://blog.csdn.net/qq_53677566/article/details/117404778

版权

java API 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

文章目录

- javaSE（API）常用类

javaSE（API）常用类

一.java API概述

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

二.基本数据类型包装类

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

1.基本数据类型

byte short int long float double char boolean

基本类型使用8种关键定义变量 int a = 10; 简单类型

引用类型类型是类类型(对象) 复合类型

2…包装类

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

! 在这里插入图片描述

包装类用途

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

包装类常用方法（以Ingeter为例）

public static final int MAX_VALUE 最大的int型数（231-1）

public static final int MIN_VALUE 最小的int型数（-231）

构造方法

Integer(int a);

Integer(String a);

比较方法

static int compareTo(Integer a); 比较大小

boolean equals(Object); 比较是否相等

int max(int a,int b); 比较传入的两个数字哪个大

int min(int a,int b);基本数据类型封装类

转换方法

static toBinaryString(int i); 将数字转换成为二进制

static String toHexString(int i); 将数字转换成为十六进制

static String toOctalString(int i); 将数字转换成为八进制

public class IntegerDemo1 {

    public static void main(String[] args) {
        // int a  = 10;

         Integer  n  = new Integer(10);
         // 包装的一些关于int类相关信息
          System.out.println(n.MAX_VALUE);
          System.out.println(n.MIN_VALUE);
          System.out.println(Integer.SIZE);
          System.out.println(Integer.BYTES);

         Integer m =  new Integer("12");
         System.out.println(m+10);

        System.out.println(m.compareTo(n));//比较大小
        System.out.println(n.equals(m));//比较是否相等
        System.out.println(Integer.max(10,5));

        System.out.println(Integer.toBinaryString(3));   //将数字按二进制返回
        System.out.println(Integer.toHexString(17));     //将数字按十六进制返回
        System.out.println(Integer.toOctalString(9));    //将数字按八进制返回
    }
}

int intValue(); 取出包装类对象包含的int值

static int parseInt(String s); 将String类型转换为int

String toString(） 将整数转换为int

static String toString(int i) 将int转换为String

static Integer valueOf(int i) 装箱将int类型的数据装箱

static Integer valueOf(String s) 将String类型的数据转换为int类型的装箱

 public static void main(String[] args) {
         // int a  = 10;
         int x = 10;
         Integer  n  = new Integer(x);
         int m  =  n.intValue();//取出对象中包含的int值

         String s = "10";
         int y = Integer.parseInt(s); //将String类型转为int

         String s1  = n.toString(); //将整数 转为 String

         Integer in =   Integer.valueOf(x);
         Integer in1 =   Integer.valueOf("10")

    }

装箱和拆箱

概念：

1.装箱

自动将基本数据类型转换为包装器类型装箱的时候自动调用的是Integer的valueOf(int)方法

2.拆箱

自动将包装器类型转换为基本数据类型拆箱的时候自动调用的是Integer的intValue方法

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dbXPDoFg-1622377141894)(C:\Users\封纪元\AppData\Roaming\Typora\typora-user-images\1620979250812.png)]$

 public static void main(String[] args) {

         int x = 10;
         /*
         基本类型转引用类型
         Integer  n  =  new Integer(x);
         Integer  n1  =  Integer.valueOf(x);
         */

         Integer n = x;  //自动装箱  默认调用valueOf()方法 创建一个Integer对象

             //n.intValue()
         int y = n;//自动拆箱  将引用类型转为基本类型  默认调用intValue()方法 取出包含的int值

    }

装箱和拆箱中要注意的一个问题

public static void main(String[] args) {

           /*
               自动装箱的问题

                  == 在比较基本类型时,比较的就是值是否相等
                  == 在比较引用类型时,比较对象在内存中的地址是否相等

                   自动装箱调用valueOf()
                   public static Integer valueOf(int i) {
                         判断值如果在 -128 到 127之间 会从缓存数组中取出一个对象返回,
                         多个值相同,返回的是同一个对象
                        if (i >= IntegerCache.low && i <= IntegerCache.high)
                            return IntegerCache.cache[i + (-IntegerCache.low)];
                        return new Integer(i);//不在-128 到 127之间会创建新的对象返回
                    }
            */
            Integer x = 127;
            Integer y = 127;
            System.out.println(x==y);//10 true  128 false


            Integer m = new Integer(128);
            Integer n = new Integer(128); //两个不同的对象比较
            System.out.println(m==n);//10 false  128 false

           System.out.println(127==127);

           Boolean b = true;
           boolean b1 = b;


    }

三.Object类

Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都实现这个类的方法。
如果在类的声明中未使用extends关键字指明其基类，则默认基类为 Object类

1.toString方法

Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。
如果在自定义的引用类型中也想通过输出方法（sout）输出对象信息则需要重写toString方法(根据自己需要来写)

2.equals方法

public boolean equals(Object obj)方法提供定义对象是否“相等”的逻辑。（如是自定义的引用类型则需要按照自己的需要来重写equals方法自己来定义相等的逻辑）
Object 的 equals 方法定义为**：x.equals ( y )** ，当 x 和 y是同一个对象的引用时返回 true 否则返回 false
JDK提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ,当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回 true 否则返回 false。（java自己提供的引用类一般都重写了equals和toString方法）

注：在引用类型的比较中"=="比较的是它们的地址值如要比较它们的内容则必须用equals方法来比较

代码（包含toString和equals方法的使用）

public class Person extends Object{

     private String name;
     private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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 && (name.equals(((Person) o).name));

    }
}

public class ObjectToString {
    public static void main(String[] args) {
        Person p = new Person();
               p.setName("张三");
               p.setAge(20);

        /*
          使用System.out.println(p);输出对象,此时会默认调用对象中的toString()
          当类中没有toString()时,默认调用父类toString()
           public String toString() {
                return getClass().getName() + "@" + Integer.toHexString(hashCode());
            }

            一般情况下可以重写Object类中toString()
        */
        System.out.println(p);
    }

}

public class ObjectEquals {
     /*
     Object类中equals
         public boolean equals(Object obj) {
            return (this == obj);
         }
    */
     public static void main(String[] args) {
         Person p1 = new Person();
         p1.setName("张三");
         p1.setAge(20);

         Person p2 = new Person();
         p2.setName("张三");
         p2.setAge(20);
         System.out.println(p1.equals(p2));

         String s = new String("abc");
         String s1 = new String("abc");
         System.out.println(s==s1);//false
                         //String类重写了equals()  比较的是对象中包含的内容是否相等
         System.out.println(s.equals(s1));//true

         Integer x = 128; //new Integer(128);
         Integer y = 128; //new Integer(128);
         System.out.println(x==y);//false
         System.out.println(x.equals(y));//true
         //几乎API中所有类都重写Object类中equals(),比较的是对象中包含的内容是否相等
     }
}

四.Arrays类

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

常用方法

1.toString 方法

声明：public static String toString(type[] a)
描述：返回指定数组内容的字符串表示形式。
基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素用“, ”(逗号加空格)分隔
若是基本类型和java中有的引用类型直接用Arrays.toString（a[]）使用就行，若是自己定义的引用类型则并且想用sout方法调用Arrays.toString来输出数组对象，那么就要根据自己需要重写toString方法

2.equals 方法

●比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。

● 声明：public static boolean equals(type[]a,type[]a2)

● 参数的类型可以是原生数据类型和引用类型的任意一种类型。

● 返回：如果两个相等，则返回true，否则返回false

Arrays.equals（type[]a,type[]a2）用来比较自定义引用类型的数组时若自定义引用类型没有重写equals方法则比较的是数组元素对应的地址也就是是否为同一个元元素，而要是重写了equals方法则按重写的规则对内容进行比较，要问原因看源码，Arrays的equals中有调用Object的equals方法

3.sort 方法 -排序

sort －排序
作用于数组的所有元素 public static void sort(type[] a)
作用于数组指定范围内的元素 public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括)) ==（区间进行排序）将指定的类型（除boolean以外的任意原生数据类型）数组所有元素（或指定范围内的元素）按数字升序进行排序。 object型数组，根据元素的自然顺序，对指定对象数组进行升序排序。（fromIndextoIndex，则排序范围为空）
自定义对象排序自定义类实现Comparable接口重写compareTo方法（除了基本类型和String类型，自定义的引用类型需要根据自己的需要来重写compareTo方法去定义他们的比较排序方式）

注：1.Arrays 中的方法sort是将数组排序且保存已经排好的数组 0—length-1 对整个数组进行排序

2. Arrays类中的sort方法会默认自动调用compareTo方法

3.int数组中由于Java中已经定义过比较规则了所以你不用重写这个方法，如果想用sort来排序你自己定义的引用类型则你就必须重写compareTo方法自定义你想用的比较方式，这种情况下如果不重写则会报错

4.copyOf方法

声明：public static int[] copyOf(int[] original, int newLength)
返回一个指定长度的新数组,并将原数组中的内容复制到新数组中

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

        int b[] = Arrays.copyOf(a, 15);
        //返回一个指定长度的数组，并将原数组复制到新数组中
        System.out.println(Arrays.toString(b));   //[5, 7, 6, 3, 2, 1, 4, 0, 0, 0, 0, 0, 0, 0, 0]
    }

5.binarySearch方法 -使用二分搜索算法搜索指定数组

声明：

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 = {2,1,3,7,6,5,8};

        Arrays.sort(a);
        //   1,2,3,5,6,7,8
        System.out.println(Arrays.binarySearch(a, 4));
        System.out.println(Arrays.binarySearch(a, 0,5,6));

//        System.out.println(mybinarySearch(a,9));
    }

Arrays综合代码

public class Student implements Comparable<Student> {   //学生类

      private int num;
      private  String name;

    public Student(int num, String name) {
        this.num = num;
        this.name = name;
    }

    //用来做比较, 提供的一个自定义排序规则的方法
    //compareTo()方法会在sort()的底层中调用
    @Override
    public int compareTo(Student o) {
        //return  this.num-o.num ;// 小于0   等于0  大于0
        return this.name.compareTo(o.name);
    }

    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return num == student.num &&
                Objects.equals(name, student.name);
    }

}

public class ArraysSortObject {       //学生类数组排序

    public static void main(String[] args) {

         Student [] students = new Student[5];

         Student s1 = new Student(101, "张三1");
         Student s2 = new Student(102, "张三2");
         Student s3 = new Student(103, "张三3");
         Student s4 = new Student(104, "张三4");
         Student s5 = new Student(105, "张三5");

         students[0] = s2;
         students[1] = s5;
         students[2] = s1;
         students[3] = s4;
         students[4] = s3;

         //对引用类型数组进行排序时,类实现
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

public class ArraysObjectEquals {    //学生类数组内容比较
    public static void main(String[] args) {
        Student s1 = new Student(101, "张三1");
        Student s2 = new Student(102, "张三2");
        Student s3 = new Student(101, "张三1");
        Student s4 = new Student(102, "张三2");

        Student[] one=new Student[2];
        Student[] two=new Student[2];

        one[0]=s1;
        one[1]=s2;
        two[0]=s3;
        two[1]=s4;

        System.out.println(Arrays.equals(one,two));
    }
}

五.String类

1.String类概述

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例. 字符串值不能改变(一旦给定字符串的值,值就不能改变) 因为底层用到一个final修饰的char 数组 private final char value[]; 底层是单个字符存储 char a=97 b=98 c=99

2.创建方式

第一种:

String s = “abc”; 先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建.
第二种:

一概在堆中创建新对象，值存储在堆内存的对象中。 String s = new String(“abc”);

public static void main(String[] args) {
           /*
             String对象的两种创建方式
             1.
             String s = "abc";

             2.
             String s1  = new String("abc");
            */

        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
    }

3.方法

构造方法

public String()

public String(String str)

public String(byte[] bytes)

    /*
         public String(byte[] bytes)
         public String(char[] value)
      */

    public static void main(String[] args) throws UnsupportedEncodingException {
        String s1 = "abc";
        byte[] b = s1.getBytes();    //将s1编码为byte类型的数组
        System.out.println(Arrays.toString(b));   //[97, 98, 99]

        String s2=new String(b);   //调用public String(byte[] bytes)构造方法  来对byte类型的数组进行解码
        System.out.println(s2);  //abc

        String s3="中文";
        byte[] c=s3.getBytes("GBK");   //用getBytes方法传入一个编码格式使字符串根据传入的编码格式编码
        System.out.println(Arrays.toString(c));   //[-42, -48, -50, -60]

        String s4=new String(c,"GBK"); //用String的构造方法来用GDK编码格式进行解码
        System.out.println(s4);      //中文

        //注：如果编码和解码两边的编码格式不统一则会出现乱码问题


        String s5="abcdefg";
        byte[] d=s5.getBytes();
        System.out.println(Arrays.toString(d));   //[97, 98, 99, 100, 101, 102, 103]
        String s6=new String(d,2,2,"utf-8");  //这是String的构造方法
        //其中offset代表从byte数组的索引值为offset的元素开始，解码的长度为lenght，编码格式为charsetName
        System.out.println(s6);    //cd

        String s7="中文";
        byte[] f=s7.getBytes("GBK");
        System.out.println(Arrays.toString(f));  //[-42, -48, -50, -60]
        String s8=new String(f,2,2,"GBK");
        System.out.println(s8);  //文

        //如在GBK编码格式下两个数组元素才能表示一个中文字符所以可知在此构造方法中无论编码格式是什么offest和length的值是对数组而言不是对编码格式而言
     
    }

public String(char[] value)

public static void main(String[] args) {

         /*
            public String(char[] value)
            char[] toCharArray()
            static String valueOf(char[] chs)
         */

        char[] chars={'a','b','c','d'};
        String s1=new String(chars);    //String的 public String(char[] value)构造方法是
           //传入一个字符数组将它转换为字符串
        System.out.println(s1);   //abcd

        char[] chars1=s1.toCharArray();   //char[] toCharArray()这个方法是将字符串转换为字符数组并返回
        System.out.println(Arrays.toString(chars1));  //[a, b, c, d]

      String s2=String.valueOf(chars1);  //String中的 static String valueOf(char[] chs)静态方法
        //也是将字符数组转换为字符串并返回
        System.out.println(s2);  //abcd

        //注：

        char [] c = {'a','b','c'};
        System.out.println(Arrays.toString(c));  //[a, b, c]
        System.out.println(c);        //abc
    
    //char类型的数组可以不用toString方法直接输出成字符串的形式

    }

注：这里的高亮的两个构造方法着重注意，注意byte类型的编码与解码，注意char类型的String类型的构造方法，以及char类型的数组可以直接输出为字符串的形式

判断功能

boolean equals(Object obj) 判断字符串内容是否相等

boolean equalsIgnoreCase(String str) 判断两个对象中的内容是否相等忽略大小写

boolean contains(String str) 判断是否包含指定字符串

boolean isEmpty() 判断是否为空("") 为空返回true

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

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

int compareTo(String anotherString) 比较两个字符串的位置

方法应用代码

 public static void main(String[] args) {
          /*
            String 构造方法
           */
        String s = new String("abC");//创建一个""  this.value = "".value;
        String s1 = new String("abc");// this.value = original.value;


        /*
          判断
          boolean equals(Object obj)
          boolean equalsIgnoreCase(String str)
          boolean contains(String str)
          boolean isEmpty() boolean
          startsWith(String prefix)
          boolean endsWith(String suffix)
         */
        System.out.println(s.equals(s1));//判断两个对象中的内容是否相等
        System.out.println(s.equalsIgnoreCase(s1));//判断两个对象中的内容是否相等 忽略大小写
        String s2 = "abcdefg";
        System.out.println(s2.contains("ab"));//判断是否包含指定字符串
        System.out.println(s2.isEmpty()); //判断是否为空("")  为空返回true
        System.out.println(s2.startsWith("ab"));//判断是否以指定的字符串开头
        System.out.println(s2.endsWith("ab"));//判断是否以指定的字符串结尾
        System.out.println("a".compareTo("c"));//比较两个字符串的位置


        /**/
    }

获取功能

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) 指定区间截取开始位置 – 结束位置(不包含结束)

方法应用代码

    public static void main(String[] args) {
              /*
                获取功能 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)
               */

           String s = "abcdedfg";
                    // 01234567
           System.out.println(s.length());
           char c = s.charAt(3);//返回指定索引的字符
           System.out.println(c);

           int index = s.indexOf("d");//获取指定字符串首次出现的位置 从前向后找
           System.out.println(index);

          int index1 = s.indexOf("d",4);//从指定的位置开始,获取指定字符串首次出现的位置
          System.out.println(index1);

          int index2 = s.lastIndexOf("d");
          System.out.println(index2);

        String s3 = "abcdedfg";
                  // 01234567

        String s4 =   s3.substring(2); //从s3 截取指定区间的字符串  从指定位置开始 到  结束
        System.out.println(s3);//abcdedfg
        System.out.println(s4);//cdedfg

        String s5 =s3.substring(2,6);//k指定区间截取  开始位置 -- 结束位置(不包含结束)
        System.out.println(s5);
    }

转换功能

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) {
          /*
            String toLowerCase()
            String toUpperCase()
            String concat(String str)
            Stirng[] split(分割符);
           */

        String s = "abcdEFG";
        System.out.println(s.toLowerCase());//转小写
        System.out.println(s.toUpperCase());//转大写

        String s1 = s.concat("HIJK"); //两个字符串拼接 并返回新的字符串对象.
        System.out.println(s1);


        String s2 = "ab:cd:E:FGH";
        String[] array =  s2.split(":");//用指定符号 来分割字符串为数组
        System.out.println(Arrays.toString(array));
        System.out.println(array[3]);

    }

替换功能（加了个切割split功能和tirm去除空格功能）

String replace(char old,char new) 将String中的oldChar字符替换为newChar字符

String replace(String old,String new) 将String中的old子字符串替换为new字符串

String trim() 去除字符串两端空格中间的去除不了

方法应用

public static void main(String[] args) {

        /*
          替换功能
            String replace(char old,char new)
            String replace(String old,String new)
            去除字符串两空格 String trim()
         */

        String s1="abcdeg";
        String s2=s1.replace('a','b');
        // String replace(char old,char new) 将String中的oldChar字符替换为newChar字符
        System.out.println(s2);   //bbcdeg

        String s3="abcdeg";
        String s4=s3.replace("ab","cd");
        // String replace(String old,String new) 将String中的old子字符串替换为new字符串
        System.out.println(s4);  //cdcdeg


        String s5="     abcd eg  ";
        System.out.println(s5.trim());
        //去除字符串两端空格中间的去处不了 String trim()

    }

split(String regex) 在字符串中根据传入的regex子字符串根据它的位置将父字符串切割为很多子字符串并把它们放到字符串数组中

replaceAll(String regex, String replacement) 在字符串中将指定的第一个regex子字符替换为replacement字符串

replaceFirst(String regex, String replacement) 在字符串中将指定的第全部regex子字符替换为replacement字符串

方法应用

public static void main(String[] args) {

        /*
            split(String regex)
            replaceAll(String regex, String replacement)
            replaceFirst(String regex, String replacement)

            regex其实是  正则表达式
         */

        String s1 = "ab5cd6ef7gh";
        System.out.println(Arrays.toString(s1.split("\\d")));  //[ab, cd, ef, gh]
        System.out.println(Arrays.toString(s1.split("5")));  //[ab, cd6ef7gh]
        // split(String regex) 将字符串按照指定regex（正则表达式的规则）分隔开

        String s2="abFGcdFG";
        System.out.println(s2.replaceFirst("FG","ab"));  //ababcdFG
        System.out.println(s2.replaceAll("FG","ab"));  //ababcdab
      //  replaceAll(String regex, String replacement)
        //在字符串中将指定的第一个regex子字符替换为replacement字符串
     //   replaceFirst(String regex, String replacement)
        //在字符串中将指定的第全部regex子字符替换为replacement字符串

    
    }

六.正则表达式

正则表达式所用到的方法

public boolean matches(@NonNls @NotNull String regex)

1.正则表达式的具体介绍和使用代码

public static void main(String[] args) {

         /*
          正则 表达式
            规则
            是一种字符串模式匹配语言
            指定规则: 手机号规则  \\d

            注册账号
              手机号  152223423423  11位  数字  以1开头  --- 格式
              邮箱    wrwuert7254632@re23.com
         */
  /*
             . 任何字符（与行结束符可能匹配也可能不匹配）
            \d 数字：[0-9]
            \D 非数字： [^0-9]
            \s 空白字符：[ \t\n\x0B\f\r]
            \S 非空白字符：[^\s]
            \w 单词字符：[a-zA-Z_0-9]
            \W 非单词字符：[^\w]
            X? X，一次或一次也没有
            X* X，零次或多次
            X+ X，一次或多次
            X{n} X，恰好 n 次
            X{n,} X，至少 n 次
            X{n,m} X，至少 n 次，但是不超过 m 次
            X|Y X 或 Y
         */

        //如制定一个手机号规则  首位必须为1第二位必须是3,5,7,8中的任意一位手机号位数必须是11位

        String s1 = "13571121819";
        String s2 = "14571121819";
        System.out.println(s1.matches("1[3578]\\d{9}"));  //true
        System.out.println(s2.matches("1[3578]\\d{9}"));  //false
        //注：容易出错的问题[]中不能有“,”号，不要把“\”  打成“/”

        //qq 数字  6--12  第一位没有0
        boolean qq1 = "012345".matches("[1-9]\\d{5,11}");
        boolean qq2 = "112345".matches("[1-9]\\d{5,11}");
        System.out.println(qq1);  //false
        System.out.println(qq2);  //true


        //X?,X*,X+ ...的用法
        String s = "13566268888";
        //boolean res = s.matches("\\d?");//一次或一次也没有
        //boolean res = s.matches("\\d*");//0次或一次也没有
        //boolean res = s.matches("\\d+");//一次或多次
        //boolean res = s.matches("\\d{n}");//恰好 n 次
        //boolean res = s.matches("\\d{1n,}");//至少 n 次
        //boolean res = s.matches("\\d{n,m}");//至少 n 次，但是不超过 m

           //正则表达式的一些使用方式
        //boolean res =  "fshdfT^&&%&".matches("\\D+");
        //boolean res =  "3  ".matches("\\d\\s+");
        //boolean res =  "daa".matches("[a-z]+");
        //boolean res =  "ASAS".matches("[A-Z]+");
        //boolean res =  "ASsdeaAS".matches("[A-z]+");
        //boolean res =  "ASsde232aAS".matches("[A-z,0-9]+");
        //boolean res =  "ASsde232_a_AS".matches("\\w+");
        //System.out.println(res);
    }

2.案例

制定手机号和QQ号码规则

 //手机号格式规则
        String s = "13566268888";
        boolean res = s.matches("1[356789]\\d{9}");
        System.out.println(res);

        //qq 数字  6--12  第一位没有0
        boolean qq =  "012345".matches("[1-9]\\d{5,11}");
        System.out.println(qq);

制定邮箱规则

 //制订邮箱的规范
        boolean res1="dfgd3AA73@163qq.com.com".matches("\\w{6,9}@\\w{2,5}\\.(com|com.cn)");
        boolean res2="dfgd3AA73@163qq.com.cn".matches("\\w{6,9}@\\w{2,5}\\.(com|com.cn)");
        System.out.println(res1);   //false
        System.out.println(res2);   //true
        //注.的使用时要用\\.对.进行转义 不然会出现误判因为在正则表达式规则里直接使用.代表的意思是任意字符

注：.的使用时要用\\.对.进行转义不然会出现误判因为在正则表达式规则里直接使用.代表的意思是任意字符

七.StringBuffer类

1.StringBuffer类概述

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String 对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题 线程安全的可变字符序列

2.String类StringBuffer类StringBuilder区别

StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程安全的
String：是字符常量,适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

3.StringBuffer方法

构造方法

public StringBuffer()

public StringBuffer(String str)

添加功能

public StringBuffer append(String str) 在字符串末尾添加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() 将字符串完全反转

截取功能

public String substring(int start)

public String substring(int start,int end)

注：截取功能和前面几个功能的不同，返回值类型是String类型，本身没有发生改变

方法应用

 public static void main(String[] args) {
        /*
           StringBuffer线程安全的,值可变的字符串(指的是底层char[]的值在变)
            public StringBuffer() {
                    super(16);
            }
             AbstractStringBuilder(int capacity) {
                value = new char[capacity];
            }
            StringBuilder线程不安全的,值可变的字符串
         */

        //StringBuffer s1 = new StringBuffer(30);
        //StringBuffer s = new StringBuffer();//创建了一个字符串对象,底层是是一个char数组
        StringBuffer s2 = new StringBuffer("abcd");
                     s2.append("11111");
                     s2.append("22222");
                     s2.append("33333");
                     s2.append("44444");
                     //s2.insert(1, "xxxx");
                     //s2.deleteCharAt(2);
                     //s2.delete(0,5);//删除指定区间的字符串  包含开始,不包含结尾
        // System.out.println(s2.reverse());

        //System.out.println(s2.replace(0, 5, "ccccc"));

         String ss = new String(s2);//new String(StringBuffer s)


       StringBuilder s1 = new StringBuilder();

       /*
         String: 值不能变  底层 final char [] value;  一旦需要改变值,必须重新创建一个String value=value+111;

         StringBuffer 值可变   char [] value  继承 AbstractStringBuilder
         StringBuilder 值可变  char [] value  继承 AbstractStringBuilder

            StringBuffer  添加synchronized 同步锁  多线程安全
                 public synchronized StringBuffer append(String str) {
                        toStringCache = null;
                        super.append(str);调用父类
                        return this;
                    }
            StringBuilder  没有添加同步锁  多线程不安全
                public StringBuilder append(String str) {
                    super.append(str);  调用父类
                    return this;
                }
        */

    }

八.Math类

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

1.方法

abs 绝对值

sqrt 平方根

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

max(double a, double b) 返回a和b中最大的

min(double a, double b) 返回a和b中最小的

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

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

public static long round(double a) double型的数据转换为long型

public static double floor(double a) 将double类型的数据向下取整

public static double ceil(double a) 将double类型的数据向上取整

方法应用

  public static void main(String[] args) {
         /*
    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 double floor(double a)  将double类型的数据向下取整
     public static double ceil(double a)   将double类型的数据向上取整
     */

        System.out.println(Math.abs(5));   //25
        System.out.println(Math.abs(-5));   //25

        System.out.println(Math.sqrt(25));   //5.0

        System.out.println(Math.pow(5,2));   //25.0

        System.out.println(Math.max(5,2));    //5
        System.out.println(Math.min(5,2));    //2

        System.out.println(Math.random());    //随即返回一个0.0（大于等于）到1.0（小于）的随机数

        double a=5;
            System.out.println(Math.round(a)); //double型的数据转换为long型

        System.out.println(Math.floor(2.57));    //2.0  将double类型的数据向下取整
            System.out.println(Math.ceil(2.01));    //3.0   将double类型的数据向上取整

    }

九.Random类

1.Random类概述

此类用于产生随机数

2.方法

构造方法

public Random() 初始化Random对象

成员方法

public int nextInt() 随机返回一个int类型的数字

public int nextInt(int n) 在0-（n-1）之间返回一个int值

public boolean nextBoolean() 随机返回一个boolean值

public long nextLong() 随机返回一个long类型的值

public void nextBytes(byte[] bytes) 随机给byte类型数组赋值

方法应用

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();

        System.out.println(random.nextBoolean());  //false 随机返回一个Boolean值
        System.out.println(random.nextInt());  //2042611766 随机返回一个int值
        System.out.println(random.nextInt(33));  //在0~32之间 随机返回一个int值
        System.out.println(random.nextLong());   //3178606934896865106  随机返回一个long值

        byte[] bytes = new byte[5];
        random.nextBytes(bytes);   //随机给byte类型数组赋值
        System.out.println(Arrays.toString(bytes)); //[-96, -4, -114, -114, 32]
    }

十.System类

1.概述

System 类包含一些有用的类字段和方法。它不能被实例化。System里面包含了一些对于系统信息相关的方法

2.方法

public static void exit(int status) 如： System.exit(0) 退出停止虚拟机
public static long currentTimeMillis() 如：System.currentTimeMillis() 自1970-1-1 0:0：0至程序运行那一刻的时间差
public static java.util.Map<String, String> getenv() 如：System.getenv() System.getenv(“Path”) 获取指定环境变量的值
public static void arraycopy(@NotNull Object src,int srcPos,@NotNull Object dest,int destPos,int length) 如：System.arraycopy(a,0,b,1,5); 数组扩容

参数意思：

Object src : 传入的原数组int srcPos ：从原数组的哪个索引值开始复制(起点)Object dest：目标数组int destPos：目标数组的起点int length：复制的数量

注：实现同样功能的方法 System.中的方法是操作系统直接来做效率更高

方法应用

 public static void main(String[] args) {
//        System.out.println();
        //PrintStream out
        //            out.println();
        System.out.println("11");
        // System.out.println(Pserson.phone.no);
        //System 里面包含了一些对于系统信息相关的方法

        System.exit(0);   //退出停止虚拟机
//        System.out.println("aaaaaaaa");    //什么也没输出

        long a = System.currentTimeMillis();   //1622076880550 自1970-1-1 0:0:0 至
//                                               // 程序运行时那一刻的时间差
//        System.out.println(a);
//
//        for (int i = 0; i <100000 ; i++) {
//            System.out.println(i);
//        }
//        System.out.println(System.currentTimeMillis()-a);  //766
        System.out.println(System.getenv());   //获取指定环境变量的值
        System.out.println(System.getenv("Path"));
       /* int a[] = {1, 2, 3, 4, 5};
        int ints[]=Arrays.copyOf(a,10);
        System.out.println(Arrays.toString(ints));

        此为老方法用Arrays的方法来将数组复制到一个新数组中

        以下为System.中的方法同样的功能而且是操作系统直接来做效率更高
        */

        int a[]={1, 2, 3, 4, 5};
        int b[]=new int[10];
        System.arraycopy(a,0,b,1,5);
        System.out.println(Arrays.toString(b));
        // Object src,int srcPos,@NotNull Object dest,int destPos,int length)
        //以上为System.arraycopy方法中的参数名称
        /*
        Object src :  传入的原数组
        int srcPos ：从原数组的哪个索引值开始复制(起点)
        Object dest：目标数组
        int destPos：目标数组的起点
        int length： 复制的数量
         */

    }

十一.Date类/Calendar类/ SimpleDateFormat类

1.Date类

（1）概述

一个日期对象，里面包含程序运行的那一刻时间

（2）方法应用及其代码

 public static void main(String[] args) {
        Date d=new Date();  //创建一个日期对象，里面包含程序运行的那一刻时间
        System.out.println(d.getYear()+1900);   //获得年 可以使用 只是官方不推荐
        System.out.println(d.getMonth()+1);    //或得月从0开始
        System.out.println(d.getDate());  //月中的第几天
        System.out.println(d.getHours());  //获取一天中的第几个小时
        System.out.println(d.getDay());     //获取一周中的第几天从星期天开始
        System.out.println(d.getMinutes());   //获取这个小时中的第几分钟
        System.out.println(d.getSeconds());  //获取这一分钟现在是第几秒
        System.out.println(d.getTime());   //从自1970-1-1 0:0:0 至程序运行时那一刻的时间差
        System.out.println(d);
        //1622168142244

        Date d2=new Date(1622168142244L);  //創建一個日期對象闖入一個long類型的參數 裡面包含long類型
        //對應的那一刻時間
        System.out.println(d2.getYear()+1900);   //获得年 可以使用 只是官方不推荐
        System.out.println(d2.getMonth()+1);
        System.out.println(d2.getDate());
        System.out.println(d2.getSeconds());
        System.out.println(d2.getTime());
//        1622168142244
        System.out.println(d2);    //Fri May 28 10:15:42 GMT+08:00 2021  直接輸出默認時間格式
        System.out.println(d2.toLocaleString());  //根據當地時間格式輸出時間 2021-5-28 10:15:42
        System.out.println();

    }

2.Calendar类

（1）概述

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建，或者利用多态new子类对象即可

（2）创建

        Calendar c = Calendar.getInstance();//返回的是子类对象
        Calendar c = new GregorianCalendar();//直接new子类对象

（3）方法应用及其代码

public static void main(String[] args) {
        //Calendar是抽象類不能創建對象
//    Calendar c=Calendar.getInstance();  //返回的是子類對象
        Calendar c=new GregorianCalendar();   //直接new子類對象

//        c.set(2002,5,10);     設置一個時間
//        System.out.println(c.getTime());   把時間取出來

        System.out.println(c.get(Calendar.YEAR)); //因為是取的Calendar的YEAR屬性所以這麼寫
        System.out.println(c.get(Calendar.MONTH)+1);  //创建对象的时间是第幾個月從0開始
        System.out.println(c.get(Calendar.DAY_OF_MONTH));  //创建对象的时间是月中的第幾天
        System.out.println(c.get(Calendar.DAY_OF_WEEK));  //创建对象的时间是星期中的第几天从星期天开始
        System.out.println(c.get(Calendar.DAY_OF_YEAR)); //创建对象的时间是年中的第几天

    }

3.SimpleDateFormat类

（1）概述

SimpleDateFormat 日期格式化类

（2）构造方法

SimpleDateFormat(String s(格式)); // 如：yyyy-MM-dd

（3）日期转字符串

        Date now=new Date(); 
        myFmt.format(now);

（4）字符串转日期

     myFmt.parse(“2018-02-10”); //字符串日期格式与 指定格式必须一致 
   //  例如:
     String s = “2018-03-15”; 
     new SimpleDateFormat(“yyyy-MM-dd”)

（5）方法应用代码及其格式规范

 public static void main(String[] args) throws ParseException {
//        Date d = new Date();
//        System.out.println(d);   //Sat May 29 12:44:26 GMT+08:00 2021   创建对象的时间
//        System.out.println(d.toLocaleString()); //2021-5-29 12:45:10  按当地日期格式返回时间

        /*日期格式化--把java中的对象型(new Date Calendar) 转为指定格式的字符    */
        Date d = new Date();
//        SimpleDateFormat s=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss:SSS:E");
//        String s2=s.format(d);
//        System.out.println(s2);   //2021年05月29日 12:54:13:211:星期六

//        SimpleDateFormat s=new SimpleDateFormat();
//        String s2=s.format(d);
//        System.out.println(s2);   //21-5-29 下午12:55

        Calendar c=new GregorianCalendar();
        System.out.println(c.get(Calendar.DAY_OF_YEAR));
        SimpleDateFormat s=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS:E");
        //2021-05-29 13:12:05:968:星期六
        SimpleDateFormat s1=new SimpleDateFormat("Y  -M  -D H  :m  :s  :S  : E");
        //2021-5-29 13:12:5:968:星期六
        String s3=s.format(d);
        String s4=s1.format(d);
        System.out.println(s3);
        System.out.println(s4);
//        String s2=s.format(d);
//        System.out.println(s2);//2021-04-29 01:04:29:535:星期六
        //SimpleDateFormat 的构造方法确定格式一般来说是根据传入的字符参数

//
       String day="2018.5.20";
       SimpleDateFormat s5=new SimpleDateFormat("y.MM.dd");
       Date d2=s5.parse(day);
        System.out.println(d2.toLocaleString());  //2018-5-20 0:00:00
//        将字符串日期转换为日期对象  注这里的天必须用小写d来表示  其中输入的字符串日期格式需要与
//        SimpleDateFormat 构造方法中的日期格式一样

//总结： 在SimpleDateFormat 的构造方法中有特定的字符串类型的参数如：
//        y 表示年份（大写小写都可以）   yyyy 和 y都行
//        m表示月份和分钟   MM(大写)表示月份  mm(小写)表示分钟   单个或两个都行入mm或m  MM或M 单个的就没有0了如 05分钟和5分钟
//        d表示天(大写表示今天是一年中的第几天，小写表示是几号)     单个或两个都行  如d和dd
//        h表示小时(大写小写都行)  单个双个都行h额hh
//        s表示秒和毫秒  单个和多个都可以  s大写和小写都可以表示秒和毫秒只是如果同时要表示秒和毫秒的话一个用大写一个用小写
//        E表示星期几
        /*注： SimpleDateFormat 的构造方法中穿入的参数的特定的字符串类型的字符没有规定位置和
        确定格式，只要按我刚才上面写的字母表示规则就行  */
    }

十二.BigInteger和BigDecimal

1.BigInteger

（1）概述

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

（2）构造方法

BigInteger(String val)

BigInteger(byte[] val)

（3）基本运算方法（普通方法）

add()，subtract()，multiply()，divide() 加，减，乘，除

（4）应用代码

public static void main(String[] args) {
    
            /*
              BigInteger 大整数  可以表示任意的整数
             */
            BigInteger a  = new BigInteger("1111111111111111111111111111111112222222222222222222222222211111111111111111");
            BigInteger b  = new BigInteger("111111111111111111111111111111111112222222222222222222222222111111111111119");
    
            BigInteger  c = a.add(b);
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
    
        }

2.BigDecimal

（1）概述

在计算机中不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去一定的精确度。 根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近于那个值。但是，在项目中，我们不可能让这种情况出现，所以我们就应该用Java在java.math包中提供的API类BigDecimal

（2）构造方法

BigDecimal(String val)

（3）基本运算方法（普通方法）

add()，subtract()，multiply()，divide() 加，减，乘，除

（4）应用代码

 public static void main(String[] args) {
       /* double d = 10.5;
        System.out.println(10.5 - 10.4);  //0.09999999999999964*/
        BigDecimal a = new BigDecimal("1222222222222222222233333333333333333333333333333333222222222222222.5");
        BigDecimal b = new BigDecimal("12.4");
        System.out.println(a.subtract(b));  //1222222222222222222233333333333333333333333333333333222222222222210.1
    }

发自己的光就好

关注

3
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
javaSE-常用API（全）

文章目录javaSE（API）常用类一.java API概述二.基本数据类型包装类1.基本数据类型2..包装类==包装类用途==**包装类常用方法（以Ingeter为例）**装箱和拆箱==装箱和拆箱中要注意的一个问题==三.Object类1.toString方法2.equals方法注：在引用类型的比较中"=="比较的是它们的地址值如要比较它们的内容则必须用equals方法来比较四.Arrays类常用方法Arrays综合代码五.String类1.String类概述2.创建方式3.方法构造方法判断功能获取功能转
复制链接

扫一扫