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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 542744848 初级黑马   /  2018-9-20 14:36  /  1455 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

语法定义: 定义格式     概念     注意事项    使用方法
API:    构造方法-->参数列表      成员方法 -->返回值类型   参数列表    方法作用    注意事项
关键字:
Object类Object类: toString方法java.lang.Object类: 根类, 所有类的父类
    // 成员方法
    String toString() :返回该对象的字符串表示  Person
    boolean equals(Object obj) :指示其他某个对象是否与此对象"相等"
   
   
Object类的特点:
    是所有类的父类, 任何一个类都直接或间接地继承自Object类, 并可以使用Object类中定义的方法
    一个类如果没有指定继承某个父类, 则默认继承Object类
   
public String toString() :返回该对象的字符串表示
    作用:
        任何类的对象都可调用toString(), 得到一个对象的字符串表示形式, 默认使用Object类中定义的方式
        如果不想使用默认方式, 子类可以重写toString()方法, 转换为自己想要的内容
   
一般我们都要输出JavaBean的属性名和属性值, Alt + Insert 选择 toString() 即可重写



// Object类中toString()的实现方式:
public class Object {

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
}


代码解释:
    getClass().getName():
        getClass(): Object类的方法, 获取当前对象的类的字节码对象
        getClass().getName(): 通过字节码对象获取该类的全名
    Integer.toHexString(hashCode())
        hashCode(): Object类的方法, 获取当前对象地址值的哈希值
        Integer.toHexString(int n): 将参数转换为十六进制数字的字符串
    最终:
        com.itheima01.Person@75412c2fObject类: 重写equals()方法
重写equals()的作用:
    不重写时, 自定义对象默认继承Object类的equals()方法, 通过 == 比较地址值
    但开发时, 一般要重写equals()方法, 让对象"根据属性值"来判断是否相等

IDEA快捷键: Alt+Insert, 选 equals() and hashCode()Objects类中的equals方法s1 = null;
s1.equals(s2);  // NullPointerException


java.util.Objects类: JDK7 添加. 操作对象的工具类, 提供了空指针安全的方法
    // 静态方法
    static boolean equals(Object a, Object b): 比较两个对象是否相等
        如果2个参数都是null, 返回true
        如果其中一个为null, 返回false
        如果2个参数都不为null, 则使用第1个参数对象的equals()方法来比较
        
// Objects类中equals()方法源码
public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}常用API日期时间相关的类
日期转换:

    long (数学计算)
        \       SimpleDateFormat
         Date -------------------- String (用户输入和显示)
        /
Calendar (获取时间的某个部分, 调整时间)


long和Date对象互转
    利用Date
        Date(long millis): long转Date
        long getTime(): Date转long
String和Date对象互转
    利用SimpleDateFormat
        Date parse(String s): String转Date
        String format(Date): Date转String
Calendar对象和Date对象互转
    利用Calendar
        Date getTime(): Calendar转Date
        void setTime(Date d): Date转CalendarDate类: 构造方法, 成员方法
注意: 不要导错包! 有2个包中都有Date类, 一个是java.sql.Date, 另一个是java.util.Date
我们用的是 java.util.Date

java.util.Date类: 日期, 表示特定的瞬间, 精确到"毫秒"
    // 构造方法
    Date(): 创建Date对象, 表示当前系统时间
    Date(long date): 创建Date对象, 使用指定的毫秒值作为时间
    // 常用成员方法
    long getTime(): 获取Date对象中保存的时间毫秒值
    void setTime(long time): 修改Date对象的时间  DateFormat 类和 SimpleDateFormat 类
java.text.DateFormat抽象类: 用于格式化和解析时间. 提供了方便的方法
    // 常用成员方法 (抽象类不能创建对象, 但可以有非抽象的方法供子类使用)
    String format(Date date): 格式化, 从Date对象转换为String对象
    Date parse(String source): 解析, 从String对象转换为Date对象
   
    date -> String "yyyy年MM月dd日 HH:mm:ss"
   
java.text.SimpleDateFormat类
    // 构造方法
    SimpleDateFormat(String pattern): 用给定的模式和默认语言环境的日期格式符号创建对象
   
        示例: "yyyy-MM-dd E HH:mm:ss.SSS"
        结果: 2016-04-01 星期五 17:29:15.868
        
        如果要匹配普通的英文字母, 则需要用单引号括起来: "'abc'"
        如果要匹配单引号, 则使用2个单引号: "''"
        
// 使用指定的模式创建对象
SimpleDateFormat format = new SimpleDateFormat("yyyy‐MM‐dd HH:mm:ss");



格式化和解析方法: format()方法, parse()方法

String format(Date date): 格式化, 从Date对象转换为String对象
    例如, SimpleDateFormat对象的模式是: "yyyy年MM月dd日  HH:mm:ss"
    那么, 将Date格式化后就可以是这种样子: 2018年01月02日  03:04:05
   
Date parse(String source): 解析, 从String对象转换为Date对象
    例如, SimpleDateFormat对象的模式是: "yyyy-MM-dd"
    要解析为Date对象的字符串必须符合模式: 2000-01-02Calendar类:
获取Calendar对象:
java.util.Calendar抽象类: 代表日历, 提供了不同国家的历法, 封装了很多时间属性
    // 静态方法
    static Calendar getInstance(): 根据当前系统设置获取合适的Calendar对象, 表示当前系统时间
   
Calendar.getInstance() 会根据当前系统获取合适的子类对象, 我们获取到的是 GregorianCalendar
   
// 获取日历对象的示例
Calendar c = Calendar.getInstance();  // 代表了当前时间


常用功能

java.util.Calendar抽象类: 代表日历, 提供了不同国家的历法, 封装了很多时间属性
    // 静态成员变量
    static int YEAR         :年份
    static int MONTH        :月份. 注意月份数值是 0-11
    static int DAY_OF_MONTH :日期
    static int HOUR         :小时(12小时制)
    static int HOUR_OF_DAY  :小时(24小时制)
    static int MINITE       :分钟
    static int SECOND       :秒
    // 非静态成员方法  2018 09 11
    int get(int field): 获取指定日历字段的值   int date = cal.get(Calendar.DAY_OF_MONTH)
    void set(int field, int value): 修改指定日历字段为指定的值
    void set(int year, int month, int date): 快速设置年月日
    void add(int field, int amount): 调整指定日历字段的值. 正数增加, 负数减少
    Date getTime(): Calendar转Date
    void setTime(Date d): Date转Calendar


// 示例
// 获取日期:
int day = calendar.get(Calendar.DAY_OF_MONTH);
// 修改年:
calendar.set(Calendar.YEAR, 2000);
// 修改月:
calendar.set(Calendar.MONTH, 0);
// 日期增加一天:
calendar.add(Calendar.DAY_OF_MONTHY, 1);
// 日期减少一天:
calendar.add(Calendar.DAY_OF_MONTHY, -1);System类
java.lang.System类: 系统相关功能
    // 静态方法
    static long currentTimeMillis(): 返回当前系统时间的毫秒值
    static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int length): 复制源数组中指定长度个元素到一个新数组中
        * Object src: 源数组 (被复制的数组)
        * int srcPos: 源数组索引 (从源数组的哪个索引开始复制)
        * Object dest: 目标数组 (要复制到哪个数组)
        * int destPos: 目标数组索引 (指定目标数组接收元素的索引位置)
        * int length: 长度 (要复制的元素个数)StringBuilder类
java.lang.StringBuilder类: 可变字符序列, 可以高效拼接字符串. 底层使用数组保存
    // 构造方法
    StringBuilder(): 构造一个空的StringBuilder容器
    StringBuilder(String str): String转StringBuilder
    // 常用方法
    StringBuilder append(任意类型): 添加任意类型数据的字符串形式, 并返回当前对象
   
链式调用:    "1hellotrue"
    new StringBuilder().append(1).append("hello").append(true);

    // 成员方法
    String toString(): 将当前StringBuilder对象转换为String对象
   
    String和StringBuilder互转: 利用StringBuilder
    StringBuilder(String str): String转StringBuilder
    String toString(): StringBuilder转String包装类
包装类: 基本数据类型对应的引用数据类型

ArrayList<Integer> list = new ArrayList<>();
list.add(10);
int a = list.get(0);


装箱: 从基本类型转换为对应的包装类对象
    装箱原理:
    //Integer i1 = new Integer(1);
    //Integer i2 = new Integer("1");
    Integer i3 = Integer.valueOf(1); //使用包装类中的静态方法valueOf()
拆箱: 从包装类对象转换为对应的基本类型
    拆箱原理:
    int num = i.intValue();



基本类型转为String:
    1. 拼接空字符串:
        String s = "" + 34
    2. 每个包装类中的静态方法 static String toString(参数):
        String s = Integer.toString(10);
    3. String类中的静态方法 static String valueOf(参数):
        String s = String.valueOf(10);

String转基本类型: 利用每种包装类中的静态方法
    static byte parseByte(String s): 将字符串参数转换为对应的byte基本类型
    static short parseShort(String s): 将字符串参数转换为对应的short基本类型
    static int parseInt(String s): 将字符串参数转换为对应的int基本类型
    static long parseLong(String s): 将字符串参数转换为对应的long基本类型
    static float parseFloat(String s): 将字符串参数转换为对应的float基本类型
    static double parseDouble(String s): 将字符串参数转换为对应的double基本类型
    static boolean parseBoolean(String s): 将字符串参数转换为对应的boolean基本类型
    注意: 没有转char的!!
基本类型
对应的包装类(位于java.lang包中)

byte
Byte

short
Short

int
Integer

long
Long

float
Float

double
Double

char
Character

boolean
Boolean
集合
集合: 长度可变容器, 可以存储多个对象

集合和数组的区别:
    1. 数组长度不可变; 集合长度可变
    2. 数组可以存基本类型或引用类型, 只能存同一种类型; 集合只能存储引用类型元素, 可以是多种类型元素
总结:

ollection接口: 单列集合顶层
    |_ List接口: 元素存取有序, 可重复, 有索引
    |_ Set接口: 不可重复, 无索引Collection常用功能java.util.Collection<E>接口:
    // 成员方法(子类都会实现)
    boolean add(E e): 把给定的对象添加到当前集合中
    void clear(): 清空集合中所有的元素
    boolean remove(E e): 把给定的对象在当前集合中删除
    boolean contains(E e): 判断当前集合中是否包含给定的对象
    boolean isEmpty(): 判断当前集合是否为空(没有元素)
    int size(): 返回集合中元素的个数
    Object[] toArray(): 把集合中的元素,存储到数组中
   
    Iterator<E> iterator(): 获取集合的迭代器对象 (后面讲到)
        Iterator接口: 迭代器


java.util.Iterator<E>接口: 迭代器
    // 成员方法
    boolean hasNext(): 判断是否有下一个元素
    E next(): 获取下一个元素
   
    void remove(): 删除next指向的元素
   
使用迭代器遍历集合的3步:
    1. 使用集合对象的 iterator() 获取迭代器对象, 用 Iterator 接口接收.(多态)
    2. 使用 Iterator 接口中的 hasNext() 方法, 判断是否有下一个元素
    3. 使用 Iterator 接口中的 next() 方法, 获取下一个元素
   


测试Collection接口的方式:
    使用多态方式创建对象: Collection c = new ArrayList();
    编译看左边, 这样只能调用Collection接口中定义的方法, 不会出现子类特有方法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())将元素添加到此列表所表示的栈中Vector集合JDK 1.0 版本中只有一个 Vector集合
JDK 1.2 开始增加了Collection集合体系

Vector底层的数据结构:
    数组
   
Vector的特点:
    查询慢
    增删快
    (同步)线程安全, 效率低
   
Vector目前几乎没人使用Set集合
Set集合体系特点:
    1. 元素不可重复
    2. 没有索引HashSet:
HashSet特点:
    1. 元素不可重复
    2. 没有索引
    3. 元素存取无序 (存入和取出顺序有可能不一致)
    4. 底层采用 哈希表 结构. (查询快)
        哈希表 = 数组 + 链表或红黑树

java.util.HashSet类:
    // 常用方法
    boolean add(E e): 添加元素, 根据元素的 hashCode() 和 equals() 方法判断是否重复. 重复则不添加并返回false, 不重复则添加并返回true
   
HashSet原理: 哈希表结构
哈希表:
    JDK 8以前   : 哈希表 = 数组 + 链表
    JDK 8及之后 : 哈希表 = 数组 + 链表或红黑树
    数组中存储的每个元素, 是哈希值相同的一组节点的链表或红黑树
   
HashSet集合保证添加元素不重复的原理:
    调用 add(E e) 添加元素时, 先调用 hashCode() 获取哈希值, 和当前HashSet集合中的元素比较
        如果哈希值不同, 则认为元素不重复, 添加, 并返回true
        如果哈希值相同, 则有可能是哈希冲突, 所以继续调用元素的 equals() 方法和所有哈希值相同的元素比较
            如果 equals() 比较所有元素都没有相同的, 则认为元素不重复, 添加, 并返回true
            如果 equals() 比较出有相同的元素, 则认为元素重复, 不添加, 并返回false
            
自定义JavaBean对象实现在HashSet中去重:
    JavaBean默认继承Object类中的 hashCode() 和 equals() 方法, 都是根据对象地址值判断是否重复的
    要根据属性值判断是否重复, 应该在JavaBean类中重写 hashCode() 和 equals() 方法, 使其按照属性值比较LinkedHashSe
LinkedHashSet特点:
    1. 元素存取有序 (存入和取出顺序一致)
    2. 元素不可重复
    3. 没有索引
   
LinkedHashSet底层数据结构:
    哈希表 + 链表   (也就是: 数组 + 链表或红黑树 + 链表)
    其中, 哈希表用于存储数据, 额外的链表用于记录元素添加时的先后顺序, 以便在获取元素时保持顺序一致
补充:

总结: 什么时候用List, 什么时候用Set?
    要存储的元素可以重复的, 用List集合:
        增删少, 用ArrayList
        增删多, 用LinkedList
    要存储的数据要求不重复, 或者相对一个集合去重, 用Set集合:
        不要求存取顺序一致, 用HashSet
        要求存取顺序一致, 用LinkedHashSetCollections集合工具类
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):将集合中元素按照指定规则排序
   
    sort(List<T> list): 默认按照"升序"将元素排序
    数字, 字母, 都可以按照升序排序
   
自定义JavaBean对象默认不能排序, 因为不知道如何比较哪个对象大, 哪个对象小
自定义JavaBean对象要想排序, 需要实现 Comparable<E> 接口, 重写 int compareTo(E e) 方法
    规则:
        this-参数: 升序(从小到大)
        参数-this: 降序(从大到小)
            

static <T> void sort(List<T> list,Comparator<? super T> c):将集合中元素按照指定规则排序         
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: 降序(从大到小)    Map集合
java.util.Map<K, V>接口
Map集合特点:
    1. 是双列集合, 一个元素包含两个值 (键key, 值value) 键值对
    2. key和value的类型可以相同, 也可以不同
    3. key不允许重复, value可以重复
    4. key和value是一一对应的, 一个键只能对应一个值
Map集合适合存储"一对一关系"的数据


java.util.Map<K, V>接口: 双列集合的根接口, 规定了共性的方法
    |
    |_ HashMap<K, V>类: 底层哈希表. key存取无序不可重复  
        |_ LinkedHashMap<K, V>类: 底层哈希表+链表. key存取有序不可重复
        
映射: 键和值的对应关系 mapping

HashSet底层使用的就是HashMap
LinkedHashSet底层使用的就是LinkedHashMap


常用方法:
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集合)
   
  
   
  Map可以通过 keySet()或 entrySet()遍历集合
  
  HashMap存储自定义JavaBean对象作为key保证key唯一不重复, 需要让JavaBean重写 hashCode() 和 equals() 方法异常
异常: 指的是程序在执行过程中, 出现的非正常的情况, 最终会导致JVM的非正常停止
    注意:
        在Java中, 每种异常都有对应的类来描述, 发生了一个异常, 就是出现了这个异常类的"对象"
        异常不是语法错误
   
// 异常的体系结构
java.lang.Throwable  // 体系最顶层
    |_ Error         // 不应该试图捕获的严重问题, 不能处理的错误
    |_ Exception     // 可以处理的异常异常的体系结构
// 异常的体系结构
java.lang.Throwable  // 体系最顶层
    |_ Error                  // 错误
    |_ Exception              // 编译时异常
        |_ RuntimeException   // 运行时异常

错误(Error): 不能捕获处理的严重问题. 绝症
    必须将程序停下来, 修改代码才能解决
    错误的类名都是 "XxxError" 方式
异常(Exception): 可以捕获处理的问题. 发烧感冒吃个药就好了
    程序执行起来后, 如果有合适的处理方式, 即使发生异常, 程序也能处理该异常并继续运行
    异常的类名都是 "XxxException" 方式
    1. 编译时异常:
        编译时期就会发生的异常, 必须在编译时期处理  Unhandled exception XxxException
    2. 运行时异常:
        编译时正常, 运行时才会发生的异常异常的产生过程解析
异常产生的过程:
    1. 当执行的代码发生异常操作时, JVM会创建一个对应的异常类对象, 包含异常的内容, 原因, 位置
        如 new ArrayIndexOutOfBoundsException(), new NullPointerException()
    2. 如果执行代码的方法没有对异常进行 try...catch 处理, 则会向该方法调用处的方法抛(向上层抛). 如果所有方法(包括main()方法)都没有 try...catch 处理异常, 则该异常会被JVM按照默认的处理方式处理
    3. JVM对于异常的默认处理方式是:
        1. 将异常信息(内容, 原因, 位置)打印到控制台
        2. 终止当前的程序throw关键字
throw关键字作用:
    在方法中抛出指定的异常对象
   
格式:
    throw new 异常类名("异常原因字符串");

    // 示例:
    public static void method(int index) {
        if (index < 0) {
            throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在,已超出范围");
        }
    }

注意:
    1. throw 必须写在方法的内部
    2. throw 后面new的异常对象, 必须是 "Exception" 或 "Excetion的子类" 的对象
    3. 一个方法内部 throw 了一个异常对象, 则该方法可以分为2种情况来处理该异常:
        如果 throw 的是"运行时异常"(RuntimeException及其子类)对象, 那么可以不处理
            该异常最终会交给JVM处理, 结果就是: 打印异常信息到控制台, 并立刻结束程序
        如果 throw 的是"编译时异常"(Exception及其子类), 则必须处理:
            处理方式1: throws 抛出
            处理方式2: try...catch 捕获
            
java.lang.Throwable
    // 成员方法
    String getMessage(): 异常的信息. 没有原因返回null
    String toString(): 异常的类型和原因信息
    void printStackTrace(): 使用标准错误输出流打印异常信息finally代码块
格式:

    try {
        // 可能发生异常的代码
    } catch(异常类型 异常变量名) {
        // 处理异常
    }
    ...
    catch(异常类型 异常变量名) {
        // 处理异常
    } finally {
        // 无论是否发生异常, 是否捕获, 最后都会执行的代码.
        // 通常在这里执行释放资源的操作
    }

注意:
    1. finally 必须和 try...catch 一起使用
    2. finally 一般用于释放资源 (IO流时用到)异常注意事项
1.捕获多个异常:
    1. 多个异常分别 try...catch 处理
    2. 一个 try 多个 catch
        如果异常存在继承关系, 子类异常在上, 父类异常在下
    3. 多个异常, 一次捕获一次处理
        用Exception多态捕获

2.finally中有return语句
    如果 finally 代码块中有 return 语句, 则永远返回 finally 中的 return 语句的值
应该避免在 finally 中写 return 语句  

3.子父类继承重写方法时的异常要求
子父类继承关系下, 子类重写父类带有throws的方法:
    1. 如果父类抛出多个异常, 子类重写父类方法时可以有3种方式:
        a: 抛出和父类相同的异常
        b: 抛出父类异常的子类
        c: 不抛出异常
    2. 父类方法没有抛出异常, 子类重写父类该方法时也不可抛出异常
    此时子类产生该异常, 只能捕获处理, 不能声明抛出
   
一般情况下:
    父类方法声明的异常是什么样的, 子类重写的方法声明异常就什么样, 保持一致即可常见异常
运行时期
NullPointerException
IndexOutOfBoundsException
ArrayIndexOutOfBoundsException
ConcurrentModificationException
ClassCastException


编译时异常
IOException
FileNotFoundException
ParseException线程多线程原理
1: 线程执行的随机性
CPU执行哪个线程是随机的, 不能人为干预
Java线程调度是抢占式的, 多个线程互相抢夺CPU的执行权

CPU高速随机切换 (本质)
线程抢夺CPU资源

2: 多线程的内存
多线程情况下, 每个线程都有各自的栈内存
每个线程各自的方法调用, 进的是各自线程的栈
栈是每个线程各自的, 堆是所有线程共用的创建多线程程序的方式
实现多线程的第一种方式:
    1. 定义类, 继承 Thread 类
    2. 重写 run() 方法, run方法内部是线程要执行的任务
    3. 创建Thread子类的对象, 调用 start() 方法启动线程

实现多线程的第二种方式:
    1. 定义类, 实现Runnable接口
    2. 重写 run() 方法, 要执行的代码(任务)
    3. 创建Runnable实现类对象 (任务对象)
    4. 创建Thread类对象, 在构造方法中传入Runnable实现类对        象 (将任务和线程绑定)
    5. 通过Thread对象调用start()方法启动线程
   
java.lang.Thread类: 表示线程. 实现了Runnable接口

实现Runnable的好处:
    1. 避免单继承的局限性
    2. 增强了程序的扩展性, 降低了程序的耦合性(解耦)
        线程是Thread, 任务是Runnable实现类对象. 相当于将线程和任务分离
        
耦合性: 相互之间的关系的紧密程度
耦合性高: 相互之间的关系非常紧密
耦合性低: 相互之间的关系不太紧密
我们追求 "低耦合"
   
匿名内部类方式创建线程
new 父接口/父类() {
    重写方法
};

继承Thread类
实现Runnable接口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): 让所在线程睡眠指定的毫秒线程安全问题
问题发生场景:
    多个线程操作共享资源
问题发生原因:
    JVM是抢占式调度, CPU在每个线程之间切换是随机的, 代码执行到什么位置是不确定的
    在操作共享资源时, 由于一个线程还没有执行完, 另一个线程就来操作, 就会出现问题
如何解决:
    在操作共享资源时, 让线程一个一个来执行, 不要并发操作共享变量, 就可以解决问题
   
   
解决多线程操作共享数据的安全问题的3种方式:
    1. 同步代码块
    2. 同步方法
    3. Lock锁机制
   
同步的原理:
    线程进入同步代码块前, 会争夺锁对象, 只有一个线程会抢到锁对象
    进入同步代码块的线程, 会持有锁对象, 并执行同步代码块中的代码
    此时同步代码块外的线程, 处于阻塞状态, 只能等待
    当同步代码块内的线程执行完代码块, 会离开同步代码块, 并归还锁对象给同步代码块
    等在同步代码块外的其他线程就可以继续争夺锁对象
   
1.同步代码块: 使用 synchronized 关键字修饰的代码块, 并传入一个当作锁的对象
格式:
    synchronized (锁对象) {
        // 操作共享数据的代码
        
    }

注意:
    锁对象可以是"任意类型的一个对象"
    锁对象必须是"被多个线程共享的唯一的"对象
    锁对象的作用: 只让一个线程在同步代码块中执行

锁对象, 也称为"同步锁", "对象监视器"

2.同步方法: 使用 synchronized 关键字修饰的方法, 具有默认的锁对象

非静态同步方法的锁对象: this
   
    // 非静态同步方法
    public synchronized void method(){
        // 可能会产生线程安全问题的代码
    }
静态同步方法:
    public static synchronized void method(){
        // 可能会产生线程安全问题的代码
    }

静态同步方法的锁对象: 当前类的字节码对象 Class对象
RunnableImpl.class -> Class对象

获取一个类的字节码对象的3种方式:
    1. 对象名.getClass()          new RunnableImpl().getClass()
    2. 类名.class                 RunnableImpl.class
    3. Class.forName("类的全名");  Class.forName("com.itheima.test05.RunnableImpl");
字节码对象的特点:
    同一个类, 他的字节码对象只有"唯一的一个"

3. Lock锁     
java.util.concurrent.locks.Lock接口: JDK 5 新增的Lock接口
    // 成员方法
    void lock(): 获取锁
    void unlock(): 释放锁
   
java.util.concurrent.locks.ReentrantLock类: Lock的实现类线程间的通信
锁对象, 也称为"同步锁", "对象监视器"
    Object类中关于线程的方法:
java.lang.Object类:
    // 成员方法 (<<注意>>: 只能通过"锁对象"调用)
    void notify(): 随机唤醒在同一个锁对象上的某一个处于等待状态的线程
    void notifyAll(): 唤醒所有在同一个锁对象上处于等待状态的线程
    void wait(): 让当前线程处于"无限等待"状态
    void wait(long timeout): 让当前线程处于"计时等待"状态, 时间到或被唤醒后结束此状态
    void wait(long timeout, int nanos): 让当前线程处于计时等待状态, 时间到或被唤醒后结束此状态
    "注意!! 以上方法只能通过锁对象调用"
   
wait() 和 sleep() 的区别:
    1. wait会释放锁, 恢复时需要重新获取锁; sleep不会释放锁
    2. wait可以被notify/notifyAll唤醒; sleep不会
    3. wait要用锁对象调用; sleep要用Thread类名调用
线程的生命周期中, 可以出现有6种状态:
    1. "NEW 新建"
       线程被创建, 但没有调用 start() 启动
    2. "RUNNABLE 可运行"
       调用 start()方法后已启动, 但可能正在执行 run() 方法的代码, 也可能正在等待CPU的调度
    3. "BLOCKED (锁)阻塞"
       线程试图获取锁, 但此时锁被其他线程持有
    4. "WAITING 无限等待"
       通过锁对象调用无参的 wait() 进入此状态.
       等待其他线程通过锁对象执行 notify() 或 notifyAll() 才能结束这个状态
    5. "TIMED_WAITING 计时等待"
       如通过锁对象调用有参的 wait(long millis) 或 sleep(long millis), 则进入此状态.
       直到时间结束之前被其他线程通过锁对象执行 notify()或 notifyAll()唤醒, 或时间结束自动唤醒
    6. "TERMINATED 终止"
       run()方法结束(执行结束, 或内部出现异常), 则进入此状态并发,并行
并行:指两个或多个事件在同一时刻发生(同时发生)。
并发:指两个或多个事件在同一个时间段内发生。

并发的关键是你有处理多个任务的能力,不一定要同时。
并行的关键是你有同时处理多个任务的能力。
所以它们最关键的点就是:是否是『同时』。进程,线程
进程指正在运行的程序。
确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。

线程是进程中的一个执行单元,
负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。

一个程序运行后至少有一个进程,一个进程中可以包含多个线程,但一个进程中至少包含一个线程。比如使用迅雷软件下载网络文件时,同时下载多个文件,就使用到了多线程下载。


线程的调度方式:
    1. 分时调度: 所有线程轮流使用CPU, 平分占用CPU的时间
    2. 抢占式调度: 优先让优先级高的线程使用CPU; 如果优先级相同, 则随机选择一个线程执行
   
Java使用的是"抢占式"调度可变参数
可变参数:
    JDK 5 出现. 指同一个类型参数个数可变的参数
    可变参数的本质就是一个"数组"
   
    格式: 用在方法的参数中
        修饰符 返回值类型 方法名(int... 变量名) {
            // 可以直接将 变量名 当作 数组名 使用
        }
        方法名();

注意事项:
    1. 可变参数可以传递的参数个数, 可以是 0个, 1个, 多个
    2. 一个方法的参数列表中, 只能有一个可变参数
    3. 如果方法的参数有多个, 可变参数必须写在参数列表的最后泛型
泛型: Generic. JDK 5 增加. 是一种未知的数据类型
    定义集合时, 某些方法不知道使用什么类型时, 就可以使用泛型
    创建集合对象时, 需要确定泛型具体的类型
   
泛型可以看作是一个"变量", 用来接收数据类型

定义:
<E>: 声明了一个泛型 (声明了一个变量)
E: 使用E这种类型作为数据类型  (参数数据类型, 返回值类型)
使用:
ArrayList<Integer>: 确定了泛型的具体类型泛型的好处
不使用泛型的问题:
    集合实际存储的是 Object 类型, 存入的元素无论是什么类型, 都会被提升为 Object, 取出来的也是 Object, 要想调用元素特有方法, 就要向下转型, 有可能发生类型转换异常 ClassCastException

泛型的好处:
    1. 避免了类型转换的麻烦
    2. 将运行时的类型转换异常, 转移到了编译时期 (有利于程序员提前发现问题)定义和使用含泛型的类
定义泛型
    <泛型名>

泛型的"定义"和"使用"
    泛型在"定义"时, "不能是"具体的类型, 只是一个变量名
    泛型在"使用"时, "必须是"具体的数据类型
   
    // 带有泛型的类定义格式
    修饰符 class 类名<代表泛型的名字> {  // 泛型的变量一般用一个大写字母表示, 但也可以是多个字母

    }
   
类中的泛型, "在创建对象时", 确定泛型的具体类型定义含有泛型的方法与使用
方法中的泛型定义位置:
    修饰符 和 返回值类型 之间
   
    // 带有泛型的方法定义格式
    修饰符 <代表泛型的名字> 返回值类型 方法名(参数){

    }
   
方法中定义泛型后, 返回值类型和参数类型都可以使用泛型

方法泛型的使用:
    "在调用方法时"确定泛型的具体类型定义与使用含有泛型的接口
定义泛型接口与定义泛型类一样

    // 带有泛型的类定义格式
    修饰符 interface 接口名<代表泛型的变量> {

    }
   
    public interface GenericInterface<I> {
        void method(I i);
    }

实现类实现了泛型接口后可以有2种选择:
    1. "定义实现类时", 确定泛型的具体类型  
      
    2. 定义实现类时仍然沿用泛型, 直到"创建该实现类对象时"才确定泛型的具体类型      

泛型定义总结:
    定义在类上的泛型:
        有效范围: 整个类中都有效
        何时确定具体类型: 创建该类对象时确定泛型的具体类型
    定义在方法上的泛型:
        有效范围: 方法中(包括返回值类型和参数类型)有效
        何时确定具体类型: 调用方法传参时确定泛型的具体类型
    定义在接口上的泛型:
        有效范围: 接口中
        何时确定具体类型:
            1. 子接口或实现类定义时确定泛型的具体类型
            2. 创建实现类对象时确定泛型的具体类型泛型通配符
泛型通配符:
    不知道使用什么类型来接收时, 此时可以使用 <?> 来表示未知通配符
   
   
    注意: 只能接收数据, 不能调用方法存储元素
        List<?> list 这种集合不能调用 add() 添加元素, 只能调用 get() 获取元素
        List<?> list 其实是一个变量, 所以可以将一个集合赋值给它
            如: List<?> list = new ArrayList<String>();
    使用方式:
        不能创建对象使用
        只能作为方法参数使用. (减少方法重载)

泛型的上限:
    格式: 类型名称<? extends 类名> 对象名称
    示例: List<? extends Number> list
    作用: 只能接收该类型及其子类 (Number及其子类的泛型)

泛型的下限:
    格式: 类型名称<? super 类名> 对象名称
    示例: List<? super Number> list
    作用: 只能接收该类型及其父类型 (Number及其父类的泛型)数据结构数据结构: 就是数据的存储方式        不同的数据结构代表了不同的存储方式        不同的数据结构中, 会有不同的存入, 取出, 查找的方式和效率, 数据的存放方式也不同!


栈:

栈的特点:
    先进后出 (FILO, First In Last Out)
    入口和出口在同一侧
   
入栈(压栈): 将元素存入栈
出栈(弹栈): 从栈中取出元素

栈的适用场景:
    栈内存 (main方法先进栈调用, main方法中的其他方法都调用完毕后, main才能出栈)
    反转内容 (车尾变车头, 进去再出来就反转了)队列
队列:

队列的特点:
    先进先出 (FIFO, First In First Out)
    入口和出口在两端
   
队列的适用场景:
    秒杀, 抢购
    在线售票
    处理高并发场景数组
数组:
        
数组的特点:
    查询快: 通过 (第一个元素地址值 + 索引) 可以快速计算出该索引元素的地址值
    增删慢: 增加一个元素, 要创建长度+1的新数组, 然后将原数组元素复制到新数组, 然后存入新元素; 删除类似
   
数组的适用场景:
    查询多, 增删少的数据存储场景   国内城市链表
链表: 链表由多个 节点(Node / Entry) 组成
   
单向链表: 每个节点存储 数据 和 下一个节点的地址值

双向链表: 每个节点存储 数据, 上一个节点地址值 和 下一个节点地址值
   
链表的特点:
    查询慢: 要找到其中某个节点, 只能从第一个节点一个一个向后寻找
    增删快: 只需要修改保存的下一个节点的地址值, 就可以快速完成增删
            
链表的适用场景:
    查询少, 增删多的场景
    链表可以实现栈和队列的结构, 因为栈和队列增删频繁红黑树
红黑树: 是一种 平衡 二叉 查找 树
    平衡: 左子节点和右子节点数量相等
    二叉: 每个节点最多有2个子节点
    查找: 节点存储的元素是按照大小顺序存储的
    特点:
        元素存储过程中就完成了大小排序
        查询比链表快, 增删比数组快 (数组和链表的折中)

红黑树的适用场景:
    查询和增删都有, 需要元素自动排序的场景

0 个回复

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