javaSE学习笔记（四）常见类，基本数据类型包装类，StringBufferStringBuilder

三、面向对象

16.Object类

方法

==和equals()

17.String类

注意

构造方法

String的最大长度

String的底层存储结构

字符串的常量池机制

String类的方法

String类的判断功能

String类的获取功能

String类的转换功能

String类拼接

String类的其他功能

18.Math类

19.Random类

20.System类

垃圾回收机制

21.BigInteger类

22.BigDecimal类

23.Date类

24.Calendar类

25.SimpleDateFormat类

26.Arrays类

27.基本类型包装类

基本类型和包装类对应关系

Integer类为例

构造方法

String和int类型的相互转换

JDK5+自动装箱和拆箱

Integer的常量池机制

28.StringBuffer&StringBuilder

StringBuffer

StringBuffer和String的区别

构造方法

成员方法

StringBuffer初始长度和扩容机制

StringBuffer和String的相互转换

StringBuffer和StringBuilder

String，StringBuffer&StringBuilder的区别

三、面向对象

API：应用程序编程接口，学习jdk提供的类，就是学习这些类提供的功能

16.Object类

类层次结构的根类，所有类都直接或者间接的继承自该类

所以该类的非私有成员，所有的类都有

方法

public native int hashCode()

//返回该对象的哈希码值，默认情况下，该方法会根据对象的地址来计算(数字)，不同对象的hashCode()一般来说不会相同，同一个对象的hashCode()值肯定相同

public final Class getClass()

//返回此Object的运行时类，常用于反射场景，Class类是用来描述类的属性，可以通过Class类中的public String getName()，获取对象的真实类的全名称

public String toString()

//返回的是对象的类名@16进制哈希值，即getClass().getName() + "@" + Integer.toHexString(hashCode()) ，这没什么意义，所以一般都会重写toString()

equals()

//指示其他某个对象是否与此对象相等，默认比较的是地址值，显然没什么意义，因此通常都会重写

==和equals()

==是一个比较运算符号

既可以比较基本数据类型，也可以比较引用数据类型

基本数据类型比较的是值，引用数据类型比较的是地址值

equals方法是一个方法

只能比较引用数据类型

如果没有重写Object类中的equals方法，equals()和==比较引用数据类型无区别

17.String类

注意

String类不能被继承，public final class String extends Object

字符串本身是常量

String str = "abc";
str = "def";		//此时，"abc"仍然是"abc"，并没有改变，但是变成了无用的垃圾，是将"def"赋值	给了引用型变量str
"abc"是常量，一旦生成，值无法改变
str是String类型的引用型变量，它的值，即指向的地址，可以改变

构造方法

public String()

public String(byte[] bytes)，将字节数组转为字符串,字节数组存的是byte类型，如97，转为a（根据平台默认字符集解码）

public String(byte[] bytes, int index, int length)，字节数组一部分转为字符串，index从0开始，第三个参数是长度--与获取子串的方法区分

public String(char[] value)，字符数组转为字符串

public String(char[] value, int index, int count)，字符数组一部分转为字符串，index从0开始，第三个参数是字符数量

public String(String str)，字符串常量转为字符串对象

char data[] = {'a','b'}; String str = new String(data) 相当于 String str = "ab"

String的最大长度

字符串的内容是由一个字符数组 char[] 来存储的，长度是int，理论上int的范围是2^31 -1

常量池规定length为u2，即两个字节，因此范围就变为了2^16- 1 = 65535

JVM限制范围为65534

String的底层存储结构

jdk8：char[]

jdk9：byte[]，优化的原因：char是两字节，很多情况下一个字符只需要一个字节，比如字母，使用char浪费空间

字符串的常量池机制

字符串常量池：如果池子中没有该字符串就创建，池子中有就用已有的，不再创建

String str1 = "abc";	//在常量池中创建"abc"
String str2 = "abc";	//直接指向常量池中的"abc"
sop(str1 == str2);		//true	比较的是地址，相同
sop(str1.equals(str2));	//true	String类的equals()重写了，比较的是值

String str1 = "abc";	//在常量池中创建"abc"
String str2 = new String("abc");	//堆中new一个String对象，对象获取了常量池中的"abc"的副本
sop(str1 == str2);		//false	比较的是地址，不同，一个指向常量池，一个指向堆
sop(str1.equals(str2));	//true	String类的equals()重写了，比较的是值

String str1 = "abc";
String str2 = "a" + "b" + "c";
sop(str1 == str2);		//true	java常量优化机制，编译时会自动优化处理常量
sop(str1.equals(str2));	//true

String str1 = "ab";
String str2 = "abc";
String str3 = str1 +  "c";
sop(str3 == str2);		//false
sop(str3.equals(str2));	//true
String之间用+号串联是通过StringBuilder或StringBuffer类和append()方法+toString()方法实现的
所以这一步实际上所以相当于生成了一个StringBuffer对象，一个String 对象--堆内存，所以是false

String类的方法

String类的判断功能

equals() 判断值是否相等

equalsIgnoreCase() 忽略大小写判断值是否相等

contains() 判断大字符串是否包含小字符串

startsWith() 判断是否以某字符串开头

endsWith() 判断是否以某字符串结尾

isEmpty() 判断是否为空

String类的获取功能

int length() 获取长度

char charAt(int index) 获取index处的字符

int indexOf(int ch) ch第一次出现的索引

int indexOf(String str) str第一次出现的索引

int indexOf(int ch, int fromIndex) ch从指定位置开始第一次出现的索引

int indexOf(String str, int fromIndex) strch从指定位置开始第一次出现的索引

lastIndexOf()类似，从后往前检索（最后一次出现的索引）

String subString(int start)

String subString(int start, int end) //左闭右开区间

String类的转换功能

byte[] getBytes() //字符串转为字节数组，根据平台的编码集，GBK码表1个中文2个字节，特点：第一个字节肯定是负数

char[] toCharArray() //字符串转字符数组

static String valueOf(char[] chs) //字符数组转为字符串

注意：

String类的valueOf()可以将任意类型数据转为字符串，对象也可以，输出的是调用toString()方法的结果

同样的，其他类型转为String也有类似的方法

byte : Byte.parseByte(String s) : 将 s 转换成 byte

double : Double.parseDouble(String s) : 将 s 转换成 double

String类拼接

concat()

String类的其他功能

String replace(char/String old, new) //替换

trim() //去除两端空格

int compareTo(String str) //按位字典顺序比较，输出按码表值作差的值，相同的是0，长短不一致的，空格算作0

int compareToIgnoreCase(String str) //忽略大小写

18.Math类

用于执行基本数学运算，如初等指数、对数、平方根和三角函数，成员全部是静态的，所以构造方法私有

public static int abs(int a) //绝对值

public static double ceil(double a) //向大取整

public static double floor(double a) //向小取整

public static int max(int a,int b) //取大

public static double pow(double a,double b)//a的b次幂

public static double random() //0.0-1.0之间的随机小数（左闭右开）

public static int round(float a) //四舍五入

public static double sqrt(double a) //开平方

public static double random() //获取随机数，返回带正号的 double 值，该值大于等于 0.0 且小于 1.0

int number = (int)(Math.random()*100)+1; //获取一个1-100之间的随机数

19.Random类

用于产生随机数，产生的随机数由入参（种子）决定，如果用相同的种子创建两个 Random 实例，那么每次重新运行程序生成随机数，都会生成相同的一连串随机数

构造方法

public Random()

public Random(long seed)

成员方法

public int nextInt()

public int nextInt(int n) //给定上限，生成0到n之间的随机数（左闭右开）

20.System类

包含一些有用的类字段和方法，它不能被实例化

成员方法

public static void gc() //运行垃圾回收器

public static void exit(int status) //终止运行java虚拟机

public static long currentTimeMillis() //获取当前时间与1970.1.1之间的时间差（毫秒值），可以通过首尾获取两次currentTimeMillis()做差得到程序运行的时间

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) //将src数组中srcPos开始的length长度复制到dest数组的destPos起始位置

垃圾回收机制

垃圾回收机制很复杂，此处只是简单描述垃圾回收的一些特点

1.无法人为控制，随机事件对随机垃圾对象进行回收

2.判断对象为垃圾的标准，没有任何引用（关联）

3.垃圾对象在被回收前会运行object类继承来的finalize()来解放内存以外的系统资源，此时垃圾对象会复苏，产生异常，但是虚拟机会进行忽略

4.触发主GC的条件，如何避免（核心是减少内存中的垃圾对象）

1.不要显式System.gc()，虽然是建议，但一般都会运行

2.循环中使用StringBuffer而不是直接操作String，减少内存中的对象

3.能使用基本类型就不用包装类，减少内存中的对象

21.BigInteger类

可以让超过Integer范围内的数据进行运算

构造方法

public BigInteger(String val)

成员方法

public BigInteger add(BigInteger val) +

public BigInteger subtract(BigInteger val) -

public BigInteger multiply(BigInteger val) *

public BigInteger divide(BigInteger val) /

public BigInteger[] divideAndRemainder(BigInteger val) //数组中存商和模（余数）

22.BigDecimal类

由于在运算的时候，float类型和double很容易丢失精度，为了能精确的表示、计算浮点数，Java提供了BigDecimal

BigDecimal表示不可变的、任意精度的有符号十进制数

构造方法

public BigDecimal(String val)

成员方法

public BigDecimal add(BigDecimal augend)

public BigDecimal subtract(BigDecimal subtrahend)

public BigDecimal multiply(BigDecimal multiplicand)

public BigDecimal divide(BigDecimal divisor)

23.Date类

表示特定的瞬间，精确到毫秒

构造方法

public Date() //当前时刻

public Date(long date) //传参date意味着从标准时间（1970.1.1）以来指定date毫秒数的时刻，但要注意电脑本机设置的区时，比如传参0，对于东八区，显示的是8点

成员方法

public long getTime() //获取该时间对象对应的毫秒值（System.currentTimeMillis()）

public void setTime(long time) //给对象设置毫秒值（距1970）

24.Calendar类

日历类，是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法

成员方法

public static Calendar getInstance() //获取默认的日历子类，当前时刻

public int get(int field) //传入对应字段，获取对应字段值

public void add(int field,int amount) //对指定字段进行加减操作

public final void set(int year,int month,int date) //设置指定字段的值或者默认顺序设置

25.SimpleDateFormat类

日期/时间格式化的抽象类，实现日期和字符串的相互转换

DateFormat是抽象类，所以使用其子类SimpleDateFormat

构造方法

public SimpleDateFormat()

public SimpleDateFormat(String pattern)

成员方法

public final String format(Date date)

public Date parse(String source)

自定义格式化

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); sdf.format(new Date());

pattern的写法

26.Arrays类

针对数组进行操作的工具类，提供了排序，查找等功能

成员方法

public static String toString(int[] a) //转字符串

public static void sort(int[] a) //排序

public static int binarySearch(int[] a,int key) //二分查找

public static List asList(T... a)

返回对象是一个Arrays内部类，并没有实现集合的修改方法，Arrays.asList 体现的是适配器模式

因为集合中只能存引用型，所以，对于存储非引用型元素的数组，会将整个数组作为一个引用型变量转为集合

27.基本类型包装类

作用：将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用操作：用于基本数据类型与字符串之间的转换

基本类型和包装类对应关系

byte 	Byte
short	Short
int	    Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer类为例

Integer 类在对象中包装了一个基本类型 int 的值

构造方法

public Integer(int value)

public Integer(String s) //这里的String，只能是数字字符串，不能是"abc"之类的字符串

String和int类型的相互转换

int->String

public static String valueOf(int i) //String类提供

public static String toString(int i) //Integer类提供

String->int

public static int parseInt(String s) //Integer类提供，基本数据类型包装类中，只有char类型没有parseInt(String str)方法，char类型显然不能有这样的方法，只能有通过str.toCharArray()将字符串转为字符数组

Integer->int

intValue()

JDK5+自动装箱和拆箱

自动装箱：把基本类型转换为包装类类型，不再需要显式使用构造方法

自动拆箱：把包装类类型转换为基本类型，不再需要显式使用intValue()

这样一来，在执行运算时，Integer和int就没有任何区别了

注意事项：

1.在运算时，要保证Integer不为null

2.Integer / Integer，两个Integer类型相除，结果还是整数，不会是小数

Integer的常量池机制

-128--127是byte的取值范围，在这个范围内自动装箱不会新创建对象，而是从常量池内获取，因此这个范围内，自动装箱的对象Integer可以直接用==比较大小，相同大小获取的是同一个对象

但是超过这个范围，直接使用==比较大小，就一定会返回false，因为拿到的不是同一个对象，因此应该使用equals()比较，包装类已经重写了equals()，比较的是值，而不是地址

Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
System.out.println("-----------");
//手动装箱，一定新建对象
//fasle
//true

Integer i3 = new Integer(197);
Integer i4 = new Integer(197);
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));
System.out.println("-----------");
//false
//true

Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5 == i6);
System.out.println(i5.equals(i6));
System.out.println("-----------");
//自动装箱，-128--127之间，同样大小不会新建对象
//true
//true

Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);
System.out.println(i7.equals(i8));