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

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

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

启用和禁用断言

  //business logic  
      
  LOG.debug("Method result : " + result);    

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)：按照指定符号分割字符串

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

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

public StringBuilder reverse():反转功能

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

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

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

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

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

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

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

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

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 可以修饰类

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类（自动加上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对象中