Java基础API详解：Object、Arrays、String及数值处理-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_64881205/article/details/131014339

1.API的基本概述

API文档：把官方提供的类和接口以及其中方法的功能进行说明

2.Object类

object类时Java中的超类，任何一个类直接或间接的继承了object类

如果没有写extends ,那么默认继承了object

toString方法

当输出一个对象时，会默认调用类中的toString（），类中如果没有toString(),那么会调用object中的toString()

默认输出对象在内存中的地址值的16进制表达式

由于object中的toString()输出的是对象在内存中的地址，可以在自己类中重写toString(),变化输出格式

public native int hashCode();

native:修饰的方法为本地方法（操作系统中的方法），是用来返回内存中的地址

package com.ffyc.javaapi.objectdemo;
public class ToString {

    public static void main(String[] args) {
        Person jim = new Person("jim",20);
        System.out.println(jim);//需要输出对象
    }
}

package com.ffyc.javaapi.objectdemo;

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {//进行了重写object中的toString()
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

equals()

equals()比较的是对象的内容是否想等，所以其他重写equals方法，比较对象中的内容是否相等

package com.ffyc.javaapi.objectdemo;

public class ObjectEquals {
    public static void main(String[] args) {
        Person p1 = new Person("jim",20);
        Person p2 = new Person("jim",20);
        int a =10;
        int b = 10;
        System.out.println(a==b);//true 比较基本类型时，直接比较的时值

        System.out.println(p1==p2);//false

        String S1 = new String("abc");
        String S2 = new String("abc");
        System.out.println(S1.equals(S2));//true
        System.out.println(p1.equals(p2));//false 比较引用类型时，比较的对象在内存中的地址是否相同

      p1.equals(p2);
    }
}

package com.ffyc.javaapi.objectdemo;

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
   @Override
   public boolean equals(Object obj) {//重写object中的equals方法
       if(obj instanceof Person){
           Person p = (Person)obj;//向下转型
           return (this.name.equals(p.name)&&this.age==p.age);
       }
       return false;
   }
}

Arrays类

binarySearch

查找数组中某一元素的位置

只能存在于有序数组，返回正数，则是元素在数组中的位置，返回负数，则元素不存在

package com.java.ffyc.arrays;

import java.util.Arrays;

public class ArraysbinarySearch {
    public static void main(String[] args) {
        int a[] = {1,2,3,4,5};
        System.out.println(Arrays.binarySearch(a,2));
    }
}

sort

将数组排序，还可进行区间排序

排序：1.可将基本类型排序

2.自定义类型排序

package com.java.ffyc.arrays;

import java.util.Arrays;

public class ArraysSort {
    public static void main(String[] args) {
        /*
        基本类型排序
         */
        int [] a = {1,2,5,6,3,4};
       Arrays.sort(a);//将数组排序
       Arrays.sort(a,0,3);//区间排序
        System.out.println(Arrays.toString(a));
      /*
        自定义对象排序


       */
        String [] strings = {"c","a","b"};
        Arrays.sort(strings);
        System.out.println(Arrays.toString(strings));


        Student student1 = new Student("jim1","男",101);
        Student student2 = new Student("jim2","男",102);
        Student student3 = new Student("jim3","男",103);
        Student student4 = new Student("jim4","男",104);
       Student[] students = new Student[4];
       students[0] = student2;
       students[2] = student4;
       students[1] = student1;
       students[3] = student3;
       /*
       使用Arrays sort方法进行排序 需要实现Comparable<>接口
       重写compareTo(object) 返回一个int值 指定用哪个属性进行排序
        */
       Arrays.sort(students);
        System.out.println(Arrays.toString(students));
        System.out.println("a".compareTo("b"));//String 类型在object 类中已经进行重写compareTo方法
    }
}

package com.java.ffyc.arrays;

public class Student implements Comparable<Student>{//实现一个Comparable<确定的比较类型>接口
    private String name;
    private String sex;
    private int age;

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

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

    @Override
    public int compareTo(Student o) {
        return this.age-o.age;//小于0 大于0 等于0
        /*
         String 类型在object中已经重写了compareTo方法
         比较String 类型时
         return this.name.compareTo(o.name);
         字符串根据底层编码比较大小
         */
        //return this.name.compareTo(o.name);

    }
}

Arrays.equals

比较数组中的元素是否相等

package com.java.ffyc.arrays;

import java.util.Arrays;

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

copyOf

创建一个指定长度的新数组，再把原来数组的内容赋值到新数组

Arrays.fill 指定元素，将数组的内容全部覆盖

package com.java.ffyc.arrays;

import java.util.Arrays;

public class CopyOf {
    public static void main(String[] args) {
        int []a = {1,2,3,4,5};
        /*
        创建一个指定长度的新数组,再把原来数组的内容赋值到新数组
         */
        int []b = Arrays.copyOf(a,2*a.length);
        System.out.println(Arrays.toString(b));
        Arrays.fill(a,0);//指定元素，将数组中的内容全部覆盖
        System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0]
    }

}

基本类型的包装类

自动装箱：

概念：将基本类型转为包装类型

隐式的使用了valueof(),值在-128到+127之间，返回同一个对象，比较时可以用equals方法

Integer 也重写了equals方法

package com.java.base;

public class IntegerDemo1 {
    public static void main(String[] args) {
        /*
        构造方法
         用Integer 对象来表示int 值，符合面向对象
         */
        Integer i1 = new Integer(10);
        Integer i2 = new Integer("10");
        i1.compareTo(i2);//比较i1中 的int 值和i2中int 值
        System.out.println(i1.compareTo(i2));//0
        int i = i1.intValue();//把对象中的int 值返回 包装类型转基本款型


        System.out.println(Integer.MAX_VALUE);//2147483647
        System.out.println(Integer.MIN_VALUE);//-2147483648
        System.out.println(Integer.BYTES);//4字节
        System.out.println(Integer.SIZE);//32个比特位


        System.out.println(Integer.toBinaryString(5));//101  二进制转换

        String s = "10";
        Integer i3 = new Integer(s);//将字符串包装成Integer类型
        int i4 = Integer.parseInt(s);//int 类型 将String类型转换为int类型
        /*
        Long l = new Long(10);
        long n = l.longValue();
         */


    }
}

String s = "10";

int i4 = Integer.parseInt(s);

可以将String 类型转为int类型

自动拆箱

将包装类型转为基本类型

package com.java.base;

public class IntegerDemo2 {
    public static void main(String[] args) {
        int a = 10;
        Integer integer = new Integer(a);
        int b = integer.intValue();//将包装类型自动拆箱为基本类型
    }
}

String类

字符串是一串字符组成，底层是字符

String s = "abc";隐式创建了一个String类的对象

String 类的特点：一旦创建，值就不能改变，底层存储字符串的数组是final修饰的，每次创建都要为其赋值，一旦要改变字符串的值，就要重新创建一个新的字符串对象

字符串的创建方式：

1.String s = "aac";

创建的字符串对象，在一个叫字符串常量池中存储，

String s1 = "abc";

String s2 = "abc";

字符串常量池中值创建了一个字符串对象，两个引用变量指向同一个对象

2.Sttring s = new String();

new 都会在堆里创建字符串地址

构造方法

getByte将字符串转为byte数组

package com.java.stringdemo;

import java.io.UnsupportedEncodingException;

public class StringDemo3 {
    /*
    String 类的构造方法
   getBytes()将字符串用默认的编码为byte数组
   getBytes(utf-8)用特定的编码将字符串转为byte数组
toCharArray 将字符串转为数组


   new String(bytes)将数组用默认的方法编码为字符串
   new String(bytes utf-8) 将数组用特定的方法编码为字符串
   new String(char[] chars) 将char数组转为字符串
     */
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s = new String();//无参的构造方法
       String s1 = new String("abc");//有参的构造方法
      /* byte[] bytes = "你好".getBytes();//传输时，将字符串转为byte数组（数字化）编码
       String s2 = new String(bytes);//解码
        System.out.println(s2);

       */
        byte[] bytes = "你好".getBytes("utf-8");//utf-8 传输时，将字符串转为byte数组  编码
        String s3 = new String(bytes,"utf-8");//解码
        System.out.println(s3);
        /*
        编码和解码的字节码要相同，否则会乱码

         */
    }
}

toCharArray,将字符串转为char数组

package com.java.stringdemo;

import java.util.Arrays;

public class StringDemo4 {
    public static void main(String[] args) {
        char[] chars = "abcd".toCharArray();//toCharArray 将”abc"转换成字符数组
        Arrays.sort(chars);//将数组中的内容排序
        String s = new String(chars);//转为char数组转为字符串形式
        System.out.println(s);
        System.out.println(String.valueOf(chars));

    }
}

判断功能

package com.java.stringdemo;

public class StringDemo5 {
/*判断功能
boolean equals(Object obj)   重写object类中的方法，判断内容是否相等
boolean equalsIgnoreCase(String str)不区分大小写  验证码
boolean contains(String str) 是否包含某一个指定的子串，且连续
boolean isEmpty()   判断是否为空
boolean startsWith(String prefix)判断是否以某个子串开始
boolean endsWith(String suffix)判断是否以某个子串结束
compareTo
 */
public static void main(String[] args) {
    String s = "abc";
    System.out.println(s.equals("abC"));//false
    System.out.println(s.equalsIgnoreCase("abC"));//true  equalsIgnoreCase 方法不区分大小写
    System.out.println(s.contains("ab"));//包含某个指定的子串 且要连续
    System.out.println(s.isEmpty());//判断是否为空” “ false
    System.out.println(s.startsWith("a"));//判断是否以某个子串开始
    System.out.println(s.endsWith("c"));//判断是否以某个子串结束
    System.out.println("a".compareTo("b"));//比较两个字符串的大小
}
}

获取功能

package com.java.stringdemo;

public class StrringDemo6 {
    /*
    获取功能
            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) {
        String s = "abfdffuahs";
        System.out.println(s.length());
        char c = s.charAt(0); //获取指定位置的字符
        System.out.println(c);
        int idex = s.indexOf('f');//idexOf 获取字符首次出现的位置
        System.out.println(idex);
        int idex1 = s.indexOf('f',idex+1);//获取字符首次出现后，下一次出现的位置
        System.out.println(idex1);
        String sub = s.substring(3);// 截取字符串，从指定位置开始，截取到最后一位
        System.out.println(sub);
        String sub1 = s.substring(3,5);//df       截取字符串，从指定位置开始，截取到截止位置之前
        System.out.println(sub1);
        int a= s.lastIndexOf("a");//最后一次出现的位置
        System.out.println(a);
    }
}

转换功能

package com.java.stringdemo;

import java.util.Arrays;

public class StringDemo7 {
    /*
    转换功能
                byte[] getBytes() 将字符串转为byte数组
                char[] toCharArray()将字符串转为char 数组
                static String valueOf(char[] chs)将char数组转为字符串
                String toLowerCase()全部小写
                String toUpperCase()全部转换为大写
                String concat(String str)连接字符串，只能连接字符串类型
                Stirng[] split(分割符); 按照指定的字符将字符串拆分成

     */
    public static void main(String[] args) {
            String a = "abcdefg";
            byte[] bytes = a.getBytes();
            char[] chars = a.toCharArray();
            String s = new String(chars);
            String h = a.toLowerCase();//abcdefg    全部转换为小写
            String j = a.toUpperCase();//ABCDEFG     全部转换为大写
        System.out.println(h);
        System.out.println(j);
        String q = "aaaa";
       String m = a.concat(q);//连接字符串，只能连接字符串
        a+=q;//可以连接其他类型
        String s1 = "ab;aad;sss;fd";
        //正则表达式  规则表达式
       String [] sarray = s1.split(";");
        System.out.println(Arrays.toString(sarray));
    }
}

\w 匹配[A-Z a-z 0-9]

\s 匹配空格字符

. 表示任意字符

正则表达式

是一种模式匹配语法

package com.java.stringdemo;
public class RegexDemo {
    public static void main(String[] args) {
        /*
        正则表达式
        (规则)
        \\d 表示只出现一个数字
        \\d*  表示出现多个数字
        [0-9]*  表示出现多个0-9的数字
        [357]*  表示出现多个只包含357的数字
        [^357]*  表示出现多个没有357 的数字
        \\d{n}  出现n个数字
        \\d{n,}  出现至少n数字
        \\d{n,m}    出现至少n个，之多m个数字
        \\d?  0次或者1次
        \\w 匹配一切大小写字母，数字，下划线
        \\s 匹配空格
        （ | ）  表示或
        .  匹配任意字符

        \\.  可以固定表示 .
        [\\u45e00-u9fa5]   匹配汉字
         */

      String s = "1111";
      boolean str = s.matches("\\d");//只允许出现一个数字
        System.out.println(str);
      boolean str1 = s.matches("\\d*");//允许出现多个数字
        System.out.println(str1);
        boolean str2 = s.matches("[0-9]*");//允许出现多个0-9的数字
        System.out.println(str2);
        String s1 = "335577";
        boolean str3 = s1.matches("[357]*");//只允许出现357的数字
        boolean str8 = s1.matches("[^357]*");//不允许出现357的数字
        System.out.println(str3);
        boolean str4 = s.matches("\\d{8}");//出现的数字的个数
        System.out.println(str4);
        boolean str5 = s.matches("\\d{8,}");//至少出现8个
        System.out.println(str5);
        boolean str6 = s.matches("[1-9]\\{4，12}");//qq号
        boolean str7 = s.matches("1[3456789]\\{8}");//手机号
        boolean str9 = s.matches("\\w"); //匹配大小写字母，数字，下划线
        boolean str10 = s.matches("\\s");  //匹配空格
        //邮箱

        String b = "";
        boolean art = b.matches("\\w{4,10}@\\w{4,8}\\.(com|com\\.cn)");
    }
}

替换功能

package com.java.stringdemo;

import java.util.Arrays;

public class StringDemo8 {
    public static void main(String[] args) {
        String a = "  ab2c d3e f 4de  ";
        String b = a.replace("a","A");//用指定字符替代字符串中指定的字符
        System.out.println(b);
        String[] c = a.split("\\d",3);//用正则表达式来匹配split截取的标记，3 表示截取数量的限制
        System.out.println(Arrays.toString(c));
        String h = a.replaceAll("\\d","D");//将字符串中的数字用D替换，正则表达式来替换字符
        System.out.println(h);
        String u = a.replaceFirst("\\d","H");//将字符串中用正则表达式匹配的第一个替换掉
        System.out.println(u);
        System.out.println(a.length());
        System.out.println(a.trim().length());//去掉字符串两边的空格
        System.out.println(a.length()-a.replaceAll("a","").length());//计算字符串中某个字符的个数
        System.out.println(a.replaceAll("\\s","").length());// 去掉字符串中所有的空格
    }
}

replace 和replaceAll之间的区别：replaceAll可以识别正则表达式匹配所替换目标的字符，replace 正常字符替换

StringBuffer

可变带缓冲区的字符串，需要大量拼接字符串

当装不下了，就会创建一个新的数组，赋给StringBuffer 对象中的value []

package com.java.stringdemo;

public class StringBufferDemo1 {
    public static void main(String[] args) {
        /*
        String 特点：值一旦确定，就无法改变
        缺点：每次拼接都要创建新的对象，耗时，浪费空间
        StringBuffer    可变带缓冲区的字符串，可用于大量的拼接字符串
         */
        StringBuffer s = new StringBuffer("abcd");//创建一个StringBuffer对象，4+16长度的char数组
                        s.append("shdj");
                        s.append("shdj");
                        s.append("shdj");
                        s.insert(0,"AAAAAAAAAAA");//向指定位置加元素
                       String s1 = s.substring(0,5);//截取字符串0-5位置的字符 左闭右开区间
                       s.replace(0,3,"AAA");//AAAdshdjshdjshdj  将StringBuffer对象的0-3位置用AAA替代
                        s.delete(0,5);//hdjshdjshdj 将字符串的0-5位置删除
                             s.deleteCharAt(0);//djshdjshdj    将字符串第0位置的元素删除
                            s.reverse();//jdhsjdhsjd  逆序输出字符串
        System.out.println(s1);
        System.out.println(s);
        //hdjshdjshdj
    }
}

StringBuilder

也是字符串的拼接，与 StringBuffer的区别是，StirngBuffer 的安全性更高

StringBuffer:多线程安全可靠，值可以改变，方法上都加了同步锁

StringBuilder:适用于单线程情况下，值可以改变字符串

Math类

package com.java.mathDemo;

public class Demo {
    public static void main(String[] args) {
        System.out.println(Math.pow(2,3));//平方
        System.out.println(Math.abs(-2));//绝对值
        System.out.println(Math.max(25,26));//较大值
        System.out.println(Math.min(26,58));//最小值
        System.out.println(Math.round(9.6));//四舍五入
        System.out.println(Math.floor(9.9));//向下舍入
        System.out.println(Math.ceil(9.1));//向上舍入
        System.out.println(Math.random());//返回0-1之间的随机的一个数
    }
}

Random

返回随机数

package com.java.stringdemo;

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());//boolean 类型随机
        System.out.println(random.nextLong());//long类型范围内随机抽一个数
        System.out.println(random.nextInt(10));//随机抽选0-9中的一个数 不包含10
        System.out.println(random.nextInt(10)+1);//随机抽选一个1-10的数 包含10
        byte[] bytes = new byte[5];//创建长度是 5的byte数组
        random.nextBytes(bytes);//将数组中的元素随机赋值
        System.out.println(Arrays.toString(bytes));//输出数组

    }

}

Data类

在系统中获取时间

new Data(); 对象中可以封装一个时间信息，可以使用里面的方法获取需要的时间信息

package com.java.stringdemo;

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.getTime());//getTime 可以计算代码运行时间
        System.out.println(date.getDay());//计算星期几，星期天时从0开始
        long a = date.getTime();//计算运行开始的时间
        for (int i=0;i<10000;i++){

        }
        Date date1 = new Date();
        long e = date1.getTime();//将时间转化为从1970年1月1日0点0分0秒开始的毫秒
        System.out.println(e-a);//计算运行结束时的时间，
        //输出for循环10000次后的运行时间
        System.out.println(date.getYear()+1900);//从1900开始

    }
}

Calender类

日历

package com.java.stringdemo;

import java.util.Calendar;
import java.util.GregorianCalendar;

public class CalendarDemo {
    public static void main(String[] args) {
        /*
        日历

         */
        Calendar calendar = new GregorianCalendar();
        System.out.println(calendar.get(Calendar.YEAR));//年
        System.out.println(calendar.get(Calendar.MONTH)+1);//月
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));

    }
}

SimpleDataFormat类

日期格式化类

创建一个SimpleDataFormat对象，并规定格式

将字符串转为格式化日期

package com.java.stringdemo;

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

public class SimpleDateFormatDemo1 {
    /*
    字符串转日期对象
     */
    public static void main(String[] args) throws ParseException {
        String s = "2002-1-26";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date parse = simpleDateFormat.parse(s);//获取将字符串转为日期对象后的时间
        long a = parse.getTime();//将时间转为毫秒
        System.out.println(a);
        System.out.println(parse.getYear()+1900);
        System.out.println(parse.getMonth()+1);
        System.out.println(parse.getDate());

    }
}

将格式化日期转为字符串

package com.java.stringdemo;

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

public class SimpleDateFormatDemo {

    public static void main(String[] args) {
        /*
        SimpleDateFormat  将日期格式化，创建一个对象
         */
        Date date = new Date();
        SimpleDateFormat sim = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss E");//创建对象，并规定格式
        String str = sim.format(date);//将时间按格式化规定输出传给str的string对象中
        System.out.println(str);
    }
}

BigInteger类

适用于特别长的数字的计算

package com.java.stringdemo;
import java.math.BigInteger;
public class BigIntegerDemo {
    public static void main(String[] args) {
        BigInteger a = new BigInteger("1");//创建BigInteger对象
        BigInteger b = new BigInteger("2");
        BigInteger c = a.add(b);//a和b 相加
        System.out.println(a);//a,b 值不变
        System.out.println(b);
        System.out.println(c);
    }
}

BigDecimal类

适用于精确的浮点数计算

package com.java.stringdemo;

import java.math.BigDecimal;


public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.1");//创建一个BigeDecimal对象
        BigDecimal b = new BigDecimal("0.2");
        BigDecimal c = a.add(b);
        System.out.println((0.1+0.2));//0.30000000000000004
        System.out.println(a);//0.1
        System.out.println(b);//0.2
        System.out.println(c);//0.3
    }
}