A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

© 卞建彬 中级黑马   /  2018-9-20 15:44  /  717 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

崔璞:


day01 Object 常用API
Object类之toString方法
public StringtoString() :返回该对象的字符串表示
Object类之equals方法
public booleanequals(Object obj) :指示其他某个对象是否与此对象"相等"
自定义类如果要使用者两个方法,一般要重写
Date类: 日期, 表示特定的瞬间, 精确到"毫秒"
// 构造方法
Date(): 创建Date对象, 表示当前系统时间
ate(long date): 创建Date对象, 使用指定的毫秒值作为时间
// 常用成员方法
long getTime(): 获取Date对象中保存的时间毫秒值
void setTime(long time): 修改Date对象的时间
ava.text.DateFormat抽象类: 用于格式化和解析时间. 提供了方便的方法
String format(Date date): 格式化, 从Date对象转换为String对象
   Date parse(String source): 解析, 从String对象转换为Date对象
DateFormat类之格式化format方法
String format(Date date): 格式化, 从Date对象转换为String对象
               y:
               M:
               d:
               H: 时 (24小时制)
               m:
               s:
               
               E: 星期
               D: 年中的天
               K: 小时(12小时制)
               S: 毫秒
例如, SimpleDateFormat对象的模式是: "yyyy年MM月dd日  HH:mm:ss"
那么, 将Date格式化后就可以是这种样子: 2018年01月02日  03:04:05
Calendar
    Calendar c =Calendar.getInstance();  // 代表了当前时间
获取日历对象, 并测试以下方法
int get(int field)  获取指定日历字段的值
void set(int field, intvalue)  修改指定日历字段为指定值
void add(int field, intamount) 调整指定日历字段的值, 整数增加,负数减少
Date getTime()  Calendar转换成 date
void setTime(Date d)    Date转换成Calendar
日期转换总结:
long (数学计算)        \      SimpleDateFormat         Date --------------------String (用户输入和显示)        /Calendar (获取时间的某个部分)longDate对象互转       利用Date               Date(long millis): longDate               long getTime(): DatelongStringDate对象互转        利用SimpleDateFormat               Date parse(Strings): StringDate               String format(Date): DateStringCalendar对象和Date对象互转        利用Calendar               Date getTime():CalendarDate                voidsetTime(Date d): DateCalendar
System类之数组复制方法
java.lang.System类: 系统相关功能
       // 静态方法
        staticvoid arrayCopy(Object src, int srcPos, Object dest, int destPos, int length): 复制源数组中指定长度个元素到一个新数组中
       * Object src: 源数组 (被复制的数组)
       * int srcPos: 源数组索引 (从源数组的哪个索引开始复制)
       * Object dest: 目标数组 (要复制到哪个数组)
       * int destPos: 目标数组索引 (指定目标数组接收元素的索引位置)
       * int length: 长度 (要复制的元素个数)
StringBuilder类字符串拼接问题
+号拼接字符串的问题:
       String是不可变的, 使用加号进行字符串拼接, 会创建很多额外的对象, 浪费内存空间
补充:
实际上+加号在最终执行时, 会被翻译为:
       new StringBuilder("原字符串").append("要拼接的字符串").toString();
额外创建了多余的StringBuilder对象
StringBuilder概述与构造
java.lang.StringBuilder类: 可变字符序列, 可以高效拼接字符串. 底层使用数组保存
       // 构造方法
       StringBuilder(): 构造一个空的StringBuilder容器
       StringBuilder(String str): String转StringBuilder
StringBuilder常用方法
java.lang.StringBuilder类: 可变字符序列, 可以高效拼接字符串. 底层使用数组保存
       // 常用方法
       StringBuilder append(任意类型): 添加任意类型数据的字符串形式, 并返回当前对象
       String toString(): 将当前StringBuilder对象转换为String对象
补充:
String和StringBuilder互转: 利用StringBuilder
       StringBuilder(String str): String转StringBuilder
       String toString(): StringBuilder转String
包装类包装类概述
包装类: 基本数据类型对应的引用数据类型
自动装箱与自动拆箱装箱: 从基本类型转换为对应的包装类对象
拆箱: 从包装类对象转换为对应的基本类型
day02 Collection 泛型
Collection集合概述
集合: 长度可变容器, 可以存储多个对象
集合和数组的区别:
       1. 数组长度不可变; 集合长度可变
       2. 数组可以存基本类型或引用类型, 只能存同一种类型; 集合只能存储引用类型元素, 可以是多种类型元素
集合框架介绍
Collection接口: 单列集合顶层
       |_ List接口: 元素存取有序, 可重复, 有索引
       |_ Set接口: 元素存取无序, 不可重复, 无索引
Collection常用功能
java.util.Collection接口:
       // 成员方法(子类都会实现)
       boolean add(E e): 把给定的对象添加到当前集合中
       void clear(): 清空集合中所有的元素
       boolean remove(E e): 把给定的对象在当前集合中删除
       boolean contains(E e): 判断当前集合中是否包含给定的对象
       boolean isEmpty(): 判断当前集合是否为空(没有元素)
       int size(): 返回集合中元素的个数
       Object[] toArray(): 把集合中的元素,存储到数组中
      
       Iterator<E> iterator(): 获取集合的迭代器对象 (后面讲到)
       Iterator接口: 迭代器
      
测试Collection接口的方式:
       使用多态方式创建对象: Collection c = new ArrayList();
       编译看左边,这样只能调用Collection接口中定义的方法, 不会出现子类特有方法
迭代器迭代器Iterator接口介绍和迭代步骤
迭代: 类似于遍历, 判断是否有下一个元素, 有则取出下一个, 直到没有
迭代器: 用于遍历集合的对象
java.util.Collection<E>接口:
       // 成员方法(子类都会实现)
       Iterator<E> iterator(): 获取集合的迭代器对象
      
java.util.Iterator<E>接口: 迭代器
       // 成员方法
       boolean hasNext(): 判断是否有下一个元素
       E next(): 获取下一个元素
      
       void remove(): 删除next指向的元素
      
使用迭代器遍历集合的3步:
       1. 使用集合对象的 iterator() 获取迭代器对象, 用 Iterator 接口接收.(多态)
       2. 使用 Iterator 接口中的 hasNext() 方法, 判断是否有下一个元素
       3. 使用 Iterator 接口中的 next() 方法, 获取下一个元素
list.for
增强for循环
       对数组只是写法上的优化, 底层还是普通for循环
       对集合是通过迭代器实现的
增强for, 普通for, 迭代器的区别:
       增强for:
               优点: 获取元素很方便, 格式简单
               缺点: 没有普通for中的索引, 没有迭代器对象可以进行元素的增删
               应用场景: 适用于遍历获取数组和集合元素的场景
       普通for:
               优点: 有索引可以使用, 某些方式可以在遍历过程中增删元素
               缺点: 格式繁琐
               应用场景: 需要用到索引的场景
       迭代器:
               优点: 可以使用迭代器对象的方法操作元素
               缺点: 格式繁琐
               应用场景: 需要在迭代过程中增删元素的场景
泛型泛型的概述以及不使用泛型产生的问题
泛型:Generic. JDK 5 增加. 是一种未知的数据类型
       定义集合时,某些方法不知道使用什么类型时, 就可以使用泛型
       创建集合对象时, 需要确定泛型具体的类型
      
泛型可以看作是一个变量, 用来接收数据类型
泛型的好处
不使用泛型的问题:
       集合实际存储的是 Object 类型, 存入的元素无论是什么类型, 都会被提升为 Object, 取出来的也是 Object, 要想调用元素特有方法, 就要向下转型, 有可能发生类型转换异常 ClassCastException
泛型的好处:
       1. 避免了类型转换的麻烦
       2. 将运行时的类型转换异常, 转移到了编译时期 (有利于程序员提前发现问题)
day03 List Set
栈的特点:
       先进后出(FILO, First In Last Out)
       入口和出口在同一侧
      
入栈(压栈): 将元素存入栈
出栈(弹栈): 从栈中取出元素
栈的适用场景:
       栈内存(main方法先进栈调用, main方法中的其他方法都调用完毕后, main才能出栈)
       反转内容 (车尾变车头, 进去再出来就反转了)
队列的特点:
       先进先出(FIFO, First In First Out)
    入口和出口在两端
队列的适用场景:
       秒杀, 抢购
       在线售票
       处理高并发场景
数组的特点:
       查询快: 通过 (第一个元素地址值 + 索引) 可以快速计算出该索引元素的地址值
       增删慢: 增加一个元素, 要创建长度+1的新数组, 然后将原数组元素复制到新数组, 然后存入新元素; 删除类似
链表的特点:
       查询慢: 要找到其中某个节点, 只能从第一个节点一个一个向后寻找
       增删快: 只需要修改保存的下一个节点的地址值, 就可以快速完成增删
红黑树: 是一种 平衡 二叉 查找 树
       平衡: 左子节点和右子节点数量相等
       二叉: 每个节点最多有2个子节点
       查找: 节点存储的元素是按照大小顺序存储的
       特点:
               元素存储过程中就完成了大小排序
               查询比链表快, 增删比数组快 (数组和链表的折中)
红黑树的适用场景:
       查询和增删都有, 需要元素自动排序的场景
List集合List介绍和常用方法
List集合体系的特点:
       1. 元素存取有序 (存入和取出元素的顺序一致)  3 2 1      3 2 1   
       2. 元素可以重复   3 2 2 1
       3. 有索引
List子体系中的实现类都具有上述特点
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的特点:
       查询快
       增删慢
       线程不安全,效率高
      
ArrayList适用场景:
       存储的数据"查询多, 增删少"的场景. 如用一个ArrayList存储中国城市名称
LinkedList集合的特点和特有方法
LinkedList底层的数据结构:
       链表
      
LinkedList的特点:
       查询慢
       增删快
       线程不安全,效率高
      
LinkedList适用场景:
       存储的数据"查询少, 增删多"的场景. 如用LinkedList实现栈或队列
      
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集合体系HashSet集合
Set集合体系特点:
       1. 元素不可重复
       2. 没有索引
      
HashSet特点:
       1. 元素不可重复
       2. 没有索引
       3. 元素存取无序 (存入和取出顺序有可能不一致)
       4. 底层采用哈希表 结构. (查询快)
               哈希表 = 数组 + 链表或红黑树
java.util.HashSet类:
       // 常用方法
       boolean add(E e): 添加元素, 根据元素的hashCode() 和 equals() 方法判断是否重复.重复则不添加并返回false, 不重复则添加并返回true
Set集合体系HashSet集合
Set集合体系特点:
       1. 元素不可重复
       2. 没有索引
      
HashSet特点:
       1. 元素不可重复
       2. 没有索引
       3. 元素存取无序 (存入和取出顺序有可能不一致)
       4. 底层采用哈希表 结构. (查询快)
               哈希表 = 数组 + 链表或红黑树
java.util.HashSet类:
       // 常用方法
       boolean add(E e): 添加元素, 根据元素的hashCode() 和 equals() 方法判断是否重复.重复则不添加并返回false, 不重复则添加并返回true
HashSet存储自定义元素的去重
自定义JavaBean对象实现在HashSet中去重:
       JavaBean默认继承Object类中的 hashCode() 和 equals() 方法, 都是根据对象地址值判断是否重复的
       要根据属性值判断是否重复, 应该在JavaBean类中重写hashCode() 和 equals() 方法, 使其按照属性值比较
LinkedHashSet集合
LinkedHashSet特点:
       1. 元素存取有序 (存入和取出顺序一致)
       2. 元素不可重复
       3. 没有索引
      
LinkedHashSet底层数据结构:
       哈希表 + 链表   (也就是: 数组 + 链表或红黑树 + 链表)
       其中, 哈希表用于存储数据, 额外的链表用于记录元素添加时的先后顺序, 以便在获取元素时保持顺序一致
补充:
总结: 什么时候用List, 什么时候用Set?
       要存储的元素可以重复的, 用List集合:
               增删少, 用ArrayList
               增删多, 用LinkedList
       要存储的数据要求不重复, 或者相对一个集合去重, 用Set集合:
               不要求存取顺序一致, 用HashSet
               要求存取顺序一致, 用LinkedHashSet
Collections集合工具类Collections集合工具类: addAll(), shuffle()
java.util.Collections类: 操作集合的工具类
       // 静态方法
       static <T> boolean addAll(Collection<? super 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):将集合中元素按照指定规则排序
Collections集合工具类:sort(List<T> list,Comparator<? super T> )
Comparable接口和Comparator接口区别
       Comparable: 让JavaBean自身具有可比较性 (自己和其他人比)
       Comparator: 定义一个比较器类, 用比较器对象比 (让第三个人来帮两个人比较)
Comparator使用方式:
       定义类作为比较器, 实现Comparator<E>接口, 重写 int compare(E o1, E o2) 方法, 泛型为要比较的元素的类型
       在Collections.sort(List<T>list,Comparator<? super T> c)方法中传入自定义比较器对象
       规则:
               o1-o2: 升序(从小到大)
               o2-o1: 降序(从大到小)
day04  Map笔记
Map集合概述
java.util.Map<K,V>接口
Map集合特点:
       1. 是双列集合, 一个元素包含两个值 (键key, 值value)
       2. key和value的类型可以相同, 也可以不同
       3. key不允许重复, value可以重复
       4. key和value是一一对应的, 一个键只能对应一个值
Map集合适合存储一对一关系的数据
Map常用子类
java.util.Map<K,V>接口: 双列集合的根接口, 规定了共性的方法
       |
       |_ HashMap<K, V>类: 底层哈希表. key存取无序不可重复
               |_ LinkedHashMap类: 底层哈希表+链表. key存取有序不可重复
               
映射: 键和值的对应关系 mapping
HashSet底层使用的就是HashMap
LinkedHashSet底层使用的就是LinkedHashMap
Map中常用方法
Map<String,Phone> map = new HashMap<>();
map.put("张三",p1);
map.put("张三",p2);
java.util.Map接口: 双列集合的顶层
       // 成员方法
       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集合中所有的Entry对象的集合(Set集合)
补充:
entry 节点
Map key value
+---------------+
| K key, V value|
+---------------+
    publicclass Entry {
       K key;
       V value;
       K getKey();
       V getValue();
    }
Map遍历方式一:keySet()方法实现通过键找值
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
      
keySet()遍历步骤:
       1. Map对象调用 keySet() 方法, 获取包含所有key的Set集合
       2. 遍历Set集合, 获取每个key
       3. 通过Map对象调用 get(Object key) 方法根据key获取到value
Entry键值对对象介绍
java.util.Map.Entry接口:
       // 常用成员方法
       K getKey(): 获取Entry对象中的键
       V getValue(): 获取Entry对象中的值
      
Entry对象就是一个节点,节点中存储了key和value
拿到一个Entry对象就可以从中获取key和value
Map遍历方式2: 通过entrySet()获取Entry对象形式遍历
java.util.Map接口
       Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
entrySet()方法遍历Map步骤:
       1. Map对象调用 entrySet() 获取包含所有Entry对象的Set集合
       2. 遍历Set集合, 获取每个Entry对象
       3. 调用Entry对象的 getKey() 和getValue() 方法获取键和值
HashMap存储自定义数据类型作为键
HashMap存储自定义JavaBean对象作为key保证key唯一不重复, 需要让JavaBean重写 hashCode() 和 equals() 方法
LinkedHashMap
LinkedHashMap底层: 哈希表 + 链表
       key不允许重复, 但key存取有序
LinkedHashSet的底层就是使用LinkedHashMap实现的
JDK9对集合添加的优化
使用集合添加大量元素时, 反复add(...)比较麻烦.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 集合
      
注意:
       1. of() 方法只适用于List接口, Set接口, Map接口, 不适用于接接口的实现类
       2. of() 方法的返回值是一个不能改变的集合, 集合不能再使用 add(), put() 方法添加元素, 会抛出异常
       3. Set接口和Map接口在调用 of() 方法的时候,不能有重复的元素, 否则会抛出异常
将 不可变集合 的元素转移到常见集合实现类中:
JDK9对集合添加的优化

您需要登录后才可以回帖 登录 | 加入黑马