• java核心技术第六篇之断言、日志、包装类型和工具类


    JDK1.5新特性:
    1.自动拆装箱.
    2.泛型
    3.可变参数
    4.静态导入
    5.增强for循环
    6.互斥锁
    7.枚举
    8.注解

    JDK1.6新特性:

    1.Desktop类和SystemTray类
    2.使用JAXB2来实现对象与XML之间的映射
    3.StAX
    4.使用Compiler API
    5.轻量级Http Server API
    6.插入式注解处理API(Pluggable Annotation Processing API)
    7.用Console开发控制台程序
    8.对脚本语言的支持
    9.Common Annotations

    JDK1.7新特性:

    1 对集合类的语言支持;
    2 自动资源管理;
    3 改进的通用实例创建类型推断;
    4 数字字面量下划线支持;
    5 switch中使用string;
    6 二进制字面量0b001;
    7 简化可变参数方法调用。
    8 泛型简化,出现菱形泛型
    9 异常的多个catch合并,每个异常用或|
    10 try-with-resources 语句

    JDK1.8 新特性:
    一、接口的默认方法:Java 8允许我们给接口添加一个非抽象的方法实现,只需要使用 default关键字即可,这个特征又叫做扩展方法,
    二、Lambda 表达式:Collections.sort(names, (a, b) -> b.compareTo(a));Java编译器可以自动推导出参数类型,所以你可以不用再写一次类型。
    三、函数式接口:每一个lambda表达式都对应一个类型,通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口,每一个该类型的lambda表达式都会被匹配到这个抽象方法。
    因为 默认方法 不算抽象方法,所以你也可以给你的函数式接口添加默认方法。
    四、方法与构造函数引用:Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用,上面的代码展示了如何引用一个静态方法,我们也可以引用一个对象的方法:
    五、Lambda 作用域:在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量,或者实例的字段以及静态变量。
    六、访问局部变量:lambda表达式中访问外层的局部变量
    七、访问对象字段与静态变量:lambda内部对于实例的字段以及静态变量是即可读又可写。该行为和匿名对象是一致的:
    八、访问接口的默认方法:Lambda表达式中是无法访问到默认方法的
    九、Date API:Java 8 在包java.time下包含了一组全新的时间日期API。新的日期API和开源的Joda-Time库差不多,但又不完全一样
    十、Annotation 注解:在Java 8中支持多重注解了,Java 8允许我们把同一个类型的注解使用多次,只需要给该注解标注一下@Repeatable即可,

    断言的使用方式:
    断言是一种测试和调测阶段所使用的战术工具.
    断言的初衷:在一个具有自我保护能力的程序中,断言很常用.假设确信某个属性符合要求,并且代码的执行依赖于这个属性.例如,需要计算
    double y = Math.sqrt(x);
    我们确信,这里的x是一个非负数的值.原因是:是另外一个计算的结果,而这个结果不可能是负值;或者x是一个方法的参数,而这个方法要求它的调用者只能提供一个正整数.
    然而,还是希望进行检查,以避免让"不是一个数"的数值参与计算操作.当然,也可以抛出一个异常:
    if(x<0) throw new IllegalArgumentException("x<0");
    但是需要注意的是,这段代码会一直保留在程序中,即使测试完毕也不会自动的删除.如果在程序中包含有大量的这种检查,程序运行起来会相当慢.
    断言机制允许在测试期间向代码中插入一些检查语句.当代码发布时,这些插入的检查语句将会被自动的移走.


    开启断言:2.在myEclipse中,Windows -> Preferences ->Java ->Installed JREs ->点击正使用的JDK ->Edit ->Default VM Arguments文本框中输入:-ea或者-enableassertions
    断言的格式:
    java中语音引入关键字assert.这个关键字有两种表现形式:
    1.assert 条件: 例如:assert x>=0; 想要断言x是一个非负数值,只需要简单的使用这条语句.
    2.assert 条件:表达式; 例如:assert x>=0 : x; 或者将x的实际值传递给AssertionError对象,从而可以在后面显示出来.
    这两个格式都会对条件进行检测,如果结果为false,则抛出一个AssertionError异常.
    在第二种格式中,表达式将被传入AssertionEeror的构造器,并转换成一个消息字符串.
    注释:"表达式"部分的唯一目的是产生一个消息字符串.AssertionErro对象并不存储表达式的值,因此,不可能在以后得到它.正如JDK文档所描述的那样:如果使用表达式的值,
    就会鼓励程序员试图从断言中恢复程序的运行,这不符合断言机制的初衷.


    启用和禁用断言

    在默认情况下,断言是被禁用的。可以在程序运行时用-enableassertions或-ea选项启用它:
    java -enableassertions MyApp
    启用或者禁用断言不必重新编译程序。启动或者禁用断言是类加载器的功能。当断言被禁用时,类加载器将跳过断言代码,因此,不会降低程序的运行速度。
    也可以在某个类或者某个包中使用断言,例如:
    java -ea:MyClass -ea:com.mycompany.mylib... MyApp
    这条命令将开启MyClass类以及在com.mycompany.mylib包和它的子包中的所有类的断言。选项-ea将开启默认包中的所有类的断言。
    也可以使用-disableassertions或-da禁用某个特定的类和包的断言:
    java -ea:... -da:MyClass MyApp
    有些类不是由类加载器加载,而是直接由虚拟机加载。可以使用这些开关有选择地启用或禁用哪些类中的断言。
    然而,启用和禁用所有断言的-ea和-da开关并不能应用到那些没有类加载器的“系统类”上。对于这些系统类而言,需要使用-enablesystemassertions/-esa开关启动断言。
    使用断言完成参数检查

    API:java.long.ClassLoader 1.0 子类MLet
    void setDefaultAssertionStatus(Boolean b) //1.4
    对于通过类加载器加载的所有类来说,如果没有显示的说明类或者包的断言 状态,就启用或禁用断言.
    void setClassAssertionSatus(String className,boolean b) //1.4
    对于给定的类和它的内部类,启用或禁用断言.
    void setPackageAssertionStatus(String packageName,boolean b) //1.4
    对于给定包和其子包中的所有类,启用或禁用断言.
    void clearAssertionStatus() //1.4
    移去所有类和包的显示断言状态设置,并禁用所有通过这个类加载器加载的类的断言.

    java中的3中处理系统错误的机制:
    抛出一个异常
    日志
    使用断言
    什么时候应该使用断言呢?
    断言失败是致命的、不可恢复的错误
    断言检查只用于开发和测试阶段
    因此,不应该使用断言向程序的其他部分通告发生了可恢复性的错误,或者,不应该作为程序向用户通告问题的手段。断言只应该是在测试阶段确定程序内部错误的位置。
    断言是一种测试和调试阶段所使用的战术性工具;而日志记录是一种在程序的整个生命周期都可以使用的策略性工具。
    public class App
    {
    public static void main( String[] args )
    {
    int a = -1;
    assert a > 0 : "liuni是笨蛋";
    System.out.println( "Hello World!" );
    }
    }

    程序中记录日志一般有两个目的:Troubleshooting和显示程序运行状态。好的日志记录方式可以提供我们足够多定位问题的依据。日志记录大家都会认为简单,但如何通过日志可以高效定位问题并不是简单的事情。这里列举下面三个方面的内容,辅以代码示例,总结如何写好日志,希望对他人有所启发和帮助:


    怎样记日志可以方便Troubleshooting
    程序运行状态可以记哪些
    应该避免怎样的日志方式
    怎样记日志可以方便Troubleshooting?
    1. 对外部的调用封装

    程序中对外部系统与模块的依赖调用前后都记下日志,方便接口调试。出问题时也可以很快理清是哪块的问题

    [java] view plain copy
    LOG.debug("Calling external system:" + parameters);
    Object result = null;
    try {
    result = callRemoteSystem(params);
    LOG.debug("Called successfully. result is " + result);
    } catch (Exception e) {
    LOG.warn("Failed at calling xxx system . exception : " + e);
    }

    2.状态变化

    程序中重要的状态信息的变化应该记录下来,方便查问题时还原现场,推断程序运行过程

    [java] view plain copy
    boolean isRunning;

    isRunning = true;
    LOG.info("System is running");

    //...

    isRunning = false;
    LOG.info("System was interrupted by " + Thread.currentThread().getName());

    3.系统入口与出口:

    这个粒度可以是重要方法级或模块级。记录它的输入与输出,方便定位

    [java] view plain copy
    void execute(Object input) {
    LOG.debug("Invoke parames : " + input);
    Object result = null;

    //business logic

    LOG.debug("Method result : " + result);
    }

    4.业务异常:

    任何业务异常都应该记下来:

    [java] view plain copy
    try {
    //business logical
    } catch (IOException e) {
    LOG.warn("Description xxx" , e);
    } catch (BusinessException e) {
    LOG.warn("Let me know anything");
    } catch (Exception e) {
    LOG.error("Description xxx", e);
    }

    5.非预期执行:

    为程序在“有可能”执行到的地方打印日志。如果我想删除一个文件,结果返回成功。但事实上,那个文件在你想删除之前就不存在了。最终结果是一致的,但程序得让我们知道这种情况,要查清为什么文件在删除之前就已经不存在

    [java] view plain copy
    int myValue = xxxx;
    int absResult = Math.abs(myValue);
    if (absResult < 0) {
    LOG.info("Original int " + myValue + "has nagetive abs " + absResult);
    }

    6.很少出现的else情况:

    else可能吞掉你的请求,或是赋予难以理解的最终结果

    [java] view plain copy
    Object result = null;
    if (running) {
    result = xxx;
    } else {
    result = yyy;
    LOG.debug("System does not running, we change the final result");
    }

    日志记录:

    程序运行状态可以记哪些?
    程序在运行时就像一个机器人,我们可以从它的日志看出它正在做什么,是不是按预期的设计在做,所以这些正常的运行状态是要有的。

    1. 程序运行时间:

    [java] view plain copy
    long startTime = System.currentTime();

    // business logical

    LOG.info("execution cost : " + (System.currentTime() - startTime) + "ms"); 

    2. 大批量数据的执行进度:

    [java] view plain copy
    LOG.debug("current progress: " + (currentPos * 100 / totalAmount) + "%");

    3.关键变量及正在做哪些重要的事情:

    执行关键的逻辑,做IO操作等等

    [java] view plain copy
    String getJVMPid() {
    String pid = "";
    // Obtains JVM process ID
    LOG.info("JVM pid is " + pid);
    return pid;
    }

    void invokeRemoteMethod(Object params) {
    LOG.info("Calling remote method : " + params);
    //Calling remote server
    }


    应该避免怎样的日志方式?
    1. 混淆信息的Log

    日志应该是清晰准确的: 当看到日志的时候,你知道是因为连接池取不到连接导致的问题么?

    [java] view plain copy
    Connection connection = ConnectionFactory.getConnection();
    if (connection == null) {
    LOG.warn("System initialized unsuccessfully");
    }

    2. 记错位置

    产品代码中,使用console记录日志,导致没有找到日志。

    [java] view plain copy
    } catch (ConfigurationException e) {
    e.printStackTrace();
    }


    3. 记错级别

    记错级别常常发生,常见的如:混淆代码错误和用户错误,如登录系统中,如果恶意登录,那系统内部会出现太多WARN,从而让管理员误以为是代码错误。可以反馈用户以错误,但是不要记录用户错误的行为,除非想达到控制的目的。

    [java] view plain copy
    LOG.warn("Failed to login by "+username+");

    4. 遗漏信息

    这里可能包含两种情况:(1)用户自己少写了信息,导致毫无参考价值;(2)用户调用log的方式导致丢失信息,如下例,没有stack trace.


    [java] view plain copy
    } catch (Exception ex) {
    log.error(ex);
    }
    */
    ----------String--------------

    构造:
    String(String original):把字符串数据封装成字符串对象

    String(char[] value):把字符数组的数据封装成字符串对象

    String(char[] value, int index, int count):把字符数组中的一部分数据

    方法:
    判断功能:

    boolean equals(Object obj):比较字符串的内容是否相同

    boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

    boolean startsWith(String str):判断字符串对象是否以指定的str开头

    boolean endsWith(String str):判断字符串对象是否以指定的str结尾

    获取功能:

    int length():获取字符串的长度,其实也就是字符个数

    char charAt(int index):获取指定索引处的字符

    int indexOf(String str):获取str在字符串对象中第一次出现的索引

    String substring(int start):从start开始截取字符串

    String substring(int start,int end):从start开始,到end结束截取字符串。包括start,不包括end

    转换功能:

    char[] toCharArray():把字符串转换为字符数组

    String toLowerCase():把字符串转换为小写字符串

    String toUpperCase():把字符串转换为大写字符串

    String replace(char oldChar, char newChar)通过用 newChar 替换此字符串中出现的所有 oldChar ,返回处理后的字符串。



    其它功能:

    String trim():去除字符串两端空格

    String[] split(String str):按照指定符号分割字符串


    --------StringBuider(可变字符串)------------
    构造:
    就一个

    方法:
    public int capacity():返回当前容量 (理论值)

    public int length():返回长度(已经存储的字符个数)

    public StringBuilder append( 任意类型 ):添加数据,并返回添加的数据

    public StringBuilder reverse():反转功能

    StringBuilder replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

    --------Integer(包装类)---------------
    构造:
    不需要,直接类名.方法名调用,如下

    方法:
    Integer.parseInt(String str):将字符串转int类型(只能数字内容的字符串,不然报错)

    ---------ArrayList(集合)-------------------
    构造:
    ArrayList();就学了空参创建

    方法:
    public boolean add(E e):添加元素,成功返回true,就业班学false
    public void add(int index,E element):在指定的索引处添加一个元素

    public E get(int index):返回指定索引处的元素

    public E set(int index,E element):修改指定索引处的元素,返回被修改的元素

    public int size():返回集合中的元素的个数

    public boolean remove(Object o):删除指定的元素,返回删除是否成功
    E remove(int index) 移除此列表中指定位置上的元素,并返回删除的数据。


    ---------FileWriter(输出普通流)-----------
    构造:
    FileWriter(String fileName); 传入一个文件的路径

    方法:
    void write(int c) 写入一个字符,int类型传入
    void write(String str) 写入一个字符串
    void write(String str, int startIndex, int len) 写入字符串的一部分
    void write(char[] cbuf) 写入一个字符数组
    void write(char[] cbuf, int startIndex, int len)写入字符数组的一部分

    void flush() 将内存中的数据刷新到文件中

    void close() 数据刷新到文件中,关流释放系统底层资源(关闭后永久关闭,直到下次程序运行)


    ---------BufferedWriter(输出缓冲流)-----------
    构造:
    BufferedWriter(new FileWriter(String fileName));传入一个FileWriter对象,FileWriter包含一个文件的路径


    方法 (同FileWriter,多了一个方法):
    void newLine() 写入换行( )

    ---------FileReader(输入普通流)-----------
    构造:
    FileReader(String fileName); 传入一个文件的路径

    方法:
    int read() 读取单个字符,若是读取成功返回参数的int类型表现形式,若读取失败,返回-1
    int read(char[] cbuf) 读取指定char数组长度个字符,并存入char数组,若是读到文件尾部,则停止读取,并返回读取字符的个数(不是char数组长度),若是一个都没读到,返回-1。
    int read(char[] cbuf, int startIndex, int len) 读取 startIndex 索引开始, len 个字符(length简拼)

    void reset() 重置流(删除前面读的记录)

    ---------BufferedReader(输入缓冲流)-----------
    构造:
    FileReader(String fileName); 传入一个文件的路径


    方法 (同FileReader,多了一个方法)
    String ReadLine() 一次读一行的内容,返回读到的内容,没读到返回null

    -----------Arrays(工具类,考试不推荐使用)-----------------
    构造:
    不需要构造,因为该类不需要创建对象

    方法:
    String toString(各种数组,集合不行) 返回该数组的全部内容的特定格式(遍历数组)



    方法重载:
    1.方法名相同
    2.参数列表不同(数量、类型、顺序)

    方法覆盖:
    1.访问修饰符相同或更宽
    2.返回值类型相同
    3.方法名相同
    4.参数表相同
    5.static 静态只能覆盖静态 非静态只能覆盖非静态
    6.子类方法不能抛出比父类更多的异常

    三大修饰符:

    static

    可以修饰属性、方法和初始化代码块,不可以修饰局部变量

    1. 静态属性、方法为全类所有,可通过类名直接调用
    2. 静态初始化代码块在类加载时执行,仅执行一次

    final

    可以修饰局部变量、成员变量、方法和类

    1. final修饰的变量一旦被赋值,就不能改变
    2. final修饰的方法不可以被覆盖
    3. final修饰的类不能被继承

    abstract

    可以修饰类和方法

    1. 抽象类只能声明引用,不能创建对象
    2. 抽象方法只有声明,没有实现(不写代码块)
    3. 如果一个类中有抽象方法,那这个类必须是抽象类
    4. 子类继承一个抽象类,如果不希望子类变成抽象类,那子类必须实现父类中的全部抽象方法


    PS:多个修饰符修饰同一方法、类时的使用问题

    1. abstract 不能与 final 一起修饰方法、类

    抽象类、方法需要被继承、覆盖才可使用,final修饰的类、方法不可被继承、覆盖

    2. abstract 不能与 private 一起修饰方法(private只能修饰内部类)

    理由同上,私有方法不能被继承

    3. abstract 不能与 static 一起修饰方法(static只能修饰类的成员,不能修饰类本身)

    抽象类需要有子类的实现类才能调用内部方法,而静态类可以直接通过本类名调用内部方法

    4. private 与 static 与 final 可以连用(属性、方法都可以)


    权限修饰符:private default protect public 可以修饰方法
    public default 可以修饰类


    接口:interface

    1. 接口是特殊的抽象类(interface 代替了 abstract class)
    2. 接口中所有属性都是公开静态常量
    3. 接口中所有方法都是公开抽象方法
    4. 一个接口可以继承多个接口(extends 多个接口,接口之间用逗号隔开)
    5. 一个类只可以继承一个父类,但是可以实现多个接口

    PS: 抽象类与接口的不同点

    1. 抽象类可以有构造方法,接口不可以有构造方法

    2. 抽象类不可以多继承,接口可以多继承

    接口的实现(被子类继承):implements

    1. 一个类实现接口,如果不希望作为抽象类,就必须实现接口中全部方法

    接口的作用;

    1. 接口与多继承

    1. 可以让子类继承主要类型,让次要类型作为一个接口让子类实现.
    2. 单继承具备简单性(相对于多继承),使用接口实现的多继承并不会破坏其简单性

    2. 接口与解耦合

    接口抽象出子类中的共性,利用多态来解耦合

    3. 接口回调

    实现某些接口,由函数库中方法自动调用。

    例:
    定义实体类是实现Comrparable<E>接口(中的comepareTo方法,返回值为int)
    在调用java.util.Arrays.sort数组排序方法时,可以排序存放实体类的数组

    Object类:

    Object是所有类的父类,如果一个类没有定义直接继承的父类,就会直接继承Object类(自动加上extends Object)

    所有的类都会继承Object类中的全部公开方法。

    Obeject类中的全部方法:

    1. finalize

    该方法在垃圾回收时,被垃圾回收器调用

    (什么是垃圾? -- 没有引用指向的对象)

    1. JVM中有自动垃圾回收机制,程序员只需要创建对象、分配空间,不需要回收垃圾

    2. JVM只有在内存不够用的时候才会进行垃圾回收
    (可能会浪费空间,但减少了垃圾回收对CPU的占用)

    2. getClass

    作用:得到对象的"实际"类型

    补充:instanceof 可看做是不是: 引用 instanceof 类型
    该引用的实际类型 是不是 某类型

    比较两个对象的实际类型是不是相等:

    1. 使用 instanceof 只能得出某对象的实际乐行是不是某类型的子类

    2. 可以使用getClass得到 对象的实际类型

    语法:m1.getClass() == m2.getClass()

    3. equals

    作用: 比较两个对象

    1. 可以在子类中覆盖equals方法,作用为使两个对象可以使用自定义的标准相互比较

    2. 如果不覆盖equals方法,默认比较两个对象的地址值(即使用 == 比较两个引用类型)

    3. 字符串类覆盖了equals方法


    覆盖equals方法的五个步骤:

    1. 判断 this == obj (地址相同直接返回true)

    2. 判断 obj == null (this一定不是null,否则无法调用equals方法)

    3. 判断 两个对象的实际类型是否相同(使用getClass方法)

    4. 强制类型转换

    5. 依次比较两个对象的属性是否相等

    4. toString

    作用:打印

    在控制台打印对象时,自动调用该对象的toString方法


    包装类:

    将基本数据类型封装为对象数据类型:

    int -- Integer
    char -- Character
    其他基本数据类型 -- 首字母大写

    int Integer String 之间的相互转换:

    1. Integer ii = new Integer( int i )

    Integer ii = new Integer( String s )

    2. int i = ii.intValue()

    int i = Integer.paresInt( String s )

    3. String s = ii.toString()

    String s = String.valueOf( int i )


    正则表达式:

    作用: 使用正则表达式可以匹配出想要的字符串

    1. [] [a-zA-Z0-9] [1235] 中括号可以匹配多个字符,或者范围内字符,范围使用-分隔,多组范围直接连着写

    2. {} {5} {5,10} 限制前一个字符内容长度,或者长度范围,范围使用逗号分隔

    3. 特殊意义字符: :转义字符,想要使用 需要使用转义字符 \

    +:放在字符后面,代表匹配一个或多个该字符,想要使用+,需要使用转义字符 \+

    .:匹配任意一个字符,使用字符本身,需要转义 \.

    \d 匹配任意字母

    \w 匹配任意字母或者数字

    ( | ) 逻辑或,匹配 | 前面或者后面的字符,例:(J|j)ava 可以匹配 Java 或者 java

    ^: 代表必须是字符串的开头,例:^[a-z] 字符串必须以小写字母开头

    $: 代表前一个字符必须是匹配内容的结尾,例:^[a-z][0-9]$ 字符串必须以数字结尾

    \_ 下划线

    内部类:

    成员内部类:

    1. 成员内部类可以访问外部类中所有的、静态的、私有的属性和方法

    2. 成员内部类中不可以定义静态的属性和方法

    3. 创建成员内部类对象,需要先创建一个外部类对象(依赖于独立的外部类对象,因此不可以有静态成员)

    创建成员内部类对象:

    外部类 out = new 外部类();

    外部类.内部类 引用名 = out.new 外部类.内部类();

    (类型是 外部类.内部类,作为一个外部类的成员,需要用一个外部类对象来创建)

    静态内部类:

    1. 静态内部类只能访问外部类中所有的静态属性和方法

    2. 静态内部类可以定义普通的和静态的属性和方法

    3. 创建静态内部类对象,可以直接使用该类的类型创建(静态成员不依赖于外部类的对象)

    创建静态内部类对象:

    外部类.静态内部类 引用名 = new 外部类.静态内部类();

    (不依赖外部类对象,直接用类型创建)

    局部内部类:

    作用同下

    匿名内部类:

    new 接口名() { 接口的实现代码 }

    用途:

    需要一个仅仅使用一次的对象时,直接在方法内部创建、使用,不需要打断思路,另开一个实现类

    缺点:

    代码可读性差


    集合框架:

    为什么使用集合: 数组的扩容、插入、删除操作十分繁琐


    集合的类型:

    Collection<Object> 接口

    --> List<Object> 接口

    --> Set<Object> 接口

    Map<Key, Value> 接口

    集合中的方法:

    Collecion :

    add (Object obj) -- boolean 添加元素

    contains (Object obj) -- boolean 查看是否包含某元素

    isEmpty() -- boolean 集合是否为空

    remove (Object obj) -- boolean 删除某元素

    clear() -- void 清空集合

    size() -- int 查看集合中元素个数


    List : 元素是对象类型,元素有下标(有顺序),元素可以重复

    add (Object obj) / add (int index, Object obj)

    添加元素,可以直接添加,或者插入到指定的index

    get (int index) set (int index, Object obj)

    根据下标,获取或者修改元素

    indexOf (Object obj) -- int

    获取元素下标


    Set: 元素是对象类型,元素没有下标(没有顺序),元素不可以重复


    Set集合没有自己特有的方法,全部方法继承自Collection


    Map: 元素是键值对类型,键不可以重复,值可以重复

    get (Object key) -- Object

    根据键,获取对应的值

    put (Object key, Object value) -- void

    添加一个键值对

    remove (Object key) -- void

    删除一个键值对,根据值

    ketSet() -- Set

    获取全部的键,放到一个Set里面返回

    values() -- Collection

    获取全部的值,放到一个Collection中返回

    containsKey/containsValus

    查看Map中是否包含某个Key/Values

    size()

    查看Map中键值对个数

    isEmpty()


    clear()


    entrySet()

    获取全部的键值对(Map.Entry类型),放到Set中返回


    集合的实现类:

    List 的实现类:

    ArrayList

    1. 使用数组实现

    2. 增删慢,查询快

    LinkedList

    1. 使用链表实现

    2. 增删快,查询慢

    Vector

    1. JDK1.0遗留的产物

    2. 重量级,线程安全,速度慢(多线程访问同一对象时,不会出现同步问题)

    Set 的实现类:

    HashSet

    1. 集合中的元素无序,不重复(可以用来去除一组元素中重复的数据)

    2. new HashSet() 默认容量16,加载因子0.75

    3. newHashSet(int 容量, float )


    LinkedHashSet

    1. 遍历时可以保留添加到集合中的顺序(Set集合中的元素是无序的)


    Set 集合是如何实现不重复元素的?

    添加进Set集合中的元素要想做到不重复需要:

    1. 需要覆盖 equals() 方法 -- 变成比较元素内容而不是比较元素地址

    2. 需要覆盖 hashCode() 方法 -- 使哈希码与元素内容有关,

    保证相同元素有相同哈希码,

    尽量保证不同元素哈希码不同,

    可节省运算、比较次数

    如何实现元素不重复的?

    1. 每个对象都有自己的 hashCode(hashSet使用数组加链表实现)

    -- hashCode决定对象在集合中的存放位置,

    初始hashCode值由对象地址决定

    2. 如果两个对象的hashCode相同,就使用 equals() 方法进行比较,

    去掉重复元素,不重复的挂到该hashCode对应数组位置中的链表里

    3. 如果两个对象hashCode不同,那么放入集合的位置就可能不同,

    两个对象就不会进行 equals() 方法比较的过程,因此必须修改hashCode方法

    让内容可能相同的对象hashCode相同,进行比较去重复。

    同时也要尽量保证内容不同的对象的hashCode不同,尽量加快运算速度。


    equals方法:

    1. 判断两个对象地址是否相同(直接等于)

    2. 判断参数对象是否为空

    3. 判断两个对象类型是否相同(使用getClass方法)

    使用 instanceof 有可能遇到父子类的情况

    4. 将参数对象类型强转成本类对象类型

    5. 逐个比较两个对象的属性

    Map 的实现类:

    HashMap

    1. 键不可以重复,同样需要覆盖 equals 方法和 hashCode 方法

    2. 允许键/值为 null

    LinkedHashMap

    1. 遍历时,保留了键的放入顺序

    HashTable

    1. 类似于 Vector ,重量级,速度慢,线程安全

    2. 当键/值为 null 时,会抛出异常


    Map 集合的三种遍历方式:

    键遍历:

    使用 keySet() 方法,拿到全部键的Set,再遍历 Set 即可(配合 get(key) 方法拿值)

    值遍历:

    使用 values() 方法,拿到全部值的Collection

    键值对遍历:

    1.使用 entrySet() 方法,拿到全部的键值对Set

    装有键值对的Set的泛型需要注意写法:

    例: Set<Map.Entry<Integer, String>> set = map.entrySet();

    键值对的类型为:Map.Entry , 例: Map.Entry entry = (Map.Entry)iter.next();

    键值对的迭代器遍历时,需要将从Set中取出

    的值强转成 Map.Entry 类型

    ↑↑以上是JDK5.0之前泛型没出的时候的做法

    加泛型之后,不需要在强转了

    2. 使用Map.Entry类中的 getKey() / getValue() 方法,获取键值对中的键和值


    PS:用迭代器遍历集合

    Iterator iter = list.iterator(); --> List 和 Set 中有iterator方法,获取迭代器

    //创建一个迭代器对象

    while( iter.hasNext() ) {

    Object value = iter.next();

    //对拿到的value进行需要的操作

    }

    foreach遍历

    1. foreach封装了迭代器遍历

    2. 迭代器对与集合长度及变化做了安全监测,

    3. 定义了异常:ConcurrentModificationException 并发修改异常

    4. 在使集合创建迭代器时,会为变量expectedModCount赋值(赋予当前modCount的值)

    5. foreach遍历集合时,先调用hasNext方法,指针后移,如果索引等于集合长度,

    则结束循环,如果索引小于集合长度,

    则通过next()取出指针指向的集合内对象地址,执行循环体。

    6. 在next()中进行集合长度及变化的安全监测,如果索引大于集合长度,则说明在

    上一次循环的循环体中,出现了修改集合长度的操作,则直接抛出

    并发修改异常;集合之中有一个成员变量modCount,

    记录了集合被增删元素的次数,next()中会先比较expectedModCount和

    modCount的值是否相同,及监测集合有没有被修改过,如果不同就抛出

    并发修改异常

    PS: 7. 安全监测是在next方法中进行的,因此若是删除集合的倒数第二个元素:

    在循环体执行删除语句,删除后集合长度-1,循环体结束进入下一次循环判断

    hasNext方法:索引长度刚好等于集合长度,结束循环,不进入next方法。

    所以:可以在foreach遍历集合中,删除倒数第二个元素。

    8. iterator的remove方法对集合修改安全监测进行了屏蔽处理,

    使用iterator中的方法删除元素,不会抛出异常

    结论:Iterator做出了安全监测,集合对象不可以在foreach循环遍历集合中,

    做出增加删除元素的操作,否则抛出并发修改异常。

    (除了删除倒数第二个元素)

    集合工具类:

    Collections :(静态方法)

    1. Collections.shuffle(list) 打乱一个List集合中元素的排列顺序

    2. Collections.sort(list) 按照自然顺序排序一个List集合内的元素

    3. Collections 只能作用于List集合


    Properties:持久的属性集


    1. Properties继承自Map集合

    2. Properties中有方法可以将集合中内容保存在文本文件中

    3. Properties限定泛型,只能装String类型数据(name,value)

    4. Properties中的常用方法:

    1. setProperties(String, String)

    2. getProperties(String key)

    3. stringPropertyNames(获取集合中全部的name的 Set 集合)

    4. store(OutputStream,String comments) -- 将集合中数据通过输出流保存在文本文件中

    自定义一个输出流,文本文件必须以.properties结尾,commetns为注释,可以为null

    5. load(InputStream) -- 通过一个输入流将文件中内容传入Properties对象中

  • 相关阅读:
    图的理论基础
    哈夫曼树(三)之 Java详解
    哈夫曼树(二)之 C++详解
    哈夫曼树(一)之 C语言详解
    基数排序
    桶排序
    归并排序
    堆排序
    选择排序
    希尔排序
  • 原文地址:https://www.cnblogs.com/haizai/p/11297587.html
Copyright © 2020-2023  润新知