内嵌，J2SE常用类，Comparator 和 Comparable

内嵌

当一个final函数被调用通常Java编译器可以通过调用方法的编译代码直接内嵌来备份子程序的字节码，这是什么意思？
1.首先要明白一点，调用一个函数除了函数本身的执行时间之外，还需要额外的时间去寻找这个函数（类内部有一个函数签名和函数地址的映射表）。所以减少函数调用次数就等于降低了性能消耗。
2.final修饰的函数会被编译器优化，优化的结果是减少了函数调用的次数。编译器是如何实现的呢？举个例子：

public class Test
{
	final void func(){System.out.println("g");}
	public void main(String[] args)
	{
		 for(int j=0;j<1000;j++)
   		func();
	}
}

//经过编译器优化之后，这个类变成了相当于这样写：
public class Test
{
	final void func(){System.out.println("g");};
	public void main(String[] args)
	{
 		for(int j=0;j<1000;j++)
   		{System.out.println("g");};
	}
}

编译器直接将func的函数体内嵌到了调用函数的地方，这样的结果是节省了1000次函数调用。当然编译器处理成字节码，我那样写是为了让你看明白。
不过，当函数体太长的话，用final可能适得其反，因为经过编译器内嵌之后代码长度大大增加，于是就增加了jvm解释字节码的时间。

当编译器发现一个final 方法调用命令时，它会根据自己的谨慎判断，跳过插入程序代码这种正常方式而执行方法调用机制（将参数压入栈，跳至方法代码处并执行，然后跳回并清理栈中的参数，处理返回值），并且以方法体中的实际代码的复本来替代方法调用。这将消除方法调用的开销。
当然，如果一个方法很大，你的程序代码就会膨胀，因而可能看不到内嵌带来的任何性能的提高。
因为，所带来的性能提高会因为花费于方法内的时间量而被缩减。
这意味着java编译器能够观察到这些情况并明智地抉择是否对final方法执行内嵌动作。
然而，最好是让编译器和JVM仅在你明确表示要阻止覆盖时，再处理效率问题，并将方法指明为final。

在1.5后的版本中，虚拟机可以探测到这些情况，并优化去掉这些效率反而降低的额外的内镶调用，因此不再需要使用final方法来进行优化了。只用要明确禁止覆盖是才将方法设置为final的。

=========================================================

Java SE常用类总结

【基本数据包装类】

Integer ：基本数据int包装类
Character ：基本数据char包装类
Long：基本数据long的包装类
Short：基本数据short包装类
Byte：基本数据byte包装类
Double：基本数据double的包装类
Float：基本数据float的包装类
Boolean：基本数据boolean的包装类、

【字符串操作类】
String 字符串类
StringBuilder，StringBuffer 字符串缓冲区

【数组工具类】
Arrays 数组工具类

【集合】
Collection（接口）：集合的父级接口
List（接口），Set（接口） ：Collection 中的常用的子接口
ArrayList，LinkedList，Vector ：由List接口衍生的集合类
HashSet，TreeSet，LinkedHashSet ：由Set接口衍生的集合类
Itetator（接口）：迭代器
Iterable（接口）：实现这个接口允许对象成为 "foreach" 语句的目标。俗话：可以使用增强for循环
Collcetions 集合工具类

Map（接口）：键值对集合接口
HashMap ：底层数据结构hash表
TreeMap ：底层数据结构二叉树
HashTable ：底层数据结构为hash表
LinkedHashMap ：可以记住存入该集合键值对的内容
Properties ：操作配置文件

【IO流】
InputStream（抽象类），OutputStream（抽象类）
FileInputStream,FileoutStream, BufferedInputStream ，BufferedOutputStream
Reader(抽象类)，Writer（抽象类）
FileReader，FileWriter，BufferedReader，BufferedWriter，
InoutStreamReader , OutputStreamWriter ：转换流
PrintStream , SequenceInputStream , 打印流 序列化流
ObjectInputStream , ObjectOutputStream对象的序列化流--- Serializable(接口)
ByteArrayInputStream ， ByteArrayOutputStream  内存操作流
PipedInputStream , PipedOutputStream 管道流
DataInputStream ， DataOutputSteam 基本数据类型操作流
RandomAccessFile 随机读写流

【文件】
File：对文件进行包装，操作的类

【多线程】
Thread  ：
Runable（接口）
Condition(接口)

【时间/日期】
Date ：
Format（抽象类） SimpleDataFormat
Calendar ：

【GUI图形化界面】
Frame ， Panel ，TextArea ，Button ，TextFiled
BorderLayout  ，FlowLaout ，
WindowListener , WindowAdapter  ，WindowEvent ，
ActionListener(接口) , ActionEvent 
KeyAdapter ， 

【网络编程】
DatagramSocket ，DatagramPacket：UDP协议
Socket ,SeverSocket ：TCP协议

【正则表达式】
Pattern ：
Matcher ：

【反射】
Class：字节码文件的基类
Constructor：构造函数类
Method：成员方法类
Field：成员变量

=========================================================

Comparator 和 Comparable

comparable&comparator    都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现的排序，Comparator是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义Comparator接口的方法compare()或在集合内实现Comparable接口的方法compareTo()。 
Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String    Integer自己就可以完成比较大小操作)。
Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。 
一、Comparator，强行对某个对象collection进行整体排序的比较函数，可以将Comparator传递给Collections.sort或Arrays.sort。
二、Comparable，强行对实现它的每个类的对象进行整体排序，实现此接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。

可以说一个是自己完成比较，一个是外部程序实现比较的差别而已。
用 Comparator 是策略模式（strategy design pattern），就是不改变对象自身，而用一个策略对象（strategy object）来改变它的行为。
比如：你想对整数采用绝对值大小来排序，Integer 是不符合要求的，你不需要去修改 Integer 类（实际上你也不能这么做）去改变它的排序行为，只要使用一个实现了 Comparator 接口的对象来实现控制它的排序就行了。
Comparator 在java.util包中
Comparable 在java.lang包中

Comparator 和 Comparable 的实例

//Comparable:
//实现Comparable接口要覆盖compareTo方法, 在compareTo方法里面实现比较：
public class Person implements Comparable {
     String name;
     int age
     public int compareTo(Person another) {
          int i = 0;
          i = name.compareTo(another.name); // 使用字符串的比较
          if(i == 0) { // 如果名字一样,比较年龄, 返回比较年龄结果
               return age - another.age;
          } else {
               return i; // 名字不一样, 返回比较名字的结果.
          }
     }
}
//   这时我们可以直接用 Collections.sort( personList ) 对其排序了.

//Comparator:
//实现Comparator需要覆盖 compare 方法：
public class Person{
     String name;
     int age
}

class PersonComparator implements Comparator { 
     public int compare(Person one, Person another) {
          int i = 0;
          i = one.name.compareTo(another.name); // 使用字符串的比较
          if(i == 0) { // 如果名字一样,比较年龄,返回比较年龄结果
               return one.age - another.age;
          } else {
               return i; // 名字不一样, 返回比较名字的结果.
          }
     }
}
 //  Collections.sort( personList , new PersonComparator()) 可以对其排序

总结:
两种方法各有优劣, 用Comparable 简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,但是需要修改源代码, 用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义的对象需要作比较的时候,把比较器和对象一起传递过去就可以比大小了, 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复劳动了。