随笔 - 109  文章 - 1 评论 - 14 trackbacks - 0

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() 写入换行(\r\n)

---------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对象中

 

posted on 2019-08-04 11:12  小小一  阅读(...)  评论(... 编辑 收藏