黑马程序员技术交流社区

标题: 学习经验总结 [打印本页]

---

作者: xyq96    时间: 2018-11-15 18:28
标题: 学习经验总结

java.util.List<E>接口:
// 常用特有成员方法 (都是按照索引来操作的)
[Java] 纯文本查看 复制代码
?
1
2
3
4
public void add(int index, E element): 将指定的元素, 添加到该集合中的指定位置上
public E get(int index): 返回集合中指定位置的元素
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素
public E set(int index, E element): 用指定元素替换集合中指定位置的元素, 返回值的更新前的元素


java.util.LinkedList<E>类: 链表结构, 查询慢, 增删快
// 特有成员方法(主要操作开头和末尾元素)
[Java] 纯文本查看 复制代码
?
1
2
3
4
5
6
7
8
9
void addFirst(E e): 将指定元素插入此列表的开头
void addLast(E e): 将指定元素添加到此列表的结尾
E getFirst(): 返回此列表的第一个元素
E getLast(): 返回此列表的最后一个元素
E removeFirst(): 移除并返回此列表的第一个元素
E removeLast(): 移除并返回此列表的最后一个元素
E pop(): (其实就是removeFirst())从此列表所表示的堆栈处弹出一个元素 栈stack
void push(E e): (其实就是addFirst())将元素推入此列表所表示的堆栈
java.util.Collections类: 操作集合的工具类

// 静态方法
[Java] 纯文本查看 复制代码
?
1
2
3
4
static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素
static void shuffle(List<?> list) :打乱集合顺序
static <T> void sort(List<T> list) :将集合中元素按照默认规则排序
static <T> void sort(List<T> list，Comparator<? super T> c):将集合中元素按照指定规则排序

单列集合体系:
Collection接口: 单列集合的根接口, 规定了公共的功能 | |_ List接口: 元素存取有序, 可重复, 有索引 | |_ Vector类: 底层数组, 有索引, 内存空间连续分配, 查询快, 增删慢, 线程安全, 效率低 | |_ ArrayList类: 底层数组, 有索引, 内存空间连续分配, 查询快, 增删慢, 线程不安全, 效率高 | |_ LinkedList类: 底层链表, 查询慢, 增删快 | |_ 遍历 | - toArray(): 可以 | - 普通for: 可以 | - 增强for: 可以 | - 迭代器: 可以 | |_ Set接口: 元素不可重复, 无索引 |_ HashSet类: 底层哈希表, 元素无序, 元素不可重复(用hashCode()和equals()方法来判断) | |_ LinkedHashSet类: 哈希表+链表, 同时具有HashSet的元素不重复, 链表存取有序的特点. | |_ TreeSet类: 底层红黑树结构(存入元素时就会按照元素自然顺序排序). | |_ 遍历 - toArray(): 可以 - 普通for: 不可以, 没有索引, 不能用! - 增强for: 可以 - 迭代器: 可以

能够说出List集合特点

1. 元素存取有序
2. 有索引
3. 元素可以重复
能够说出数组结构特点

查询快
增删慢
能够说出栈结构特点

先进后出
入口出口是同一个
能够说出队列结构特点

先进先出
入口出口在两侧
能够说出单向链表结构特点

查询慢
增删快

栈, 队列
能够说出Set集合的特点

1. 没有索引
2. 元素不能重复
能够说出哈希表的特点

哈希表 = 数组 + 链表/红黑树

先调用 hashCode()算出哈希值, 根据哈希值判断数组中是否有重复元素
如果要没有, 就添加
如果有元素, 哈希值冲突
则调用元素的 equals() 遍历 链表/红黑树 依次比较
如果有重复的, 则不添加
如果没有重复的, 则添加
使用HashSet集合存储自定义元素

去重
重写 hashCode()
   重写 equals()
能够说出可变参数的格式

方法名(参数类型... 变量名) {
   // 当作数组来使用
}

方法名();  // 数组

注意事项:
只能有1个可变参数, 必须放在最后
能够使用集合工具类

Collections类
[Java] 纯文本查看 复制代码
?
1
2
3
4
5
6
static addAll(Collection c, T... t)
   static shuffle(List list)
   static sort(List list)
   static sort(List list, Comparator c)
能够使用Comparator比较器进行排序
static sort(List list, Comparator c)

   
传递Comparator实现类对象, 重写 compare(T o1, T o2)
    规则:
o1 - o2 升序
o2 - o1 降序
Day04

java.util.Map接口: 双列集合的顶层
// 成员方法
[Java] 纯文本查看 复制代码
?
1
2
3
4
5
6
V put(K key, V value): 添加/修改键值对. 如果键存在, 则用新值替换已有值
V remove(Object key): 根据键删除键值对, 返回被删除元素的值
V get(Object key): 根据键获取值. 如果键不存在, 则返回null
boolean containsKey(Object key): 判断是否包含指定的键
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)

// JDK 9对于集合初始化的优化
java.util.List
// 静态方法
static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
java.util.Set
// 静态方法
static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
java.util.Map
// 静态方法
static Map<K, V> of(K k1, V v1): 返回包含指定键值对的 不可变Map 集合
Map双列集合总结

Map接口: 双列集合的根接口, 规定了共性的方法
|_ HashMap类: 哈希表=数组+链表+红黑树. key无序不可重复, 可存null键null值, 线程不安全效率高
| |_ LinkedHashMap类: 哈希表+链表. 哈希表实现key不可重复, 链表实现key存取有序
|
|_ Hashtable类: 哈希表. Hash特性针对key, key无序不可重复, 不可存null键null值, 线程安全效率低
|_ TreeMap类: 红黑树结构(存入时就排序). Tree特性针对key, 可以按照key排序, 要求key具备比较性
|_ 遍历
|_ keySet(): 获取所有key组成的Set集合, 遍历Set集合拿到key, 通过Map的get(key)得到value
| |_ 对于Set<Key>的遍历
| |_ 增强for
| |_ 迭代器
|_ entrySet(): 获取所有的key和value组成的Entry对象的Set集合, 遍历出entry对象, 通过entry对象的getKey()获取对应的key, 通过Entry对象的getValue方法获取对应的value
|_ 对Set<Entry>的遍历
|_ toArray()
|_ 增强for
|_ 迭代器
Map集合特点

1. 键值对方式存储
2. 键和值必须是引用类型, 可以类型相同, 也可不同
3. 键不能重复的, 存取无序
4. 一个键只能对应一个值

适合存储 一对一关系 的数据

HashMap: 可以存null值和null键
使用Map集合添加方法保存数据

V put(K key, V value):
如果键不存在, 添加键值对, 并返回null
如果键存在, 用新值替换旧值, 并返回旧值
使用”键找值”的方式遍历Map集合

keySet()
   
[Java] 纯文本查看 复制代码
?
1
2
3
4
Set<键> set = map.keySet();
for (键的类型 key : set) {
   值 = map.get(key);
}

使用”键值对”的方式遍历Map集合

Entry  entrySet()
   
[Java] 纯文本查看 复制代码
?
1
2
3
4
5
Set<Map.Entry<K, V>> set = map.entrySet();
for (Map.Entry<K, V> entry : set) {
   entry.getKey();
   entry.getValue();
}

使用HashMap存储自定义键值对的数据
自定义对象 Person

作为值
没有特殊要求
作为键
需要重写 hashCode() equals()


Day05
今日API

java.lang.Throwable: 异常的顶级
// 成员方法
String getMessage(): 异常的信息. 没有原因返回null
String toString(): 异常的类型和原因信息
void printStackTrace(): 使用标准错误输出流打印异常信息
java.lang.Thread类: 表示线程. 实现了Runnable接口
   void start(): 启动线程, 即让线程开始执行run()方法中的代码
程序中异常和错误的区别

异常: XxxException, 可以处理
错误: XxxError, 不能处理, 需要修改代码
异常的分类

编译时异常: Exception及其子类(排除RuntimeException)
   编写代码时就发生的异常, 在编写代码时必须进行处理
运行时异常: RuntimeException及其子类
运行时发生的异常, 可以不处理
虚拟机处理异常的方式

打印错误信息红字
中断程序
常见的三个运行期异常

运行时期
[Java] 纯文本查看 复制代码
?
1
2
3
4
5
NullPointerException
IndexOutOfBoundsException
ArrayIndexOutOfBoundsException
ConcurrentModificationException
ClassCastException



编译时异常
IOException
FileNotFoundException
ParseException
使用try...catch关键字处理异常

[Java] 纯文本查看 复制代码
?
1
2
3
4
5
6
7
8
9
try {
   // 可能发生异常的代码
   // 可能发生异常的代码
   // 可能发生异常的代码
   // 可能发生异常的代码
   // 可能发生异常的代码
} catch (异常类型 变量名) {
   // 处理异常的逻辑
}

...
[Java] 纯文本查看 复制代码
?
1
2
3
4
5
catch (异常类型 变量名) {
   
} finally {
   // 释放资源 (无论是否有异常都会被执行)
}


方法内部自己可以处理, 就是用 try-catch
使用throws关键字处理异常

public static void 方法名() throws 异常类名, 异常类名... {
   
}

方法自己不能(不适合)处理, 交给方法的调用处进行处理
自定义异常类

编译时异常: 定义类继承Exception          强制要求方法调用者处理的异常
运行时异常: 定义类继承RuntimeException   不是特别严重的异常
处理自定义异常类

制造: throw 异常对象;
处理:
throws声明抛出
try-catch捕获处理
进程的概念

程序中至少有一个进程, 可以有多个进程
程序 > 进程

进程: 一个应用程序在内存中的一次执行过程
线程的概念

线程: 进程中的一条执行路径

一个进程中至少有1个线程, 可以有多个线程

进程 > 线程

最终执行代码的是线程
并发与并行的区别

并发: 同一时间段内交替执行
并行: 同一时刻同时执行

我们研究的是"并发"
开启新线程
1. 定义类, 继承Thread类
2. 重写run()方法, 方法中是线程要执行的任务
3. 创建子类的对象
4. 通过子类对象调用start()方法启动线程


day06
java.lang.Thread类: 表示线程. 实现了Runnable接口
// 构造方法
   Thread Thread(): 创建Thead对象(---就是创建一个线程)
   Thread Thread(String threadName): 创建Thead对象并指定线程名
   Thread Thread(Runnable target): 通过Runnable对象创建Thread对象
   Thread Thread(Runnable target, String threadName): 通过Runnable对象创建对象并指定线程名
// 成员方法
   void run(): 用于让子类重写, 表示该线程要执行的任务.不能直接调用
   void start(): 启动线程, 即让线程开始执行run()方法中的代码
   String getName(): 获取线程的名称
   void setName(String name): 设置线程名称
// 静态方法
   static Thread currentThread(): 返回对当前正在执行的线程对象的引用
   static void sleep(long millis): 让所在线程睡眠指定的毫秒
   
java.lang.Object类:
// 成员方法 (只能通过"锁对象"调用)
void notify(): 随机唤醒在同一个锁对象上的某一个处于等待状态的线程
void notifyAll(): 唤醒所有在同一个锁对象上处于等待状态的线程
void wait(): 让当前线程处于无限等待状态
void wait(long timeout): 让当前线程处于计时等待状态, 时间到或被唤醒后结束此状态
void wait(long timeout, int nanos): 让当前线程处于计时等待状态, 时间到或被唤醒后结束此状态

线程的6种状态
   NEW: 新建
   RUNNABLE: 运行
   BLOCKED: 阻塞
   WAITING: 无限等待
   TIMED_WAITING: 计时等待
   TERMINATED: 终止

Java中多线程运行原理

CPU高速在多个线程之间切换 (本质)
多个线程抢夺CPU的执行时间
使用继承类的方式创建多线程
继承Thread
1. 定义类继承Thread类
2. 重写run()方法
3. 创建子类的对象
4. 调用start()方法启动线程
使用实现接口的方式创建多线程

实现Runnable接口
1. 定义类实现Runnable接口
2. 重写run()
3. 创建Runnable实现类对象
4. 创建Thread对象, 并将Runnable实现类对象传入
5. 调用Thread对象的start()
说出实现接口方式的好处

1. 避免单继承的局限性
2. 解耦(提高程序的扩展性, 降低程序的耦合性) 将线程和任务分离
解释安全问题的出现的原因

多线程操作共享变量
使用同步代码块解决线程安全问题

synchronized (锁对象) {
// 操作共享变量的代码(可能发生安全问题的代码)   
}

锁对象:
1. 类型可以是任意类型
2. 锁对象必须是多个线程共享的唯一的同一个对象
使用同步方法解决线程安全问题

非静态:
public synchronized 返回值类型 方法名(参数列表) {
// 操作共享变量的代码(可能发生安全问题的代码)   
}
锁对象: this

静态:
public static synchronized 返回值类型 方法名(参数列表) {
// 操作共享变量的代码(可能发生安全问题的代码)   
}
锁对象: 当前类的字节码对象 Class对象 (同一个类, 字节码对象只有唯一的一个)
对象.getClass()
   类名.class
   Class.forName("类的全名字符串")
线程6个状态的名称
NEW 新建
RUNNABLE 可运行
BLOCKED 锁阻塞
WAITING 无限等待
TIMED_WAITING 计时等待
TERMINATED 终止terminated

---

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

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