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

Posted 卫可欣

tags:

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

文章目录

一、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();

十一、BigInteger、BigDecimal 类

1、BigInteger

(1).BigInteger类型的数字范围较Integer,Long类型的数字范围要大得多,它支 持任意精度的整数。

(2).构造方法

BigInteger(String val)

BigInteger(byte[] val) …

(3).基本运算方法

add(),subtract(),multiply(),divide()

2、BigDecimal

(1).小数在计算机内以近似值存储,会造成精度丢失。

Java在java.math包中提供的API类BigDecimal

(2

以上是关于JavaAPI常用类超详细笔记——基本数据类型包装类Object类Arrays类String类StringBuffer和StringBuilder类正则表达式数学类日期类大数据类的主要内容,如果未能解决你的问题,请参考以下文章

Java笔记10-Object包装类型字符串

Java学习笔记4.4.2 包装类 - 基本数据类型包装类与字符串相互转换

JAVA学习笔记-包装类

从零开始的Java开发1-5-2 包装类与基本数据类型常用API基本数据类型与包装类字符串之间的转换包装类的初始值与比较对象常量池

常用对象API( 基本数据类型对象包装类 )

JAVA-初步认识-常用对象API(基本数据类型对象包装类-概述)