常用API

1.javaAPI

JDK中包含大量的API类库，API就是一些已经写好，可直接调用的功能
经常使用的API有：字符串操作、集合操作、文件操作、输入输出操作、网络操作
、多线程等
JDK中经常使用的包有：
java.lang java程序基础类，如字符串，多线程等，不需要import，直接使用
java.util 常用工具类，如集合、随机数产生、日历、时钟等
java.io 文件操作、输入输出操作
java.net 网络操作
java.math 数学相关操作
java.security 安全相关操作
java.sql 数据库访问
java.test 处理文字、日期、数字、信息格式

2.文档注释

以/**开头，以*/结尾
通常在类和方法上面，说明坐着的时间、版本、要实现的功能的详细描述等信息；
用法：
通过javadoc视图查看
将整个项目的api文档导出

3.String

String是不可变的对象，本质是字符数组
String对象的创建---两种方式
1.String str=new String("a");
2.String str="a";
java为了提高性能，将创建出的字符串直接量保存在常量池中。特点：在
创建字符串直接量对象时，先去常量池中找是否有相同内容的对象是否存在，
存在的话直接引用，没有则在堆中创建一份，常量池中保存引用指向堆中的
对象；
常量池中的目的：为了实现字符串对象的重用
注意点：
1.在jdk1.7之前，常量池存放在方法区中，之后存放在堆中
原因：堆中大小随意分配，可以用gc回收
2.常量池中保存的其实是对象的引用
常用方法：
构造方法
方法：
length()返回String字符串长度
indexOf（）查找字符串出现的内容下标
注意若没有对应的内容，返回-1；
indexOf(String str，int fromIndex) 从指定位置开始
查找下一次出现的下标
substring() 截取内容
trim（）去除字符串两边的空格
charAt（int） 返回指定位置的char字符
stratsWith()  字符串是否已指定字符开始
endsWith() 字符串是否已指定字符结尾
toUpperCase() 将字符串大写
toLowerCase()  将字符串小写
valueOf()  得到其他类型的字符串表示
intern() 返回字符串池中的地址
注意：若池中没有String对象，则在堆中创建一个引用
指向堆中的对象

4.StringBuilder

StringBuilder提供了一个可变的字符数组，所以字符串内容的修改都是
在这个数组中进行的，不会每次都创建一个新对象
1.构造方法
StringBuilder（String str）
2.方法
append（String str）字符串拼接，接在原字符串后面
toString（）字符串生成后将其转换为String类型
String s7=s1+s2//底层用StringBuilder拼接完成
insert（int destOffset，String str）在指定位置插入字符串
delete（int start，int end）删除【start到end）位置的字符串，包头不包尾
replace（int start，int end，String str）str替换【strat~end）位置字符串
包头不包尾
reverse（）将内容反转
3.注意点：
StringBuilder的很多方法返回值均为StringBuilder类型。
这些方法返回语句均为：return this
java的字符串连接过程是利用StringBuilder实现的

StringBuffer和StringBuilder区别
StringBuffer是线程安全的，性能低         多线程程序使用
StringBuilder是非线程安全的，性能高 单线程程序使用

5.日期操作

5.1Date
构造方法：
Date（）：创建Date对象指向此时此刻
Date（long date）：创建Date对象指向给定long值指向的时刻
方法：
getTime（Date date）获取Date对象指定的毫秒值
setTime（long date）给定long值指向的Date
5.2simpleDateFormat：父类是抽象类DateFormat类
日期转换类：完成Date类型与String类型间的转换
构造方法：
SimpleDateFormat(String pattern) pattern是格式
方法：
format（Date）-String 将Date对象格式化成字符串
parse（String）-Date  将日期字符串转化为Date对象

5.3Calendar类：抽象类
对象的创建有两种方式：
1.创建实现类对象
Calendar cal = new GregorianCalendar;创建格里高利历（阳历）子类对象
2.调用静态方法
getInstance()-会根据系统当前时区来创建子类对象（可能会创建当地历法对象）
，但是创建的一般都是GregorianGalendar对象
Calendar类中定义了一些日历字段
static  int  YEAR  指示年份的字段数字
static  int   MONTH 指示月份的字段数字（0-11）调用时需要加1
static  int   DATE  指示一个月份中的第几天
static  int   DAY_OF_WEEK  指示一个星期中的某天，1为星期日
方法：
get方法：
get（int filed）获得对应的（年，月，日）值
getTime（）返回Date对象
getTimeMills（）返回对应的毫秒值
set方法：
set(int filed, int value) 设置对应字段（年，月，日）的值
setTime（Date date）让Calendar对象给定的Date对象指向的时间
add（int filed,int amount）增加或减少对应字段的值（cmount正数代表加负数减）

getActualMaximum(int filed) 通常用于获取月份对应的最大天数

6.Objcet类

在java类继承结构中，java.lang.Object类位于顶端；
如果定义一个java类时没有使用extends关键字声明父类，则父类默认位Object类
Object类型的引用变量可以指向任何类型变量。

方法：
equals()
在Object类中，这个方法判断两个对象是否具有相同的引用，即是否为相同的对象
==
String类中对equals（）方法进行了重写：比较两字符串内容是否相等
在实际应用中，一般需要重写改方法，通过比较对象的成员属性，使该方法
更有意义，建议重写。

hashcode（）：返回一个哈希值（散列值），是一个整数，十进制数

toString（）：返回字符串对象表示
字符串表示：类名全称@哈希码值（散列值（hex）），16进制
直接输出对象的引用，默认会调用toString（），如果本类中没有toString（），
那么调用父类中Object中的toString（）
通常建议重写toString（）
强烈建议为自定义的每一个类增加toString（）方法，它是非常有用的调试工具
格式大多数遵循“类的名字[ 属性值=值 ]”
java提供的API几乎都重写了toString（）

7基本数据类型的包装类

基本类型 包装类型 父类
int java.lang.Integer java.lang.Number
long java.lang.Long java.lang.Number
double java.lang.Double java.lang.Number
short java.lang.Short java.lang.Number
float java.lang.Float java.lang.Number
byte java.lang.Byte java.lang.Number
char java.lang.Character java.lang.Object
boolean java.lang.Boolean java.lang.Object

7.1 Number类
抽象类Number是Byte，Short，Integer，Long，Float，Double的父类

7.2 Integer类的常用用法
1.static parseInt(String)-int  将String类型数值转换成int类型
2.toString（）-String 将Integer值转换成String
static toString(int i) -将int转换成String
3.static valueOf(int i) -Integer 将一个基本数据类型包装成一个包装类型
4.intValue() -int 从Integer对象中得到int值
其他包装类用法类似
7.3自动装箱和拆箱
装箱：基本类型转换成包装类型  Integer i = 1；
拆箱：包装类型转换成基本类型 int j = i；
在jdk1.50后加入了 autoboxing功能
自动“拆箱”和“装箱”是依靠编译器在编译期的“预处理”优化工作
包装类在进行运算时进行自动拆装箱。

8.正则表达式

正则表达式是一串特定字符，组成一个“规则字符串”是描述文本规则的工具
。正则表达式就是记录文本规则的代码。正则表达式最终是一个字符串。
数量词：
X? 0或1个X
X* 0或多个X
X+ 1或多个X
X{n} n个X
X{n，} n到任意多个X（大于等于）
X{n，m} n到m个X
预定义字符集：
注意使用预定义字符时要加\(转义字符)
如：\\d
. 任意一个字符
\d 任意一个数字字符，相当于[0-9]
\w 单词字符，相当于[a-zA-Z0-9]
\s 空白字符，相当于[\t\n\r]
\D 非数字字符
\W 非单词字符
\S 非空白字符
分组（）
（）圆括号表示分组，可以将一系列正则表达式看做一个整体
例如：条件一与条件二 必须为（条件一|条件二）当成一个整体
边界匹配
^匹配开始，$匹配结束
String regex = "\\d{32}";
案例：匹配8-10个\w 两种写法的区别
String regex = "\\w{8,10}";部分符合regex就行
String regex = "^\\w{8,10}$"整体与regex一致
注意点：
java的String类中的方法自带边界匹配符
String API：
str.matches(String regex)-boolean  若字符串str与正则表达式regex
匹配，返回true，否则返回false
str.split(String regex) -String[]  对一个字符串进行分割，
分隔符为regex
str.replaceAll(String regex, String replacement)-String
对一个字符串的所有符合regex的部分进行替换
，可用于铭感词过滤
如何在正则表达式中表示中文：\u4e00-\u9fa5  Unicode编码

9.集合

9.1 Collection
Collection是一个接口，定义了集合相关的操作方法，其有
两个子接口：
List：可重复集合
Set： 不可重复集合
注意点：
集合中储存的都是引用类型元素，并且集合只保存
每个元素对应的引用，而非将元素本身存入集合。
创建集合，向集合中保存数据
Collection col = new ArrayList();
API:
add(Object obj): -boolean
Collection定义了一个add方法用于向集合中添加新元素。
该方法将给定的元素添加进集合，若添加成功则返回true，
否则返回false
集合中保存的都是引用数据类型
基本类型会自动包装成包装类型存入集合中
size（）：获取集合长度
contains(Object obj)-boolean
该方法会用于判断给定的元素是否被包含在集合中
判断方式：
这里需要注意的是，集合判断元素是否被包含在集合中
是根据每个元素的equals（）方法比较后的结果
通常有必要重写equals方法来保证合理结果
clear():移除此集合中的全部元素
isEmpty():判断集合是否为空
addAll（）：将一个集合添加进去，成功返回true，失败false
containsAll（）：判断当前集合是否包含给定集合
9.2.泛型：
泛型是java5.0引入的特性，泛型本质是参数化类型。在类、接口方法
定义过程中，所操作的数据类型被传入的参数指定。
注意点：
1.泛型机制在运行期是无效的
2.jdk1.7后创建对象可以只在引用添加泛型


9.3 迭代器
迭代器用于遍历集合元素，获取迭代器可以使用Collection定义的方法：
iterator（）
迭代器Iterator是一个接口，集合在重写Collection的iterator（）方法
利用内部类提供了迭代器的实现。
遍历方式：
hasNext（）判断是否有下一个元素
next（） 返回下一个元素
remove（） 删除元素
注意：
在使用迭代器遍历集合时，不能通过集合的remove删除集合元素
，否则会抛出并发更改异常。我们可以通过迭代器自身的remove方法
来删除next（）迭代出的元素
forEach循环：增强循环
for（引用类型 引用：集合/数组）{

}

10.集合操作 --线性表

Collection接口下的子接口：
学习的：
List：可重复集合
Set：不可重复集合
10.1 List
List接口是Collection的子接口，用于定义线性表结构。可以将List
理解为存放对象的数组，只不过其元素可以动态的增加或减少
List接口两个常见的实现类为ArrayList和LinkedList，分别用动态
数组和链表方式实现了List接口。

ArrayList和LinkedList两者数据结构：
ArrayList：采用动态数组结构
优点：查询性能高
通常用于查询操作
LinkedList：采用的是双向循环链表结构
优点：插入和删除元素效率高
缺点：查询性能低
通常用于对集合的增删操作

可以认为这两种结构的方法逻辑上一样，性能要求不是特别苛刻下
可以忽略这种区别
API:
get(int index):获取集合中指定下标对应的元素
set（int index，E elment）：将给定元素存入给定位置，并
将原位置的元素返回
插入和删除：
void add（int index，E elment）：
将给定的元素插入指定位置，原位置元素和后续后移
remove（int index）：
删除给定位置元素，并将删除元素返回。
List转换为数组：
List的toArray方法用于将集合转换为数组。实际上是在Collection
中定义的
有两种方法：
toArray（）-Object[] 返回Object数组
toArray（T[] a）-T[] 这种方法常用，我们可以传入一个
指定类型数组（创建一个数组），该数组的元素类型与集合
元素一致。
数组转换成List：
Arrays提供一个静态方法asList（T[] a）-List
注意该List不能增删，会报异常
修改该List数组元素也会改变
10.2List排序
Collections 是集合的工具类，它提供了很多便于我们操作集合的
方法，其中就有用于集合排序的sort方法
该方法定义为：void sort(List<T> list)
该方法的作用是对给定集合进行自然排序。
sort（List）对给定集合进行自然排序，排序规则是定义在集合元素
中对象的所属类中
即：如果想对一个集合调用sort方法排序，前提：
集合中的元素所属类必须实现Comparable接口，重写其中的
compareTo（Object），在此方法中定义比较规则。

Comparable：
collections的sort方法是对集合元素进行自然排序，那么两个
对象之间就一定一定要有大小之分。这个大小之分是如何界定的？
实际上，在使用Collections的sort排序的集合元素都必须是Comparable
接口的实现类，该接口表水其子类是可比较的，因为实现该接口必须重写抽象方法
- int compareTo(T t);
该方法使用于使当前对象与给定对象进行比较。
若当前对象大与给定对象，那么返回大于0的整数
若小于给定对象，那么返回值因为小于0的整数
若等于给定对象，那么返回0

Comparator：
1.一旦java类实现了Complarable接口，其比较逻辑就已经确定；
如果希望在排序操作中临时指定比较规则，可以采用Comparator
接口的方式。
2.Comparator接口要求必须重写其定义的方法：int compare（T o1，T o2）
对集合使用临时的规则进行排序，比较器写好后，调用
-Collections.sort(List<T>,Comparator<T>)
10.3 Set接口
元素不可重复
添加元素时，调用集合中元素的equals方法
实现类：HashSet  元素间是没有顺序的
注意HashSet其实是HashMap中的Key
TreeSet  红黑树自动排序
API：与List一致

11.队列和栈:容器

数据结构:存储数据
LinkedList，此类实现了Queue接口
    Queue：
       java.util.Queue
队列,可以存储一组元素,但是存取元素必须遵循
先进先出原则(FIFO,First Input First Output)
队列（Queue）是常用的数据结构，可以将队列看成特殊的线性表，
队列限制了对线性表的访问方式：只能从线性表的一端添加（offer）
元素，从另一端取出（poll）元素。
队列遵循先进先出（FIFO First Input First Output ）的原则。
JDK中提供了Queue接口，同时使得LinkedList实现了该接口.
（LinkedList实现Queue的原因在于Queue经常要进行添加和删除
的操作，而LinkedList在这方面效率较高）。     
       方法：
Offer(E e):将一个对象添加至队尾，如果添加成功则返回true。
           poll(): 从队首删除并返回一个元素。
           peek():返回队首的元素（但并不删除）。
Deque:
Deque是Queue的子接口，定义了所谓“双端队列”即从队列的两端分别
可以入队（offer）和出队（poll），LinkedList实现了该接口。
Queue,Deque,LinkedList之间的关系:
class LinkedList implements Deque
interface Deque extends Queue
 
方法：
Offer(E e) 默认从队尾入队
offerFirst(E e) 从队首入队
offerLast(E e) 从队尾入队
poll() 默认队首出队
pollFirst() 队首出队
        pollLast() 队尾出队
注意点:
在Deque,Queue中,如果队列中没有元素,调用poll()或peek()返回null
Stack：栈
如果将Deque限制为只能从一端入队和出队，则可实现“栈”（Stack）
的数据结构，对于栈而言，入栈称之为push，出栈称之为pop。
栈遵循先进后出（FILO First Input Last Output ）的原则。
API:
push(E e) 将元素压入栈顶，输出与压入的顺序相反
pop（）从栈顶弹出元素
数据结构：
双向循环链表，队列，双端队列，栈

12. 查找表：

12.1 Map接口
Map接口定义的集合又称查找表，用于存储所谓“Key-Value”映射对。Key可以
看做是Value的索引，作为Key的对象在集合中不可以重复。
根据内部数据结构的不同，Map接口有多种实现类，其中常用的内部
为Hash表实现的HashMap和内部为排序红黑树实现的TreeMap。
具有映射关系的数据：
颜值 90
实力 90
Key——Value
Map接口中定义的方法：
put（K key，V value）：向集合中存入元素。
get（K key）-V 获取对应Key的Value
containsKey(Object key):判读某个key是否在Map中存在
12.2 HashMap
hashCode（）：
Object类中的hashCode方法：返回与该对象所在内存地址相关的
整数，如果两个对象equals相等，那么得到的hasCode值相等，
但是这两个对象的hashCode值相等，这两个对象不一定是equals相等
即hashCode值不是唯一的
hashCode方法有范围，越过范围再去范围内其他值
HashMap数据结构的实现：
1.HashMap内部由数组实现，是当今查询速度最快的数据结构。
key》hashCode（）》code》散列算法》int（值为元素在数组位置）
HashMap根据key元素决定这组键值对应存放的数组位置，并且也是根据
key元素得到的位置来检索数组中组键值，对此省去了遍历数组的过程
使用HashMap时数据结构中可能会产生链表
产生原因：
HashMap是根据Key元素的hashCode方法返回值经过散列计算得到因
存放数组位置，而当Key出现hashCode值相等但是equals不相等情况出
现时，则会在数组的当前位置产生链表。这样将来根据Key检索时会出现
遍历链表的情况，这样就会出现HashMap查询性能降低！！！！
如何避免出现链表？
重写hashCode和equals方法
12.3 Map的遍历
keySet（）-Set<K>得到Map集合中所有Key值的Set集合
entrySet（）-Set<Entey<K,V>> 得到Map集合所有key-Value的Entry<K,V>
的Set集合
注意：
需要建立一个Set集合引用来接收keySet
Set<Key> set = map.keySet()
建立一个Set<Entry<K,V>>引用来接收entrySet（）
Set<Entry<Key,Value>> set = map.entrySet()
entry.getKey()获得Key entry.getValue获得Value
Entry在java.util.Map中
12.4有序的Map ————LinkedHashMap
使用的Map接口的哈希表和链表实现，具有可预知的迭代顺序。次数实现与
HashMap的不同之处在于：
LinkedHashMap维护着一个双向循环链表。此链表定义了迭代顺序，该迭代
顺序通常就是存放元素的顺序。
HashMap中元素取出顺序和存入顺序不一定一样
LinkedHashMap中元素取出顺序和put顺序一致

12.IO输入输出

Input/Output,输入和输出
java.io包
File
RandomAccessFile
流
12.1 File
表示文件或目录
封装一个文件或目录的磁盘路径字符串
可以表示文件，也可以表示目录
可以表示存在的文件，也可以表示不存在的文件
例如：d:\abc\a.txt
创建对象
File f = new File("d:\abc\a.txt");
File f = new File("d:\abc","a.txt");
方法
文件或目录属性：
canRead() 是否可读
canWrite() 是否可写
canExecute()是否可执行
isHidden()是否隐藏
exists()是否存在
getAbsolutePath()获得完整路径
getName() 得到文件名
getParent()得到父目录
isDirectory()是否是文件夹
isFile() 是否是文件
lastMOdified()最后修改时间
length() 字节量
getTotalSpace()总空间大小
getFreeSpace（）可用空间大小
创建删除文件
createNewFile（）创建文件
mkdir（）创建单层目录
mkdirs（）创建多层目录
delete（）删除文件，删除空目录
renameTo() 改名
以上方法操作成功返回true，失败返回false
File.createTempFile（）
在系统的临时目录中创建临时文件，可能会被系统
或系统管理软件自动清理
UIID.randomUIID()生成32位随机16进制数
目录列表
list（）
只列出文件名，获得文件名数组 String[]
listFiles()
对列表的每个文件创建File对象，封装文件的完整路径，
得到的是file对象数组File[]
list(new FilenameFilter(){})获得过滤文件名后的文件名数组
listFiles（new FileFilter（）{}）
对文件进行过滤
12.2RandomAccessFiles
读写文件的工具
把文件看做一个字节数组，使用下标，读写指定下标位置的字节值
创建对象：
raf = new RandomAccessFile(File，"r");
raf = new RandomAccessFile(File，"rw");
方法
write（int b）int四个字节中，只输出一个字节值
注意写入文件后，指针会指向下一个元素
write(byte[] b,int start,int length)

read()读取一个字节值，补3个0字节，转换成int
4--》[1][2][3][4]
read(byte[] buff)
按数组长度，读取一批字节存入数组中，返回值是这一批
的字节量（有多少返多少），若读取结束，返回-1
seek（int position）
把指针下标定位到指定位置
getFilePointer（）
得到下标位置
13.流Stream
数据读写操作，抽象成数据在管道中流动
流只能单向流动
输入流：读
输出流：写
只能从头到尾流动一次
一.字节流:
InputStream OutputStream
字节流的抽象父类
API
OutputStream：
write(int b)
write(byte[] a)
write(byte[] a,int start,int length)
InputStream
read()
read(byte[] byte)
字节流的子类
FileInputStream
BufferedInputStream
DataInputStream
PrintStream
ByteArrayInputStream
ObjectInputStream
FileInputStream与FileOutputStream
文件输入流与文件输出流
直接与文件相连，读写文件中的数据
RandomAccessFile用来读写文件中间的位置
流一次性从头到尾读写数据
创建对象
out= new FileOutputStream（File）；
无论文件是否存在，都新建空文件
out = newFileOutputStream（file , true）
true 文件存在，追加（覆盖），不存在则新建
高级流/操作流
与其他的流相接,提供特定的数据处理功能
操作高级流时,它对相接的流执行相同的操作
高级流,不能直接接数据原
BufferedInputStream / BufferedOutputStream
提供数据缓冲区,提高单字节的读写效率
从BufferedInputStream 单字节读取数据,
它会预读一批数据,换存在内存数组中,它会帮我们做批量读取
向 BufferedOutputStream 输出单字节,它会将字节值缓存在
内存数组中,缓存一批再批量输出,缓存不满就要输出,可以手动flush()输出
3.1    创建对象
out = new BufferedOutputStream(相接的流);
内部缓存数组 8192
out = new BufferedOutputStream(相接的流,缓存数组大小);
内部缓存数组是指定的大小
DateInputStream/DateOutputStream
读写固定字节格式数据
int 4字节
double 8字节
………
String 前两个字节表示字节长度，后面是字符串的UTF-8编码
创建对象
out = new DataOutputStream(相接的流)；
方法
wirteInt(int i)
输出int的完整的四个字节
writeDouble（double d）
输出double的八个字节
……
writeUTF（String s）
先输出两个字节表示长度，再输出字符串的字节值
readInt（）
读取四个字节，转换成int
readDouble（）
读取8个字节，装换成double
readUTF（）
先读取两个字节来确定字节量，再读取这些字节转换成String

PrintStream
任何类型的数据，转换成字符串输出
97-->“9“”7”
new Date() -->对象.toString()
创建对象
out = new PrintStream（相接的流）；
out = new PrintStream（文件）；
内部自动创建了一个文件流相接
out =  new PrintStream（文件，字符编码）；
输出字符串是，装换成指定的编码再输出
方法：
print（）
println()
末尾补换行
win：两个字符\r\n 0d0a
其他系统： 一个字符 \n 0a

二.字符流Reader/Writer

以字符为单位，读写文本数据
Reader/Writer 是字符流的抽象父类
方法：
write（int c）
int 的末端两个字节，是char类型字符，
截取末尾两个字节的char值输出
write（char[] a）
write(char[] a,int start,int length)
write(String s)
Reader:
read()读取一个char类型字符,再补两个0字节,转换成int
read(char[] buff)读取char数组长度的字节数据,并将
数据保存到char数组中
实现类:InputStreamReader/OutputStreamWriter
InputStreamReader:
读取其他编码,转换成Unicode
必须接InputStream
OutputStreamWriter:
将内存中的Unicode编码字符转化成其它编码,再输出
FileReader/FileWriter
内部是文件字节流接"转换流"
缺点:不能指定编码,只能使用默认编码
构造方法：
out = new FileWriter(File);
PrintWriter:
与PrintStream相同
PrintStream:
只能接字节流
PrintWriter:
能接字节流也能接字符流
BufferedReader/BufferedWriter
内存缓冲区,提高单字节读写效率
BufferedReader提供了一个常用方法:readLine();
readLine()
读取一行字符串,不含末尾换行符,
读取结束,再读取,返回null

三.序列化

序列化:对象按固定字节格式,转换成一串字符串序列进行输出
反序列化:从字节数据读取,根据序列化数据,重建对象
ObjectOutputStream
将对象变成一串字节序列输出
ObjectInputStream
读取对象的序列化字节值,重建对象

队象序列化,要求被序列化的对象,必须实现Serializable接口

14.异常

异常是封装错误信息的对象
错误信息：
类型
消息
行号
异常继承结构
Throwable
|-Error 系统级异常
|-Exception 异常，例外，可修复错误
|-其他Exception
|-ParseException
|-IOException
……
|-RuntimeException 运行时异常
|-NullPointerException
|-ArithmeticException运算异常，例如除零
|-ArrayIndexOutOfBroundsException
|-NumberFormatException
|-InputMismatchException
……
try-catch-finally
捕获异常，并对异常进行修复
finally不管怎样，最后都会执行，例如会在break和return之前执行

throws
在方法上设置异常的抛出管道，它所有的子类型都可以从默认管道抛出其他
异常类型，必须添加管道才能抛出，不加管道的话，必须捕获其他类型异常
，java强制开发人员实现给出异常处理方案，二选一
throws添加管道
try-catch捕获
RuntimeException
非检查异常
代码中不添加异常处理代码，编译器也能允许编译通过
其他Exception
检查异常
编译器会检查，如果没有添加异常处理代码，编译报错
throw
手动抛出异常对象，执行异常抛出的动作
场景：
判断到出错条件，手动创建异常并抛出
捕获到异常对象，仅记录出错信息而不处理，再手动向前抛，抛给前面
的方法处理
捕获异常对象，将异常对象进行封装，封装成其他异常类型，再手动抛出
异常包装：
捕获的异常，包装起来，包装成另一种类型的异常，在抛出
场景：
不能抛出的异常，包装成可以抛出的异常类型，再抛
多种异常包装成一种类型抛出，简化异常
不能抛出的异常
子类重写父类方法时，异常类型不能比父类方法多
自定义异常
现有异常类型，不能表示业务中的错误情况
需要自定义异常，来描述错误
1.类型名
2.选择父类
3.天假适当构造方法

XML

扩展的标记语言
为什么要学
XML无处不在
格式严格
简单
结构化数据
XML不是给普通用户看的，不用来显示数据
由机器来处理或生成xml数据
XML作用：
存储数据
传输数据
xml语法：
1.xml头标签<?xml version="1.0" encoding="UTF-8"?>
可选
必须是文档的第一个字节
2.根元素，只能有一个
最外层元素，顶层元素
3.标签必须要有一个结束标签
<a></a>
简写<a/>
4.元素必须正确嵌套
<a><b></b></a>
5.属性必须有属性值
6.属性必须有引号，单引号或双引号都行
<a k1="v1" k2='v"2' k3="v'v3">
7.实体转义
8.CDATA标签
标签中的文本，程序在提取时，不做任何处理，
全部当成普通字符提取出来
<![DATA[内容]]>
9.<!--注释-->
注释中不能有连续的减号
JAVA处理XML
SAX - Simple API for XML
jdk提供的api来处理xml
DOM
W3C 的 DOM API，不是专门为JAVA设计的API，多数编程语言
提供DOM API支持
DOM4----常用
专门为java编写的DOM API
由第三方开源API
XML PULL
更加简洁高效的XML处理API
....
SAX
使用xml解析器，从xml文档提取
类：
SAXParserFactory
解析器工厂，负责创建解析器对象
创建工厂对象：
f=SAXParserFactory.newInstance();

SAXParser
解析器，负责读取xml文档，从xml提取数据
创建对象：
p = f.newSAXParser();
方法：
p.parse(文件或流，数据处理器)

DefailtHander
数据处理器父类
常用方法：
startElement（）
endElement（）
characters()

DOM4J

DOM:文档对象模型 Documnet Object Model
读取xml数据，按xml的层次结构，在内存中生成一个树状结构
Node节点类
|-Document 根节点
|-Element 元素节点
|-Text    文本节点
|-Attribute 属性节点
|-CDATA    CDATA块节点（不处理特殊字符的块）
|……
读取xml，生成dom树
1.读取xml的工具
SAXReader reader = new SAXReader（）；
2.读取xml文档生成DOM树，并获得树根
Document doc = reader.reader(文件或流)；
3.从树根，获得下一层元素
Element email = doc.getRootElement();
访问树上的数据
主要使用Document 类和Element类的方法，来访问数据
Document
getRootElement（）
获得下层根元素
SelectSingleNode（xPath）
用路径来获取单个节点
selectNodes(xPath)
用路径来获取一组节点，返回List集合
valueOf（xPath）
用路径直接取出该节点的值
Element
element(元素名)
获得下一层,指定的单个元素
elements()
获得下层素有子元素
elements(元素名)
获得下一层指定名称的一组元素,返回List<Element>集合
elementText(元素名)
获得下一层指定元素中的文本
isTextOnly()
当前元素是否仅包含文本
getText()
获得当前节点的文本
nodeCount()
下层节点的数量
node(下标)
下层指定下标的子节点
selectNodes(xPath)
selectSingleNode(xPath)
用路径访问节点
getNodeType()
  获得节点的类型代码
Node.DOCUMENT_NODE
Node.ELEMENT_NODE
Node.TEXT_NODE
...
elementIterator()
elementIterator(元素名)
attributeIterator()
  获得下层子元素,或者属性的迭代器
attribute(下标)
attribute(属性名)
用下标或者属性名,获得当前元素的属性节点
attributes()
  获得属性节点List集合
attributeValue(属性名)
  用下标或者属性名得到属性值

凭空创建DOM树，反向生成XML

Scanner类

next（）与nextLine（）区别
next（）：
1.一定要读取到有效字符后才可以结束输入。
2.对输入的有效字符之前遇到的空白，next（）方法会自动将其去掉。
3.只有输入有效字符后才将其后面的空白作为分隔符或结束符。
4.next（）不能得到带有空格的字符串
nextLine（）：
1.以enter为结束符，也就是说nextLine（）方法返回输入回车之前的
所有字符
2.可以获得空白
注意：
如果要输入int或float类型数据，在Scanner类中也有支持，但是
在输入之前最好先使用hasNextXxx（）方法验证，再使用nextXxx
读取