JavaAPI常用类超详细笔记——基本数据类型包装类Object类Arrays类String类StringBuffer和StringBuilder类正则表达式数学类日期类大数据类

Posted 2022-07-04 卫可欣

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaAPI常用类超详细笔记——基本数据类型包装类Object类Arrays类String类StringBuffer和StringBuilder类正则表达式数学类日期类大数据类相关的知识，希望对你有一定的参考价值。

文章目录

一、Java API概述
二、基本数据类型封装类
三、Object类
四、Arrays类
五、String类
六、StringBuffer类
七、StringBuilder类
八、正则表达式
九、Math、Random类
十、Date、Calendar、SimpleDateFormat类
十一、BigInteger、BigDecimal 类

一、Java API概述

1、API(Application Programming Interface)应用程序编程接口。

是对java对类或接口的功能和函数功能的说明文档，一般我们所说的api是指api文档，供开发人员学习使用。

基本数据类型包装类

1.基本类型结构很简单，但是不利于面向对象的编程，所以为基本类型提供一个类，类中包含一个基本类型成员。

2.具体有以下八个封装类：

二、基本数据类型封装类

以Integer包装类为例进行学习：

1、Integer包装类常用属性方法：

(1).public static final int MAX_VALUE 最大的int型数

public static final int MIN_VALUE 最小的int型数

(2).构造方法

Integer(int a);

Integer(String a);

(3).比较方法

static int compareTo(Integer a);

boolean equals(Object);

int max(int a,int b);

int min(int a,int b);

(4).转换方法

static toBinaryString(int i);

static String toHexString(int i);

static String toOctalString(int i);

int intValue();

static int parseInt(String s);

String toString();

static Integer valueOf(int i)

static Integer valueOf(String s)

2、类型转换：

(1).基本类型转换为包装类型

Integer a = new Integer(10);

Integer b = new Integer(“20”);

Integer c = Integer.valueOf(11);

(2).引用类型转为基本类型

int a=b.intValue()//将对象a中包装的基本类型取出来,取的是数值

如果是int b=a;返回的是Integer对象

(3).字符串类型转为基本类型

int d=Integer.parseInt(“15”);

(4).自动装箱和拆箱

Integer e=new Integer(10);

int f=e;//自动拆箱:把包装类型转为类型int f=e.intvalue();

Integer m=f;//自动装箱：把基本类型转为包装类型Integer m=Integer.valueOf(f);

注意：底层实现valueOf(128)

将-128到+127做了缓存数组在此区间的之外从缓存中获取，在此区间之外重新new对象。

//基本数据类型==比较的是值
int a=10;
int b=10;System.out.println(a==b);//true
//new了两个对象 地址不同
Integer c=new Integer(10);
Integer d=new Integer(10);
System.out.println(c==d);//flase

//将基本类型转为引用类型
//引用数据类型==比较的是两个引用所指的对象地址是否相同
//自动装箱 Integer.valueOf(128)Integer e=128;
//newInteger f=128;//new
System.out.println(e==f);//false在-128--127之间 在库中取出相同对象所以相同 之外创建不同对象
System.out.println(e.equals(b));//equals方法比较的是对象中的值是否相等

三、Object类

1、Object类是所有Java类的父类（根基类）。

2、方法

方法1：toString();

Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。

/*要对对象进行输出，默认会调用类中的toString()返回对象的字符串表现形式
Car类中没有toString(),会去调用父类中toString()
public String toString()
将对象内存地址(哈希值)，转为16进制return getClass().getName()+"@"+Integer.toHexString(hashCode());
*/

@Overridepublic String toString() 
    return "Car" +
        "name='" + name + '\\'' +
        ", price=" + price +
        '';

方法2：equals方法

Object类中定义有public boolean equals(Object obj)方法，提供定义对象是否“相等”的逻辑。

JDK提供的一些类，如String，Date，包装类等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ,当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回 true 否则返回 false。

而我们自定义的类中需要重写equals方法，不然equals的作用将与==一样。

四、Arrays类

1、Arrays类中提供一些关于数组操作的方法(例如排序，二分查找)

2、方法

方法1：equals 方法

int []a=new int[]1,2,3,4,5;
int []b=new int[]1,2,3,4,5;
//==比较地址
System.out.println(a==b);//false
//equals(a1,a2)比较两个数组内容是否相等System.out.println(Arrays.equals(a,b));//true

//注意：还有一个toString(a)方法可以将数组对象内容以字符串格式输出System.out.println(Arrays.toString(a));

方法2：sort方法

基本类型排序：

int[] a = new int[]4, 1, 5, 3, 2;
// Arrays.sort(a); //引用传递 0,length-1        Arrays.sort(a,1,a.length-1);//sort(数组，开始位置(包含)，结束位置(不包含的))        System.out.println(Arrays.toString(a));

引用类型排序：

对引用类进行排序，需要特殊处理:重写compareTo方法（此方法是用于引用类型排序时，自定义排序规则的）。

//给类连接一个接口Comparable+<类名>
//Compare接口是提供排序比较的接口
public class Car implements Comparable<Car>


//按int类型排序
@Override
public int compareTo(Car o) 
return this.number-o.number;


//按String类型排序
@Override
public int compareTo(Car o) 
return this.name.compareTo(o.name);
//按照名字比 此处的compareTo调用的是String类中的方法

另外，字符串也可以比较大小：

String [] s="a","d","b","c","e";
Arrays.sort(s);
System.out.println(Arrays.toString(s));

//输出结果：[a, b, c, d, e]

方法3：binarySearch方法

二分查找/折半查找，提高查询效率

查询数组中有没有指定的元素

二分查找前提是数组是有序的

Arrays.sort(数组名);

int []a=5,10,2,6,1,9,3;
Arrays.sort(a);//先给数组排序System.out.println(Arrays.toString(a));//[1, 2, 3, 5, 6, 9, 10]

//int index=Arrays.binarySearch(a,9); index不是负数说明找到了int 
index=Arrays.binarySearch(a,4,6,9);//index不是负数说明找到了

System.out.println(index);

方法4：copyOf方法

数组特点：创建时必须给予长度，长度一旦定义不能修改，空间是连续的。

数组扩容：将原来数组的内容复制到一个新的指长度的数组中，称为数组扩容。

int a[]=new int[]1,2,3,4,5;
int b[]= Arrays.copyOf(a,8);//数组扩容System.out.println(Arrays.toString(b));//[1, 2, 3, 4, 5, 0, 0, 0]

五、String类

1、字符串是由多个字符组成的一串数据(字符序列)的字符串常量，java中所有的字符串"",都可以视为String类的实例。

String对象的值一旦定义就不能改变,底层是使用char数组存储（private final char value[];）

2、构造方法

public String()

public String(String str)

public String(byte[] bytes)

public String(char[] value)

3、创建字符串对象两种方式

方式1: String s = “abcd”;

隐式创建,字符串对象直接在字符串常量池中存储,如果值相同,就直接返回字符串常量池中的对象地址。

String s1 = "abcd";
String s2 = "abcd";
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true

方式2：通过new创建，new会在堆中创建不同的对象。

String s3=new String("abcd");
String s4=new String("abcd");
System.out.println(s3==s4);//false
System.out.println(s3.equals(s4));//true

4、功能

(1).判断功能

boolean equals(Object obj)

boolean equalsIgnoreCase(String str)

boolean contains(String str)

boolean isEmpty()

boolean startsWith(String prefix)

boolean endsWith(String suffix)

 String s="abcd";
 String ss="abcd";
 /*判断功能*/  
System.out.println(s==ss);//true    System.out.println(s.equals(ss));//true 比较字符串内容是否相等

String s3="AbcD";    System.out.println(s.equalsIgnoreCase(s3));//true 比较时忽略大小写  

System.out.println(s.contains("d"));//true 是否包含指定的子串

String s4="";//不是String s4=null;    System.out.println(s4.isEmpty());//true 是否为空""   

System.out.println(s.startsWith("abc"));//true 判断以xxx开头(子串)    System.out.println(s.endsWith("cd"));//true 判断以xxx结尾(子串)

(2).获取功能

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="abcdcb5";
/*获取功能*/
System.out.println(s.length());//7 返回字符串长度System.out.println(s.charAt(1));//b 返回指定位置上的字符System.out.println(s.indexOf("c"));//2 获取指定字符首次出现的位置  从前向后System.out.println(s.indexOf("c",s.indexOf("c")+1));//4 从指定位置开始找的System.out.println(s.lastIndexOf("c"));//4 从后往前找System.out.println(s.substring(2,5));//cbc 从指定的位置开始截取一个到指定位置新的子串System.out.println(s.substring(1));//bcdcb5 从指定的位置开始截取一个新的子串到结尾

(3).转换功能

byte[] getBytes()

char[] toCharArray()

static String valueOf(char[] chs)

String toLowerCase()

String toUpperCase()

String concat(String str)

Stirng[] split(分割符);

/*getBytes用法*/
String s = "中文";
//传输时，需要把字符串转为字节数组 转码 默认使用平台的字符集
byte[] bytes = s.getBytes("gbk");
//接收到字节数组后，把字节数组转为字符串 解码
String s1 = new String(bytes, "gbk");
System.out.println(s1);//中文
//注意：转码和解码使用的字符集必须一致 默认的平台字符集utf-8 也可以使用gbk(国标)，gbk中2个字节一个汉字 utf-8中3个字节一个汉字

/*toCharArray用法*/
String str="abc";
char[]chars=str.toCharArray();//将字符串转字符数组
Arrays.sort(chars);//数组排序
String str2=new String(chars);//将字符数组转为字符串
System.out.println(str2);

/*valueOf用法*/
Integer ii = null;
String s3 = String.valueOf(ii);//  建议将其他类转为String时，使用valueOf(),引用的值如果为null,返回null的字符串形式，不报错
//Integer ii=null;引用值为空 就会报空指针异常
//String s3=ii.toString();//Integer中的toString()

/*toUpperCase和toLowerCase用法*/
String s4 = "AbcDEfg";
System.out.println(s4.toUpperCase());//ABCDEFG
System.out.println(s4.toLowerCase());//abcdefg

/*concat用法*/
String s5 = "abcd";
System.out.println(s5.concat("efg"));//效果其实和s5+="efg"一样
String s6 = "abcd" + 20 + true;//区别是+=能连接别的 而concat只能连接一个字符串
System.out.println(s6);

/*split用法*/
String s7 = "abc:de:fg";
String[] sarray = s7.split(":");//[abc, de, fg] 使用指定的分隔符号拆分字符串,不能用正则表达式中有意义的符号
System.out.println(Arrays.toString(sarray));

(4).替换功能

String replace(char old,char new)

String replace(String old,String new)

replaceAll(String regex, String replacement)

replaceFirst(String regex, String replacement)

String s1="aB3adB4E0f9";
System.out.println(s1.replace("a","AA"));//用指定的字符串替换制定目标子串System.out.println(s1.replaceAll("\\\\d",""));//以正则表达式方式进行匹配替换 所有匹配的替换System.out.println(s1.replaceFirst("\\\\d",""));//以正则表达式方式进行匹配替换 替换第一个

(5).去除字符串两空格

String trim()

String s2=" abc ";
System.out.println(s2.length());//5
System.out.println(s2.trim().length());//3去掉字符串两端的空格

public class StringUtil 
public static String subFileType(String filename)
return filename.substring(filename.indexOf(".")+1);


public class Test
public static void main(String[] args)    
//使用工具类获取文件后缀
System.out.println(StringUtil.subFileType("Test.java"));

六、StringBuffer类

1、StringBuffer类是线程安全的可变字符序列（有缓冲区暂存数据）。

1.String特点: 值一旦给定,就不能改变：

s=“1”; s+=1; s+=2; 每次拼接创建新的对象, 耗时,浪费空间。

2.StringBuffer 可变带缓冲区的字符串如果需要大量的字符串拼接,建议使用StringBuffer。

2、构造方法

public StringBuffer()

public StringBuffer(String str)

3、功能

(1).添加功能

public StringBuffer append(String str)

public StringBuffer insert(int offset,String str)

StringBuilder sb = new StringBuilder("abcd");//4+16长度的char数组sb.append("efg");//7
sb.append("efg");//10
sb.append("efg");//13
sb.append("efg");//16
sb.append("efg");//19
sb.append("efg");//22 装不下了，创建一个新的数组，赋给StringBuffer对象中的value[]
System.out.println(sb);//abcdefgefgefgefgefgefg

(2).删除功能

public StringBuffer deleteCharAt(int index)

public StringBuffer delete(int start,int end)

sb.delete(0,2);删除从指定位置开始到指定位置结束的内容，并返回本⾝(自动缩小容量 节省空间)
sb.deleteCharAt(0);删除指定位置的字符，并返回本⾝

(3).替换功能

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

sb.replace(0,3,"CCC");

(4).反转功能

public StringBuffer reverse()；

sb.reverse();//逆序输出 gfegfegfegfegfegfedcba

(5).截取功能

public String substring(int start)

public String substring(int start,int end)

String s=sb.substring(2);//截取字符 原来的不变
String s=sb.substring(2,5);//截取字符 原来的不变
System.out.println(s);

七、StringBuilder类

1、StringBuilder 可变带缓冲区的字符串如果需要大量的字符串拼接,建议使用StringBuilder

StringBuilder类功能和StringBuffer功能完全一致, 但StringBuffer是线程安全的。

2、StringBuffer和StringBuilder：

相同点：底层实现方式是完全一致的，类的内部有一个没有用final修饰的char数组，之后对象字符串进行增删操作，都是对底层数字直接操作。
不同点：StringBuffer是多线程操作安全的，方法都被synchronized关键字修饰。

public synchronized int length()

return count;

StringBuilder是多线程不安全的，建议单线程情况下使用。

3、String类StringBuffer类StringBuilder区别

● String：是字符常量,适用于少量的字符串操作的情况

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

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

4、String和StringBuilder StringBuffer之间的转换

/*String和StringBuilder StringBuffer之间的转换*/
String s="abc";
StringBuilder sb1=new StringBuilder(s);
StringBuffer sb2=new StringBuffer(s);
String s1=new String(sb1);

八、正则表达式

1、正则表达式

又称规则表达式，(Regular Expression,在代码中常简写为regex,regexp或RE),是一种模式匹配语言(用一种规则来匹配文本)。

重点：表达式中有哪些符号，如何使用这些符号来制定简单的规则。

eg:规则：输入一个字符串，判断该字符串是否符合手机号格式。
11位数字
第一位是1
第二位不能是1,2
第三位开始任意数字

2、匹配规则

\\d匹配0-9的数字

[a-z]匹配小写字母

[A-Z]匹配大写字母

\\w 匹配单词字符

/*匹配数字：*/
String s = "378";
//boolean b=s.matches("\\\\d");//匹配到只有一位数字
//boolean b=s.matches("\\\\d11");//11位数字
//boolean b=s.matches("\\\\d5,11");//5-11位数字
//boolean b=s.matches("\\\\d*");//(0次或多次)至少有0位数字,不为空必须全为数字  匹配长度0,
//boolean b=s.matches("\\\\d+");//(1次或多次)至少有一位数字  匹配长度1,  
//boolean b=s.matches("[1-9]+");//(1次或多次)从第一位开始都是1-9没有0的数字  匹配长度1,
boolean b = s.matches("[3,5,7,8,9]+");//(1次或多次)  匹配长度1,
/*举例*/
//可以直接在某一位置上规定数字，第一位是1，第二位是这五个数中的一个：boolean b = s.matches("1[3,5,7,8,9]");   
//boolean b=s.matches("1[3,4,5,6,7,8]\\\\d9");//手机号
//boolean b=s.matches("[1-9]\\\\d5,11");//qq号
System.out.println(b);

 /*匹配字母：*/
//boolean b=s.matches("[a-z]+");
//boolean b=s.matches("[A-Z]+");
//boolean b=s.matches("\\\\w+");//匹配[A-z,0-9,_]
/*举例*/
boolean b=s.matches("[A-z]\\\\d5,10@\\\\w2,5\\\\.(com|com\\\\.cn)");//自定义匹配邮箱格式        System.out.println(b);

/*对正则表达式的理解*/
String str="abc2de3fg";
str.split("\\\\d");//以数字分割
str.replaceAll("\\\\d","a");//把所有的数字换成a

九、Math、Random类

1、Math

Math.abs(-9);//绝对值

Math.sqrt(9);//平方根

Math.pow(2,3);//a的b次幂

Math.max(2,3);

Math.min(2,3);

Math.random();//返回 0.0 到 1.0 的随机数

Math.ceil(9.1);//返回大于或等于参数的最小double值

Math.floor(9.9);//返回小于或等于参数的最大double值Math.round(8.8);//四舍五入

2、Random

Random random=new Random();

random.nextInt()

random.nextBoolean()

random.nextFloat()

random.nextDouble()

random.nextInt(34)//0-34 0(包含的)-指定值(不包含的)

随机一个数组：

byte []bytes=new byte[5];
random.nextBytes(bytes);
System.out.println(Arrays.toString(bytes));

十、Date、Calendar、SimpleDateFormat类

1、Date

1.构造方法：

Date d = new Date();

Date d = new Date(long d);

2.Date中的getTime方法：

d.getTime());//1656317873847 从1970-1-1 0：0：0 —至今的毫秒差

可以利用此方法计算某一时刻和现在时刻的时间差。

2、Calendar 日历类里面可以包含更丰富的日历信息

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象：

/*可以使用*/
Calendar c1 = Calendar.getInstance(); 
c1.get(Calendar. YEAR);
/*也可以*/
Calendar c = new GregorianCalendar();//Calendar的子类公历
c.getTimeInMillis()//从1970-1-1 0：0：0 ---至今的毫秒差
c.get(Calendar.YEAR)等等

3、SimpleDateFormat

(1).构造方法

SimpleDateFormat(格式); // yyyy-MM-dd

(2).把日期对象转换为一个指定格式的字符串

Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
String s = sdf.format(d);
System.out.println(s);

(3).把字符串构造成一个日期对象

String birthday = "2003-1-1";//把字符串构造成一个日期对象SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
tryDate date=sdf1.parse(birthday);                  System.out.println(date);
   catch (ParseException e)
    e.printStackTrace();