一、Java常用类库
* java.lang包
Object类
☆是类层次结构的根类。每个类都使用 Object 作为超类。
所有对象（包括数组）都实现这个类的方法
☆toString（）返回该对象的字符串表示，返回值类型为String
☆equals（Object obj）判断其他对象和此对象相等，返回值Boolean
System类
err:标准错误输出流
out：标准输出流
in：标准输入流
1、currentTimeMillis（）返回以毫秒为单位的当前时间，返回值为静态long类型
2、gc()运行垃圾回收器
Number类-->基本数据类型的封装类
▲xxxValue 将number对象转换为xxx数据类型的值并返回
▲equals()判断number对象是否与参数相等
▲valueOf()返回一个 Number 对象指定的内置数据类型
▲toString 以字符串方式返回
▲abs() 返回参数的绝对值
▲ceil() 对整形变量向左取整，返回double类型
▲floor（）对整形变量向右取整，返回double类型
▲rint()返回与参数最接近的整数，返回double类型
▲round（）返回与参数最接近的int，long值，返回double类型
▲min()返回两个参数中的最小值
▲max（）返回两个参数中的最大值
▲exp()返回e的参数次方
▲pow()返回第一个参数的第二个参数次方
▲sqrt()求参数的平方根
▲sin()/cos()/tan() 求指定double类型的正弦，余弦和正切值
▲toDegress()将参数转化为角度
▲random（）返回一个随机数
String类
◆valueOf(char[] c)：将其他类型转为字符串类型String
◆trim()：清除头部和尾部的空白，String
◆toUpperCase()：将字符串中的所有英文字母转为大写String
◆toLowerCase()：将字符串中的所有英文字母转为小写String
◆toCharArray()：把字符串转为字符组数char[]
◆substring(int index,int end)：截取字符串 String
◆startsWith(String prefix)：判断字符串是否以指定前缀开始Boolean类型
◆split()：按照指定的字符串（或者正则表达式）分割老字符串
◆replace(String old,String new)：新字符串替换老字符串String
◆length()：字符串长度int
◆lastIndexOf(int ch)：返回指定的字符或字符串最后一次出现的下标
◆isEmpty()：当长度lenght（）为0时，返回true
◆getBytes(String charsetName)：把字符串转为字节数组，结果储存到一个新
的字节数组byte[]返回
◆indexOf(int ch)：返回指定的字符或字符串第一次出现的下标int
◆getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：将字符串截取
自定义长度，存入字符数组中的自定义位置
◆endsWith(String suffix)：判断字符串是否以指定的后缀suffix为结尾返回Boolean
◆copyValueOf(char[] data,int offset,int,count)：把字符数组中指定的位置上的字符，拼
接为一个新的字符串.返回String
◆concat(String str)：把指定的字符串拼接到原字符串的末尾
◆charAt(int index)：返回指定下标的字符
◆equals（object anobject）将此字符串与指定的对象比较，返回Boolean类型
◆compareTo int i = s1.compareTo(s2);
顺序在s2的前面，返回小于0的值；也适用于有索引的集合
◆Collections.sort(list, new Comparator<Student>(){
* int compare(Student o1, Student o2) 返回一个基本类型的整型，
* 返回负数表示：o1 小于o2，
* 返回0 表示：o1和o2相等，
* 返回正数表示：o1大于o2。
public int compare(Student o1, Student o2) {
if(o1.getAge() > o2.getAge()){
return 1;
}
if(o1.getAge() == o2.getAge()){
return 0;
}
return -1;
}
}); 所有内容都在sort括号内
StringBuffer类
StringBuilder类（线程不安全）
●char charAt(int index)返回当前索引处的char值
●int indexOf(String str)返回第一次出现指定字符串在该字符串中的索引位置（下标）
●int lastindexOf(String str)返回最右边出现指定字符串的下标
●int lastindexOf(String str,intfromindext)返回指定字符串最后一次出现的下标
●int length()返回字符串长度
Math类
abs(double a)返回double类型a的绝对值，参数还可以是int，float，long用法一样
sqrt(double a)返回double值的平方根
cbrt(double a)返回double值a的立方根
floor（double a）返回一个无限接近正无穷大的小于等于参数a的整数，返回值类型为double
型ceil（double a）返回一个无限接近负无穷大的double值，并且大于等于参数a的整数
log（double a）返回以e为底的a的自然对数
log10(double a)返回以10为底的a的自然对数
max（double a,double b）返回两个参数a和b中的最大值，参数类型int，long,float类似
min(double a,double b)返回两个参数的最小值，参数类型int，long,float类似
pow(double a,double b)返回参数a的b次方
rint(double a)返回最接近参数a的整数型double值
round（double a）返回最接近参数a的long类型的值
round（float a）返回最接近参数a的int类型的值
Comparable接口（比较器）
File 类 文件和目录路径名的抽象表示形式。
Throwable类-->Error、Exception，Exception类--> RuntimeException
Execption类的层次
1、ArithmeticException算术异常
2、ArrayIndexOutOfBoundsException数组下标越界异常
3、ArrayStoreException数组中有错误对象存储异常
4、ClassCastException类型转换异常
5、IndexOutOfBoundsException数组或者字符串下标越界异常
6、StringIndexOutOfBoundsException字符串下标越界异常
7、NullPointerException空指针异常
8、NumberFormatException字符串转数字格式不匹配异常
9、UnsupportedOperationException不支持当前操作请求抛出的异常
10、InputMismatchException输入不匹配异常（例如把字母当做数字输入）
error类的层次
代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error
异常处理
1、 try-catch-catch-finally语句块
try代码块中放的是可能会出现异常的代码
catch() ，括号中是指要捕获的异常类，代码块中是处理异常的代码
如果有多个catch语句块，捕获异常的顺序应该为由小到大，子类在上，父类在下（是具有直
接继承关系的子类和父类）
finally代码块中的代码在任何情况下都会被执行，一般写资源关闭的代码，例如关闭流
2、自定义异常
自定义异常类要继承Exception类
使用throw关键字抛出自定义异常的对象
在自定义异常类中一般声明两个构造方法，一个有参的，一个无参的；有参的是用来描述具
体的异常信息
Package类、Void类
* java.util包
Arrays类
Collection接口 -- > List、Set接口
List接口
方法、实现类 ArrayList
增
boolean add(Object obj); 直接添加对象，
void add(int index,Object obj); 把对象添加到指定的索引
boolean addAll(Collection c); 添加指定 collection 中的所有元素到此列表的结尾
boolean addAll(int index,Collection c); 添加指定 collection 中的所有元素到此列表
的指定索引位置
删
boolean remove(Object obj); 删除列表中已存在的对象
Object remove(int index); 删除指定索引位置的元素
boolean removeAll(Collection c); 删除多个元素
改
Object set(int index,Object obj); 修改指定索引位置的元素，第二个参数是新元素
查
使用普通for循环遍历，通过get()方法获取指定索引的元素
使用foreach循环遍历
通过Iterator()方法获得迭代器对象，使用hashNext()判断是否有下一个元素，使用next()获得下一个元素
其他方法
1、contains(Object o) contains(Object o)
2、containsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素，则返回 true
3、equals(Object o)比较指定对象与此 set 的相等性
4、size()返回 set 中的元素数（其容量）。
5、toArray()
返回一个包含 set 中所有元素的数组。
6、iterator()返回在此 set 中的元素上进行迭代的迭代器。
7、可以根据返回值的true/false使用嵌套循环归类元素中的不同属性
标注
list按照特定属性排序
◆Collections.sort(list, new Comparator<Student>(){
* int compare(Student o1, Student o2) 返回一个基本类型的整型，
* 返回负数表示：o1 小于o2，
* 返回0 表示：o1和o2相等，
* 返回正数表示：o1大于o2。
public int compare(Student o1, Student o2) {
if(o1.getAge() > o2.getAge()){
return 1;
}
if(o1.getAge() == o2.getAge()){
return 0;
}
return -1;
}
}); 所有内容都在sort括号内
String s1 = "1";
String s2 = "2";
判断顺序：数字 --> 大写 --> 小写
int i = s1.compareTo(s2);
小于0的值；
Collections类（Collection接口的“包装器”）
1、addAll(Collection<? super T> c, T... elements) 将所有指定元素添加到指定
Collection中
2、binarySearch(List<? extends Comparable<? super T>> list, T key)使用二分法对指
定元素进行查找，返回元素所在位置下标int，查之前先对集合进行自然升序排列
3、sort(List<T> list) 对集合中元素进行自然升序排列
4、reverse(List<?> list) 反转集合中原来的位置顺序
5、shuffle(List<?> list, Random rnd) 将集合中元素随机排序
6、copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另
一个列表
7、fill(List<? super T> list, T obj) 用指定元素替换列表中所有元素
Set接口实现类 HashSet
声明：public Set<String> s = new HashSet<String>();
增
1、s.add("李四");2、String[] str = {"赵六","田七","孙八"};
s.addAll(Arrays.asList(str));
删
1、
public void del(){
Iterator<String> it = s.iterator();
while(it.hasNext()){
String str = it.next();
if(str.equals("张三")){
it.remove();
}
}
2、/清除所有元素
public void delAll(){
s.clear();
}
改
修改，此方法在for循环中不可取，只能删除列表最后一个元素，并且不能修改，可以在循环体外直接操作
remove
public void update(){
for (String str : s) {
if(str.equals("田七")){
s.remove(str);
System.out.println("yes");
}
}
}
查
1、使用foreach遍历集合
public void find(){
for (String str : s) {
System.out.println(str);
}
}
2、 使用迭代器遍历
public void it(){
Iterator<String> it = s.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
set排序实现类TreeSet
Set集合排序，泛型的类型要实现Comparable接口，并重写comparable的compareTo方法制定排序的规则，使用TreeSet实
现类来对集合中的数据排序Set<Student> set = new TreeSet<Student>();public class Student implements <Student>........public
int compareTo (Student stu) {
return this.age.compareTo(stu.age);
}
排序方法：Collections.sort(list, new Demo());
ArrayList类
ArrayList()构造一个初始容量为10的空列表
1、size（）返回列表中的元素个数，返回值为int类型
2、toArray（）返回包含此列表中所有元素的数组，返回值为Object[]
3、trimToSize()将此ArrayList实例的容量调整为当前列表的大小
4、isEmpty()若列表为空返回true
5、indexOf（Object o）返回列表中首次出现指定元素的索引，若不包含索引返回值为-1
6、lastIndexOf（Object o）返回列表中最后一次出现指定元素的索引，若不包含索引返回值为-1
7、Arrays.asList(数组)把存有对象的数组以集合的方式输出
8、set(int index, E element)用参数中元素代替列表中指定位置index上的元素
9、contains(Object o) 如果列表中含有指定元素，返回boolean类型的true
Vector类
已实现的接口 Collection<E>, List<E>,
构造方法
Vector（）；构造一个初始化大小为10的数组向量空间
一般方法
add(E e) 指定元素添加到向量末尾，返回boolean
add(int index, E element) 将指定元素添加到向量指定位置，返回值为空
capacity() 返回向量的当前容量，int
size() 返回向量的组件数，int
clear() 移除向量所有元素
contains(Object o) 向量包含指定元素，返回true
remove(int index) 移除向量指定位置元素
set(int index, E element) 用指定元素替换指定坐标下向量的元素
toString() 返回向量的字符串形式，返回值为String
TreeSet类
set排序实现类TreeSet
Set集合排序，泛型的类型要实现Comparable接口，并重写comparable的compareTo方法制定排序的规
则，使用TreeSet实现类来对集合中的数据排序Set<Student> set = new TreeSet<Student>();
public class Student implements Comparable<Student>........public int compareTo (Student stu) {
return this.age.compareTo(stu.age);
}
排序方法：Collections.sort(list, new Demo());
Map接口--> Map.Entry<K,V>
HashMap类
Map<K,V>接口实现类 HashMap<k,V>
方法
声明：Map<String,Student> map = new HashMap<String,Student>();
添加
map.put("县长", new Student("小明",20));
map.put("2", new Student("小王",21));
查找
根据键来查找对应的值，返回的是对象
Student stu = map.get("县长");
遍历
Set<Entry<String,Student>> set = map.entrySet();
for (Entry<String, Student> entry : set) {
System.out.println("获得键："+entry.getKey());
System.out.println("获得值："+entry.getValue().name+","+entry.getValue().age);
1、遍历Map.entrySet()：它的每一个元素都是Map.Entry对象，这个对象中，
放着的就是Map中的某一对key-value；
2、遍历Map.keySet()：它是Map中key值的集合，我们可以通过遍历这个集合来
读取Map中的元素；
3、遍历Map.values()：它是Map中value的集合，我们可以直接通过这个集合遍历
Map中的值，却不能读取key。
标注
删除
Student s2 = map.remove("县长");
System.out.println(s2.name+"被删除了"
get(Object key) 返回指定键的值（对象）
put(K key, V value)根据键值对映射关系添加元素到map集合中
remove(Object key) 删除键值对应的映射值
containsKey(Object key) 根据键判断map中有没有对应的映射，有就返回true
containsValue(Object value) 根据值判断map中有没有对应的键
clear() 清除map中所有映射关系的元素
TreeMap类
get(Object key) 返回指定键所映射的值
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图
Set<K> keySet() 返回此映射包含的键的 Set 视图
remove(Object key) 如果此 TreeMap 中存在该键的映射关系，则将其删除
int size() 返回此映射中的键-值映射关系数。
Collection<V> values() 返回此映射包含的值的 Collection 视图。
Iterator接口
迭代器循环 使用迭代器Iterator(也是一个集合)，遍历集合
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
if(obj instanceof Student1){
Student1 stu=(Student1) obj;
System.out.println(stu.name);
}
Calendar类（子类GregorianCalendar）
■getTimeZone()获得时区，返回TimeZone类型
■isLeapYear（int year）判断是否为闰年
■setTimeZone(TimeZone zone)设置时区
TimeZone类
1、getID（）获取此时区的ID返回String类型
2、getDisplayName（）返回符合指定区域的时区名称
3、getTimeZone（String ID）获取指定ID的TImeZone并返回
4、setID（String ID）设置时区
5、setDefault（TimeZone zone）设置由getDefault方法返回的TimeZone
6、getDefault（）获取此主机默认的TimeZone
Scanner类
Δclose（）关闭此扫描器
ΔnextInt（）将输入信息的下一个标记扫描为一个 int，其他数据类型同样用法
Random类
Random()创建一个新的随机数生成器
Random（long seed）使用单个的long种子创建一个新的随机数生成器
nextInt（）返回下一个伪随机数
nextInt（int n）返回[0,n)区间的一个int类型的随机数
nextDouble（）返回下一个伪随机数0.0-1.0之间的double值，nextFloat（）类似
nextBytes（Byte[] byte）生成随机字节存入用户提供的Byte[]数组中
Comparator接口（比较器）
SortedMap.comparator()
返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
SortedSet.comparator()
返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回null。
◆Collections.sort(list, new Comparator<Student>(){
* int compare(Student o1, Student o2) 返回一个基本类型的整型，
* 返回负数表示：o1 小于o2，
* 返回0 表示：o1和o2相等，
* 返回正数表示：o1大于o2。
public int compare(Student o1, Student o2) {
if(o1.getAge() > o2.getAge()){
return 1;
}
if(o1.getAge() == o2.getAge()){
return 0;
}
return -1;
}
}); 所有内容都在sort括号内
* java.text
Format类 --> DateFormat（★SimpleDateFOrmat）
1、format(Date date, StringBuffer toAppendTo, FieldPosition pos) 将给定的 Date 格
式化为日期/时间字符串，并将结果添加到给定的 StringBuffer
2、parse(String text, ParsePosition pos) 解析字符串的文本，生成 Date
●getAvailableLocales() 返回所有语言环境的数组，此类的 get*Instance 方法可以为其返
回已本地化的实例
●getCalendar() 获取与此日期/时间格式器关联的日历。
●getTimeZone() 获取时区。返回TimeZone
●parse(String source) 从给定字符串的开始解析文本，以生成一个日期，返回Date类型
●setTimeZone(TimeZone zone) 为此 DateFormat 对象的日历设置时区。
●setNumberFormat(NumberFormat newNumberFormat) 允许用户设置数字格式器
-->NumberFormat（DecimalFormat类）?parse（String text）将参数文本解析为数字，返回给Number对象
* java.io包
Serializable接口
在序列化和反序列化过程中需要实现该接口
File类
InputStream 字节流 -- > FileInputStream、ObjectInputStream、FilterInputStream-- >DataInputStream
文件导入方法1，传一个Sting类型的路径
File file=new File("E:\\workspace\\a.jnt");
文件导入方法2,传两个String类型参数，第一个表示路径，第二个表示文件名
File file=new File("E:\\","Atm.java");
文件导入方法3
File parent=new File("E:\\");
将上述File对象作为第一个参数，String类型文件名作为第二个参数，这样方便访问同一目录下的多个文件
File file3=new File(parent,"Atm.java");
常用方法：
boolean b=file.exists();
System.out.println("文件是否可写："+file.canWrite());
System.out.println("文件是否可读："+file.canRead());
System.out.println("文件是否可执行："+file.canExecute());
System.out.println("文件是否隐藏："+file.isHidden());
System.out.println(file.length());
file.createNewFile();
RandomAccessFile raf=new RandomAccessFile(file, "rw");
输出，从内存写入硬盘
raf.write(by, 0, by.length);
raf.write(by);
输入，从硬盘读入内存
int len=(int) raf.length();
byte[] bx=new byte[len];
raf.read(bx);
String s=new String(bx);
System.out.println(s);
raf.close();
File fi=file.createTempFile("pri", "suf");
file.delete();
file.deleteOnExit();
String s=file.getPath();
String s1=file.getName();
boolean b=file.isAbsolute();
String s2=file.getAbsolutePath();
boolean b1=file.isDirectory();
Boolean b2=file.isFile();
long l=file.length();
long l1=file.lastModified();
String[] str=file.list();
File[] f1=file.listFiles();
boolean b3=file.mkdir();
boolean b4=file.mkdirs();
boolean b5=file.renameTo(file);
String sr=file.toString();
OutputStream
Reader 字符流 --> InputStreamReader、BufferedReader
Writer --> OutputStreamWriter、BufferedWriter、PrintWriter
&正则表达式
对复杂的字符串做匹配、拆分的特殊字符串
正则符号：
含义 表达式一 表达式二(自定义)
数字 \d [0-9]
字母 [a-zA-Z]
字母、数字、下划线 \w [a-zA-Z_0-9]
空白字符 \s [ \t\n\x0B\f\r]
非空白字符 \S [^ ]
非字母 [^a-zA-Z]
非数字 [^0-9]
任意符号 .
除了换行符之外
正则开始符号 ^
正则结束符号 $
正则数量：
符号 含义
+ 1个到多个
* 0个或1到多个
？ 0个到1个
{n} n个
{n,m} n个到m个
{n,} n个到多个
正则逻辑：
* 正则逻辑
含义 符号
分组 ()
或 |
且 什么都不加
