常用类

• Object类

Object类位于java.lang包中，java.lang包包含着Java最基础和核⼼的类，在编译时会⾃动导⼊
Object类是所有Java类的祖先,每个类都使⽤ Object 作为超类
 
# 常用方法
public final native Class<?> getClass()
    获取对象的运⾏时class对象，class对象就是描述对象所属类的对象, 类的对象可以获取这个类的基本信息，如名、包、字段、⽅法等（⽤于反射会⽐较多，以后有机会再了解）
public native int hashCode()
    获取对象的散列值，集合框架中应⽤，⽐如HashMap
public boolean equals(Object obj)
    ⽐较两个对象，如果这两个对象引⽤指向的是同⼀个对象，那么返回true，否则返回false集合框架中有讲
public String toString()
    ⽤于返回⼀个可代表对象的字符串，看源码可以得知，默认返回格式如下：对象的class名称 + @ + hashCode的⼗六进制字符串,所以前⾯课程写对象时候，需要重写这个⽅法，⽅便调试

• Math类

Java操作数学运算相关的类
构造函数被私有化，所以不允许创建对象
都是静态⽅法，使⽤是直接类名.⽅法名
 
# 常用api
//计算平⽅根
System.out.println(Math.sqrt(16));
 
//计算⽴⽅根
System.out.println(Math.cbrt(8));
 
//两个数的最⼤，⽀持int, long, float,double
System.out.println(Math.max(2.9,4.5));
System.out.println(Math.min(2.9,4.5));
 
//ceil向上取整，更⼤的值⽅向靠拢, 中⽂是天花板
System.out.println(Math.ceil(19.7));
System.out.println(Math.ceil(-20.1));
 
//floor向下取整，更⼩的值⽅向靠拢，中⽂是地板意思
System.out.println(Math.floor(19.7));
System.out.println(Math.floor(-20.1)); 
 
//随机数
System.out.println(Math.random()); //⼩于1⼤于0的double类型的数
 
//产⽣1到10的随机数，int⽅法进⾏转换它会去掉⼩数掉后⾯的数字即只获取整数部分,不是四舍五⼊
int random=(int)(Math.random()*10+1);

• String

字符串是对象，不是简单数据类型
封装在java.lang包，⾃动导⼊
 
# 字符串比较
== 是⽐较地址
内容是否相等需要⽤ equals()⽅法⽐较
 
# 常用api
String str = "adsfasdfas"
//获取字符串⻓度:
str.length();
 
//通过下标获取字符：
char char = str.charAt(5);
 
//字符串⽐较：
boolean result = str1.equals(str2);
 
//字符串⽐较忽略⼤⼩写
boolean result = str1.equals(str2);
 
//查找字符串出现的位置
int index = str.indexOf(".");
 
//字符串截取
String result1 = str.substring(index)；
String result2 = str.substring(index1, index2)；
 
//字符串拆分
String [] arr = str.split("\\.");
 
//字符串替换
str.replace("x","a");
 
//字符串⼤⼩写转换
str.toUpperCase();
str.toLowerCase();
 
//字符串去除空格
str1.trim();
 
# 类型转换
boolean bool = Boolean.getBoolean("false"); //字符串类型转换为布尔类型
int integer = Integer.parseInt("20"); //字符串类型转换为整形
long LongInt = Long.parseLong("1024"); //字符串类型转换为⻓整形
float f = Float.parseFloat("1.521"); //字符串类型转换为单精度浮点型
double d = Double.parseDouble("1.52123");//字符串类型转换为双精度浮点型

• StringBuilder 和 StringBuffer

StringBuilder 是一个可变的字符序列。它继承于AbstractStringBuilder，实现了CharSequence接口
StringBuffer 也是继承于AbstractStringBuilder的子类
StringBuilder和StringBuffer不同，前者是非线程安全的，后者是线程安全的

• 常用方法

private static void testInsertAPIs(){
    StringBuilder sbuilder = new StringBuilder();
    // 在位置0处插入字符数组
    sbuilder.insert(0, new char[]{'a', 'b', 'c', 'd', 'e'});
    // 在位置0处插入字符数组。0表示字符数组起始位置，3表示长度
    sbuilder.insert(0, new char[]{'A', 'B', 'C', 'D', 'E'}, 0, 3);
    // 在位置0处插入float
    sbuilder.insert(0, 1.414f);
    // 在位置0处插入double
    sbuilder.insert(0, 3.14159d);
    // 在位置0处插入boolean
    sbuilder.insert(0, true);
    // 在位置0处插入char
    sbuilder.insert(0, '\n');
    // 在位置0处插入int
    sbuilder.insert(0, 100);
    // 在位置0处插入long
    sbuilder.insert(0, 12345L);
    // 在位置0处插入StringBuilder对象
    sbuilder.insert(0, new StringBuilder("StringBuilder"));
    // 在位置0处插入StringBuilder对象。6表示被在位置0处插入对象的起始位置(包括)，13是结束位置(不包括)
    sbuilder.insert(0, new StringBuilder("STRINGBUILDER"), 6, 13);
    // 在位置0处插入StringBuffer对象
    sbuilder.insert(0, new StringBuffer("StringBuffer"));
    // 在位置0处插入StringBuffer对象。6表示被在位置0处插入对象的起始位置(包括)，12是结束位置(不包括)
    sbuilder.insert(0, new StringBuffer("STRINGBUFFER"), 6, 12);
    // 在位置0处插入String对象
    sbuilder.insert(0, "String");
    // 在位置0处插入String对象。1表示被在位置0处插入对象的起始位置(包括)，6是结束位置(不包括)
    sbuilder.insert(0, "0123456789", 1, 6);
    sbuilder.insert(0, '\n');
    // 在位置0处插入Object对象。此处以HashMap为例
    HashMap map = new HashMap();
    map.put("1", "one");
    map.put("2", "two");
    map.put("3", "three");
    sbuilder.insert(0, map);
    System.out.printf("%s\n\n", sbuilder);
}
 
private static void testAppendAPIs() {
    StringBuilder sbuilder = new StringBuilder();
    // 追加字符数组
    sbuilder.append(new char[]{'a','b','c','d','e'});
    // 追加字符数组。0表示字符数组起始位置，3表示长度
    sbuilder.append(new char[]{'A','B','C','D','E'}, 0, 3);
    // 追加float
    sbuilder.append(1.414f);
    // 追加double
    sbuilder.append(3.14159d);
    // 追加boolean
    sbuilder.append(true);
    // 追加char
    sbuilder.append('\n');
    // 追加int
    sbuilder.append(100);
    // 追加long
    sbuilder.append(12345L);
    // 追加StringBuilder对象
    sbuilder.append(new StringBuilder("StringBuilder"));
    // 追加StringBuilder对象。6表示被追加对象的起始位置(包括)，13是结束位置(不包括)
    sbuilder.append(new StringBuilder("STRINGBUILDER"), 6, 13);
    // 追加StringBuffer对象。
    sbuilder.append(new StringBuffer("StringBuffer"));
    // 追加StringBuffer对象。6表示被追加对象的起始位置(包括)，12是结束位置(不包括)
    sbuilder.append(new StringBuffer("STRINGBUFFER"), 6, 12);
    // 追加String对象。
    sbuilder.append("String");
    // 追加String对象。1表示被追加对象的起始位置(包括)，6是结束位置(不包括)
    sbuilder.append("0123456789", 1, 6);
    sbuilder.append('\n');
    // 追加Object对象。此处以HashMap为例
    HashMap map = new HashMap();
    map.put("1", "one");
    map.put("2", "two");
    map.put("3", "three");
    sbuilder.append(map);
    sbuilder.append('\n');
    // 追加unicode编码
    sbuilder.appendCodePoint(0x5b57); // 0x5b57是“字”的unicode编码
    sbuilder.appendCodePoint(0x7b26); // 0x7b26是“符”的unicode编码
    sbuilder.appendCodePoint(0x7f16); // 0x7f16是“编”的unicode编码
    sbuilder.appendCodePoint(0x7801); // 0x7801是“码”的unicode编码
    System.out.printf("%s\n\n", sbuilder);
}
 
private static void testReplaceAPIs() {
    StringBuilder sbuilder;
    sbuilder = new StringBuilder("0123456789");
    sbuilder.replace(0, 3, "ABCDE");
    System.out.printf("sbuilder=%s\n", sbuilder);
    sbuilder = new StringBuilder("0123456789");
    sbuilder.reverse();
    System.out.printf("sbuilder=%s\n", sbuilder);
    sbuilder = new StringBuilder("0123456789");
    sbuilder.setCharAt(0, 'M');
    System.out.printf("sbuilder=%s\n", sbuilder);
    System.out.println();
}
 
private static void testDeleteAPIs() {
    StringBuilder sbuilder = new StringBuilder("0123456789");
    // 删除位置0的字符，剩余字符是“123456789”
    sbuilder.deleteCharAt(0);
    // 删除位置3(包括)到位置6(不包括)之间的字符，剩余字符是“123789”
    sbuilder.delete(3,6);
    // 获取sb中从位置1开始的字符串
    String str1 = sbuilder.substring(1);
    // 获取sb中从位置3(包括)到位置5(不包括)之间的字符串
    String str2 = sbuilder.substring(3, 5);
    // 获取sb中从位置3(包括)到位置5(不包括)之间的字符串，获取的对象是CharSequence对象，此处转型为String
    String str3 = (String)sbuilder.subSequence(3, 5);
    System.out.printf("sbuilder=%s\nstr1=%s\nstr2=%s\nstr3=%s\n",
    sbuilder, str1, str2, str3);
}
 
private static void testIndexAPIs() {
    StringBuilder sbuilder = new StringBuilder("abcAbcABCabCaBcAbCaBCabc");
    System.out.printf("sbuilder=%s\n", sbuilder);
    // 1. 从前往后，找出"bc"第一次出现的位置
    System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\")",
    sbuilder.indexOf("bc"));
    // 2. 从位置5开始，从前往后，找出"bc"第一次出现的位置
    System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\", 5)",
    sbuilder.indexOf("bc", 5));
    // 3. 从后往前，找出"bc"第一次出现的位置
    System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\")",
    sbuilder.lastIndexOf("bc"));
    // 4. 从位置4开始，从后往前，找出"bc"第一次出现的位置
    System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\", 4)",
    sbuilder.lastIndexOf("bc", 4));
    System.out.println();
}
 
private static void testOtherAPIs() {
    StringBuilder sbuilder = new StringBuilder("0123456789");
    int cap = sbuilder.capacity();
    System.out.printf("cap=%d\n", cap);
    /**
     * capacity()返回的是字符串缓冲区的容量
     * StringBuffer( ); 分配16个字符的缓冲区
     * StringBuffer( int len ); 分配len个字符的缓冲区
     * StringBuffer( String s ); 除了按照s的大小分配空间外,再分配16个 字符的缓冲区
     * 你的StringBuffer是用字符构造的，"0123456789"的长度是10另外再分配16个字符，所以一共是26
     */
    char c = sbuilder.charAt(6);
    System.out.printf("c=%c\n", c);
    char[] carr = new char[4];
    sbuilder.getChars(3, 7, carr, 0);
    for (int i=0; i<carr.length; i++){
        System.out.printf("carr[%d]=%c ", i, carr[i]);
    }
    System.out.println();
}

• 执行速度比较：StringBuilder > StringBuffer > String

# String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中
无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的
# 而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下

• System类

位于java.lang包中，它是系统类，代表程序所在系统，提供了对应的⼀些系统属性信息和系统操作
final类型，构造函数被私有化
 
# 常用api
//输⼊输出包含三个成员变量，分别是in，out，err
System.out //常⽤调试
System.in //⽤于数据读取，少⽤
System.err //⽤在错误输出，少⽤
 
//获取系统当前毫秒值
System.currentTimeMillis()
 
//获取系统环境的属性
System.getProperties()
 
//根据指定key获取系统属性
System.getProperties(key)

• 基础数据类型对应的包装类型

# Java是⼀个⾯相对象的编程语⾔，但基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型
# 集合框架⾥⾯需要存储对象，不能存储基本数据类型，所以需要存储包装类型
 
基本类型　 包装器类型
boolean   Boolean
char      Character
int       Integer
byte      Byte
short     Short
long      Long
float     Float
double    Double
 
# 类型转换
int i1 = 0; 
Integer integer1 = new Integer(i);    // int转为Integer
Integer integer2 = new Integer(0); 
int i2 = integer2.intValue();    // Integer转为int
 
Boolean booleanObj1 = new Boolean(false);
boolean baseBool1 = booleanObj.booleanValue();    // Boolean转为boolean
 
boolean baseBool2 = false;
Boolean booleanObj2 = new Boolean(baseBool2);    // boolean转为Boolean

• 基本数据类型和包装数据类型区别

基本数据类型不⽤new, 包装类型需要使⽤new关键字来在堆中分配存储空间
存储⽅式及位置不同，基本类型是直接将变量值存储在栈中，包装类型是将对象放在堆中，然后通过引⽤来使⽤
初始值不同，基本类型的初始值如int为0，boolean为false，包装类型的初始值为null