基础类库：>使用api(帮助文档 java基础类库的说明书)
>多敲例子(上课案例 作业)
Obejct:
所有类的直接或者间接父类
如果一个类没有继承其他类 默认继承Object类
构造方法：无参数的构造方法
成员变量：无
普通方法：
> int hashCode() 返回该对象的10进制内存地址
> Class getClass() 获取当前对象的类的字节码文件对象
Class ----描述类的字节码文件对象
getClass()方法是所有对象的方法---对象是由类创建的
---每个类对应一个字节码文件----字节码文件被封装成对象
---对象的类型Class
Class类的方法 获取类名
> String toString() 返回该对象的字符串表示。
[email protected]
类名@16进制内存地址
*** > boolean equals(Object obj)
判断当前引用和参数引用是不是指向同一个对象
//重写equals方法 判断两个引用指向的对象是不是在描述同一个实物
//(判断两个对象的所有数据是不是完全相同)
//1 方法声明必须完全与Object类一致 参数是Object类型
初级难点：
forfor循环嵌套
数组排序
字符串练习
字符串：String
注意1：字符串对象是常量；字符串创建之后 字符序列不能更改
注意2：创建字符串对象两个常用方法:String s="1233";通过双引号创建
String s=new String("1233");通过new
构造方法：
>1 String()
无参数的构造方法 创建一个空字符序列 类似于""
>2 String(String original)
创建一个参数字符串序列的副本字符串对象
>3 参数是byte、int、char数组 由数组或者数组是一部分创建一个字符串对象
String(byte[] bytes)
String(char[] value)
String(char[] value, int offset, int count)
String(byte[] bytes, int offset, int length)
String(int[] codePoints, int offset, int count)
String(byte[] bytes, String charsetName)
普通方法：
--- >1 boolean equals(Object anObject)
Obejct类中equals方法 判断两个引用是否指向一个对象
重写后 判断两个引用指向的字符序列是否相同
boolean equalsIgnoreCase(String anotherString)
不区分大小写
--- >2 char charAt(int index)
通过下标获取字符
>3 int length()
获取字符个数
>4 int compareTo(String s)
按编码集逐个字符做比较
当前字符串大 返回正数、当前字符串小 返回负数 、相同返回0
int compareToIgnoreCase(String str)
不区分大小写
>5 String concat(String str) 完全等价于+
把参数字符串连接到当前字符串后面 形成一个新的字符串
>6 boolean contains(String s)
判断当前字符串是不是包含参数字符串
>7 boolean endsWith(String suffix)
boolean startsWith(String prefix)
判断当前字符串是不是以参数字符串开始、结尾
---- >8 byte[] getBytes()
byte[] getBytes(String charsetName)
由当前字符串和指定(默认)编码集获取一个字节数组
>9 char[] toCharArray()
由当前字符串获取一个字符数组
>10 通过字符获取下标
int indexOf(int ch) 获取参数字符第一次出现的位置
int indexOf(int ch, int fromIndex)
int indexOf(String str)
int indexOf(String str, int fromIndex)
int lastIndexOf(int ch)
int lastIndexOf(int ch, int fromIndex)
int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)
面试题：== 与equals方法的区别
>(1) == 是比较运算符 可以判断引用数据类型和基本数据类型
操作基本数据类型 判断值是否相同
操作引用数据类型 判断是不是同一个对象
equals是方法 只能操作引用数据类型的数据
>(2) == 是运算符 判断依据无法更改
equals是Obejct类的方法 可以被子类重写
---->11 String replace(char oldChar, char newChar)
使用newChar替换当前字符串中所有的oldChar
String replace(String oldStr,String newStr)
使用newStr替换当前字符串中所有的oldStr
---->12 String[] split(String regex)
使用参数字符串切割当前字符串
-----13 String substring(int beginIndex)
获取从beginIndex开始到末尾的子串
String substring(int beginIndex, int endIndex)
获取从beginIndex开始到endIndex-1结束的子串
14 String toUpperCase()
所有字母转换为大写
String toLowerCase()
所有字母转换为小写
15 String trim()
去除前后的空字符 ‘ ‘
系统输入流监控器类：Scanner
创建创建Scannar对象： Scanner sr=new Scanner(System.in);
以下方法都是阻塞方法：(等待输入 只有输入内容程序才继续执行)
String next() 获取一个字符串
String nextLine() 获取一行
int nextInt() 获取一个整数
float nextFloat() 获取一个float
System:系统
静态的成员变量：
static PrintStream err 错误输出流
static InputStream in 系统输入流
static PrintStream out 标准输出流
err和out注意：
err打印是红色 out是黑色
err和out执行顺序不固定(多线程)
普通方法：
static void exit(0) 结束程序运行
static long currentTimeMillis()
获取当前时间与1970 年 1 月 1 日午夜之间的时间毫秒值差
Math：与数学运算有关的所有方法
静态成员变量:
E:自然对数
PI:圆周率
静态普通方法:
-->static long abs(int a) 求绝对值
>static double cbrt(double a) 求立方根
-- static double sqrt(double a) 求平方根
static double pow(double a, double b) 求a的b次方
>static double ceil(double a) 大于等于参数的最小整数
static double floor(double a) 小于等于参数的最大整数
static double rint(double a) 四舍六入 五取偶
static long round(double a) 四舍五入
--- >static double random()
返回带正号的 double 值，[0.0,1.0)
*/
StringBuffer、StringBuilder API兼容(方法属性完全相同)
字符串缓冲区、字符可变序列
面试题：
String与StringBuffer、StringBuilder
相同之处：都是字符串字符序列
不同之处
String字符串常量：字符串对象一旦创建 字符序列不能更改
StringBuffer、StringBuilder：字符串缓冲区 字符序列可以变化
StringBuffer、StringBuilder：API兼容(方法属性完全相同)
>版本不同：
StringBuffer jdk1.0
StringBuilder jdk1.5
>是否支持多线程
StringBuilder 线程不安全 不支持多线程 线程不同步 效率高
StringBuffer 线程安全 支持多线程 线程同步 效率低
构造方法：
StringBuffer() //创建一个没有字符的字符串缓冲区
StringBuffer(String str) //创建一个有初始字符序列的字符串缓冲区
普通方法：
与String相同的方法：
> char charAt(int index)
通过下标获取字符
> int indexOf(String str)
获取参数字符串第一次出现的位置
int indexOf(String str, int fromIndex)
从fromIndex处检索 获取参数字符串第一次出现的位置
int lastIndexOf(String str)
倒着查找 获取参数字符串第一次出现的位置
int lastIndexOf(String str, int fromIndex)
倒着查找 从fromIndex处开始 获取参数字符串第一次出现的位置
> int length()获取字符个数
> String substring(int start, int end)
获取从start到end-1处的子串
特有：
>添加
StringBuffer append(Object obj)
把对象的字符串表示形式加到当前字符串缓冲区后面 返回当前字符串缓冲区对象
>删除
StringBuffer delete(int start, int end)
删除start到end-1下标处的所有字符
StringBuffer deleteCharAt(int index)
删除index下标处的字符
> 插入
StringBuffer insert(int offset, Object obj)
把参数对象obj的字符串表示形式 插入到 offset位置处
> 替换
StringBuffer replace(int start, int end, String str)
使用str替换start到end1-处的字符
> 翻转
StringBuffer reverse()
> 设置字符
void setCharAt(int index, char ch)
把ch设置到index位置处
当对字符串频繁的进行"正删改" 从建议使用字符串缓冲区
3 写一个方法由参数字符串获取一个新的字符串
：要求 大写转换为小写 小写转换为大写 删除数字
public static String getNew(String str){
//由str获取一个字符串缓冲区
//对字符串缓冲区进行操作
//由字符串缓冲区获取一个字符串对象
}
1 写一个方法 有参数字符串获取一个数字组成的字符串数组
如"123kjh123hgfr98jhfgdd876"---{"123","123","98","876"}
基本思路：使用指定字符如‘-‘替换所有非数字字符
然后再用‘-‘切割
然后把其中非""的元素挑出来即可
2 写一个方法 由参数字符串获取一个新的字符串
如ssssddddiiiiiuuuuuusssedf--->s4d4i5u6s3edf
3 已知一个Stu类 属性 age name sex score
//写一个方法 public static Stu suiJi(){}
//此方法返回一个Stu对象 对象的所有属性随机
//要求：age取值范围[22,29] score取值[0.0,100.0] sex取值男或者女
// name只有4个大小写字母组成
Date: 日期类
*注意：>大部分方法 都是已过时(不易于实现国际化) 通常有替代者Calendar(日历类)
>包名是 java.util.Date 别导错java.sql.Date
构造方法：
*** > Date() 获取当前时间
> Date(int year, int month, int date, int hrs, int min, int sec)
参数是年月日时分秒
year-1900
month-1 [0,11]
> Date(long date)
参数为距离历元(1970-1-1 00:00:00)之间的毫秒值
普通方法：
>时间先后比较
boolean after(Date when) 判断当前时间对象 是不是在参数时间之后
boolean before(Date when) 判断当前时间对象 是不是在参数时间之前
*** >获取和设置时间参数
void setXxx(int value)
int getXxx()
>日期与毫秒值之间的转换
long getTime() ; 获取当前时间对象对应的毫秒值
void setTime(long time); 把当前时间对象设置成参数毫秒值表示的时间
> 获取本地字符串表示形式
String toLocaleString()
1 写一个方法 获取参数字符串表示的时间相对于2000年1月1日过了多少天
// 字符串格式：xxxx年xx月xx号
// 建议使用：java.util.Date类
2 写一个方法获取参数字符串表示的时间 30天后是什么时间
字符串格式：xxxx年xx月xx号
建议使用：java.util.Date类
Calendar:日历类 生死决斗
注意：>此类是 抽象类： 通过静态方法static Calendar getInstance() 返回子类对象
普通方法：
>1 静态方法返回子类对象
static Calendar getInstance()
>2 两个时间做比较
boolean after(Object when)
boolean before(Object when)
>3 给指定的字段添加指定值(字段：Calendar的静态成员变量)
void add(int field, int amount)
--->4 获取和设置 字段的值
int get(int field)
void set(int field, int value)
--->5 实现日历对象与日期对象之间的转换
Date getTime() 由当前日历对象获取一个相同时间的日期对象
void setTime(Date date) 把当前日历对象时间设置为参数日期对象对应的时间
--->6 实现毫秒值与日历对象之间的转换
long getTimeInMillis()
void setTimeInMillis(long millis)
Calendar:日历类 生死决斗
注意：>此类是 抽象类： 通过静态方法static Calendar getInstance() 返回子类对象
// 创建一个表示2010年1月12日 的日历对象
//创建Calendar对象只有一种方法 通过calendar的静态方法 getInstance()
//获取的是当前时间的日历对象
Calendar c1=Calendar.getInstance();
//方式1： 通过set方法
c1.set(Calendar.YEAR, 2010);
c1.set(Calendar.MONTH, 1-1);
c1.set(Calendar.DAY_OF_MONTH, 12);
Demo3_Calendar.cal2Str(c1);//2010年1月12号 星期二 16:0:29
//方式2： 实现日期对象与日历对象之间的转换
//获取日期对象 时间2010年1月12日
Date date=new Date(2010-1900, 1-1, 12);
//把c1设置成date表示的时间
c1.setTime(date);
Demo3_Calendar.cal2Str(c1);
//方式3：通过毫秒值与日历对象之间的转换
long lon=date.getTime();
//把c1设置成lon表示的时间
simpledateformat:自定义日期格式化类
实现指定格式的字符串与Date对象之间的转换
格式化 (由日期对象获取指定格式的字符串)
解析 (由指定格式的字符串获取日期对象)
构造方法：
SimpleDateFormat(String pattern)
普通方法：
public final String format(Date date) 获取参数date对象对应指定格式的字符串
public Date parse(String source) 由参数字符串 获取一个date对象
注意：parse使用时 需要在方法声明添加throws ParseException
通过特殊字符来指定字符串的模式：
y--年
M--月
d--号
E--星期
H--时
m--分
s--秒
*/
插入排序：假设前面的元素是有序的 依次拿当前元素倒着和其前面的元素作比较
//排序 把小的排在左边
for (int i =1; i < arr.length; i++) {
//当前元素arr[i]
//定义变量记录当前元素的值
int k=arr[i];
//倒着和其前面的元素做比较
int j;
for ( j= i-1; j >=0; j--) {
//当前面的元素大于当前元素时 前面的元素后移一位
if(arr[j]>k){// -1 -2 10 6,9,0,-3,4,5,2
arr[j+1]=arr[j];
}else{
//找到了当前元素的位置 j+1
//把当前元素放在j+1位置处
//arr[j+1]=k;
break;
}
}
arr[j+1]=k;
}
在创建二维数组时 可以先只定义二维数组的一维数组个数 可以不定义每个一维数组中元素的个数
如 int[][] arr=new int[3][];
在给一维数组的元素赋值时 再定义元素个数
arr[0]=new int[4];
////////////////////////////////////////////////////////////////
集合框架：给集合有关的所有类和接口组成一个体系
集合：装引用数据类型 长度可变的容器
数组：装相同类型 指定个数个数据的容器
集合和数组的区别：
相同之处：装多个数据的容器(都是引用数据类型)
不同之处： >元素类型不同：
数组的元素可以是基本数据类型和引用数据类型
集合的元素只能是引用数据类型
>长度是否可变
数组一旦创建 元素个数不能变化
集合元素个数可以变化
>元素类型是否相同
数组中元素类型必须相同
集合中元素类型可以不同
>元素是否有默认初始值
数组中元素有对应的默认初始值
集合中元素没有默认初始值
集合框架：
两个顶层接口 Collection、Map
Collection 单列集合的顶层接口
---List(接口) 有序列表
---ArrayList(主讲)
---Vector
---Set(接口) 无序列表
---HashSet(主讲)
---TreeSet
Map 双列集合的顶层接口
---HashMap(主讲)
---HashTable
注意：1 目前 看到<> 就当没有 /看到E 就当Object
2 集合中获取的元素都是Object类型
Collection：
-- >1 boolean add(E e) 添加元素
boolean addAll(Collection c) 把参数集合中的所有元素添加到当前集合中
-- >2 int size() 获取元素个数
>3 void clear() 清除所有元素
boolean isEmpty() 判断是不是空的集合
-- >4 boolean remove(Object o) 移除指定元素
boolean removeAll(Collection c) 移除当前集合中所有存在于参数集合c中的元素
-- >5 Object[] toArray() 获取对应的数组
创建一个集合 Collection c1=new ArrayList();
装5个字符串 5个整数
删除含有a的字符串元素(instancof判断元素类型)
获取所有数字元素的平均值
Collection的实现类
ArrayList：长度可变的数组的实现(模拟长度可变的数组)
有序的 可重复的 元素可以为null
面试题： ArrayList与Vector 区别：
相同之处：都是单列集合Collection的实现类
都是长度可变的数组的实现
不同之处：>ArrayList是不同步 线程不安全 效率高
Vector是同步 线程安全 效率低
>ArrayList 1.2版本
Vector 1.0版本
构造方法：
ArrayList()
特有方法：(都是给下标有关)
> void add(int index, E element) 在指定下标出添加元素
> E get(int index) 通过下标获取元素
> int indexOf(Object o) 获取参数对象在集合中第一次出现的位置
int lastIndexOf(Object o) 倒着查找 获取参数对象在集合中第一次出现的位置
> E remove(int index) 通过下标删除元素 返回的是被删除的元素
> E set(int index, E element) 把下标index处的元素设置为element 返回被替换的元素
集合中使用概率最高的类 ArrayList
创建一个学生类：属性：名字 性别 班级 分数
创建10个学生对象 装入arraylist中
给所有女生分数+1
分别获取女生和男生的平均分
HashSet: 无序 不重复 允许null作为元素的单列集合
方法：完全实现于 Collection
遍历HashSet：三种：简洁for循环 转换为数组遍历数组 迭代器
研究HashSet怎么保证元素不重复：
boolean add(obj);
>先调用参数对象obj的hashCode()方法 获取hashCode值
如果此hashCode值唯一(与已有的元素的hashCode值都不相同) 就直接加入
>如果此hashCode值 与已有n个元素的hashCode值相同
就调用obj的equals方法与这n个元素分别比较 当都返回false 才允许加入
Generics 泛型：给集合的元素定义类型(jdk1.5的新特性)
关键字：<>
泛型使用：集合类型<元素类型>
泛型好处： >通过编译器检测 再也不会出现ClassCastException异常
>获取元素时 不需要再向下转型
以后使用集合 必须定义泛型 zx
Map 双列集合 增删改查操作的都是一对数据
这一对数据：键值对
特点：一个键只能对应一个值/键不能重复
实现类：HashMap
HashMap与HashTable的区别：
相同之处：都是Map基于hash表的实现类 方法基本一样
不同之处：>HashMap 允许null作为值和键
HashTable 不----------
>HashMap 不同步 线程不安全 效率高
HashTable 同步 线程安全 效率低
构造方法：HashMap()
方法：
添加： V put(K key, V value)
返回值为 键key原来对应的值 如果原来没有键key 返回null
获取： V get(Object key) 通过键获取值
int size() 获取键值对的个数
Set<K> keySet() 获取map的所有键 对应的Set
Collection<V> values() 获取map所有的值对应的Collection
判断：
boolean containsKey(Object key)
判断当前map是不是包含指定的键
boolean containsValue(Object value)
判断当前map是不是包含指定的值
删除：
V remove(Object key) 删除参数键对应的键值对
void clear() 清空map
练习：创建一个Stu类 属性 名字 学号 班级 分数
创建一个arraylist装10个学生对象
创建一个hashmap 把list中的10个元素作为值 把学生的学号作为键 装入map中
遍历map
求平均分
删除分数小于60的学生
遍历map的方式二：
Set<Entry<K,V>> entrySet()
Entry：一个键值对对象
K getKey() 获取键
V getValue() 获取值
一：创建一个Stu类 属性 名字 学号 班级 分数
创建一个arraylist装10个学生对象
获取每个班级的平均分 与班级编号组成的 map
二：
通过键盘输入 一行字符串 Scanner
使用map记录每个字符出现的次数 字符(键)和次数
Collections:集合工具类
Arrays:数组工具类
> static void fill(boolean[] a, boolean val)
把所有的元素赋值为val
> static void sort(byte[] a)
从小到大排序
//当数组的元素没有比较性时 会包异常classcastexception
>static String toString(boolean[] a)
获取字符串表示形式
工具类的特点：所有的成员都是静态
异常：程序运行过程中 发生不正常的情况
异常体系： 所有异常类组成的整体
顶层父类：Throwable
异常体系特点：
> 异常体系的类都是Throwable的子类
只有是Throwable的子类 才能称为异常类 才能被关键字 throws throw catch操作
> 所有的子类方法都继承于Throwable 都没有特有方法
> 异常类之间的不同：异常原因(通过构造方法参数) ,异常类型(类名)
> Error和Exception的子类都是以父类的名字结尾
异常体系结构：
Throwable
---Error 错误 不能通过代码逻辑来处理或者避免非常严重的异常情况
处理方式：只能修改代码
eg:> 不符合语法
> java.lang.OutOfMemoryError 内存溢出
> java.lang.NoClassDefFoundError 类找不到错误
---Exception 异常 可以通过代码逻辑来处理或者避免的异常情况
常见的异常：>空指针异常NullPointerException
引用指向null 但调用了此引用的成员
>数组下标越界异常 ArrayIndexOutOfBoundsException
访问到不存在的下标时
>数学运算异常 ArithmeticException
被零除等一些不符合数学运算语法
>类型转换异常 ClassCastException
向下转型时 把多态对象转换为其他类型
>数字格式异常 NumberFormatException
把带有非数字字符的字符串转换为数字时
> 解析异常 ParseException
把字符串解析为一个对象时
> 不支持的编码集 UnsupportedEncodingException
使用字符串表示编码集时
> IO异常 IOException
读写文件时出现的异常
> 文件找不到异常 FileNotFoundException
Throwable方法：
构造方法：
Throwable() 把null作为异常原因
Throwable(String message) 指定异常原因
异常：程序运行过程中 发生不正常的情况
异常体系： 所有异常类组成的整体
顶层父类：Throwable
异常体系特点：
> 异常体系的类都是Throwable的子类
只有是Throwable的子类 才能称为异常类 才能被关键字 throws throw catch操作
> 所有的子类方法都继承于Throwable 都没有特有方法
> 异常类之间的不同：异常原因(通过构造方法参数) ,异常类型(类名)
> Error和Exception的子类都是以父类的名字结尾
异常体系结构：
Throwable
---Error 错误 不能通过代码逻辑来处理或者避免非常严重的异常情况
处理方式：只能修改代码
eg:> 不符合语法
> java.lang.OutOfMemoryError 内存溢出
> java.lang.NoClassDefFoundError 类找不到错误
---Exception 异常 可以通过代码逻辑来处理或者避免的异常情况
常见的异常：>空指针异常NullPointerException
引用指向null 但调用了此引用的成员
>数组下标越界异常 ArrayIndexOutOfBoundsException
访问到不存在的下标时
>数学运算异常 ArithmeticException
被零除等一些不符合数学运算语法
>类型转换异常 ClassCastException
向下转型时 把多态对象转换为其他类型
>数字格式异常 NumberFormatException
把带有非数字字符的字符串转换为数字时
> 解析异常 ParseException
把字符串解析为一个对象时
> 不支持的编码集 UnsupportedEncodingException
使用字符串表示编码集时
> IO异常 IOException
读写文件时出现的异常
> 文件找不到异常 FileNotFoundException
Throwable方法：
构造方法：
Throwable() 把null作为异常原因
Throwable(String message) 指定异常原因
普通方法：
> String getMessage() 获取异常原因
> void printStackTrace() 通过错误输出流输出异常基本信息
// java.lang.Throwable: 文件太大了！
// at day23_Exception.Demo2_Throwable2.main(Demo2_Throwable2.java:64)
> String toString() 获取异常的字符串表示形式: 异常类型:异常原因
处理异常的方式：
1 抛出机制：把可能产生的异常 封装成对象 抛给方法的调用者
抛出机制关键字：throws 和 throw
抛出机制格式：在方法声明上加 throws 异常类型1, 异常类型2
eg:public static void hehe(String s) throws ParseException{}
类似于：现实生活中 把问题以书面格式交给领导/
throws ParseException 好比超市特价面包上面的标签
ParseException p1=new ParseException("解析出错！", 1);//第二个参数 不用管
//new一个异常对象 不代表程序出现异常情况
//程序出现异常情况 需要使用关键字throw
throw p1;
重点：throws和throw的区别：
>位置不同
throws用在方法声明上
throw用在方法体中
>后面跟的内容不一样
throws 跟多个异常类型
throw 跟一个异常对象
> 作用不一样
throws 用在方法声明上 给调用者警告 此方法有可能产生那些异常
一旦产生这样的异常 会被封装成异常对象 自动抛给方法的调用者
throw 用在方法体中 表示程序发生一个异常情况
注意： >1 一个方法不可能同时抛出两个异常
一个方法一旦产生异常 并且选择抛出机制来处理 那么此方法的其他代码不再执行
>2 子类只能抛 父类相同 、父类异常的子类异常
子类不能抛 新的 大的异常
>3 一直选择抛出 最终异常抛给虚拟机 虚拟机统一处理方式
先通过错误输出流打印 异常的所有信息 然后结束程序
抛出机制是消极的处理异常方式 提倡尽量捕获
2 捕获机制
*
*/
2 捕获机制：捕获产生的异常对象 然后处理
捕获机制关键字：try catch finally
捕获机制格式：
try{
try代码块(可能产生异常的代码块)
}catch(定义异常引用1){
catch代码块1(对引用1捕获的异常进行处理的代码块)
}catch(定义异常引用2){
catch代码块2(对引用2捕获的异常进行处理的代码块)
}catch(定义异常引用3){
catch代码块3(对引用3捕获的异常进行处理的代码块)
}finally{
finally代码块("无论"任何情况都要执行的代码块)
}
注意：>1 无论try代码块是否产生异常 无论catch代码块如何处理异常
都要执行finally代码块
>2 当try代码块是否产生异常 try代码块 不再执行 而是执行对应的catch的代码块
不可能同时执行两个catch代码块
* >3 捕获父类异常的catch代码块 必须放在捕获子类异常的catch代码块后面
* finally代码块 一般用于关闭流 释放资源(io)
*/
Throwable
---Error
---Exception
---运行时异常 (未检测异常)：继承RuntimeException的异常
---编译时异常(已检测异常)： 没有继承RuntimeException的异常
区别：>1 是否为 RuntimeException的子类
运行时异常是 RuntimeException的子类
编译时异常不是 RuntimeException的子类
>2 编译器是否检测
运行时异常编译器不检测 (如果有可能产生运行时异常 不捕获也不抛出 编译器不会报错)
编译时异常编译器会检测(如果有可能产生编译时异常 不捕获也不抛出 编译器会报错)
>3 是否默认抛出
运行时异常如果不捕获 默认抛出
>4 出现概率不同
运行时异常出现的概率高
编译时异常只有在特定情况下才会出现
自定义异常：
异常之间的区别：异常原因(通过构造方法的参数列表传递)和异常类名
MiaoTiaoBaoExcption
1 创建类 继承异常体系中的类 称为异常类
2 通过构造方法的参数列表传递异常原因
3 通过调用父类的有参数的构造方法 传递错误原因
4 在方法中产生一个自定义异常情况
集合重点：
>每种集合类的特点
>每种集合类的遍历方式
集合概念：装引用数据类型的容器
集合和数组的区别：
相同之处：都是容器 可以装多个数据
>1 是否可以装基本数据类型
集合只能装引用数据类型
数组可以装基本数据类型和引用数据类型
>2 元素类型是否必须相同
集合中元素的类型可以不同
数组中元素的类型必须相同
>3 元素个数是否可变
集合的元素个数可变
数组一旦创建 元素个数固定
>4 元素是否有默认初始值
集合中元素没有默认初始值
数组中元素有默认初始值
集合框架：
集合框架顶层接口：Collection(单列集合顶层接口) Map(双列集合顶层接口)
Collection(单列集合顶层接口)
普通方法：
>添加： boolean add(E e)
boolean addAll(Collection<E> c)
>删除： boolean remove(Object o)
boolean removeAll(Collection<E> c)
void clear()
>获取： Iterator<E> iterator() 获取迭代器
int size()
Object[] toArray()
>判断： boolean isEmpty()
boolean contains(Object o)
Iterator接口中的方法：
boolean hasNext()
E next()
遍历方式： 1 简洁for循环 2 转换为数组 遍历数组 3迭代器
>for(E e:c1){}
>Object[] arr=c1.toArray();
for(int index=0;index<arr.length;index++){}
>Iterator<E> it=c1.iterator();
while(it.hasNext){
E e=it.next();
}
子接口---List(有序列表)
---ArrayList
特有普通方法
>添加： void add(int index, E element) 把参数对象添加到index位置处
>删除： E remove(int index) 移除index位置处的元素
>获取： E get(int index) 获取index位置处的元素
int lastIndexOf(Object o) 倒着检索 获取第一次出现o元素的下标
int indexOf(Object o) 获取第一次出现o元素的下标
>设置： E set(int index, E element) 把index位置处的元素替换为element
遍历方式： 1 简洁for循环 2 转换为数组 遍历数组 3迭代器 4通过下标获取元素
>for(int index=0;index<array.size();index++){
E e=array.get(index);
}
---Vector
ArrayList与Vector的区别：
相同之处：都是模拟长度可变数组的Collection的实现类
不同之处：>版本不同：Vector1.0 ArrayList1.2
>是否同步 Vector 线程安全 同步 但效率低
ArrayList 线程不安全 不同步 但效率高
子接口---Set(无序 但不重复集合)
---HashSet
没有特有方法：
遍历方式： 1 简洁for循环 2 转换为数组 遍历数组 3迭代器
HashSet保证不重复的原理：
set.add(obj)
>先定义obj的hashCode()方法 获取hashcode值 如果此hashcode值唯一
直接加入
>如果有n个元素与此hashcode值相同 则调用obj的equals方法与此n个元素分别比较
只有当都返回false 才允许加入
Map(双列集合顶层接口)
---HashMap(键值对 键不能重复 允许null值和null键)
HashMap和HashTable的区别：
相同之处：都是基于hash表的Map的实现类
不同之处： > HashMap允许有null值和null键 但HashTable不允许
> HashMap线程不安全 效率高 HashTable线程安全 效率低
普通方法：
添加： V put(K key,V value);
删除： V remove(Object key)
获取： V get(Object key)
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()
int size()
判断： boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
File :文件(文件、文件夹)
静态成员变量：separator \
构造方法：
File(File parent, String child)
File(String pathname)
File(String parent, String child)
普通方法：
> 创建新文件(不能创建文件夹)
boolean createNewFile()
boolean mkdir()
boolean mkdirs()
> 判断
boolean isDirectory() 判断是不是目录
boolean isFile() 判断是不是标准文件
> 获取
String getPath() 获取创建文件时构造方法的参数
String getName() 获取文件名(不带目录)
String getAbsolutePath() 获取绝对路径(带盘符)
String getParent() 获取父目录路径
File getParentFile() 获取父目录对象
long length() 获取当前文件所占的字节数
File[] listFiles() 获取当前目录下的直接子文件
> 删除
boolean delete()
IO流： 对计算机中数据传输的抽象(抽取共同的数据和方法)
流：一组有序的 有起点的 有终点的字节集合
IO流：
>按方向分类： 参照物为内存
输入流：把外部存储设备上的信息 读到内存中
输出流：把内存中的信息 写到外部存储设备上
把A文件中的信息复制到B文件中
>通过输入流 把A文件中的信息 读到内存中
>再通过输出流 把内存中的信息 写到B文件中
>按基本单位分类
字节流：每次存在一个字节 以byte为单位
字符流： 字节流+编码表
所有的文件都可以用字节流操作 但只有纯文本文件 可以用字符流
>按关联的对象分类
节点流：关联文件的流
过滤流/装饰流： 关联的是其他流 具有更多的方法和属性
文件：源文件 目的文件
InputStream :字节输入流
----FileInputStream
OutputStream :字节输出流
注意：导包：java.io.*
InputStream :字节输入流
----FileInputStream
构造方法：
FileInputStream(String name)
FileInputStream(File file)
普通方法：
int read() 一次读一个字节
int read(byte[] b) 一次读一个字节数组
读取到文件末尾时 返回-1
void close() 关闭流释放资源
InputStream :字节输入流
----FileInputStream
OutputStream :字节输出流
----FileOutputStream
注意：导包：java.io.*
InputStream :字节输入流
----FileInputStream
构造方法：
FileInputStream(String name)
FileInputStream(File file)
普通方法：
int read() 一次读一个字节
int read(byte[] b) 一次读一个字节数组
读取到文件末尾时 返回-1
void close() 关闭流释放资源
OutputStream :字节输出流
----FileOutputStream
构造方法：
FileOutputStream(File file) //关联目的文件对象
FileOutputStream(String name)
FileOutputStream(File file, boolean append)
FileOutputStream(String name, boolean append)
普通方法：
void close() 关闭流释放资源
void write(byte[] b)
void write(int b)
void write(byte[] b, int off, int len)
字符流： 读进来 写出去
Reader: 字符输入流的父类
---FileReader
构造方法：
FileReader(File file)
FileReader(String fileName)
普通方法：
int read() 一次读取一个字符
int read(char[] cbuf) 一次读取一个字符数组
void close() 关闭流释放资源
Writer:字符输出流的父类
---FileWriter
构造方法：
FileWriter(File file)
FileWriter(String fileName)
FileWriter(String fileName, boolean append)
FileWriter(File file, boolean append)
普通方法：
void close()
void write(char[] cbuf)
void write(int c)
void write(String str)
普通方法：
void close()
void write(char[] cbuf)
void write(int c)
void write(String str) 一次写一个字符串
void flush() 把内容从缓冲区刷新到目的文件
BufferedInputStream 高效字节输入流
BufferedOutputStream 高效字节输出流
没有特有方法：
BufferedWriter 高效字符输出流
特有方法：
BufferedReader 高效字符输入流
特有方法： String readLine() 逐行读取 读取的内容中没有互换
到达文件末尾返回null
除了FileOutputStream 其他所有输出流 必须刷新
过滤流/装饰流：直接关联的不是文件 是其他流
让被关联的流具有一些本类不具有的方法
以stream结尾的是 字节流
以reader、writer结尾的是 字符流
转换流：(字符流)
InputStreamReader：把字节输入流 转换为字符输入流
OutputStreamWriter：把字节输出流转换为字符输出流
构造方法：
InputStreamReader(InputStream in, String charsetName)使用指定编码集
OutputStreamWriter(OutputStream out, String charsetName)
InputStreamReader(InputStream in) 使用默认编码集
OutputStreamWriter(OutputStream out)
没有特有方法：所有方法和filewriter 和filereader完全一样
不要使用scanner 只使用System.in //static InputStream in
写一个方法 把键盘输入的数字 字母 和其他字符 分别写到三个不同的文件中
进程： 本电脑上正在运行的程序 一个程序对应一个进程
线程： 运行的程序中 正在执行的代码块
java默认执行 main方法中的代码块---main方法的代码块对应一个
一个进程至少一个线程在执行 ：
一个进程只有一个线程在执行---单线程
一个进程有多个线程在执行(一个程序有多个代码块同时执行)--多线程、线程并发
多线程原理：cpu在时间轮片内在多个线程之间随机的切换
时间轮片： 时间单位 25ms
进程是线程的执行空间 进程好比 正在开工的工厂
线程是进程的基本单位 线程好比 正在运行的流水线
***java的垃圾处理机制：
垃圾：不存在更多引用的对象
Object: void finalize():当垃圾回收器确定不存在对该对象的更多引用时，
由对象的垃圾回收器调用此方法。
System: static void gc(): 运行垃圾回收器。
垃圾回收和主方法(主线程)不是同一个线程：
系统会不定时的启动垃圾回收器 垃圾回收器会通过判断对象是不是存在更多引用
来判断对象是不是垃圾 如果是垃圾就调用对象的finalize方法 销毁对象释放内存
程序员可以通过System.gc()来启动垃圾回收器 来主动干涉垃圾回收机制
线程类：Thread
创建线程方式一：
将类声明为 Thread 的子类。
该子类应重写 Thread 类的 run 方法。
接下来可以分配并启动该子类的实例。
>1 创建一个类继承Thread类
>2 重写run方法 方法中写线程任务
>3 创建此线程类的对象
>4 调用线程对象的方法 实现多线程
Thread类的方法：
void start() 开启线程；java虚拟机会自动调用此线程的run方法
写三个线程 分别随机打印100个 数字 小写字母 大写字母
Thread类
构造方法：
Thread() 默认线程名字：Thread-编号
Thread(String name) 指定线程名字
Thread(Runnable target)
Thread(Runnable target, String name)
普通方法：
String getName() 获取线程名字
void setName(String name) 设置线程名字
void start() 开启线程；Java 虚拟机调用该线程的 run 方法。
void run() 方法体是线程任务
static void sleep(long millis) 线程休眠执行毫秒
static Thread currentThread() 获取当前正在执行的线程对象
思考一下：
怎么实现 通过多线程来模拟 三个学生分别给一个老师每人交5本作业
老师得到一本作业 就打印一下老师的已收到的作业数
创建线程方法二：
声明实现 Runnable 接口的类。
该类然后实现 run 方法。
然后可以分配该类的实例，
在创建 Thread 时作为一个参数来传递并启动
>1 创建一个类 实现Runnable接口
>2 实现run方法 方法体是线程任务
>3 创建实现类对象
>4 创建Thread对象 通过参数列表关联实现类对象
>5 开启线程
继承Thread类 子类要重写run方法 start方法调用时 虚拟机调用的是线程类的重写后的run方法
实现Runnable接口 创建的Thread类的对象 start方法调用时 虚拟机调用的是实现类的run方法
void join() 等待该线程终止。
在a线程任务中 调用b线程的join方法 a线程会等待b线程执行完毕 再继续执行
(a线程任务中要使用b线程的执行结果时 )
*/
死锁方式一：使用join方法
两个线程对象互相调用对方的join方法
同步代码块：synchronized
线程安全问题：多个线程有多行代码操作共享数据时 发生结果无法预期的现象
前提： > 多线程
> 多个线程之间有共享数据
> 线程有多行代码操作共享数据
根本原因：A线程在操作共享数据时 B线程对共享数据进行修改
A线程的前后操作共享数据的结果不一致
通过技术解决线程安全问题： 当一个线程在操作共享数据时 其他线程不能使用共享数据
同步代码块：
synchronized(任意对象){
操作共享数据的所有代码
}
同步代码块小括号中的对象：可以是任意类型的对象 锁对象
使用同步代码块时注意：
> 1 同步代码块 必须包括了所有操作共享数据的代码
> 2 所有线程 的 锁对象必须唯一
*/
同步方法：当一个方法的整个方法体都是同步时 可以把此方法定义为同步方法
有synchronized修饰符
同步方法的锁是 当前对象 this
线程章的重点：
> 创建线程两种方式步骤和区别
> 同步代码块
> 两种死锁
死锁情况二：两个线程 两个同步代码块互相嵌套 内外锁交替
内部类： 当A类依赖于B类的存在而存在时 把A类定义为B类的内部类
内部类是外部类的成员
类的成员：成员变量 普通方法 构造方法 内部类 静态代码块 构造代码块(给成员变量赋值)
内部类： 当A类依赖于B类的存在而存在时 把A类定义为B类的内部类
内部类是外部类的成员
类的成员：成员变量 普通方法 构造方法 内部类 静态代码块 构造代码块(给成员变量赋值)
xml: extended markup language
可扩展的标记语言
作用: 非编程语言 是描述性语言
用于存储有关系的数据
用于存储软件配置信息(初始数据的加载)
语法: xml的代码 就是标签
<标签名 属性名="属性值" 属性名="属性值">数据</标签名>
<标签名 属性名="属性值" 属性名="属性值">：起始标签
数据 :存储和描述的数据
</标签名> ：结束标签
起始标签和结束标签的相同之处区别： 标签名字相同
不同之处：>位置不同 一前一后
>是否有属性 起始标签中可以加属性
>格式不同 结束标签面前有/
语法要求:
> xml文件必须有两部分组成 声明区和数据区
声明区： 对整个xml文件进行说明 格式<?xml version="1.0" encoding="gbk" ?>
数据区： 有且只有一个根标签
> 标签名和属性名 都是自定义的
标签和属性命名：由数字 字母 下划线 汉字组成 不能以数字开头 不能包含空格 : . ?
> 起始标签中可以写多个属性 属性格式：属性名=属性值
属性值 规范写法使用""括起来
> xml中区分大小写
> 标签之间可以合理嵌套： <a><b>额呵呵呵</b><c>二哥哥哥</c></a>
> 注释格式：<!--注释的内容-->
> xml是纯文本语言 使用可以操作文本的软件 都可以作为xml的编辑工具
xml文件的后缀名必须是.xml 所有浏览器中内置有xml的解析器
> 对xml有特殊含义的字符 需要通过字符实体来表示：字符实体格式：&xxxx;
> 大于号
< 小于号
" 双引号
& 单与
xml的解析：从xml文件中 对数据进行增删改查
方式一：DOM解析： document object model 文档对象模型
核心：把xml文件本身和其所有的元素 都封装成对象 这些有关系的对象形成了dom树
所有对象类型的顶层接口：Node(节点)
文档本身： Document(文档)
标签： Element
属性： Attr
文本内容： Text
方式二：SAX解析： simple api xml 简单的xml解析类库
核心： 按照顺序 以事件监听的机制对xml文件中的数据进行快速读取
特点：
Dom解析：优点：支持对xml文档增删改查
缺点：所有的元素都对应一个对象 对象创建在内存中 占内存
SAX解析：优点：支持快速读取
缺点：不支持对xml的正删改
*/
xml文档解析： 查询
对xml操作 必须先获取Document对象 步骤固定：
Document： NodeList getElementsByTagName(String tagname)
通过标签名获取标签集合
NodeList： int getLength() 获取元素个数
Node item(int index) 通过下标获取元素
Element： String getAttribute(String name) 通过属性名获取属性值
NodeList getElementsByTagName(String name) 获取指定名称的所有子标签
Node: String getNodeName() 获取节点名称(属性名和标签名)
String getTextContent() 获取标签的文本内容
short getNodeType() 获取节点类型
Node getParentNode() 获取父标签
NodeList getChildNodes() 获取所有的子标签
增删改查：create delete update read
curd
添加： Document: Element createElement(String tagName) 创建标签
Element : void setAttribute(String name, String value) 给标签添加属性
Node : void setTextContent(String textContent) 给标签设置文本内容
: Node appendChild(Node newChild) 把参数标签添加到当前标签下面
一般情况：只有最低层的标签 才设置文本内容
在红方标签下添加一个子标签
<中野司令 name="徐向前">
<军长 id="5" name="张大彪">
<师长 name="孙德胜" number="10007">骑兵师</师长>
</军长>
</中野司令>
删除：
Node : Node removeChild(Node oldChild) 通过父标签删除子标签
Element: void removeAttribute(String name) 删除属性
Node:所有元素的父接口
---Document：文档本身
---Element：标签
---Text ：文本内容
---Attr ：属性
增删改查：create delete update read curd
查询：
Node: String getNodeName() 获取当前标签的名字
NodeList getChildNodes() 获取所有的子标签
Node getParentNode() 获取父标签
String getTextContent() 获取文本内容
其他方法
boolean hasAttributes() 判断是不是含有属性
booleen hasChildNodes() 判断是不是含有子标签
NamedNodeMap getAttributes()
Document: NodeList getElementsByTagName(标签名); 通过标签名获取标签集合
Element: String getAttribute(属性名); 通过属性名获取属性值
NodeList getElementsByTagName(标签名); 通过标签名获取指定的子标签集合
添加：
Document: Element createElement(标签名);创建标签
Node: void setTextContext(文本内容); 添加文本内容
Node appendChild(子标签) ; 把参数子标签添加到当前标签下
Element： void setAttribute(属性名,属性值); 添加属性
删除： Node: Node removeChild(Node oldChild);由父标签删除子标签
void setTextContext(" "); 删除文本内容
Element: void removeAttribute(String name) 删除属性
1 html概念：
hyper text markup language
超文本标记语言
作用：把数据以指定的样式通过浏览器显示到页面上
原理：通过标签封装数据 通过属性控制样式
基本语法：<标签名 属性名=属性值 属性名=属性值>数据</标签名>
<标签名 属性名=属性值 属性名=属性值>：起始标签
</标签名> ：结束标签
属性名=属性值 ：属性
2 html文件组成
>html文件 后缀名为.html/.htm
>html文件 根标签 是<html></html>
html标签中有两个子标签head标签和body标签
head标签中 是对当前html文件进行描述的信息 如<title></title>
body标签中 是当前页面的显示数据
3 html代码注意事项
>html非严谨语言 不区分大小写
>html注释 <!--注释的内容-->
>html中的标签 基本都是以起始标签和结束标签
有些标签没有要封装的数据 效果单一----内部闭合标签
如<br/>换行标签 <hr/>水平线标签
>html起始标签中可以加属性控制样式
属性：属性名=属性值 属性值可以有双引号/单引号括起来 或者不括
建议使用双引号
> 标签之间可以合理嵌套 <p>数据0<font color="red">数据1</font></p>
>html代码规范：子标签缩进对其
>html中标签和属性是预定义的(那些标签有哪些属性是定义好的)
4 文本标签：
文本块标签：
> <br/> 换行标签
> <h1>标题标签</h1> hn的n取值1到6
效果：换行 加粗 居左 后面有空行 1到6字体由大到小
属性：align 水平对其方式 值：left(默认) right center
> <hr/> 水平线标签
效果：水平线
属性：size 粗细 值：像素px
color 颜色 值：英文单词/#6个16进制表示三原色
width 左右宽度 值：像素px/百分百
align 水平对其方式 值：left right center(默认)
> <pre>格式化标签</pre>
效果：保留数据的原有格式
> <p>段落标签</P>
效果：前后有空行
属性：align 水平对其方式 值：left(默认) right center
> <center>居中标签</center>
文本行标签：
> <font>文本标签</font>
效果：封装数据
属性：color：文字颜色 值：英文单词/#6个16进制表示三原色
size: 文字大小 值：1-7 -2---+4
face: 字体样式
> 特殊效果的文本标签
b标签 基础
i标签 斜体
u标签 下划线
s标签 中划线
sup标签 上标
sub标签 下标
内部类分为4种，成员内部类，局部内部类，静态内部类，匿名内部类
成员内部类：作为外部类的一个成员存在，与外部类的属性，方法并列。
注意：1.成员内部类不能定义静态变量。内存加载情况。*************************************
2.访问外部成员时默认外部 类名.this.(外部的)成员，若
没有重名的，可以直接（外部类）成员名。
3.访问内部类成员变量默认有this.同普通类一致。
4.外部类静态方法访问内部类，和外部类外部访问内部类一样（注意静态方法的独立加载区域）
方法为：Out out=new Out();Inner inner=out.new Inner();创建外部类对象，利用
外部类对象创建内部类对象。使用对象对内部类的成员完成调用。
5.外部类非静态方法使用内部类，与普通类之间相互调用一致。
成员内部类优点：
1.内部类可以访问外部类所有属性。
2.可用内部类定义外部类无法使用的属性，实现比private小的权限。（内部类属于编译时的概念，
一旦编译成功，就是两个完全不同的类，形成2个字节码文件.class）
3.可以实现类的多继承。外部类继承一个类A，内部类继承另外一个类B，即可实现内部类同时继承
外部类、A、B三个类。
局部内部类：在方法中定义的内部类，与局部变量类似,不能用范围修饰符修饰，范围为定义它的代码块。比较复杂，先不管。
静态内部类：静态内部类定义在类中，内部可有静态和非静态成员，可用范围修饰符(但不能用private)。
1.内部类可访问外部类的静态成员，不能访问非静态成员。
2.外部类访问内部类静态成员：内部类.静态成员。外部类访问内部类的非静态成员：与普通
类之间调用方法一致。外部类外创建内部类对象：外部类名.内部类名 引用名=new 外部类名.内部类名 ();******************
匿名内部类：一个类用于继承其他类或实现接口，并不需要增加额外的方法（加了也不能用），只要对继承的方法实现或重写。
1.只是为了获得一个对象，不需要知道其实际类型（多态引用）。
2.没有类名，也没有构造方法。
内部类：实现较高封闭等级，实现多继承。
序列化流：(过滤流/装饰流:关联的是其他流)
(节点流：关联的是文件)
ObjectInputStream： 反序列化流:把存储对象信息的文件读到内存中 重构成对象
ObjectOutputStream： 序列化流:把内存中对象的信息写入外部存储设备中(文件)
---实现数据的持久化存储
构造方法： ObjectOutputStream(OutputStream out)
ObjectInputStream(InputStream in)
void writeObject(Object obj) 一次写一个对象
Object readObject() 到达文件末尾 抛出一个EOFException异常
注意事项：
>1 明确序列化流和反序列化流 各自的作用 字节类型的过滤流
>2 序列化流存在的对象必须实现接口Serializable
>3 读写方式：逐个对象的读写
Object readObject()读到文件末尾时 排除一个EOFException异常
只能通过判断是不是捕获到EOFException异常 来判断是不是到达文件末尾
正则表达式：为字符串定义正确规则的字符串
正则的优点：代码简洁 缺点：可读性差
使用一些特殊字符来表示指定的含义
a 表示 字符a
[] 表示字符取值范围 [abd] a或者b或者c
^ 在[]中表示取反 [^abc] 处理abc以为的所有任意一个字符
- 在[]中表示 到 [a-zA-Z] a到z A到Z
[a-z[0-9]] 等价于 [a-z0-9]
[a-z&&[b-f]] 等价于[b-f]
. 表示任意字符
\d [0-9]
\D [^0-9]
\w [a-zA-Z_0-9]
\W [^a-zA-Z_0-9]
^ 单词开始
$ 单词结束
x? x次数<=1
x* x次数>=0
x+ x次数>=1
x{n} x次数=n
x{n,} x次数>=n
x{n,m} n<=x次数 <=m
[\u4e00-\u9fa5]汉字
boolean matches(String regex) 判断当前字符串是不是匹配参数正则
String replaceAll(String regex, String str)
使用str替换符合指定规则的所有子串
String[] split(String regex, int limit)