第五章 Java中的常用类

API（Application Programing Interface）

API：官方给开发人员提供的一个说明文档，对语言有哪些类，类中有哪些方法进行说明

函数库

API文档

Object类

存放在java.lang.Object包中

它是java类体系结构中最顶层的类,所有的类都直接或间接的继承Object类

Object可以表示Java中任意的类

Object类中的方法

toString方法

把对象所在的类的地址和对象在内存中的哈希值返回(以16进制),

可以在自己的类中对Object中的toString()进行重写,后面调用时,就调用我们自己类中的toString();

equals方法

==比较等号两边是否相等

==用于基本类型比较时，比较多是变量值是否相等

==用于引用类型比较适，比较的是对象的地址是否相等

Object类中的equals默认笔记两个对象的地址是否相等

在其他类中，一般都重写了equals（）；把它改造为比较对象中的内容是否相等

Arrays类

用于操作数组的各种方法（如排序和搜索）

类的地址为java.util.Arrays

equals方法

比较两个数组对象中元素是否相等

而数组对象中的equals用来判断与另一个数组对象是否相等

sort方法

将指定的类型数组所有元素按照数字升序进行排序

作用于数组的所有元素
public static void sort(type[] a)

binarySearch方法（二分查找）

使用二分搜索算法搜索指定数组

public static int binarySearch(type[] a, type key)
public static int binarySearch(long[] a,int fromIndex,int
toIndex,long key)

查找的数组必须有序,可在查找前使用sort对数组进行排序

若返回负数则此元素不存在,存在则返回该元素的索引

● 参数：
a - 要搜索的数组。
key - 要搜索的值。
fromIndex - 要排序的第一个元素的索引（包括）。
toIndex - 要排序的最后一个元素的索引（不包括）

如果一个类要进行排序,那么这个类必须实现compareable接口,指定一个排序的方法(这一所有的类都使用同一点方法进行排序)

compareaTo方法

用来指定排序规则

可以执行用类中那个属性作为排序的项

这个方法在sort()方法的底层调用,来排序大小

1.返回参与比较的前后两个字符串的asc码的差值，如果两个字符串首字母不同，则该方法返回首字母的asc码的差值

　 String a1 = "a";
        String a2 = "c";
        System.out.println(a1.compareTo(a2));//结果为-2

Comparable接口中的compareTo

compareTo方法内必须做非空判断（规范问题），当然int类型就不用了。

注意事项：

1、模型必须实现Comparable接口

2、Collection.sort(list)会自动调用compareTo,如果没有这句，list是不会排序的，也不会调用compareTo方法

3、如果是数组则用Arrays.sort(a)方法

public int compareTo(Book o) {
        // TODO Auto-generated method stub
        
    //return this.bookPrice-o.bookPrice;//按价格排序 升序
    //return o.bookPrice-this.bookPrice;//按价格排序 降序
        
    //return this.bookName.compareTo(o.bookName);//按书名排序 升序
        
    //先按 id 再按价格 最后按书名排序 升序
    int result = this.bookId - o.bookId;
        if(result == 0){
            result =this.bookPrice - o.bookPrice;
        }
        if(result == 0){
            result = this.bookName.compareTo(o.bookName);
        }        
        return result;
        
    }

copyOf方法

copyOf（数组复制方法）可以用于创建一个新数组，复制旧数组中的内容并且可以设置新数组的长度

fill方法

用指定值将指定数组中的每个元素填充

fill(int[] a, int val)

toString方法

返回指定数组内容的字符串表示形式

基本类型包装类

java中的基本数据类型是使用8个关键字声明的,不是面向对象的

java语言是面向对象的,可以为每个基本类型定义一个类来进行表示

这样我们在类中还是保持有一个基本类型的变量存储数据,

同时还可以提供许多的方法对变量进行操作(例如将十进制转为二进制)

类型转换的方法

//转换的方法
//包装类型  转换为基本类型
int aa = a.intValue();//自动拆箱:把引用类型转为基本类型
int c = a;//自动拆箱:把引用类型转为基本类型
int bb = Integer.parseInt(20);
//吧基本类型 转换为包装类型
int cc = 10;
Integer dd = new Integer(cc);
Integer ee = Integer.value0f(cc);

自动装箱

把基本类型转为引用类型

int x = 10;
Integer yy = Integer.valueOf(x);
Integer y = x;

自动装箱时,.会默认调用valueOf();方法

在valueOf()中如果基本类型值在-128-127之间,会从缓存数组中直接取出一个Integer对象,减少创建次数,如果两个值相同,获取的是同一个对象

基本类型值如果不在这个区间,每次都创建一个新的Integer对象返回

int x= 1000;
//Integer yy = Integer.value0f(x);
Integer y=x;//自动装箱 会默认自动调用value0f()方法
Integer z=x;
System.out.println(y==z);// x=10 truex=128 false
//system.out.printin(y.equals(z));//true

String类

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例.

java中字符串都是java.lang.String类的实例,String的底层是一个char数组

字符串对象创建方式:

1.String s = “abc”;

创建时,先去字符串常量池中去查找有没有同值的对象,如果没有.就创建一个字符串对象,并返回地址,如果字符串中`已经储存,不用创建新的,直接返回已存在对象的地址

2.String s1 = new String(“abc”);

new每次都创建新的字符串变量

字符串不变:它们的值在创建后不能被更改

String s="abcd";// abcd
		s+="efg";//abcdefg
		s+="aaaa";//abcdefgaaaa
System.out.println(s);

每次都指向另一段字符串,最后输出的是最后定义的s

String类的方法

构造方法

String();

String(String a);

String(byte[] bytes);把字节数组 转为字符串

s3.getBytes(); 把字符申转为字节数组

String(char[] chars);把数组转换为字符串

s4.toCharArray();把字符串转为字符数组

String s3 ="你好";
byte[]bytes=s3.getBytes();//编码 把字符转为 字节数组
System.out.println(Arrays.tostring(bytes));
String s4 = new string(bytes);//解码 把字节数组转五字符
System.out.println(s4);

判断功能

boolean equals(object obj) 比较字符串对象中内容是否相等

String sl = new string( "abcd");
String s2 = new string( "abcd");
System.out.println(s1.equals(s2))
//此时结果为true

String sl = new string( "abcd");
String s2 = new string( "abcD");
System.out.println(s1.equals(s2))
//此时结果为false

boolean equalsIgnoreCase(string str)

忽略大小写进行比较

String sl = new string( "abcd");
String s2 = new string( "abcD");
System.out.println(s1.equals(s2))
//此时结果为true,忽略了大小写

boolean contains(string str)

//判断字符串中是否包含指定的子串

String sl = new string( "abcd");
System.out.println(s1.contains("ab"));
//结果为true

boolean isEmpty()

判断字符串值是否为" "(空)

boolean startsWith(string prefix)

判断字符串是否以指定的字符串开头

boolean endsWith(string suffix)

判断字符串是否以指定的字符串结尾

获取功能

int length()

获取字符串长度char

charAt(int index)

返回值为char 获取指定位置上的字符

String s1 = "abcdefg"
System.out.println(s1.charAt(4));
//输出的是e
for(int i=0;i<s1.length();i++){
  System.out.println(s1.charAt(i))

int indexof(string str)

返回的是指定字符串首次出现的位置

String s1 = "abcdefg"
System.out,println(s1.indexOf("c"));
//输出的结果为2,数组的第三位

int index0f(string str,int fromIndex)

从指定的位置开始查找

int lastIndexOf(“c”)

从后向前找,返回指定字符串首次出现的位置

String substring(int start)

从指定的位置开始截取一个字符串副本,到结束

String substring(int start,int end)

从指定的位置开始截取到指定的位置,不包含结束的位置

转换功能

byte[ ] getBytes()

将字符串转为byte数组

char[ ]toCharArray()

将字符串转为字符数组

static string value0f(char[] chs)

将传入的参数转为字符串类型

String s= string.value0f(1000);//将int类型变为s字符串
System.out.println(s.charAt(1));//0
int a = Integer.parseInt(s);//将s字符串变为int类型
String sl= string.value0f("abc".tocharArray());//将abc变为char数组然后变为s1字符串
System.out.println(s1);//abc字符串

String toLowerCase();

将输入的字符串中的字母全部变为小写输出一个新的副本

String toUpperCase();

将输入的字符串中的字母全部变为大写输出一个新的副本

String concat(string str);

拼接指定字符串内容到原字符串末尾 返回一个新的字符串对象

Stirng[] split(分割符);

将一个字符串用指定的分割符拆分为一个字符串数组

String s2 = "ab,cd,ef"
String [] strings = s2.split(";");
System.out.println(Arrays.toString(strings));
//输出为[ab;cd;ef]

替换功能

String replace(char old,char new)

用新的字符替换字符串中指定字符

String s = "abcedfg";
System.out.println(s.replace(c,C));//输出abCedfg

String replace(string old,string new）

用新内容替换字符串中指定的字符串

replaceAll(String regex,string replacement)

用新内容替换字符串中正则表达式匹配的字符串

String s = "ab2ced3fg5";
System.out.println(s.replaceAll( regex:\\d,replacement: "C"));
//将所有的数字替换为C

replaceFirst(string regex,String replacement)

用新内容替换字符串中正则表达式匹配的第一个字符串

String s = "ab2ced3fg5";
System.out.println(s.replaceFirst( regex: "\\d", replacement: "c"));
//输出为abCced3fg5,替换了第一个被正则表达式匹配的字符

去除字符串两空格string trim()

StringBuffer类

为什么指定StringBuffer字符串？

因为String字符串声明的字符串对象值一旦给定就不能改变了

每次拼接都会创建新的字符串对象，耗时且占空间

而StringBuffer创建的是内容可以改变的字符串，底层是用一个数组来储存数据的，没有使用final修饰，每一次添加内容都是对此数组进行操作，不会创建新的字符串对象

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。

而StringBuffer就可以解决这个问题

线程安全的可变字符序列

添加方法

public StringBuffer append(String str)

向字符串末尾添加字符串内容

public StringBuffer insert(int offset,String str)

向指定位置插入指定的字符串

public substring

String s2=s1.substring(0,5);
//截取字符串，从StringBuffer中截取一个字符串副本
//返回给一个新的String对象

删除功能

public StringBuffer deleteCharAt(int index)

删除指定位置的字符

public StringBuffer delete(int start,int end)

删除指定区间的字符串内容，包含开始的位置不包含结尾

替换功能

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

用新的字符串替换原字符串指定区间内的字符串内容，不包含结尾索引

反转功能

public StringBuffer reverse()

将数组的内容逆序（反转字符串）

StringBuilder类

String和StringBuffer和StringBuilder的区别

正则表达式

正则表达式（Regular Expression）简称regex，是一种用于文本处理和搜索的强大工具，它允许用户创建一个模式，用于在字符串中匹配特定的字符串

[0-9][1-9][357][a-z][A-z0-9]*+{n}{n,}fn,m}
\d匹数字     \D匹配非数字
\W匹配数字字母下创线  \W非数字字母下创线
\s匹配空格字符   \S非空格字符
丨逻辑或
.匹配任意字符，使用时需要转义
[\\u4e00-\\u9fa5]匹配汉字

如果字符串与规则相匹配，放回true，否则返回false

String s =“1234”;
//System.oUt.println(s.matches(“[0-9]*”));[0-9]*允许出现0次或多次数字

//System.oUt.printin(s.matches(“[0-9]+”));[0-9]+允许出现至少1次或多次数字

//System.out.println(s.matches(regex:“1[0-9]{3}”));允许第一位为1，后面3位为0-9的数字

//System.out.println(s.matches(regex:“[0-9]{n, }”))至少出现n次数字

//System.out.println(s.matches(regex:“[0-9]{n,m}”));至少n次，不超过m次

System.out.println(s.matches(regex:“\d{3,6}”));// \d =[0-9]反斜杠d和数字0-9含义相同 \D匹配任意非数字，与小d相反

Math类

java.lang.Math提供了一系列静态方法用于科学计算；

其方法的参数和返回值类型一般为double型。

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型（四舍五入）

floor向下取整，ceil向上取整，round四舍五入

Random类

Random类概述

此类用于产生随机数

构造方法

public Random()

成员方法

public int nextInt()

public int nextInt(int n)

//bound可以给定一个范围，0-bound，在给定范围内随机取值

Date类

使用Date类来代表系统时间

构造方法

Date d = new Date();

获取程序运行时刻的时间

Date d = new Date(long d);

getYear，getMonth，getDate等方法

方法上有删除线

有删除线的方法表示已弃用，但是可以正常使用，已有其他方法替代其作用

getTime（）

获取的是自1970.1.1 0：0：0至程序运行时刻的毫秒值

可以用程序运行结束时刻的毫秒值减去程序运行刚开始的毫秒值

Date date = new date();
Date date1 = new date();
System.out.println(date1.getTime()-date.getTime());

Date date2=new Date(1708843278948L);//将指定long类型的时间戳构造出一个时间对象

Calendar类

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

Calendar c1 = Calendar.getInstance()；

c1.get(Calendar. YEAR);//获得今年的年份

c1.get(Calender.需要获得的日期)；//通过调用Calender中不同的时间常量的编号来获得所需的时间

SimpleDateFormat类

SimpleDateFormat，日期格式化类

构造方法

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

日期转字符串

Date now=new Date();

myFmt.format(now);

字符串转日期

myFmt.parse(“2018-02-10”);

字符串日期格式与 指定格式必须一致

String s =“2018-03-15”;
new SimpleDateFormat(“yyyy-MM-dd”)

/
把字符串日期转为Date对象
*/
String s="2002-02-03";
SimpleDateFormat sdf =  new SimpleDateFormat(pattern:"yyyy-MM-dd");
Datedate sdf.parse(s);
System.out.println(date.getYear()+1900);
04
/*
把日期对象转为指定格式的字符串
*/
Date date1 new Date();
SimpleDateFormat sdf1 new SimpleDateFormat(pattern:"yyyyMM dd HH:mm:ss");
String s1 sdf1.format(date1);
System.out.println(s1)

BigInteger类

int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类

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

构造方法

BigInteger(String val) /BigInteger(byte[] val)

基本运算方法

add()，subtract()，multiply()，divide()

BigDecimal类

在计算机中float 还是double都是浮点数，而计算机是二进制的，浮点数会失
去一定的精确度

根本原因是:十进制浮点值没有完全相同的二进制表示形式;十进制浮点值的二进
制表示形式不精确,只能无限接近于那个值

构造方法

BigDecimal(String val)

基本运算方法

add()，subtract()，multiply()，divide()