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”);

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

[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”); }

  1. 记错位置

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

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

  1. 记错级别

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

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

  1. 遗漏信息

这里可能包含两种情况:(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对象中

我的博客即将同步至腾讯云+社区,邀请大家一同入驻:https://cloud.tencent.com/developer/support-plan?invite_code=1myurdlyd4tqm

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券