day03
迭代器iterator
格式
Iterator<类型> xxx=修改对象.iterator(不是new出来的)
while(xxx.hashNext()){
sout(xxx.next)
}
List
list集合：有序，有索引，可以存取重复元素
list.add(索引，xxx) 添加到指定索引上
list.get(inde)，返回索引上的值
list.remove(inde） 返回被删除的值
list.set(index,xxx) 替换索引的值，返回的是被替换的值
ArrayList集合特点：底层是数组，查询慢，增删快 线程不安全, 效率高。
Set
set集合：没有顺序没有索引，不存储重复元素。
HashSet集合：底层是红黑树或数组+链表。没有顺序没有索引，不存储重复元素。
JavaBean里面添加hashCode（） equals可以判断Hashset中自定义（person，student）类的元素是否一样。
数据结构特点
栈：stack，又称堆栈，对元素的存取特点是：先进后出
队列：queue，简称队，对元素的存取特点是：先进先出
数组:Array，是有序的元素序列，对元素的存取特点是：
查找元素快： 查询快: 通过 (第一个元素地址值 + 索引) 可以快速计算出该索引元素的地址值
增删元素慢
增删慢: 增加一个元素, 要创建长度+1的新数组, 然后将原数组元素复制到新数组, 然后存入新元素; 删除类似
LinkedList特有的方法：
（1）基本方法：add, set, get, remove, clear, size等方法；
（2）特有方法：addFirst（push,）, addLast, getFirst, getLast, removeFirst（ pop）, removeLast, clear等方法。
链表:linked list，对元素的存取有如下的特点：
查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素。
增删元素快：
增加元素：只需要修改连接下个元素的地址即可。
删除元素：只需要修改连接下个元素的地址即可。
红黑树
查找: 节点存储的元素是按照大小顺序存储的
特点:
元素存储过程中就完成了大小排序
查询比链表快, 增删比数组快 (数组和链表的折中)
红黑树的适用场景:
查询和增删都有, 需要元素自动排序的场景
day04 Map集合
Map集合的遍历增强for，先用entrySet（进入），再用entry.key和entry.value 分别输出键和值。
HashMap key存取无序，可添加null
LinkedHashMap key存取有序 不可加null
boolean containsKey(Object key): 判断是否包含指定的键
Map.put 可修改（同key）可添加
map.remove （键，值）,删除元素
Map.keySet 通过键找值
Collections工具类
sort(List<T> list): 默认按照"升序"将元素排序
数字, 字母, 都可以按照升序排序
o1-o2: 升序(从小到大) o2-o1: 降序(从大到小)
shuffle 打乱，用Collections调用，
sort 排序 ,用Collections调用
1装牌，HashMap<Integer,String>集合，键是索引，值是 什么牌
2.创建一个相同索引的数组
Arraylist<Interger> list=new Arraylist;
创建了四个对象 Arraylist<Interger> person1=new Arraylist;
3.洗数组排序，然后i>=51{
dipai.add(list.get(i))
}
把这个相同索引的数组分给了四个对象。
两种方法遍历map
请使用Map集合存储自定义数据类型Car做键，对应的价格做值。并使用keySet和entrySet两种方式遍历Map集合。
Map<Car,Integer> map=new HashMap<>();
map.put(new Car("凯迪拉克","黄色"),50000);
map.put(new Car("宝马","黑色"),50000);
Set<Car> cars = map.keySet();
//for (Car car : cars) {
// Integer integer = map.get(car);
// System.out.println(car+" "+integer);
// }
Set<Map.Entry<Car, Integer>> entries = map.entrySet();
for (Map.Entry<Car, Integer> entry : entries) {
Car key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+" "+value);
}
今日API
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接口: 双列集合的根接口, 规定了共性的方法
|_ 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
|_ 迭代器
day05 异常
异常继承体系为：异常的根类是 java.lang.Throwable，其下有两个子类：
java.lang.Error 与 java.util.Exception 。而Exception又分为编译时期异常：checked异常，与运行时期异常：runtime异常。
异常的分类:
错误(Error): 不能捕获处理的严重问题. 错误的格式都是"xxxError"
异常(Exception):可以捕获的问题，运行过程中就算发生异常，程序也能处理完继续运行
运行时期异常（runtimeException）:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)
常见异常
NullPointerException:空指针异常。
ArrayIndexOutOfBoundsException:数组索引越界异常。
ArithmeticException:算术运算异常。
NumberFormatException:数字格式异常。
throw与throws的区别
1.throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行
到throw语句时立即停止，它后面的语句都不执行。
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。
多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，
就会将异常对象抛给方法调用处。
try...catch...finally是捕获异常,自己处理,处理完毕后面的程序可以继续运行
a)try代码块中是可能出现异常的代码
b)catch代码块,是遇到异常,对异常进行处理的代码
c)finally代码块是无论是否发生异常,都必须执行的代码,用于释放资源.
对象.endwith(equale("")) 测试此字符串是否以指定后缀结束,返回布尔值
对象.startswith(s.equale(""))测试字符串和前缀是否一致。返回布尔值
今日API
java.lang.Throwable: 异常的顶级
// 成员方法
String getMessage(): 异常的信息. 没有原因返回null
String toString(): 异常的类型和原因信息
void printStackTrace(): 使用标准错误输出流打印异常信息
java.lang.Thread类: 表示线程. 实现了Runnable接口
void start(): 启动线程, 即让线程开始执行run()方法中的代码
day06 多线程 同步
并行和并发
并行:指两个或多个事件同时发生
并发:两个或多个事件交给cpu，让cup交替运行。
继承Thread类，定义类继承Thread重写run()方法, 要执行的任务
创建子类的对象, 调用start()方法启动线程
Thread类中的start()方法与run()方法的区别：run只是调用方法，并不能开启线程，start：我全都要！
currentThread()获取当前线程的名称
获得主线程的名称:在测试类里面调用Thread.currentThread().getname();
获得子线程的名称:在继承类Thread里面调用Thread.currentThread().getname()，
也可以在测试类用匿名方法new Thread(){}.getName;
线程的6种状态:
NEW(新建） Runnable(可运行) Blocked(锁阻塞) Waiting(无限等待)
Timed Waiting(计时等待)===等于Thread.sleep teminated(被终止)
同步线程synchronized(锁住唯一的对象，一般定义一个Object
类的没人用的对象或者对象的 字节码){
共享代码 }
获得字节码对象的3种方式(特点:唯一的一个)
1. 对象名.getClass() new RunnableImpl().getClass()
2. 类名.class RunnableImpl.class
3. Class.forName("类的全名"); Class.forName("com.itheima.test05.RunnableImpl");
lock.lock()获得锁, lock.unlock()释放锁 lock.wait() 无限等待
lock.notify()释放锁并返回到上边的lock.wait()
今日API
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): 让当前线程处于计时等待状态, 时间到或被唤醒后结束此状态
|
|
收藏
淘帖
踩
