String类的概述和使用(掌握)
(1)多个字符组成的一串数据。
其实它可以和字符数组进行相互转换。
(2)构造方法：
A:public String()
B:public String(byte[] bytes)
C:public String(byte[] bytes,int offset,int length)
D:public String(char[] value)
E:public String(char[] value,int offset,int count)
F:public String(String original)
下面的这一个虽然不是构造方法，但是结果也是一个字符串对象
G:String s = "hello";
(3)字符串的特点
A:字符串一旦被赋值，就不能改变。
注意：这里指的是字符串的内容不能改变，而不是引用不能改变。
B:字面值作为字符串对象和通过构造方法创建对象的不同
String s = new String("hello");和String s = "hello"的区别?
(4)字符串的面试题(看程序写结果)
A:==和equals()
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
B:字符串的拼接
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2);// false
System.out.println(s3.equals((s1 + s2)));// true
System.out.println(s3 == "hello" + "world");// 应该是true
System.out.println(s3.equals("hello" + "world"));// true
(5)字符串的功能
A:判断功能
boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
boolean contains(String str):判断大字符串中是否包含小字符串
boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
boolean isEmpty():判断字符串是否为空。
B:获取功能
int length():获取字符串的长度
char charAt(int index):返回字符串中给定索引处的字符
int indexOf(int ch):返回指定字符在此字符串中第一次出现的索引
int indexOf(String str):返回指定字符串在此字符串中第一次出现的索引
String substring(int start):截取字符串。返回从指定位置开始截取后的字符串。
String substring(int start,int end)截取字符串。返回从指定位置开始到指定位置
结束截取后的字符串。
lastIndexOf:最后一次出现的位置。
C:转换功能
byte[] getBytes():转为byte类型数组
char[] toCharArray()转为char类型数组
String toLowerCase()：把字符串变成小写
String toUpperCase():把字符串变成大写
String replace(char oldChar,char newChar)：用新的字符去替换指定的旧字符
String replace(String oldStr,String newStr)：用新的字符串去替换指定的
旧字符串
String[] split(String regex)：切割功能，注意正则表达式（以后讲）。
把字符串用“,”分割
String trim()：去除字符串两端空格
String是不可变的，因此上面的操作都是生成新的字符串对象子串，要用返回值去取
新的字符串。
---------------------------------------------------------
StringBuffer字符串缓冲区(掌握)
构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
特点：
1：可以对字符串内容进行修改。
2：是一个容器。
3：是可变长度的。
4：缓冲区中可以存储任意类型的数据。
5：最终需要变成字符串。
容器通常具备一些固定的方法：
1，添加。
StringBuffer append(data):在缓冲区中追加数据。追加到尾部。
StringBuffer insert(index,data):在指定位置插入数据。
2，删除。
StringBuffer delete(start,end);删除从start至end-1范围的元素
StringBuffer deleteCharAt(index);删除指定位置的元素
//sb.delete(0,sb.length());//清空缓冲区。
3，修改。
StringBuffer replace(start,end,string);将start至end-1替换成string
void setCharAt(index,char);替换指定位置的字符
void setLength(len);将原字符串置为指定长度的字符串
4，查找。（查不到返回-1）
int indexOf(string); 返回指定子字符串在此字符串中第一次出现处的索引。
int indexOf(string,int fromIndex);从指定位置开始查找字符串
int lastIndexOf(string); 返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(string,int fromIndex); 从指定的索引开始反向搜索
5，获取子串。
string substring(start); 返回start到结尾的子串
string substring(start,end); 返回start至end-1的子串
6，反转。
StringBuffer reverse();字符串反转
StringBuilder
JDK1.5出现StringBuiler；构造一个其中不带字符的字符串生成器，
初始容量为 16 个字符。
该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程
使用的时候（这种情况很普遍）。
方法和StringBuffer一样；
StringBuffer 和 StringBuilder 的区别：
StringBuffer线程安全。
StringBuilder线程不安全。
单线程操作，使用StringBuilder 效率高。
多线程操作，使用StringBuffer 安全。
//常用方法操作
StringBuilder sb = new StringBuilder("abcdefg");
sb.append("ak"); //abcdefgak
sb.insert(1,"et");//aetbcdefg
sb.deleteCharAt(2);//abdefg
sb.delete(2,4);//abefg
sb.setLength(4);//abcd
sb.setCharAt(0,'k');//kbcdefg
sb.replace(0,2,"hhhh");//hhhhcdefg
//想要使用缓冲区，先要建立对象。
StringBuffer sb = new StringBuffer();
sb.append(12).append("haha");//对象方法调用链。
String s = "abc"+4+'q';
s = new StringBuffer().append("abc").append(4).append('q').toString();
---------------------------------------------------------
包装类(掌握)
基本数据类型对象包装类：是按照面向对象思想将基本数据类型封装成了对象。
好处：
1：可以通过对象中的属性和行为操作基本数据。
2：可以实现基本数据类型和字符串之间的转换。
关键字 对应的类名
byte Byte
short Short paserShort(numstring);
int Integer 静态方法：parseInt(numstring)
long Long
float Float
double Double
char Character
Boolean Boolean
基本数据类型对象包装类：都有 XXX parseXXX 方法
只有一个类型没有parse方法：Character ；
Integer对象：
数字格式的字符串转成基本数据类型的方法：
1：将该字符串封装成了Integer对象，并调用对象的方法intValue();
2：使用Integer.parseInt(numstring):不用建立对象，直接类名调用；
将基本类型转成字符串的两种方式：
1：Integer中的静态方法 String toString(int);
2：int+"";
将一个十进制整数转成其他进制：
转成二进制：toBinaryString
转成八进制：toOctalString
转成十六进制：toHexString
toString(int num,int radix);
将其他进制转换十进制：
parseInt(string,radix); //将给定的数转成指定的基数进制；
在jdk1.5版本后，对基本数据类型对象包装类进行升级。
在升级中，使用基本数据类型对象包装类可以像使用基本数据类型一样，进行运算。
Integer i = new Integer(4); //1.5版本之前的写法；
Integer i = 4; //自动装箱，1.5版本后的写法；
i = i + 5;
//i对象是不能直接和5相加的，其实底层先将i转成int类型，在和5相加。
而转成int类型的操作是隐式的。自动拆箱：拆箱的原理就是i.intValue();
i+5运算完是一个int整数。如何赋值给引用类型i呢？其实有对结果进行装箱。
Integer c = 127;
Integer d = 127;
System.out.println(c = = d); //true
//在装箱时，如果数值在byte范围之内，那么数值相同，不会产生新的对象，也就是说多个数值
相同的引用指向的是同一个对象。
---------------------------------------------------------
时间数据类型(掌握)
Date/DateFormat
(1)Date是日期类，可以精确到毫秒。
A:构造方法
Date()
Date(long time)
B:成员方法
getTime()
setTime(long time)
C:日期和毫秒值的相互转换
案例：你来到这个世界多少天了?
(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，
所以使用其子类SimpleDateFormat
A:SimpleDateFormat(String pattern) 给定模式
yyyy年MM月dd日 HH:mm:ss”、“yyyy-MM-dd”。
B:日期和字符串的转换
a:Date -- String
format()
return new SimpleDateFormat(format).format(d);
b:String -- Date
parse()
return new SimpleDateFormat(format).parse(s);
C:案例：获取当前时间
Date now = new Date();
SimpleDateFormat date = new SimpleDateFormat("yyyy-MM-dd mm :ss");
String s = date.format(now);
制作了一个针对日期操作的工具类。
Calendar
(1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
(2)如何得到一个日历对象呢?
Calendar rightNow = Calendar.getInstance();
本质返回的是子类对象
(3)成员方法
A:根据日历字段得到对应的值
B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
C:设置日历对象的年月日
---------------------------------------------------------
异常(掌握)：
就是不正常。程序在运行时出现的不正常情况。其实就是程序中出现的问题。
这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问
题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些
信息进行封装。
异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。
出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。
而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，
问题出现的位置，所以可以不断的向上抽取。形成了异常体系。
--------java.lang.Throwable：
Throwable：可抛出的。
|--Error：错误，一般情况下，不编写针对性的代码进行处理，通常是jvm发生的，需要对程序进行修正。
|--Exception：异常，可以有针对性的处理方式
在开发时，如果定义功能时，发现该功能会出现一些问题，应该将问题在定义功能时标示出来，
这样调用者就可以在使用这个功能的时候，预先给出处理方式。
如何标示呢？通过throws关键字完成，
格式：throws 异常类名,异常类名... throw new IllegalArgumentException("....")
这样标示后，调用者，在使用该功能时，就必须要处理，否则编译失败。
处理方式有两种：1、捕捉；2、抛出。
对于捕捉：java有针对性的语句块进行处理。
try {
需要被检测的代码；
}
catch(异常类 变量名){
异常处理代码；
}
fianlly{
一定会执行的代码；
}
catch (Exception e) { //e用于接收try检测到的异常对象。
System.out.println("message:"+e.getMessage());//获取的是异常的信息。
System.out.println("toString:"+e.toString());//获取的是异常的名字+异常的信息。
e.printStackTrace();//打印异常在堆栈中信息；异常名称+异常信息+异常的位置。
}
异常处理原则：功能抛出几个异常，功能调用如果进行try处理，需要与之对应的
catch处理代码块，这样的处理有针对性，抛几个就处理几个。
特殊情况：try对应多个catch时，如果有父类的异常catch语句块，一定要放在下面。
throw 和throws关键字的区别：
throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。
throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。
通常情况：函数内容如果有throw，抛出异常对象，并没有进行处理，那么函数上一定
要声明，否则编译失败。但是也有特殊情况。
自定义异常的步骤：
1：定义一个子类继承Exception或RuntimeException，让该类具备可抛性。
2：通过throw 或者throws进行操作。
记住：finally很有用，主要用户关闭资源。无论是否发生异常，资源都必须进行关闭。
System.exit(0); //退出jvm，只有这种情况finally不执行,否则一定会执行内部语句体。
