API(持续更新)

API

常用类:java系统中提供的一些使用频率较高的类

API(Application Programming Interface)应用程序接口

• java系统中所提供的一系列类和接口

API文档:官方给广大开发者学习者提供对类和接口功能的说明文档

Object类

java.lang.Object 是java类体系的最顶级,万类之祖

toString

当我们输出一个对象时,会默认调用toString()方法,把对象以字符串形式输出

public class A extends Object{
    private String name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {//相当于把Object的toString方法重写
        return name;
    }
}
class test{
    public static void main(String[] args) {
        A a=new A();
        a.setName("崔渭阳");
        System.out.println(a);//默认调用toString();方法
    }
}

类中如果没有toString(),那么父类会调用(Object)中的toString();

public String toString(){
		Object类中的默认输出类的名字和对象在内存中的地址(10进制转化6进制)
		return get getClass().getName+"@"+Integer.toHexString(hashCode());
}

equals

String类中equals()用来比较字符串内容是否相等

Object 中equals()用来表示两对象地址是否相等,可以通过方法的重写修改来比较对象中的内容是否相等

public class A extends Object{
    private String name;
    private int age;

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

    @Override
    public boolean equals(Object obj) {
        if(obj==null){
            return false;
        }
        if(this==obj){
            return true;
        }
        if(obj instanceof A){
            A a=(A)obj;
        return this.name.equals(a.name)&&age==age;
        }
        return false;
    }
    class test{
    public static void main(String[] args) {
        A a=new A("张三",18);
        A b=new A("张三",18);
        System.out.println(a.equals(b));
    }
}
    结果:ture;

== 用于基本类型代表数值是否相等,在引用类型中代表地址是否相等**

Arrays类

equals 方法

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

import java.util.Arrays;

public class ArraysEQuals {
    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.equals(b));//直接用的是Object类,因为数组也是对象
        System.out.println(Arrays.equals(a,b));//调用Arrays类中的equals,比较两个数组元素内容
    }
}

binarySearch(二分查找法)

必须是有序数组，若找到返回脚码(索引)，若没找到返回负数

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,2);
        System.out.println(index);
    }

}
结果：
	1

• 也支持区间查找Arrays.binarySearch(数组,起始区间,结束区间,目标元素);//检索范围包含起始，不包含结尾

index=Arrays.binarySearch(a,0,4,2);
        System.out.println(index);
结果
	1

Copyof(数组复制)

解决了不能改变数组长度的弊端

将原来数组内容和新定义的newLength返回个新数组

public class ArraysCopyof {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5};
        System.out.println(Arrays.toString(a));
        a= Arrays.copyOf(a,20);
        System.out.println(Arrays.toString(a));//自己延长自己
        //Arrays.toString(a);遍历数组
        
    }
}

sort(排序)

• 对数组(基本数据,引用数据类型)排序 引用数据排序需要实现
• 还可以对数组区间排序(包含起始不包含末端)
• 还可以定义排序方法
• 默认升序排序

package arraysdemos;

import java.util.Arrays;

public class ArraysSort {
    public static void main(String[] args) {
        int []a={1,2,7,9,9,0,3};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}
结果:
[0, 1, 2, 3, 7, 9, 9]

import java.util.Arrays;

public class ArraysSort {
    public static void main(String[] args) {
        int []b={1,2,7,9,9,0,3};      
        Arrays.sort(b,0,4);
        System.out.println(Arrays.toString(b));
    }
}
结果:[1, 2, 7, 9, 9, 0, 3]

对对象某个属性进行排序

package arraysdemos;

import java.util.Arrays;

class Student implements Comparable<Student>{//需要实现Comparable接口
    private String name;
    private String id;

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

    @Override
    public String toString() {
        return this.name+this.id;
    }

    @Override
    public int compareTo(Student o) {
        return this.id.compareTo(o.id);
    }
}
class ArraysSort {
    public static void main(String[] args) {
        Student [] stu=new Student[4];
        Student people=new Student("张一","1314521");
        stu[0]=people;
        stu[1]=new Student("张二","1314523");
        stu[2]=new Student("张四","1314522");
        stu[3]=new Student("张三","1314524");
        Arrays.sort(stu);
        System.out.println(Arrays.toString(stu));
    }
}
结果
[张一1314521, 张四1314522, 张二1314523, 张三1314524]

基本数据类型的包装类

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

基本数据类型	包装类(包裹类型)
ｂｙtｅ	Ｂｙｔｅ
ｓｈｏｒｔ	Ｓｈｏｒｔ
ｃｈａｒ	Ｃｈａｒａｃｔｅｒ
ｉｎｔ	I ｎｔｅｇｅｒ
ｌｏｎｇ	Ｌｏｎｇ
ｆｌｏａｔ	Ｆｌｏａｔ
ｄｏｕｂｌｅ	Ｄｏｕｂｌｅ
ｂｏｏｌｅａｎ	Ｂｏｏｌｅａｎ

Integer

声明

		Integer a=new Integer(12);
        Integer b=new Integer(10);

调用非静态方法

int compareTo();

boolean equals();

 //调用非静态方法
        System.out.println(a.compareTo(b));//前面大返回1,后面大返回-1,一样大返回0;
        System.out.println(a.equals(b));//比较a与b内容是否相同 与"=="要区分 返回一个boolean类型
        System.out.println(a==b);//比较a与b是否指向一个内容
        //.....

调用静态方法

Integer valueOf

int compare(int a,int b)

     //调用静态方法
		Integer c=Integer.valueOf(12);//调用静态方法,返回一个Integer类型变量给C
        Integer d=Integer.valueOf("10");//调用静态方法,把字符串类型(必须是数字)转换为Integer返回一个Integer类型变量
        System.out.println(Integer.compare(13,10));//前面大返回1,后面大返回-1,一样大返回0;
        System.out.println(Integer.max(13,10));//返回较大的数值
        System.out.println(Integer.valueOf(10));//返回的时引用类型

装箱和拆箱

• 装箱:

将基本类型可以自动转换为包装类型

Integer a=10;//默认调用Integer.valueOf(a)把10转化为引用类型即Integer类型

• 拆箱:.

将包装类型转化为基本类型

int c=a.intValue();//拆箱
int c=a;//自动拆箱

源码: 
public static Integer valueOf(int i) {//low:-128;high:127
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);    
    }

 Integer a=10;//默认调用Integer.valueOf(a)
        Integer a=10;
        Integer b=10;
        System.out.println(a.equals(b));//结果为true
		System.out.println(a==b);//结果也为true
		Integer c=128;
        Integer d=128;
        System.out.println(c==d);//结果为false
        System.out.println(c.equals(d));//结果为true

有源代码可知,当在方法内部对 -128~127之间进行缓存(数组),在此期间的自动装箱,不会创建新的Integer对象,直接从中获得,(因为a与b传过去对应i的参数都为10,则返回的是同一个对象地址的引用),而超出此区间的每次都会返回新的对象(所以c和d虽然值相等但是返回的都是一个新的对象地址,所有c==d结果为false)

String类

• java中使用**" "**括起来的,都是String类的实例(对象)
• 字符串的值是不可以被修改的,一旦字符串对象被创建,值就不能被改变

String s="abc";
s+="aaa";
s+="bbb";
s+="ccc";
System.out.println(s);//结果为abcaaabbbccc
//实际上每次的字符串连接都是创建新的对象病赋值给s;s+="aaa"表示abcaaa这个新对象然后赋值给s,依次类推....;

底层存储字符串内容的是数组,是被final修饰的,必须在创建之初由构造方法对其赋值

字符串创建的两种方式

• 方式1：

String s = "abc";

String s1 = "abc";
String s2 = "abc";
在第一此创建s1变量时，会去内(堆内存)中有一个叫字符常量池的空间检索,有没有与内容相同的字符串对象,如果没有就会在字符串常量池中创建一个字符串对象,把对象的地址赋值给s1,在第二次创建s2这个变量时,继续会去字符串常量池去检索,如果有,直接把之前的字符串内容的对象赋值给s2
System.out.println(s1==s2);//结果为true

• 方法2：

String s1 = new String("abc");
String s2 = new String("abc");
这种方法每次都会创建新的字符串对象
System.out.println(s1==s2);//结果为false

构造方法

• 无参构造:

String s1=new String();//无参构造,相当于this.value = "".value;
//        public String() {
//            this.value = "".value;
//        }源码

• 有参构造

String s2=new String("abc123");//有参构造

成员方法(常用)

判断功能

boolean equals(String str);

• 判断俩个字符串内容是否相等

 		String s4="abcd";
        System.out.println(s4.equals("abcD"));//false

boolean equalsIgnoreCase(String str);

• 判断两个字符串内容是否相等不区分大小写

		System.out.println(s4.equalsIgnoreCase("ABcD"));//true

*oolean contains(String str)

• 判断str是否为子串(字符串必须连续)

		System.out.println(s4.contains("ab"));//true
		System.out.println(s4.contains("ad"));//false

boolean isEmpty()

• 判断字符串是否为空字符串

  注:“”–>指空字符串,而null–>指的是空地址并不能进行使用,否则会报错

		String s5="";
		System.out.println(s4.isEmpty());//true

获取功能

byte[] getBytes()

• //将字符串转化为编码,存在byte数组中并返回数组首地址

		String s2=new String("abc123");//有参构造
        //把字符串处理为编码返回给byte数组;
        byte []bytes=s2.getBytes();
        System.out.println(Arrays.toString(bytes));
结果:[97, 98, 99, 49, 50, 51]

当然也可以通过有参构造方法将byte数组的编码转化为字符串new String(byte[]);

 		//把编码转化为字符串可以使用 new String(byte[]);
        s2=new String(bytes);

char[] toCharArray()

• 将字符串转化为字符数组,并把字符数组的首地址返回

		String s3=new String("qwertyuiopasdfghjklzxcvbnm");
        //toCharArray()方法可以将字符串转化为字符数组
        char[] chars=s3.toCharArray();

当然也可以通过有参构造的方法将字符数组转化为字符串

 		Arrays.sort(chars);//这里对字符数组进行了排序处理
        //new String(char[]);
        s3=new String(chars);
        System.out.println(s3);
结果:abcdefghijklmnopqrstuvwxyz

 String s="abcdefg";

先定义一个字符串

int length();

• 获取字符串长度

System.out.println(s.length());//结果为7

char charAt(int index)

• 获取index位置上的字符

 System.out.println(s.charAt(2));//结果为c

在java没有输入字符的方法,我们可以节约这个方法来实现字符的输入

Scanner in=new Scanner(System.in);
String str= in.next;
char c=str.charAt(0);//读取字符串第一个

int indexOf(int ch)

• 查找ch字符,如果查到返回索引,如果未查到,返回一个负数

System.out.println(s.indexOf('a'));//结果为0

int indexOf(String str)

• 查找str字符串,如果查到返回首字母的索引,如果未查到返回一个负数

System.out.println(s.indexOf("cd"));//结果为2

int index(int ch/String str,int fromIndex)

• 查找字符ch或字符串str,从fromIndex位置开始查找,返回

System.out.println(s.indexOf("ef", s.indexOf('e')));//结果为4

String substring(int start);

• 表示从start处截取字符串,将这个新的字符串地址作为返回值

System.out.println(s.substring(2));//结果edefg

String substring(int start,int end);

• 表示从start开始,end结束之间的截取,不包括结尾

System.out.println(s.substring(0,2));//结果ab

转化功能

byte[] getByte();

• 把字符串返回成编码数组//

char[] toCharArray();

• 把字符串返回成字符数组,返回新的字符串,不改变原来字符串

 		String s5="abcdef";
        char[] chars1=s5.toCharArray();

static String valueOf(char[] chs)

• 把字符数组转化为字符串类型返回的是字符串首地址

		String strings= String.valueOf(chars1);//把字符数组转化为字符串类
        System.out.println(strings);//结果为abcdef

String toLowerCase();

• 把字符串改为小写,返回新的字符串,不改变原来字符串

String s6="ABCD";
System.out.println(s6.toLowerCase());//结果:abcd

String toUpperCase();

• 把字符串改为大写,返回新的字符串,不改变原来字符串

String s7="abcd"
System.out.println(s7.toUpperCase());//结果ABCD

String concat(String str);

• 把字符串str连接到对象字符串,返回新的字符串,不改变原来字符串

String s8="abc";
System.out.println(s8.concat("def"));//结果abcdef

String[] split(分割符)

• (分割符)

 String s9="ab;cd;efg";
 String []strings1 =s9.split(";");
 System.out.println(Arrays.toString(strings1));//结果[ab,cd,efg]

String replace(char old,char new);

• old字符被new字符替换,返回新的字符串,不改变原来字符串

String s10="abcDEF";
System.out.println(s10.replace('a', 'A'));
System.out.println(s10);//结果:AbcDEF;

String replace(String old,String new);

• old字符串被new字符串替换,返回新的字符串,不改变原来字符串

System.out.println(s10.replace("ab", "AB"));//若无法匹配到目标字符串则不会替换

String replaceAll(String regex, String replacement);

• 基本功能类似于String replace(String old,String new);

replaceFirst(String regex, String replacement);

• 替换第一个目标字符串

public class StringUtil(自己定义工具类)

通过自己编写方法,便于后续使用

Random类

构造方法

public Random()无参构造

Random r =new Random();

public Random(long seed)无参构造

Random r1 = new Random(1l);

方法

public int nextInt()获取随机整数

int num1 = r.nextInt();
//可以使用取余方式来获得想要的随机数

public boolean nextBoolean()

public double nextDouble()

public long nextLong()

用法与上面类似

…

Date类

• Date类

• 使用Date类代表当前系统时间

• Date d = new Date();
  Date d = new Date(long d);
  

getYear()

获取从1900年到今天的年数

• 如果要显示年份可以

  date.getYear()+1900
  

getDay()

星期从0开始,周日为0

• date.getDay();
  

getMonth()

月份,从0开始

• date.getMonth();
  

getDate()

日期 一月中的几号

• date.getDate();
  

getTime()

返回毫秒值,获取的是 1970 1.1 00:00:00起的时间差

• date.getTime();
  

也可以使用Date的有参构造,将一个毫秒的时间封装成一个对象,Date会自动将毫秒转化为时间

• Date d = new Date(1694588952086L);//注意里面必须是long类型
  
  //Wed Sep 13 15:09:12 CST 2023
  

…

Calendar类

• Calendar类

• 是一个抽象类,在实际使用时实现特定的子类的对象,创建对象的过程对程序员来说是透明的,只需要使用getInstance方法创建即可

• Calendar c1 = Calendar.getInstance();
  Calendar c1 = new GregorianCalendar();
  

get(Calendar.XXX);

get(Calendar.Year)

• 获取年份

get(Calendar.MONTH)

• 获取月份
• 切记月份是从0开始的

get(Calendar.DAY_OF_MONTH)

• 获取今天是月份的第几天

get(Calendar.DAY_OF_WEEK)

• 获取今天是一周的第几天
• 切记1是周日,从周日开始算

get(Calender.WEEK_OF_YEAR)

• 获取这周是今年的第几周(注意:国外是从星期日开始的)

get(Calender.HOUR_OF_DAY)

• 此时是今天的第几个小时

…

set(年,月,日)

• 设置日期,改变get获得的日期

SimpleDateFormat类

Format(Date类型)方法

• 日期格式化

• SimpleDateFormat sdf = new SimpleDateFormat("制定格式")
      
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月");
  

• 调用format方法格式化上面格式日期

• System.out.println(sdf.(date));//结果是四位数字的年,两位数字的月份
  
  2023年09月
  

  )

parse(String 类型)

• 把字符串日期转化为Date类型

• String str = "2004-07-10";
  SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
  Date date2 = sdf2.parse(str);
  System.out.println(date2);
  
  结果:
  Sat Jul 10 00:00:00 CST 2004
  

BigInteger类

• BigInteger 支持任意精度的整数,可以准确的表达任何大小的整数而不丢失精准度

• BigInteger 位于 java.math包中

• BigInteger()括号里必须是字符串

• BigInteger a = new BigInteger("8888888888888888");
  BigInteger b = new BigInteger("9999999999999999");
  

运算方法add()，subtract()，multiply()，divide()

• 注意:divide方法里默认无限小数会报错,所以必须使用divide方法规定小数位数

add()

a.add(b);

subtract()减法

a.subtract(b);

multiply()乘法

a.multiply(b);

divide()除法

a.divide(b,3,BigDecimal.ROUND_DOWN);

取三位小数,第三个是取整方式

BigDecimal()类

• 由于Double类型运算有精度损失,所以需要使用BigDecimal类来运算,BigDecimal类运算浮点不会有精度损失,但必须传入String类型
• 运算方法与BigInteger一样

StringBuffer类

• 由于String类型创建字符串每次改变后都会创建新的对象,旧的对象地址不会及时的被Java垃圾回收机制回收,造成内存的浪费
• **所以我们可以引用StringBuffer类来处理字符串,StringBuffer类 带缓冲区,弥补了String不可改变字符串的缺点,char[] value是StringBuffer类中的数组,默认16长度,装满16元素后会进行数组扩容(数组长度*2+2) **

构造方法

public StringBuffer(); 无参构造

public StringBuffer( String ); 有参构造,初始化字符串

public StringBuffer( int );有参构造,初始化缓冲区大小,即底层数组大小

方法

StringBuffer stringBuffer = new StringBuffer();//无参构造
StringBuffer stringBuffer1 = new StringBuffer("abc");//有参构造
StringBuffer stringBuffer2 = new StringBuffer(123);//有参构造指定数组长度

public StringBuffer append (String str);

stringBuffer.append("abc");
//结果:拼接字符串 相当于String中的'+';

public StringBuffer insert(int i , String str/int i/char/…)

stringBuffer.insert(1,"123");
//从指定位置,插入字符串/整数/字符...

public StringBuffer delete(int start , int end);

stringBuffer.delete(1, 3);
//删除指定片段,包含开始位置,不包含结束位置

public StringBuffer deleteCharAt(int index);

stringBuffer.deleteCharAt(0);
//删除指定位置;

public synchronized StringBuffer replace(int start, int end, String str)

 stringBuffer.replace(0,stringBuffer.length(), "123");
//替换指定区域字符串;

public synchronized StringBuffer reverse()

stringBuffer.reverse();
//翻转字符串

public synchronized String substring(int start)

 String str1 = stringBuffer.substring(1);
 //从某一位置开始截取字符串,返回String类型,注意:不会改变原来类里面的字符串

public synchronized String substring(int start, int end)

String str2 = stringBuffer.substring(1,2)
//截取某一区域的字符串,不包含结束位置,返回值为String,不会改变原来的字符串

StringBuilder类

方法与StringBuffer类似,区别是StringBuffer的方法被synchronized修饰,而StringBuilder方法没有被修饰

StringBuffer与StringBuilder共同点与区别

共同点

• 字符串是可以改变的,不会创建对象,变的只是底层的数组在改变

区别

• 由于StringBuffer的方法是被synchronized修饰的,表示一次只允许一个请求进入方法,适合多线程场景
• StringBuilder 不是加锁的(即它的方法不被synchronized修饰),一次可以允许多个请求进入方法适合单用户操作

ArrayList类(对List接口的实现,底层由数组实现)

构造方法

ArrayList arrayList = new ArrayList();//默认为Object类,可以存储任意类型

//ArrayList<E>  E为泛型
ArrayList<String> stringArrayList = new ArrayList<>();//定义String类型
ArrayList<Integer> integerArrayList = new ArrayList<>();//定义Integer类型集合

方法

public boolean add(E e)

integerArrayList.add(10);//自动装箱,10自动转为Integer类型,自动添加内容
		stringArrayList.add("0");
        stringArrayList.add("1");
        stringArrayList.add("2");
        stringArrayList.add("3");
        stringArrayList.add("4");

返回值为boolean类型,添加成功-true 失败-false

public void add(int index , E element)

stringArrayList.add(1,"0");
//在指定位置Index插入数据,不能对没有使用的位置进行插入操作(从0到size(集合元素个数))

public boolean remove(Object O)

stringArrayList.remove("1");
//删除指定元素,并自动进行排序,返回值为boolean类型,如果匹配到对应元素删除成功返回-true 找不到-false

public E remove( int index)

stringArrayList.remove(1);
//删除指定位置(index)元素并返回该元素,并对剩余元素进行排序,并返回该元素

public boolean contains(Object O)

boolean b = stringArrayList.contains("1");
//判断是否包含该元素,返回boolean类型数据

public E get (int index)

stringArrayList.get(2);
//获取指定位置上的元素

public int indexOf(Object O)

stringArrayList.indexOf("1");
//查找指定位置元素,并返回该元素位置
//查找方式:从头查找

public int lastIndexOf(Object O)

stringArrayList.lastIndexOf("1");
//查找指定位置元素,并返回该元素位置
//查找方式:从末尾开始查找

public boolean isEmpty()

stringArrayList.isEmpty();
//判断该集合是否为空,, 是-true 否-false

public int size()

stringArrayList.size();
//返回集合元素个数(即长度)

public void clear()

stringArrayList.clear();
//清空元素个数

Vector类(对List接口的实现,底层由数组实现)

构造方法

Vector<Integer> vector = new Vector<>();

方法

public synchronized boolean add(E e)

public synchronized void add(int index , E element)

public synchronized boolean remove(Object O)

public synchronized E remove( int index)

public synchronized boolean contains(Object O)

public synchronized E get (int index)

public synchronized int indexOf(Object O)

public synchronized int lastIndexOf(Object O)

public synchronized boolean isEmpty()

public synchronized int size()

public synchronized void clear()

用法和ArrayList类方法一样,区别是,Vector类方法被synchronized关键字修饰,当多线程运行时,只允许一个请求调用方法,相比ArrayList是安全的

LInkedList类(对List接口的实现,底层是链表)

构造方法

//1.
LinkedList linkedList = new LinkedList();//可以存储任意类型

//2.
LInkedList<String(可以是任意类型)> stringLinkedList = new LinkedList<>();
//可以存储<>里对应的类型

方法

public boolean add(E e)

public void add(int index , E element)

public boolean remove(Object O)

public E remove( int index)

public boolean contains(Object O)

public E get (int index)

public int indexOf(Object O)

public int lastIndexOf(Object O)

public boolean isEmpty()

public int size()

public void clear()

---

ic synchronized boolean remove(Object O)

public synchronized E remove( int index)

public synchronized boolean contains(Object O)

public synchronized E get (int index)

public synchronized int indexOf(Object O)

public synchronized int lastIndexOf(Object O)

public synchronized boolean isEmpty()

public synchronized int size()

public synchronized void clear()

用法和ArrayList类方法一样,区别是,Vector类方法被synchronized关键字修饰,当多线程运行时,只允许一个请求调用方法,相比ArrayList是安全的

LInkedList类(对List接口的实现,底层是链表)

构造方法

//1.
LinkedList linkedList = new LinkedList();//可以存储任意类型

//2.
LInkedList<String(可以是任意类型)> stringLinkedList = new LinkedList<>();
//可以存储<>里对应的类型

方法

public boolean add(E e)

public void add(int index , E element)

public boolean remove(Object O)

public E remove( int index)

public boolean contains(Object O)

public E get (int index)

public int indexOf(Object O)

public int lastIndexOf(Object O)

public boolean isEmpty()

public int size()

public void clear()

---

方法与上面用法一摸一样