Java基础类库（上）
Java提供了丰富的基础类库，Java 8提供了4000多个基础类，这些类可以帮我们降低开发难度，提高开发效率。但是这些基础类并不需要我们去背，我们只需要在平常的使用中去反复的查阅API文档，就可以记住大部分功能，下面介绍几个在Java中常用的基础类，来了解并学习基础类的使用方法。
Object类
Object类、枚举类、数组的父类，也就是说，Java允许把任何类型的对象赋给Object类型的变量。所有的类默认继承Object父类。下面简单介绍其中的几个方法：
boolen equals(Object o)
这个方法用来判断对象是否与该对象相等，相等的标准是地址值，而不是内容相等，所以没有太多实用价值，因此我们都一般重写此方法。
使用方法如下：
Object obj = new Object();
Object obj2 = new Object();
boolean b = obj.equals(obj2);
System.out.println(b);
我们再举一个例子Student类如果我我们采用equals来进行比较两个实例它会一直返回false，因为他比较的是其中的地址值比较，但是很显然这不是我们想要的结果，所以我们可以通过重写来达到我们想要的目的
public boolean equals(Object obj) {
if(obj==null){//判断对象是否为空
return false;
}
if(this==obj){
return true;
}
if(!(obj instanceof Student)){
return false;
}
//向下转型
Student stu= (Student) obj;
return this.age==stu.age&&this.name.equals(stu.name);
}
这样重写过后我们就可与通过调equals方法来实现对象的内容比较。
int hashCode()
返回对象的hashCode值，也就是对象的十六进制地址值转换成整型输出，底层通过哈希算法实现。
int cod1 = obj.hashCode();
int cod2 = obj2.hashCode();
System.out.println(cod1);
System.out.println(cod2);
String toString()f
返回对象的字符串表示，其实我们在使用System.out.print()方法输出一个对象时，或者将一个对象和字符串拼接时，系统就会默认调用toString方法返回该对象的字符串表示，Object类的toString()方法返回“类名@十六进制hashCode值”格式的字符串。使用方法如下：
Object obj = new Object();
String s = obj.toString();
System.out.println(s);
但是，你不觉的这个东西对你而言意义也不是很大吗？所以我们同样的也是会重写toString()方法来实现对于这个类的描述。
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
Class<?> getClass()
方法可以获取一个对象的类型类，然后在调用该类的方法可以获取该类的相关信息，比如父类的名字，该类的名字。
Object obj = new Object();
System.out.println(obj2.getClass());
Scanner类
Scanner类是一个基于正则表达式的文本扫描器，它可以从文件输入流、字符串中解析出基本类型值和字符串值。Scanner(InputStream source)构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。其中InputStream 代表输入流
in是其中System类的一个常量public static final InputStream in“标准”输入流。此流已打开并准备提供输入数据.
nextXxxx方法
这类方法一般是获取一个输入项，Xxx表示你所输入的类型。使用方法如下：
InputStream in = System.in;
Scanner scanner = new Scanner(in);
int a = scanner.nextInt();
double b = scanner.nextDouble();
String str = scanner.nextLine();
但是这里面还是字符串读取用nextLine有时还是有一些小BUG.
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数");
int num = sc.nextInt();
System.out.println("请输入一段字符串");
//当你录入整数,敲了一个回车换行,那么sc.nextLine()就会把回车换行当作字符串录入了
// String s = sc.nextLine();//录入字符串
String s = sc.next();//录入字符串,但是没有上面这种情况
System.out.println(s);
System.out.println(num)；
在默认情况下Scanner用空白作为输入分隔符。但是用户可以通过UseDelimiter自定义分隔符。
Scanner input = new Scanner(System.in);
sc.UseDelimiter(String pattern);//该方法的参数是一个正则表达式。
hasXxxx方法
这个方法的意思是是否含有下一个输入项返回值为bool类型，Xxxx可以是基本类型，但是如果是要判断包含下一个字符串，则直接使用hasNext();
使用方法如下：
boolean b = scanner.hasNextInt();//判断是否还有int型值输入
if(b){//如果有
int num = scanner.nextInt();//将int值保存在num中
}
String类
String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。例如：
String str = "abc";
等效于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
下面给出了一些如何使用字符串的更多示例：
System.out.println("abc");
String cde = "cde";
System.out.println("abc" + cde);
String c = "abc".substring(2,3);
String d = cde.substring(1, 2);
下面我们简单了解一下String的几种常用方法
构造方法
1.String()
初始化一个新创建的 String 对象，使其表示一个空字符序列。
这是String的一个无参的构造器。
String s = new String();//创建了一个对象,不过字符串的内容是个空串、
System.out.println(s.toString());
2.String( byte[] bytes)
通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
上面这句话是Java API文档中给出的解释，总的来讲他的做用就是将一个字节数组转化成字符串。比如：
byte[] bytes={98,99,100,101};
String s = new String(bytes)
3String( byte[] bytes, int index, int length)
把字节数组的一部分转成字符串(index:表示的是从第几个索引开始, length表示的是长度)
byte[] bytes={98,99,100,101};
String s = new String(bytes, 1, 2);
同过上面的转化我们就可以得到原数组从索引1——索引2处的转化后的字符串。
4.String( char[] value)
分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
同样的这个构造器的意思就是将一个字符数组转化为字符串。
char data[] = {'a', 'b', 'c'};
String str = new String(data);
5.String( char[] value, int index, int count)
分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
char data[] = {'a', 'b', 'c'};
String str = new String(data,1,2);
int length()
这个方法可能就已经很熟悉了，它的作用就是返回一个字符串的长度
String s = new String("abc");
System.out.println(s.length());//获取字符串的长度
String创建之后不可更改
我们刚刚提到过String创建后不可更改，但是，你有没有试过下面的操作。
String s = "Hello";
s = "Hi";
System.out.println(s) ；
编译并运行上面的程序，你会发现，它会输出Hi,那么这不就把s的值更改了吗？可是Java又说字符串是常量不可更改，这很矛盾吗？我们来通过一张图来看看，为什么？
也就是说你是将S的引用指向了常量池中的另一个对象但是并没有从实际上改变Hello的内容。所以输出才会是Hi。
6.String中equals和==的区别
==可以比较基本数据类型也可以用来比较引用数据类型，但是在比较引用数据类型时，是用其地址来作为比较条件的。
equals在Object类中也是同样的以地址作为相等条件来进行比较，但是在大多数类中，我们都是通过重写此方法来让它达到我们想要的结果也就是比较其中的内容，同样的String类中同样的重写了这个方法。
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2));//true
String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3 == s4);//false
System.out.println(s3.equals(s4));//true
String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);//true
System.out.println(s5.equals(s6));//true
从上面的结果我们就可以看出，String类中重写过后的equals方法可以实现我们想要的结果。
String类中的判断方法
接着我们来看看在String中的一些判断方法。
1.boolean equals (Object obj)
比较字符串的内容是否相同, 区分大小写
boolean b = "abc".equals("Abc");//b为false
2.public boolean equalsIgnoreCase (String str)
比较字符串中的内容不区分大小写
boolean b="abc".equalsIgnoreCase("ABC");//b为true
3.boolean contains (String str)
判断字符串中是否含有该子串
boolean b="abc".contains("ab")；
4.**boolean startsWith (String str) **
判断字符串是否以传递进来的字符串开头
boolean b="abc".startsWith("b")；
5.boolean endsWith (String str)
判断字符串是否以传递进来的字符串结尾
boolean b="abc". endsWith("a")；
6.boolean isEmpty ()
判断字符串的内容是否为空串 “”
boolean b="abc".isEmpty()；
。。。。
这类方法还有许多这里就不一一赘述了。
String中的获取方法
1.char charAt ( int index)
获取指定索引位置的字符
char ch = "String".charAt(1);
2.int indexOf ( int ch)
返回指定字符在此字符串中第一次出现处的索引。
int index = "String".indexOf('t');
3.int indexOf (String str)
返回指定字符串在此字符串中第一次出现处的索引。
int index = "String".indexOf("St");
4.int indexOf ( int ch, int fromIndex)
返回指定字符在此字符串中从指定位置后第一次出现处的索引。
int index = "String".indexOf('i',2);
5.int indexOf (String str,int fromIndex)
返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
int index = "String".indexOf("ing",2);
6.lastIndexOf方法
用法和上面的方法相同只不过返回的时最后一次出现的索引
String类截取方法
1.String substring ( int start)
从指定位置开始截取字符串, 默认到末尾。
String str = "acacascas".substring(6)
2.String substring ( int start, int end)
从指定位置开始到指定位置结束截取字符串。
String str = "acacascas".substring(3,6)
String类的遍历
说到遍历字符串我们想到最常用的方法就是用循环来遍历就像这样
String str="School;
for(int i=0;i<str.length();i++){
char ch= str.charAt(i);
System.out.println(ch);
}
String类的转换
1.byte[] getBytes ()
把字符串转换为字节数组。
2.char[] toCharArray ()
把字符串转换为字符数组。
3.String valueOf ( char[] chs)
把字符数组转成字符串。
4.String valueOf ( int i)
把int类型的数据转成字符串。
5.String toLowerCase ()
把字符串转成小写。
6.String toUpperCase ()
把字符串转成大写。
使用方法和其他的String方法使用类似这里就不再一一举例了。
String的替换
1.String replace(char old,char new)
将指定字符替换为其他字符
2.String replace(str old,str new)
将指定字符串替换为其他字符串
3.** String trim()**
去除字符串的两端空格。
String的比较
1.int compareTo(String anotherString)
比较两个字符串，返回ASCAL码差值
2.int compareToIgnoreCase(String str)
忽略大小写比较两个字符串，返回ASCAL码差值
StringBuffer类和StringBuilder类
StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。同样的StringBuffer类中也提供了很多方法，来方便我们使用。
StringBuilder一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
1.StringBuffer append( type variable_name)
追加任意类型的变量到StringBuffer的末尾。其中的参数可以是任意类型的数据
2.**StringBuffer insert(int offset, type variable_name) **
在指定位置插入内容
3.StringBuffer deleteCharAt(int index)
移除此序列指定位置的 char。
4.StringBuffer delete(int start, int end)
移除此序列的子字符串中的字符。
5.StringBuffer replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。
6.StringBuffer reverse()
将此字符序列用其反转形式取代。
除了以上方法外，String类中的大多方法同样适用于StringBuffer和StringBulider。
String和StringBuffer的转换
1.通过append方法实现
//String-----StringBuffer
String s="abc";
StringBuffer sb = new StringBuffer(s);
StringBuffer sb2 = new StringBuffer().append(s);
2.通过toString方法
//StringBuffer----String
StringBuffer sb3 = new StringBuffer("eee");
String s1 = sb3.toString();
System.out.println(s1);
3.通过substring方法
String s2 = sb3.substring(0);
System.out.println(s2);
4.通过字符串的构造方法把StringBuffer转换成String类型
String s3 = new String(sb3);
System.out.println(s3);