黑马程序员技术交流社区

标题: 笔记总结 [打印本页]

作者: 沃土乐也强了 时间: 2018-11-20 17:01
标题: 笔记总结
Day 03总结
         数据结构：
                        栈：先进后出。出入口只有一个在同一侧。（入栈：存入元素。出栈：取出元素）
                     队列：先进先出。入口和出口在两端。
                       数组：查询快（通过第一个元素地址+索引来快速计算）、增删慢（每增加一个元素就要创建一个新的数组再将原来的数组复制进去）；
                     链表：由节点组成。（单向列表：每个节点储存数据+下个节点的地址值）
                        特点：查询慢（只能从第一个节点依次向后查询）
                                 增删快（只要修改保存的下一个节点的地址值就可以快速增删）
                        红黑树：每个节点最多有两个子节点。（节点的元素是按大小顺序储存的，查询比链表快，增删比数组快）
List集合：
          特点：1.元素存取有序；
                     2.元素可以重复；
                     3.有索引；
          java.util.List接口:
               // 常用特有成员方法 (都是按照索引来操作的)
                  void add(int index, E element): 将指定的元素, 添加到该集合中的指定位置上
               E get(int index): 返回集合中指定位置的元素
               E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素
                  E set(int index, E element): 用指定元素替换集合中指定位置的元素, 返回值的更新前的元素

ArrayList集合的特点：
                     ArrayList底层的数据结构:  数组
                     ArrayList的特点:查询快；增删慢；线程不安全, 效率高
java.util.LinkedList<E>类:
                     链表结构, 查询慢, 增删快
                  // 特有成员方法(主要操作开头和末尾元素)
                  void addFirst(E e): 将指定元素插入此列表的开头
                  void addLast(E e): 将指定元素添加到此列表的结尾
               E getFirst(): 返回此列表的第一个元素
               E getLast(): 返回此列表的最后一个元素
               E removeFirst(): 移除并返回此列表的第一个元素
               E removeLast(): 移除并返回此列表的最后一个元素
               E pop(): (其实就是removeFirst())从此列表所表示的栈中弹出一个元素
               void push(E e): (其实就是addFirst())将元素添加到此列表所表示的栈中

Set集合：
Set集合体系特点:
1. 元素不可重复
2. 没有索引
HashSet特点:
1. 元素不可重复
2. 没有索引
3. 元素存取无序 (存入和取出顺序有可能不一致)
4. 底层采用哈希表结构. (查询快)
哈希表 = 数组 + 链表或红黑树
java.util.HashSet类:
// 常用方法
boolean add(E e): 添加元素, 根据元素的 hashCode() 和 equals() 方法判断是否重复. 重复则不添加并返回false, 不重复则添加并返回true

day04
其中主要是学习了map集合其中常用的子类有HashMap<k，v>，和LinkedHashMap<k,v>
HashMap<k，v>：底层是哈希表，键值存取无序，不可重复。
LinkedHashMap<k,v>：地层是哈希表+链表，key存取有序，不可重复。
map中常用的方法：
V put(K key, V value): 添加/修改键值对.
如果键存在, 则用新值替换已有值, 返回被替换的值; 如果键不存在, 添加键值对, 返回null
V remove(Object key): 根据键删除键值对, 返回被删除元素的值
如果键不存在, 返回null
V get(Object key): 根据键获取值.
如果键不存在, 则返回null
boolean containsKey(Object key): 判断是否包含指定的键
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的Entry对象的集合(Set集合)

了解JDK9对集合的优化：
   提供了一些静态方法：
   静态方法
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 集合
注意事项:
1. of() 方法只适用于List接口, Set接口, Map接口, 不适用于接口的实现类
2. of() 方法的返回值是一个不可变的集合, 集合不能再使用 add(), put() 方法添加元素, 会抛出异常
3. Set接口和Map接口在调用 of() 方法的时候, 不能有重复的元素, 否则会抛出异常

Debug调试模式介绍：
f8:逐行执行程序
f7:进入到方法中
shift+f8:跳出方法
f9:跳到下一个断点,如果没有下一个断点,那么就结束程序
ctrl+f2:退出debug模式,停止程序
Console:切换到控制台

Day05

异常的介绍与练习：

异常的体系结构

java.lang.Throwable  体系最顶层
               |_ Error       不应该试图捕获的严重问题, 不能处理的错误
               |_ Exception    可以处理的异常
                                 |_ RuntimeException 运行时异常
异常(Exception): 可以捕获处理的问题. 发烧感冒吃个药就好了
程序执行起来后, 如果有合适的处理方式, 即使发生异常, 程序也能处理该异常并继续运行
异常的类名都是 "XxxException" 方式
1. 编译时异常:
编译时期就会发生的异常, 必须在编译时期处理  Unhandled exception XxxException
2. 运行时异常:
编译时正常, 运行时才会发生的异常

异常的处理方式有两种：
1.throws声明异常抛出：
注意:
1. throws 必须写在方法声明上
2. throws 后面的异常类名, 一般是 Exception 或 Exception的子类
(RuntimeException及其子类也行, 但是没有什么意义)
3. 方法内部如果抛出了多个异常对象, throws 后也必须声明多个异常
如果抛出的异常对象有子父类关系, 那么直接声明父类异常即可
4. 调用了一个带有 throws 声明抛出异常的方法, 就必须处理该异常:
要么继续声明 throws 抛出
要么 try...catch 捕获处理异常

2.try。。。catch处理：
try {
      // 可能产生异常的代码
} catch (异常类名变量名) {
      // 处理异常的代码
      // 一般会将异常信息存储到日志中
}

多线程：
并发：(交替执行) 指两个或多个事件在"同一时间段内"发生
并行：(同时执行) 指两个或多个事件在"同一时刻"发生 (同时发生)
线程: 是进程内的一个独立执行单元 (一条代码执行路径)
一个程序运行后至少有一个进程, 一个进程中可以包含多个线程

创建多线程的方式：继承Thread类
实现多线程的第一种方式:
1. 定义类, 继承 Thread 类
2. 重写 run() 方法, run方法内部是线程要执行的任务
3. 创建Thread子类的对象, 调用 start() 方法启动线程

java.lang.Thread类: 表示线程. 实现了Runnable接口
void start(): 启动线程, 即让线程开始执行run()方法中的代码
注意:
必须调用 start() 方法来开启线程, 不能直接调用 run() 方法, 调用 run() 会变成单线程
同一个线程对象, 不能多次调用 start() 方法
Java是抢占式调度, 不同线程的代码, 执行顺序是随机的

Day06
Java中多线程运行原理
随机性
抢占式, CPU高速随机切换执行(本质), 多个线程抢夺CPU的执行资源
内存
每个线程都有各自栈, 堆共用

Thread的常用方法；
java.lang.Thread类: 表示线程. 实现了Runnable接口
// 构造方法
Thread(): 创建Thead对象
Thread(String threadName): 创建Thead对象并指定线程名
Thread(Runnable target): 通过Runnable对象创建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): 让所在线程睡眠指定的毫秒

Thread和Runnable的区别
实现Runnable的好处:
1. 避免单继承的局限性
2. 增强了程序的扩展性, 降低了程序的耦合性(解耦)
线程是Thread, 任务是Runnable实现类对象. 相当于将线程和任务分离

耦合性: 相互之间的关系的紧密程度
耦合性高: 相互之间的关系非常紧密
耦合性低: 相互之间的关系不太紧密
我们追求 "低耦合

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

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