黑马程序员技术交流社区

标题: 笔记整理 [打印本页]

作者: 说什么好 时间: 2018-4-14 18:15
标题: 笔记整理
包装类&正则表达式把基本数据类型包装成引用数据了
8种基本数据类型的包装
byte Byte
short Short
char Character
int Integer
long Long
float Float
double Double
boolean Boolean
Integer:
String---int
方式1：int Value()
方式2：static int parseInt(String s)
int----String
方式1： +" "
方式2：String toString();
构造方法：
Integer(int value)
Integer(String s)
包装类的自动装箱和拆箱
自动拆箱：对象转成基本数值
Integer i = 10;
int a = i;
自动装箱：基本数值转成对象
Integer i = new Integer(10);
Integer i  = 10;
正则表达式：
正则表示是匹配字符串的工具
在API中查找Pattern类

Date类-----------------------------------------------
Date:
表示特定的瞬间，精确到毫秒，他可以通过方法来设定自己所表示的时间，可以表示任意时间。
Date类的构造方法：
Date() ：创建的是一个表示当前系统时间的Date对象
Date(long date) ：根据"指定时间"创建Date对象
Date类的常用方法：
void setTime(long time)`;
long getTime();

DateFormat类&SimpleDateFormat
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat类）允许进行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化。
通过这个类可以帮我们完成日期和文本之间的转换.
DateFormat类&SimpleDateFormat的常用方法：
format(Date date); //日期转文本
parse(String source) //文本转日期
Calendar类：
Calendar 是日历类，在Date后出现，替换掉了很多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取
Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，将语言敏感内容处理好，再返回子类对象。
Object类----------------------------------------------------
Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。
获取字节码的三种方式：
1.通过Object类的getClass()方法获取
2.通过类名调用属性class来获取
3. 通过Class类的静态方法forName()来获取
toString()方法:
因为toString方法返回的结果是内存地址，我们经常需要按照对象的属性得到相应的字符串变现形式，因此需要重写它
equals()方法：
equals方法，用于比较两个对象是否相同，它其实就是在比较两个对象的内存地址
Object类中的equals方法内部使用的就是==比较运算符
在开发中要比较两个对象是否相同，通常是比较对象中的属性值，所以需要重写equals方法根据对象的属性值进行比较
System类：
System 类包含一些有用的类字段和方法。它不能被实例化。

成员方法：
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) :
从src源数组的srcPos索引开始,复制length个元素
从destPost位置开始将这些元素放至到dest数组中

static long currentTimeMillis() 返回以毫秒为单位的当前时间
static void exit(int status) 终止当前正在运行的 Java 虚拟机
常见的数据结构----------------------------------------
数组：
查找元素快：根据索引来查找
增删元素慢：每次增删数组都需要创建新的数组，移动大量元素
链表：
多个节点之间，通过地址进行拼接
查找元素慢：通过连接的节点，依次向后查找指定元素
增删元素快：只需要修改连接下个元素的地址即可
栈&队列：
堆栈：先进后出，比如弹夹
队列：先进先出，比如安检

并发修改异常 & 增强 & 泛型-------------------------------------------
产生原因：
使用迭代器遍历集合的时候，同时对集合中的元素进行增删操作产生的异常
Exception in thread "main" java.util.ConcurrentModificationException
解决方案：
不使用迭代器遍历集合，在遍历的时候使用集合的方法进行增删
使用Iterator的子接口ListIterator实现向集合中增删
泛型：
可以自定义的一种类型，把明确数据类型的工作提前到编译期
避免了类型转换的问题
可以减少黄色警告线
可以简化我们代码的书写
增强for
内部原理其实是Iterator迭代器，所以在遍历的过程中不能对集合中的元素进行增删操作
格式：
for(元素的数据类型变量： Collection集合 or  数组){
}
只能遍历数组，不能对数组中
集合&迭代器---------------------------------------------------
Collection接口：
包含了所有集合类的共同属性和方法，所以可以称为集合类的父接口
Cillection中常用的功能
boolean add():向集合中添加元素
void clear():清除集合中所有的元素
boolean contains(Object o):判断集合中是否包含某个元素
boolean isEmpty():判断集合中的元素是否为空
boolean remove(Object o ):根据元素的内容来删除某个元素
int size():获取集合的长度
Object[] toArray():能够将集合转换成数组并把集合中的元素存储到数组中
迭代器
一种获取集合中元素的通用方式
这种方式描述在Iterator接口中
Iterator常用的方法：
hasNext():判断集合中是否有元素可以迭代
next():用来返回迭代的下一个元素，并把指针向后移动一位
List的特有功能：
void add(int index,E  element) :将元素添加到Index索引位置上
E get(int index):根据index索引获取元素
E remove(int index):根据Index索引删除元素
E set(int index, E element):将Index索引位置上的元素设置为element
LinkedList特有功能：
LinkedList底层使用的是链表结构，所以增删快，查询相对ArrayList较慢
void addFirst(E e):向链表的头部添加元素
void addLast(E e):向链表的尾部添加元素
E getFirst():获取链头的元素
E getLast():获取链尾的元素
E removeFirst():返回链头的元素，并删除
E removerLast():返回链尾的元素，并删除

HashMap集合------------------------------
Map接口：
Map接口下的集合和Collection接口下的集合存储形式不同：
Collection中的集合，元素都是单个存在，添加元素采用一个个元素的方式存储
Map中的集合，元素都是成对存在，由键和值两部分组成，通过键可以获取所对应的值
Collection 中的集合称为单列集合，Map中的集合称为双列集合
Map中的集合不能包含重复的键，但是值可以，每个键只能对应一个值
Map常用功能：
映射功能：
V put(K key,V value):以键= 值的方式存入Map集合
获取功能：
V get(Object key) 根据键获取值
int size() 返回Map中键值对的个数
判断功能：
boolean containsKey(Object key) : 判断Map集合中是否包含键为key的键值对
boolean containsValue(Object value):判断Map集合中是否包含值为value键值对
boolean isEmpty():判断Map集合中是否没有任何键值对
删除功能：
void clear():清空Map集合中所有的键值对
V remove(Object key) :根据键值删除Map中键值对
遍历功能：
Set<Map.Entry<K,V>>entrySet():将每个键值对封装到一个个Entry对象中，再把所有的Entry的对象封装到Set集合中返回
Map的两种变量方式：
map.setKey();
获取索引key键，然后遍历key键，通过key键来获取对应的值 .get(value)
Set<Map.Entry<K,V>>entrySet();
把一对对键值封装到Entry中，然后调用getKey();  getValue();分别获取键和值
HashSet集合--------------------------
Set 接口的特点：（无序，无索引，无重复的集合）
存入集合的顺序和取出集合的顺序不一致
没有索引
存入集合的元素没有重复
HashSet唯一性原理（无重复元素）：
新添加到HashSet集合中的每个元素都会与集合中已有元素一一比较，
首先会产生一个哈希值，如果新添加的元素与集合中已有的元素的哈希值都不同，把新元素存入集合
如果新添加的元素与已有元素哈希值相同，再调用equals（）比较，返回true则说明新添加的元素与集合中已有元素属性值相同，则不添加
如果返回false说明不重复，则添加。

Collections:（它里面都是静态方法）--------------------------
是一个工具类，方法都是用来操作Collection集合
常用方法：
static void swap(List list , int  i , int j):将指定列表中的两个索引进行位置互换
static void sort(List <T> list) :把列表中的元素按自然顺序进行排序
static void shuffle (List list) :索引随机置换
static void reverse(List list) :反转集合
static void fill(List list ,Object obj) :用指定的对象填充列表所有元素
static void copy(List dest, List src) :把源列表中的数据覆盖到目标列表（目标列表长度大于等于源列表）
static void binarySearch(List list, Object key) 使用二分法查找指定元素在指定列表的索引位置（列表必须有序才可以使用二分法）

可变参数本质上就是一个长度可变的数组
Java可以把多个参数帮我们直接转成数组
格式：
实参：一个参数一个参数的传递
形参：类型...变量名
注意：
在可变参数之后不可以再追加参数
参数的数量定义，可以给多个甚至也可以一个都不给

异常的概述和体系：------------------------
异常：在代码编译或者运行时发生的错误
常见异常：
NULLPointerException 空指针异常
ArrayIndexOutOfBoundException 数组索引超出界限
异常的体系：
java.lang.Throwable(最顶层)
|_ Error (不应该试图捕获的严重问题, 不能处理的异常)
|_ Exception (可以处理的异常) # 编译时异常: 编译时期就会发生的异常
|_ RuntimeException       # 运行时异常: 编译时正常, 运行时才会发生的异常
异常输出信息详解：
Exception in thread "main" java.util.ConcurrentModificationException 在main线程发生异常
java.util.ConcurrentModificationException: 异常的具体类型, 这里是并发修改异常
at xxx.xxx.xxx: 异常发生的位置
异常的处理方式：
JVM默认处理方式：
如果开发者没有出来异常，JVM就会把异常的类型原因位置显示在命令行上，并终止程序。并且异常以后的代码都不会再执行
手动处理异常的两种方式：
try...catch
把可能发生异常的代码进行处理，纠正错误防止程序终止
try {
// 将可能会发生异常的代码
// 放在这里
// 可以有多行代码
} catch (异常类型异常对象名) {
// 对异常进行处理的代码
// 也可以通过异常对象名获取异常的信息
}
try..catch的执行顺序：
先执行try的语句体，如果发生异常去找catch里对应的异常类型，try语句体里异常语句之后的语句都不执行
throws
定义位置：方法形参后，如果抛出多个异常，可以用，逗号分隔
不捕获异常，把异常向外界抛出，直到最顶层的方法，最终终止程序
一般在无法处理异常，希望外界处理异常时使用
多异常处理：
多异常的捕获：
可以写多个catch代码块来处理同一个try代码块中的多个异常
多异常捕获catch的顺序：
如果被捕获的异常类没有继承关系，则catch的顺序可以随意定义
如果异常关系是继承关系的类，必须子类异常在上，父类异常在下
因为如果父类包含子类的异常，如果上方的父类异常被catch捕获了，那么捕获子类异常的catch永远也不会用到
多个catch代码块的执行逻辑：
try代码块中抛出的异常，如果catch中有对应的异常，则执行对象catch代码块，其他不会catch不会执行
try代码块中抛出的异常，如果catch中没有具体对应的异常，则所有代码块不会执行，相当于异常没有捕获，程序会终止运行
补充: JDK1.7新特性: 在一个catch中捕获多个异常类型
* 在一个catch的参数中填写多个异常类型, 格式: `catch (异常类型1 | 异常类型2 异常变量名) {}`
* 注意
* 不同异常类型之间用`|`分隔, 变量名只有一个
* catch代码块中, 由于不同异常类型都只对应同一个变量名, 所以在需要判断是哪种异常时, 可以使用`变量名 instanceof 异常类型`来判断具体是何种类型; 如果不需要针对具体异常类型分别处理, 可以不判断异常类型, 统一通过异常变量名来做统一的处理, 示例如下:

```java
// 格式
try {
// 可能抛出异常的代码
} catch (异常类型1 | 异常类型2 异常变量名) {
// 异常处理代码
if (异常变量名 instanceof 异常类型1) {
// 处理异常类型1
} else if (异常变量名 instanceof 异常类型2) {
// 处理异常类型2
}
}

异常的分类：
编译时异常：编译时发生的异常
Exception及其子类（除RuntimeException体系）
处理方式：编译时期就必须处理（try...catch）
运行时异常：编译时异常，但运行时发生的异常
处理方式：编译时期可以自由选择处理或不处理
自定义异常：
自定义编译时异常类：
定义一个类，继承Exception或其子类（不包含RuntimeException类），重写构造方法
自定义运行时异常类：
定义一个类，继承RuntimeException或其子类，重写构造方法
使用自定义异常类：
使用编译时异常：
在方法声明上，使用throws抛出Exception或其子类的类型（除RuntimeException）
使用运行时异常：
在方法内部代码中，使用throw抛出RuntimeException或其子类的异常
throws和throw的区别：
throws：主动抛出编译时异常，在方法声明上使用
throw:用于主动抛出运行时异常，在方法中适应
finally:
是一个关键字，与try catch配合，无论是否发生异常，无论是否捕获异常都会执行finally代码块
Throwable的常用方法;
String getMessage():异常的信息，没有原因返回
String toString(); 异常的类型和原因
void printStackTrace():使用标准错误输出流打印异常信息
递归概述：
递归是一种思想，把大问题拆成小问题，把小问题再拆成小问题，解决了所有的小问题，大问题也就解决了
在java中代码的实现方式：方法自己调用自己
作用：简化代码书写
注意事项：
必须定义方法的结束方式（出口）.没有结束的方式会导致内存溢出
递归次数要注意，次数太多会导致内存溢出
扩展：（能用循环实现不用递归）
所有的递归都可以转换为循环
而循环不一定能转换为递归

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2