Java基础笔记4
八、接口API
Application Programming Interfaces——应用程序接口
Object对象
是java中所有类的父类——顶级父类
没有写父类的都默认继承Object类。
clone()克隆——克隆出一个新对象，新对象的属性值和原来的一样。
如果一个类的对象想要被克隆，那么这个类必须实现一个接口Cloneable(这个接口没有任何属性和方法，仅仅作为标志作用)。
右键菜单Source–>Generate hashCode() and equals()自动为属性重写hashcode()和equals()方法
public boolean equals(Object obj) {
if (this == obj) //判断是否是同一个对象
return true;
if (obj == null) //判断对象是否为空值
return false;
if (getClass() != obj.getClass()) //判断对象类型是否一致
return false;
Student other = (Student) obj; //强转传入参数Object类为要判断的Student类
if (name == null) { //当当前对象的name为空值
if (other.name != null)//传参对象的name不为空值，返回false
return false;
//调用String类型的equals()方法，判断两个字符串name是否一致
} else if (!name.equals(other.name))
return false;
return true;
}
}
finalize()：通知垃圾回收器进行回收，当垃圾回收器GC不一定执行。
getClass()：返回运行时类。获取对象的实现类（非声明类）。
equal()：默认判断两个对象的地址。
hashcode()：哈希码值——根据哈希散列算法计算出来的。
1.不同的对象计算出来的哈希码是均匀地散列分布在int的取值范围内。因为不同对象的哈希值重复概率非常小，所以人为的认为哈希值是唯一的。故在计算对象的存储位置的时候是根据对象的哈希值来分配的。
2.固定环境下（同一台主机上）每次计算的哈希值是不变的。
String字符串
本身依靠字符数组存储的元素，作为最终类存在，不可以被继承。
字符串是常量，字符串是被共享的。
String str = “abc”; — 1个对象
String str2 = new String(“abc”); — 2个对象
String str3 = “a”; str3 += “b”; — 5个对象
String str3 = “a”;— 1个对象
str3 = new StringBuilder(str3).append(“b”).toString(); — 4个对象
String s1="ab";
String s2=new String("ab"); //s1、s2指向的是不同的地址
//为了提高编译效率，字面量先运算再赋值，故String s3="ab";
String s3="a"+"b";
String s4="a";
//使用+拼接两个字符串，底层实际上调用了StringBuilder中的append方法
s4=s4+"b";//相当于s4=new StringBuilder(s4).append("b").toString();
System.out.println(s1==s2); //false
System.out.println(s1==s3); //true
System.out.println(s1==s4); //false 比较的是引用地址
System.out.println(s1.equals(s4)); //true 比较的是地址里存的内容
String[] arr = {100个元素};
// 将字符串数组中的元素拼接成一个字符串
String str = “”; // 1
for(String s : arr){
str = str + s; // 每拼接1次，要额外产生3个对象。拼接100次，额外产生300个对象
}
// 整个过程中，一共产生了301个对象
StringBuilder sb = new StringBuilder(); // 1
for(String s : arr){
sb.append(s); // 每拼接1次，要额外产生1个对象。拼接100次，额外产生100个对象
}
String str = sb.toString(); // 1
// 整个过程中，一共产生了102个对象
在拼接字符串的时候，如果个数比较少可以使用+;如果个数比较多，建议使用StringBuilder
StringBuilder是线程不安全的类，StringBuffer是线程安全的。
①将字符串转化成数组，调用toCharArray()方法。
String str=new String();
char[] cs=str.toCharArray();
②将字符数组转化成字符串
char[] cs={‘a’,‘b’,‘c’,‘d’,‘e’};
String str=new String(cs);
System.out.println(str);//输出结果：abcde
③将字符串转化为字节数组。在转化的时候如果没有指定编码会依据平台码来进行转化。
String s = “字节数组”;
byte[] bs = s.getBytes();
byte[] bs = s.getBytes(“utf-8”);//指定转换字符集
④ 将字节数组转化为字符串
String str = new String(bs);
charAt()：获取指定下标的字符
indexOf()：从开始位置找指定字符第一次出现对应的下标
lastIndexOf()：查找指定字符最后一次出现的下标位置
toUpperCase()：将字符串中的小写字母转化成大写字母
toLowerCase()：将字符串中的大写字母转化成小写字母
注意：在String中提供了一系列的方法是新生成了一个字符串，并不改变原字符串。
concat()：将指定字符串拼接到原字符串末尾
contains()：判断是否包含指定的子字符串。只能判断具体值，不判断范围
endsWith()：判断是否以指定字符为结尾
startsWith()：判断是否以指定字符为开头
equals()：判断两字符串是否一样。底层已做过重写，比较的是内容。
equalsIgnoreCase()：忽略大小写，判断两字符串是否一样。
instanceof：判断前一个对象是否是后边的类或者接口产生。
“abc”instanceof String 判断abc是否是字符串类，结果是true。
注意：判断类型为其父类时，结果也是true。例“abc”instanceof Object
Windows系统默认编码： GBK Linux系统默认编码： UTF-8
hashcode()：String类型已经重写过此方法，保证了同一个字符串在任何场景下哈希值是一致的。
java中char类型在存储到内存中的时候用的编码是utf-16，汉字占2个字节。
replace()：替换指定字符，只能替换具体字符
replaceAll()：替换所有符合规则的元素
split()：按照指定规则切分字符串
String str=“d4ag4ha64ha4hs2”;
String[] s=str.split("\d"); //指定规则：数字作为切割
System.out.println(Arrays.toString(s)); //[d, ag, ha, , ha, hs]
substring()：截取指定字符串。范围：包左不包右，包小不包大
trim()：去头尾处空白字符（中间空格无法去除），去掉空格、换行符、\t、\r、\n
valueof()：将参数转化成字符串显示。如果参数是对象，底层默认调用了tostring()，转化成对象的引用地址。字符数组例外。
Object o = new Object();
System.out.println(String.valueOf(o));//java.lang.Object@15db9742
System.out.println(o);//java.lang.Object@15db9742
char[] cs = {'a','b','c'};
System.out.println(String.valueOf(cs)); //abc
System.out.println(cs.toString()); //[C@15db9742
isEmpty()：判断字符串是否为空。字符串赋值为null，运行时报错空指针异常。
reverse()：使StringBuffer对象的值反转
正则表达式regex
regular expression
用于指定规则
JDK API里搜pattern
在正则表达式里.表示任意通配符，\.表示.
\\会被java转义为\，正则表达式又转义为
Pattern p = Pattern.compile("ab");//匹配规则包含字符a零个或多个，包含字符b一个
Matcher m = p.matcher(“aaaaab”);//添加要判断的字符串aaaaab
boolean b = m.matches();//判断结果为一个boolean值
正则表达式简短，使用次数少，可直接判断输出。
String str = “8531585285”;
// 匹配一个由数字组成的长度为5的字符串。d表示数字，{n} 表示这个字符恰好出现n次
System.out.println(str.matches("\d{5}"));
字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
Greedy 数量词
X? X，一次或一次也没有
X X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
Logical 运算符
XY X 后跟 Y
X|Y X 或 Y
(X) X，作为捕获组
一个字符最多匹配一个数量词。
正则表达式里不允许出现空格，空格也表示匹配的字符。
范例1：字符替换
String str = “ks4sdlg3dkl0csbk2sbdk”;
System.out.println(str.replaceAll("\d", “”));// 将字符串中的所有的数字都去除掉
范例2：取消叠字
String str=“我我我我我爱爱学学编编编程程程”;
System.out.println(str.replaceAll("(.)\1+","$1" )); //我爱学编程
范例3：调整顺序
String str = “Cat Dog Pig Mouse Spider”;
System.out.println(str.replaceAll("(.)(Dog)(.)(Spider)", “$1$4$3$2”));
包装类package
针对每一种基本类型都提供了对应的类形式——包装类。
byte short int long float double char boolean void
Byte Short Integer Long Float Double Character Boolean Void
Void 类是一个不可实例化的占位符类，它表示对 Java 关键字 void 的 Class 对象的引用。
自动封箱、拆箱是JDK 1.5特性之一。
利用基本类型的变量构建了引用类型的变量——此过程称为封箱操作。
int i=1;
Integer in=new Integer(i);
System.out.println(in);//输出1。底层重写了toString方法
将一个基本类型的变量之间赋值给对应的引用类型的对象——自动封箱
//对于自动封箱而言，底层实际上是调用了Integer中的valueOf方法
Integer it=i; //Integer it=Integer.valueOf(i);
将引用类型的对象之间赋值给了对应的基本类型的变量——自动拆箱
Integer ie=new Integer(5);
//在底层实际上调用了对象身上的Value方法
int i2=ie;//int i=in.intValue();
Double dd=new Double(3.1);
double d=dd;//double d=dd.doubleValue();
Boolean bo = new Boolean(true);
boolean b = bo; // boolean b = bo.booleanValue();
对应整数类型而言，在自动封箱的时候会有范围判断。
范围在-128~127时，返回的是数组的值。
Integer i3=-128;//底层调用了cache[]数组
Integer i4=-128;
System.out.println(i3i4);//输出true
超出此范围，返回一个新对象。
Integer i5=228;
Integer i6=228;
System.out.println(i5i6);//输出false
如果引用类型与基本类型进行计算，那么会进行自动拆箱操作。
int i7=8;
Integer i8=6;
System.out.println(i7+i8); //输出14
Integer类型会依次判断每一位是否是一个数字字符
Integer i9=new Integer(0x291);//0x291数值的十六进制写法
System.out.println(i9);//输出657
Integer i9=new Integer(“0x291”);//添加双引号变成字符串，编译不报错，运行时报错
int i10=Integer.parseInt(“291”);//将字符串转换成int类型
System.out.println(i10);//输出291
double d1=Double.parseDouble(“2.91”);//将字符串转换成double类型
System.out.println(d1);//输出2.91
编译报错 char c=Character.parseChar(“65”);//此方法不适用与char类型
char c=“A”.charAt(0);//正确方法：调用String类的chartAt()方法
System.out.println©;//输出A
对于包装类而言，每一个对象的哈希码都是固定的，不随环境改变。
总结：字面量的哈希值是固定不变的。null的哈希值为0，也是固定的。
NaN跟任何东西不相等包括自己本身。
NaN获取方式①0.0/0 ②0/0.0 ③0.0/0.0
数学类Math
本身是一个最终类，只能执行基本的数学运算。
E——无限不循环小数：2.718281828459045
PI——圆周率π：3.141592653589793
Math.ceil(浮点数a) 向上取整， 获取大于或等于a的最小整数
Math.floor(浮点数a) 向下取整， 获取小于或等于a的最大整数
System.out.println(Math.ceil(3.1));//输出4.0
System.out.println(Math.floor(3.1));//输出3.0
Math.round(double a)四舍五入方法
System.out.println(Math.round(3.75));//输出4
Math.random()获取一个随机小数，每次运行得到的小数都不一样。
导包import java.util.Random;可以获取指定范围的随机整数。
Random random=new Random(); //生成Random对象
int a=random.nextInt(100); //得到0-100之间的随机正数
Math类也无法解决小数运算不精确的问题。
因为小数以二进制形式进行存储，转换过程出现精度损失。
strictfp只能修饰方法，表示方法在计算过程中，是以80位二进制进行，但最后的存储依然是64位二进制。
public strictfp static void main(String[] args) {}
利用BigDecimal类进行精确运算。
注意参数必须以字符串的形式传入，否认运算结果依旧不准确
原理：字符串的数组逐位运算，所以每一个运算都是以整数形式运行
BigDecimal b1=new BigDecimal(“3.13”); //若未加“”
BigDecimal b2=new BigDecimal(“4.10”);
//System.out.println(b1+b2); //编译报错，对象不能直接运算
System.out.println(b1.add(b2)); //调用加法运算，结果：7.23
System.out.println(b1.subtract(b2));//调用减法运算，结果：-0.97
BigInteger：表示任意大小的整数。要求以字符串的形式传入参数。
multiply()：求积
BigInteger b=new BigInteger(“13245665854234564343415346434133434”);
BigInteger bi=new BigInteger(“15435445643434797979777973311143434”);
System.out.println(b.multiply(bi));//求积，结果仍为大整数
日期类Date
导包import java.util.Date;
Date类下大部分方法已过时。
DateFormat：是日期/时间格式化子类的抽象类
SimpleDateFormat()：规范日期格式
parse()：字符串转日期
format()：日期转字符串
Date date=new Date();
System.out.println(date); //Wed Jun 20 14:28:27 CST 2018获取当前系统时间
String str=“2018-03-12 15:30:05”;
SimpleDateFormat s=new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);//规范解析格式
Date da=s.parse(str); //将String类型转换成Date对象
System.out.println(da);//Mon Mar 12 15:30:05 CST 2018
String st=s.format(date);//将指定Date转换成格式字符串输出
System.out.println(st);
String st=new SimpleDateFormat(“yyyy年MM月dd日”).format(da);
System.out.println(st);//2018年03月12日
通过System.currentTimeMillis()可以获取自1970.1.1零时到此时此刻的毫秒数。