1.Single Table Strategy ,单表策略,一张表包含基类与子类的所有数据,很多情况下都是采用这样的冗余设计,通过一个discriminator来区分

2.Table Per Class Strategy ,每个子类对应一张表,每张表都拥有基类的属性

3.Join Strategy ,仍然是每个子类对应一张表，但此表中不包含基类的属性,仅仅是此子类的扩展属性,共享基类的属性

以一个例子来说明3种情况:

一.单表策略

比如Pet作为基类,Cat和Dog继承此类并拥有自己的扩展属性,如:

package com.denny_blue.ejb3.inheritance;

import java.io.Serializable;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "animal_type", discriminatorType = DiscriminatorType.STRING)
public class Pet implements Serializable {
 private int id;

 private String name;

 private double weight;

 public Pet() {
 }

 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public double getWeight() {
  return weight;
 }

 public void setWeight(double weight) {
  this.weight = weight;
 }

}

Pet类值的注意的就是通过@Inheritance(strategy = InheritanceType.SINGLE_TABLE)确定采用单表策略,通过@DiscriminatorColumn确定了标志值的字段和类型，我想熟悉hibernate的朋友对这些都应该很熟悉.然后是两个子类:

//Cat.java

package com.denny_blue.ejb3.inheritance;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue("cat")
public class Cat extends Pet {
 private String HairBall;

 public String getHairBall() {
  return HairBall;
 }

 public void setHairBall(String hairBall) {
  HairBall = hairBall;
 }

}

//Dog.java

package com.denny_blue.ejb3.inheritance;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("dog")
public class Dog extends Pet {
 private String trick;

 public String getTrick() {
  return trick;
 }

 public void setTrick(String trick) {
  this.trick = trick;
 }

}

两个子类最值的关注的就是@DiscriminatorValue注释,比如Cat的此值为cat,意味着当Cat类型的Entity存入数据库时,JPA将自动把cat的值赋给animal_type字段,Dog的值则为dog,由此就可以在同一张表中区分开两个不同的子类.

二.Table per Class

采用Table Per Class策略的话，每个子类都将单独建表，并且都独立拥有基类中的所有属性,互相之间不共享,在我们的例子中所要进行的修改很小,像这样:

//基类

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Pet implements Serializable {
 private int id;

 private String name;

 private double weight;

........

//子类:不需要任何设置

@Entity
public class Dog extends Pet {
 private String trick;

  .......

  .......

三.Join策略

每个子类同样独立建表,基类也独立建表，只不过所有的子类的表中只有扩展属性,他们共享基类的表,在我们的例子中修改下即可:

//基类

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Pet implements Serializable {
 private int id;

 private String name;

 private double weight;

  ........

//子类

@Entity

@Inheritance(strategy = InheritanceType.JOINED)
public class Dog extends Pet {
 private String trick;

  .......

  .......

这部分的内容实在没什么新意,与hibernate完全一致.JAVA EE5向spring和hibernate借鉴了太多东西.
{}

1. 使用表的别名(Alias)
　　当在SQL语句中连接多个表时， 请使用表的别名并把别名前缀于每个Column上。这样一来，就可以减少解析的时间并减少那些由Column歧义引起的语法错误。
　　(Column歧义指的是由于SQL中不同的表具有相同的Column名，当SQL语句中出现这个Column时，SQL解析器无法判断这个Column的归属)
　　2. 用EXISTS替代IN
　　在许多基于基础表的查询中，为了满足一个条件，往往需要对另一个表进行联接。在这种情况下， 使用EXISTS(或NOT EXISTS)通常将提高查询的效率。
　　低效：
　　SELECT*
　　FROMEMP(基础表)
　　WHEREEMPNO>0
　　ANDDEPTNOIN(SELECTDEPTNO
　　FROMDEPT
　　WHERELOC=‘MELB’)
　　高效：
　　SELECT*
　　FROMEMP(基础表)
　　WHEREEMPNO>0
　　ANDEXISTS(SELECT‘X’
　　FROMDEPT
　　WHEREDEPT.DEPTNO=EMP.DEPTNO
　　ANDLOC=‘MELB’)
　　(相对来说，用NOT EXISTS替换NOT IN 将更显著地提高效率，下面将指出)
　　3. 用NOT EXISTS替代NOT IN
　　在子查询中，NOT IN子句将执行一个内部的排序和合并。 无论在哪种情况下，NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历)。 为了避免使用NOT IN ，我们可以把它改写成外连接(Outer Joins)或NOT EXISTS.
　　例如：
　　SELECT…
　　FROMEMP
　　WHEREDEPT_NONOTIN(SELECTDEPT_NO
　　FROMDEPT
　　WHEREDEPT_CAT=’A’);
　　为了提高效率。改写为：
　　(方法一： 高效)
　　SELECT….
　　FROMEMPA,DEPTB
　　WHEREA.DEPT_NO=B.DEPT(+)
　　ANDB.DEPT_NOISNULL
　　ANDB.DEPT_CAT(+)=‘A’

1. 用EXPLAIN PLAN 分析SQL语句

　　EXPLAIN PLAN 是一个很好的分析SQL语句的工具，它甚至可以在不执行SQL的情况下分析语句。 通过分析，我们就可以知道ORACLE是怎么样连接表，使用什么方式扫描表(索引扫描或全表扫描)以及使用到的索引名称。

　　你需要按照从里到外，从上到下的次序解读分析的结果。 EXPLAIN PLAN分析的结果是用缩进的格式排列的， 最内部的操作将被最先解读， 如果两个操作处于同一层中，带有最小操作号的将被首先执行。

　　NESTED LOOP是少数不按照上述规则处理的操作， 正确的执行路径是检查对NESTED LOOP提供数据的操作，其中操作号最小的将被最先处理。

　　通过实践， 感到还是用SQLPLUS中的SET TRACE 功能比较方便。

　　举例：

SQL> list
1 SELECT *
2 FROM dept, emp
　3* WHERE emp.deptno = dept.deptno
SQL> set autotrace traceonly /*traceonly 可以不显示执行结果*/
SQL> /
14 rows selected.
Execution Plan
----------------------------------------------------------
　0　　 SELECT STATEMENT Optimizer=CHOOSE
　1　　0　NESTED LOOPS
　2　　1　　TABLE ACCESS (FULL) OF 'EMP'
　3　　1　　TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'
　4　　3　　 　INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)
Statistics
----------------------------------------------------------
　　 　 　0 recursive calls
　　 　 　2 db block gets
　　 　 30 consistent gets
　　 　 　0 physical reads
　　 　 　0 redo size
　　 　2598 bytes sent via SQL*Net to client
　　 　503 bytes received via SQL*Net from client
　　 　 　2 SQL*Net roundtrips to/from client
　　 　 　0 sorts (memory)
　　 　 　0 sorts (disk)
　　 　 14 rows processed

通过以上分析，可以得出实际的执行步骤是：

　　1. TABLE ACCESS (FULL) OF 'EMP'

　　2. INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)

　　3. TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'

　　4. NESTED LOOPS (JOINING 1 AND 3)

　　注： 目前许多第三方的工具如TOAD和ORACLE本身提供的工具如OMS的SQL Analyze都提供了极其方便的EXPLAIN PLAN工具。也许喜欢图形化界面的朋友们可以选用它们。

　　2. 用索引提高效率

　　索引是表的一个概念部分，用来提高检索数据的效率。 实际上，ORACLE使用了一个复杂的自平衡B-tree结构。 通常，通过索引查询数据比全表扫描要快。 当ORACLE找出执行查询和Update语句的最佳路径时， ORACLE优化器将使用索引。 同样在联结多个表时使用索引也可以提高效率。 另一个使用索引的好处是，它提供了主键(primary key)的唯一性验证。

　　除了那些LONG或LONG RAW数据类型， 你可以索引几乎所有的列。 通常， 在大型表中使用索引特别有效。 当然，你也会发现， 在扫描小表时，使用索引同样能提高效率。

　　虽然使用索引能得到查询效率的提高，但是我们也必须注意到它的代价。 索引需要空间来存储，也需要定期维护， 每当有记录在表中增减或索引列被修改时， 索引本身也会被修改。 这意味着每条记录的INSERT ， DELETE ， UPDATE将为此多付出4 ， 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理，那些不必要的索引反而会使查询反应时间变慢。

　　定期的重构索引是有必要的。

　　ALTER INDEX REBUILD

　　3. 索引的操作

　　ORACLE对索引有两种访问模式。

　　索引唯一扫描 ( INDEX UNIQUE SCAN)

　　大多数情况下， 优化器通过WHERE子句访问INDEX.

表LODGING有两个索引 ： 建立在LODGING列上的唯一性索引LODGING_PK和建立在MANAGER列上的非唯一性索引LODGING$MANAGER.

　　SELECT*
　　FROMLODGING
　　WHERELODGING=‘ROSEHILL’;

　　在内部 ， 上述SQL将被分成两步执行， 首先 ， LODGING_PK 索引将通过索引唯一扫描的方式被访问 ， 获得相对应的ROWID， 通过ROWID访问表的方式执行下一步检索。

　　如果被检索返回的列包括在INDEX列中，ORACLE将不执行第二步的处理(通过ROWID访问表)。 因为检索数据保存在索引中， 单单访问索引就可以完全满足查询结果。

　　下面SQL只需要INDEX UNIQUE SCAN 操作。

　　SELECTLODGING
　　FROMLODGING
　　WHERELODGING=‘ROSEHILL’;

　　索引范围查询(INDEX RANGE SCAN)

　　适用于两种情况：

　　1. 基于一个范围的检索

　　2. 基于非唯一性索引的检索

　　例1：

　　SELECT LODGING FROM LODGING WHERE LODGING LIKE ‘M%’;

　　WHERE子句条件包括一系列值， ORACLE将通过索引范围查询的方式查询LODGING_PK . 由于索引范围查询将返回一组值， 它的效率就要比索引唯一扫描低一些。

　　例2：

　　SELECTLODGING
　　FROMLODGING
　　WHEREMANAGER=‘BILLGATES’;

　　这个SQL的执行分两步， LODGING$MANAGER的索引范围查询(得到所有符合条件记录的ROWID) 和下一步同过ROWID访问表得到LODGING列的值。 由于LODGING$MANAGER是一个非唯一性的索引，数据库不能对它执行索引唯一扫描。

　　由于SQL返回LODGING列，而它并不存在于LODGING$MANAGER索引中， 所以在索引范围查询后会执行一个通过ROWID访问表的操作。

　　WHERE子句中， 如果索引列所对应的值的第一个字符由通配符(WILDCARD)开始， 索引将不被采用。在这种情况下，ORACLE将使用全表扫描。

　　SELECTLODGING
　　FROMLODGING
　　WHEREMANAGERLIKE‘%HANMAN’;

1. 基础表的选择

　　基础表(Driving Table)是指被最先访问的表(通常以全表扫描的方式被访问)。 根据优化器的不同， SQL语句中基础表的选择是不一样的。

　　如果你使用的是CBO (COST BASED OPTIMIZER)，优化器会检查SQL语句中的每个表的物理大小，索引的状态，然后选用花费最低的执行路径。

　　如果你用RBO (RULE BASED OPTIMIZER) ， 并且所有的连接条件都有索引对应， 在这种情况下， 基础表就是FROM 子句中列在最后的那个表。

　　举例：

　　SELECTA.NAME，B.MANAGER
　　FROM　WORKERA，
　　LODGINGB
　　WHERE　A.LODGING=B.LODING;

　　由于LODGING表的LODING列上有一个索引， 而且WORKER表中没有相比较的索引， WORKER表将被作为查询中的基础表。

　　2. 多个平等的索引

　　当SQL语句的执行路径可以使用分布在多个表上的多个索引时， ORACLE会同时使用多个索引并在运行时对它们的记录进行合并， 检索出仅对全部索引有效的记录。

　　在ORACLE选择执行路径时，唯一性索引的等级高于非唯一性索引。 然而这个规则只有当WHERE子句中索引列和常量比较才有效。如果索引列和其他表的索引类相比较。 这种子句在优化器中的等级是非常低的。

　　如果不同表中两个想同等级的索引将被引用， FROM子句中表的顺序将决定哪个会被率先使用。 FROM子句中最后的表的索引将有最高的优先级。

　　如果相同表中两个想同等级的索引将被引用， WHERE子句中最先被引用的索引将有最高的优先级。

　　举例：

　　DEPTNO上有一个非唯一性索引，EMP_CAT也有一个非唯一性索引。

　　SELECTENAME，
　　FROMEMP
　　WHEREDEPT_NO=20
　　ANDEMP_CAT=‘A’;
这里，DEPTNO索引将被最先检索，然后同EMP_CAT索引检索出的记录进行合并。 执行路径如下：
　　TABLEACCESSBYROWIDONEMP
　　AND-EQUAL
　　INDEXRANGESCANONDEPT_IDX
　　INDEXRANGESCANONCAT_IDX
　　3. 等式比较和范围比较
　　当WHERE子句中有索引列， ORACLE不能合并它们，ORACLE将用范围比较。
　　举例：
　　DEPTNO上有一个非唯一性索引，EMP_CAT也有一个非唯一性索引。
　　SELECTENAME
　　FROMEMP
　　WHEREDEPTNO>20
　　ANDEMP_CAT=‘A’;
　　这里只有EMP_CAT索引被用到，然后所有的记录将逐条与DEPTNO条件进行比较。 执行路径如下：
　　TABLEACCESSBYROWIDONEMP
　　INDEXRANGESCANONCAT_IDX
　　4. 不明确的索引等级
　　当ORACLE无法判断索引的等级高低差别，优化器将只使用一个索引，它就是在WHERE子句中被列在最前面的。
　　举例：
　　DEPTNO上有一个非唯一性索引，EMP_CAT也有一个非唯一性索引。
　　SELECTENAME
　　FROMEMP
　　WHEREDEPTNO>20
　　ANDEMP_CAT>‘A’;
　　这里， ORACLE只用到了DEPT_NO索引。 执行路径如下：
　　TABLEACCESSBYROWIDONEMP
　　INDEXRANGESCANONDEPT_IDX
　　译者按：我们来试一下以下这种情况：
　SQL> select index_name， uniqueness from user_indexes where table_name = 'EMP'；
　　INDEX_NAME　　　　　　　　　　 UNIQUENES
　　------------------------------ ---------
　　EMPNO　　　　　　　　　　　　　UNIQUE
　　EMPTYPE　　　　　　　　　　　　NONUNIQUE
　　SQL> select * from emp where empno >= 2 and emp_type = 'A' ；
　　no rows selected
　　Execution Plan
　　----------------------------------------------------------
　　0　　　SELECT STATEMENT Optimizer=CHOOSE
　　1　　0　 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
　　2　　1　　 INDEX （RANGE SCAN） OF 'EMPTYPE' （NON-UNIQUE
　　虽然EMPNO是唯一性索引，但是由于它所做的是范围比较， 等级要比非唯一性索引的等式比较低!
　　5. 强制索引失效
　　如果两个或以上索引具有相同的等级，你可以强制命令ORACLE优化器使用其中的一个(通过它，检索出的记录数量少) .
　　举例：
　　SELECTENAME
　　FROMEMP
　　WHEREEMPNO=7935
　　ANDDEPTNO+0=10/*DEPTNO上的索引将失效*/
　　ANDEMP_TYPE||‘’=‘A’/*EMP_TYPE上的索引将失效*/
　　这是一种相当直接的提高查询效率的办法。 但是你必须谨慎考虑这种策略，一般来说，只有在你希望单独优化几个SQL时才能采用它。
　　这里有一个例子关于何时采用这种策略，
　　假设在EMP表的EMP_TYPE列上有一个非唯一性的索引而EMP_CLASS上没有索引。
　　SELECTENAME
　　FROMEMP
　　WHEREEMP_TYPE=‘A’
　　ANDEMP_CLASS=‘X’;
　　优化器会注意到EMP_TYPE上的索引并使用它。 这是目前唯一的选择。 如果，一段时间以后， 另一个非唯一性建立在EMP_CLASS上，优化器必须对两个索引进行选择，在通常情况下，优化器将使用两个索引并在他们的结果集合上执行排序及合并。 然而，如果其中一个索引(EMP_TYPE)接近于唯一性而另一个索引(EMP_CLASS)上有几千个重复的值。 排序及合并就会成为一种不必要的负担。 在这种情况下，你希望使优化器屏蔽掉EMP_CLASS索引。
　　用下面的方案就可以解决问题。
　　SELECTENAME
　　FROMEMP
　　WHEREEMP_TYPE=‘A’
　　ANDEMP_CLASS||‘’=‘X’;

1. 避免在索引列上使用计算

　　WHERE子句中，如果索引列是函数的一部分。优化器将不使用索引而使用全表扫描。

　　举例：

　　低效：

　　SELECT…
　　FROMDEPT
　　WHERESAL*12>25000;

　　高效：

　　SELECT…
　　FROMDEPT
　　WHERESAL>25000/12;

　　：这是一个非常实用的规则，请务必牢记

　　2. 自动选择索引

　　如果表中有两个以上(包括两个)索引，其中有一个唯一性索引，而其他是非唯一性。

　　在这种情况下，ORACLE将使用唯一性索引而完全忽略非唯一性索引。

　　举例：

　　SELECTENAME
　　FROMEMP
　　WHEREEMPNO=2326
　　ANDDEPTNO=20;

　　这里，只有EMPNO上的索引是唯一性的，所以EMPNO索引将用来检索记录。

　　TABLEACCESSBYROWIDONEMP
　　INDEXUNIQUESCANONEMP_NO_IDX

　　3. 避免在索引列上使用NOT

　　通常，我们要避免在索引列上使用NOT， NOT会产生在和在索引列上使用函数相同的影响。 当ORACLE“遇到”NOT，他就会停止使用索引转而执行全表扫描。

　　举例：

　　低效： (这里，不使用索引)

　　SELECT…
　　FROMDEPT
　　WHEREDEPT_CODENOT=0;

　　高效： (这里，使用了索引)

　　SELECT…
　　FROMDEPT
　　WHEREDEPT_CODE>0;

　　需要注意的是，在某些时候， ORACLE优化器会自动将NOT转化成相对应的关系操作符。

　　NOT > to <=

　　NOT >= to <

　　NOT < to >=

　　NOT <= to >

　　：在这个例子中，作者犯了一些错误。 例子中的低效率SQL是不能被执行的。

　　我做了一些测试：

SQL> select * from emp where NOT empno > 1；
　no rows selected
　Execution Plan
　----------------------------------------------------------
　　0　　　SELECT STATEMENT Optimizer=CHOOSE
　1　　0　 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
　2　　1　　 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）
　　SQL> select * from emp where empno <= 1；
　no rows selected
　Execution Plan
　----------------------------------------------------------
　　0　　　SELECT STATEMENT Optimizer=CHOOSE
　1　　0　 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
　2　　1　　 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）

　　两者的效率完全一样，也许这符合作者关于“ 在某些时候， ORACLE优化器会自动将NOT转化成相对应的关系操作符” 的观点。

　　4. 用>=替代>

　　如果DEPTNO上有一个索引，

　　高效：

　　SELECT*
　　FROMEMP
　　WHEREDEPTNO>=4

　　低效：

　　SELECT*
　　FROMEMP
　　WHEREDEPTNO>3

　　两者的区别在于， 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录。

1. 避免在索引列上使用计算

　　WHERE子句中，如果索引列是函数的一部分。优化器将不使用索引而使用全表扫描。

　　举例：

　　低效：

　　SELECT…
　　FROMDEPT
　　WHERESAL*12>25000;

　　高效：

　　SELECT…
　　FROMDEPT
　　WHERESAL>25000/12;

　　：这是一个非常实用的规则，请务必牢记

　　2. 自动选择索引

　　如果表中有两个以上(包括两个)索引，其中有一个唯一性索引，而其他是非唯一性。

　　在这种情况下，ORACLE将使用唯一性索引而完全忽略非唯一性索引。

　　举例：

　　SELECTENAME
　　FROMEMP
　　WHEREEMPNO=2326
　　ANDDEPTNO=20;

　　这里，只有EMPNO上的索引是唯一性的，所以EMPNO索引将用来检索记录。

　　TABLEACCESSBYROWIDONEMP
　　INDEXUNIQUESCANONEMP_NO_IDX

　　3. 避免在索引列上使用NOT

　　通常，我们要避免在索引列上使用NOT， NOT会产生在和在索引列上使用函数相同的影响。 当ORACLE“遇到”NOT，他就会停止使用索引转而执行全表扫描。

　　举例：

　　低效： (这里，不使用索引)

　　SELECT…
　　FROMDEPT
　　WHEREDEPT_CODENOT=0;

　　高效： (这里，使用了索引)

　　SELECT…
　　FROMDEPT
　　WHEREDEPT_CODE>0;

　　需要注意的是，在某些时候， ORACLE优化器会自动将NOT转化成相对应的关系操作符。

　　NOT > to <=

　　NOT >= to <

　　NOT < to >=

　　NOT <= to >

　　：在这个例子中，作者犯了一些错误。 例子中的低效率SQL是不能被执行的。

　　我做了一些测试：

SQL> select * from emp where NOT empno > 1；
　no rows selected
　Execution Plan
　----------------------------------------------------------
　　0　　　SELECT STATEMENT Optimizer=CHOOSE
　1　　0　 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
　2　　1　　 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）
　　SQL> select * from emp where empno <= 1；
　no rows selected
　Execution Plan
　----------------------------------------------------------
　　0　　　SELECT STATEMENT Optimizer=CHOOSE
　1　　0　 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
　2　　1　　 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）

　　两者的效率完全一样，也许这符合作者关于“ 在某些时候， ORACLE优化器会自动将NOT转化成相对应的关系操作符” 的观点。

　　4. 用>=替代>

　　如果DEPTNO上有一个索引，

　　高效：

　　SELECT*
　　FROMEMP
　　WHEREDEPTNO>=4

　　低效：

　　SELECT*
　　FROMEMP
　　WHEREDEPTNO>3

　　两者的区别在于， 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录。

 {http://blog.chinaunix.net/u/20483/showart_546882.html}

HashMap是Java新Collection Framework中用来代替HashTable的一个实现，HashMap和HashTable的区别是： HashMap是未经同步的，而且允许null值。HashTable继承Dictionary，而且使用了Enumeration，所以被建议不要使用。
HashMap的声明如下：
public class HashMap extends AbstractMap implements Map, Cloneable,Serializable
有关AbstractMap：http://blog.csdn.net/treeroot/archive/2004/09/20/110343.aspx
有关Map：http://blog.csdn.net/treeroot/archive/2004/09/20/110331.aspx
有关Cloneable：http://blog.csdn.net/treeroot/archive/2004/09/07/96936.aspx
这个类比较复杂，这里只是重点分析了几个方法，特别是后面涉及到很多内部类都没有解释
不过都比较简单。

static final int DEFAULT_INITIAL_CAPACITY = 16; 默认初始化大小

static final int MAXIMUM_CAPACITY = 1 << 30; 最大初始化大小

static final float DEFAULT_LOAD_FACTOR = 0.75f; 默认加载因子

transient Entry[] table; 一个Entry类型的数组，数组的长度为2的指数。

transient int size; 映射的个数

int threshold; 下一次扩容时的值

final float loadFactor; 加载因子

transient volatile int modCount; 修改次数

public HashMap(int initialCapacity, float loadFactor) {
　　 if (initialCapacity < 0)
　　　　 throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);
　　 if (initialCapacity > MAXIMUM_CAPACITY)
　　　　 initialCapacity = MAXIMUM_CAPACITY;
　　 if (loadFactor <= 0 || Float.isNaN(loadFactor))
　　　　 throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
　　 int capacity = 1;
　　 while (capacity < initialCapacity)
　　　　 capacity <<= 1;
　　 this.loadFactor = loadFactor;
　　 threshold = (int)(capacity * loadFactor);
　　 table = new Entry[capacity];
　　 init();
}

public HashMap(int initialCapacity) {
　　 this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap() {
　　 this.loadFactor = DEFAULT_LOAD_FACTOR;
　　 threshold = (int)(DEFAULT_INITIAL_CAPACITY);
　　　　　　注意：这里应该是一个失误！ 应该是：threshold =(int)(DEFAULT_INITIAL_CAPACITY * loadFactor);
　　 table = new Entry[DEFAULT_INITIAL_CAPACITY];
　　　init();
}

public HashMap(Map m) {
　　 this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　DEFAULT_LOAD_FACTOR);
　　 putAllForCreate(m);
}

void init() {}

static final Object NULL_KEY = new Object();

static Object maskNull(Object key){
　　 return (key == null ? NULL_KEY : key);
}

static Object unmaskNull(Object key) {
　　 return (key == NULL_KEY ? null : key);
}

static int hash(Object x) {
　　 int h = x.hashCode();
　　 h += ~(h << 9);
　　 h ^= (h >>> 14);
　　 h += (h << 4);
　　 h ^= (h >>> 10);
return h;
}
在HashTable中没有这个方法，也就是说HashTable中是直接用对象的hashCode值，但是HashMap做了改进 用这个算法来获得哈希值。

static boolean eq(Object x, Object y) {
　 　return x == y || x.equals(y);
}

static int indexFor(int h, int length) {
　　 return h & (length-1);
}
根据哈希值和数组的长度来返回该hash值在数组中的位置，只是简单的与关系。

public int size() {
　　 return size;
}

public boolean isEmpty() {
　　return size == 0;
}

public Object get(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry e = table[i];
　　 while (true) {
　　　　 if (e == null) return e;
　　　　 if (e.hash == hash && eq(k, e.key)) return e.value;
　　　　 e = e.next;
　　 }
}
这个方法是获取数据的方法，首先获得哈希值，这里把null值掩饰了，并且hash值经过函数hash()修正。 然后计算该哈希值在数组中的索引值。如果该索引处的引用为null，表示HashMap中不存在这个映射。 否则的话遍历整个链表，这里找到了就返回,如果没有找到就遍历到链表末尾，返回null。这里的比较是这样的：e.hash==hash && eq(k,e.key) 也就是说如果hash不同就肯定认为不相等，eq就被短路了，只有在 hash相同的情况下才调用equals方法。现在我们该明白Object中说的如果两个对象equals返回true，他们的 hashCode应该相同的道理了吧。假如两个对象调用equals返回true，但是hashCode不一样，那么在HashMap 里就认为他们不相等。

public boolean containsKey(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry e = table[i];
　　 while (e != null) {
　　　　 if (e.hash == hash && eq(k, e.key)) return true;
　　　　 e = e.next;
　　 }
　　return false;
}
这个方法比上面的简单，先找到哈希位置，再遍历整个链表，如果找到就返回true。

public Object put(Object key, Object value) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 for (Entry e = table[i]; e != null; e = e.next) {
　　　　 if (e.hash == hash && eq(k, e.key)) {
　　　　　　 Object oldValue = e.value;
　　　　　　 e.value = value;
　　　　　　 e.recordAccess(this);
　　　　　　 return oldValue;
　　　　 }
　　 }
　　 modCount++;
　　 addEntry(hash, k, value, i);
　　 return null;
}
首先获得hash索引位置，如果该位置的引用为null，那么直接插入一个映射，返回null。如果此处的引用不是null，必须遍历链表，如果找到一个相同的key，那么就更新该value，同时返回原来的value值。如果遍历完了没有找到，说明该key值不存在，还是插入一个映射。如果hash值足够离散的话，也就是说该索引没有被使用的话，那么不不用遍历链表了。相反，如果hash值不离散，极端的说如果是常数的话，所有的映射都会在这一个链表上，效率会极其低下。这里举一个最简单的例子，写两
个不同的类作为key插入到HashMap中，效率会远远不同。
class Good{
　　int i;
　　public Good(int i){
　　　this.i=i;
　　}
　　public boolean equals(Object o){
　　　return (o instanceof Good) && (this.i==((Good)o).i)
　　}
　　public int hashCode(){
　　　return i;
　　}
}
class Bad{
　　int i;
　　public Good(int i){
　　　　this.i=i;
　　}
　　public boolean equals(Object o){
　　　　return (o instanceof Good) && (this.i==((Good)o).i)
　　}
　　public int hashCode(){
　　　return 0;
　　}
}
执行代码：
Map m1=new HashMap();
Map m2=new HashMap();
for(int i=0;i<100;i++){
　　m1.put(new Good(i),new Integer(i)); //这里效率非常高
}
for(int i=0;i<100;i++){
　　m2.put(new Bad(i),new Integer(i)); //这里几乎要崩溃
}
上面的是两个非常极端的例子，执行一下就知道差别有多大。

private void putForCreate(Object key, Object value) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 for (Entry e = table[i]; e != null; e = e.next) {
　　　　 if (e.hash == hash && eq(k, e.key)) {
　　　　　　　 e.value = value;
　　　　　　　 return;
　　　　 }
　　 }
　　 createEntry(hash, k, value, i);
}

void putAllForCreate(Map m) {
　　 for (Iterator i = m.entrySet().iterator(); i.hasNext(); ) {
　　　　 Map.Entry e = (Map.Entry) i.next();
　　　　 putForCreate(e.getKey(), e.getValue());
　　 }
}
上面的两个方法是被构造函数和clone方法调用的。

void resize(int newCapacity) {
　　 Entry[] oldTable = table;
　　 int oldCapacity = oldTable.length;
　　 if (size < threshold || oldCapacity > newCapacity)
　　　　 return;
　　 Entry[] newTable = new Entry[newCapacity];
　　 transfer(newTable);
　　 table = newTable;
　　 threshold = (int)(newCapacity * loadFactor);
}
这个方法在需要的时候重新分配空间，相当于ArrayList的ensureCapacity方法，不过这个更加复杂。

void transfer(Entry[] newTable) {
　　 Entry[] src = table;
　　 int newCapacity = newTable.length;
　　 for (int j = 0; j < src.length; j++) {
　　　　 Entry e = src[j];
　　　　 if (e != null) {
　　　　　　 src[j] = null;
　　　　　　 do {
　　　　　　　　　 Entry next = e.next;
　　　　　　　　　 int i = indexFor(e.hash, newCapacity);
　　　　　　　　　 e.next = newTable[i];
　　　　　　　　　 newTable[i] = e;
　　　　　　　　　 e = next;
　　　　　　 } while (e != null);
　　　　 }
　　 }
}
遍历原来的数组，如果该Entry不是null的话，说明有映射，然后遍历这个链表，把所有的映射插入到新的数组中，注意这里要从新计算索引位置。

public void putAll(Map t) {
　　 int n = t.size();
　　 if (n == 0)
　　　　 return;
　　 if (n >= threshold) {
　　　　 n = (int)(n / loadFactor + 1);
　　　　 if (n > MAXIMUM_CAPACITY)
　　　　　　 n = MAXIMUM_CAPACITY;
　　　　 int capacity = table.length;
　　　　 while (capacity < n) capacity <<= 1;
　　　　　　 resize(capacity);
　　 }
　　 for (Iterator i = t.entrySet().iterator(); i.hasNext(); ) {
　　　　 Map.Entry e = (Map.Entry) i.next();
　　　　 put(e.getKey(), e.getValue());
　　 }
}
这个方法先确定是否需要扩大空间，然后循环调用put方法。

public Object remove(Object key) {
　　 Entry e = removeEntryForKey(key);
　　 return (e == null ? e : e.value);
}

Entry removeEntryForKey(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry prev = table[i];
　　 Entry e = prev;
　　 while (e != null) { 　如果e==null表示不存在
　　　　 Entry next = e.next;
　　　　 if (e.hash == hash && eq(k, e.key)) {
　　　　　　 modCount++;
　　　　　　 size--;
　　　　　　 if (prev == e)
　　　 　　　　　table[i] = next; 链表的第一个元素就是要删除的，这里最好加一句 e.next=null.
　　　　　　 else
　　　　　　　　 prev.next = next; 存在担不是链表的第一个元素， 这里最好加一句 e.next=null.
　　　　　　 e.recordRemoval(this);
　　　　　　 return e;
　　　　 }
　　　　 prev = e;
　　　　 e = next;
　　 }
　　return e;　　　这里其实就是return null;
}
这个方法其实也不复杂，也是遍历链表，这里建议加一句e.next=null,可以改为
if(prev==e)
　　table[i]=next;
else
　　prev.next=next;
e.next=null; 这一句是多加的，可以提高效率。
这里简单说明我的看法：
因为e是被删除的节点，删除它其实就是指向它的指针指向它的后面一个节点。所以e可以作为GC回收的对象。
可以e还有一个next指针指向我们的数据，如果e没有被回收。而且此时e.next指向的节点也变为没用的了，但是
却有一个它的引用(e.next),所以虽然e的下一个节点没用了，但是却不能作为GC回收的对象，除非e先被回收。
虽然不一定会引起很大的问题，但是至少会影响GC的回收效率。就像数据库中的外键引用一样，删除起来很麻烦呀。

Entry removeMapping(Object o) {
　　 if (!(o instanceof Map.Entry))
　　　　 return null;
　　 Map.Entry entry = (Map.Entry)o;
　　 Object k = maskNull(entry.getKey());
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry prev = table[i];
　　 Entry e = prev;
　　 while (e != null) {
　　　　 Entry next = e.next;
　 　　　if (e.hash == hash && e.equals(entry)) {
　　　　　　 modCount++;
　　　　　　 size--;
　　　 　　　if (prev == e)
　　　　　　　　 table[i] = next;
　　　　　　 else
　　　　　　　　 prev.next = next;
　　　　　　 e.recordRemoval(this);
　　　　　　 return e;
　　　　　 }
　　　　　 prev = e;
　　　　　 e = next;
　　 }
　　 return e;
}
这个方法和上面的一样。

public void clear() {
　　 modCount++;
　　 Entry tab[] = table;
　　 for (int i = 0; i < tab.length; i++)
　　　　 tab[i] = null;
　　 size = 0;
}
同样可以改进

public boolean containsValue(Object value) {
　　 if (value == null)
　　　　 return containsNullValue();
　　 Entry tab[] = table;
　　 for (int i = 0; i < tab.length ; i++)
　　　　 for (Entry e = tab[i] ; e != null ; e = e.next)
　　　　　　 if (value.equals(e.value)) return true;
　　 return false;
}

private boolean containsNullValue() {
　　 Entry tab[] = table;
　　 for (int i = 0; i < tab.length ; i++)
　　　　 for (Entry e = tab[i] ; e != null ; e = e.next)
　　　　　　 if (e.value == null) return true;
　　 return false;
}

public Object clone() {
　　 HashMap result = null;
　　 try {
　　　　 result = (HashMap)super.clone();
　　 }
　　 catch (CloneNotSupportedException e) { // assert false; }
　　 result.table = new Entry[table.length];
　　 result.entrySet = null;
　　 result.modCount = 0;
　　 result.size = 0;
　　 result.init();
　　 result.putAllForCreate(this);
　　 return result;
}

static class Entry implements Map.Entry {
　　 final Object key;
　　 Object value;
　　 final int hash;
　　 Entry next;
　　 Entry(int h, Object k, Object v, Entry n) {
　　　　 value = v;
　　　　 next = n;
　　　　 key = k;
　　　　 hash = h;
　　 }
　　 public Object getKey() {
　　　　 return unmaskNull(key);
　　 }
　　　public Object getValue() {
　　　　 return value;
　　 }
　　　public Object setValue(Object newValue) {
　　　　　 Object oldValue = value;
　　　　　 value = newValue;
　　　　　 return oldValue;
　　 }
　　　public boolean equals(Object o) {
　　　　 if (!(o instanceof Map.Entry)) return false;
　　　　 Map.Entry e = (Map.Entry)o;
　　　　 Object k1 = getKey();
　　　　 Object k2 = e.getKey();
　　　　 if (k1 == k2 || (k1 != null && k1.equals(k2))) {
　　　　　　 Object v1 = getValue();
　　　　　　 Object v2 = e.getValue();
　　　　　　 if (v1 == v2 || (v1 != null && v1.equals(v2))) return true;
　　　　 }
　　　　 return false;
　　　 }
　　　 public int hashCode() {
　　　　　 return (key==NULL_KEY ? 0 : key.hashCode()) ^ (value==null ? 0 : value.hashCode());
　　　 }
　　　 public String toString() {
　　　　　 return getKey() + "=" + getValue();
　　　 }
　　　 void recordAccess(HashMap m) { }
　　　 void recordRemoval(HashMap m) { }
}
一个静态内部类

void addEntry(int hash, Object key, Object value, int bucketIndex) {
　　　 table[bucketIndex] = new Entry(hash, key, value, table[bucketIndex]);
　　　 if (size++ >= threshold)
　　　　　 resize(2 * table.length);
}
注意这个方法，插入连表的头。
可以写成这样更好理解：
Entry oldHead=table[bucketIndex];
Entry newHead = new Entry(hash,key,value,oldHead);
table[bucketIndex]=newHead;

void createEntry(int hash, Object key, Object value, int bucketIndex) {
　　 table[bucketIndex] = new Entry(hash, key, value, table[bucketIndex]);
　　 size++;
}

private abstract class HashIterator implements Iterator {
　　 Entry next;
　　 int expectedModCount;
　　 int index;
　　 Entry current;
　　 HashIterator() {
　　　　 expectedModCount = modCount;
　　　　 Entry[] t = table;
　　　　 int i = t.length;
　　　　 Entry n = null;
　　　　 if (size != 0) {
　　　　　　 while (i > 0 && (n = t[--i]) == null) ;
　　　　 }
　　　　 next = n;
　　　　 index = i;
　　 }
　　 public boolean hasNext() {
　　　　 return next != null;
　　 }
　　 Entry nextEntry() {
　　　　 if (modCount != expectedModCount)
　　　　　　 throw new ConcurrentModificationException();
　　　　 Entry e = next;
　　　　if (e == null)
　　　　　　 throw new NoSuchElementException();
　　　　 Entry n = e.next;
　　　　 Entry[] t = table;
　　　　 int i = index;
　　　　 while (n == null && i > 0)
　　　　　　　 n = t[--i]; index = i;
　　　　 next = n;
　　　　 return current = e;
　　 }
　　 public void remove() {
　　　　 if (current == null)
　　　　　　 throw new IllegalStateException();
　　　　 if (modCount != expectedModCount)
　　　　　　 throw new ConcurrentModificationException();
　　　　 Object k = current.key;
　　　　 current = null;
　　　　 HashMap.this.removeEntryForKey(k);
　　　　 expectedModCount = modCount;
　　 }
}

private class ValueIterator extends HashIterator {
　　 public Object next() {
　　　　 return nextEntry().value;
　　 }
}

private class KeyIterator extends HashIterator {
　　 public Object next() {
　　　　 return nextEntry().getKey();
　　 }
}

private class EntryIterator extends HashIterator {
　　 public Object next() {
　　　　 return nextEntry();
　　 }
}

Iterator newKeyIterator() {
　　 return new KeyIterator();
}

Iterator newValueIterator() {
　　 return new ValueIterator();
}

Iterator newEntryIterator() { 　
　 　return new EntryIterator();
}

private transient Set entrySet = null;

public Set keySet() {
　　 Set ks = keySet;
　　 return (ks != null ? ks : (keySet = new KeySet()));
}

private class KeySet extends AbstractSet {
　　 public Iterator iterator() {
　　　　 return newKeyIterator();
　　 }
　　 public int size() {
　　　　 return size;
　　 }
　　 public boolean contains(Object o) {
　　　　 return containsKey(o);
　　 }
　　 public boolean remove(Object o) {
　　　　 return HashMap.this.removeEntryForKey(o) != null;
　　 }
　　 public void clear() {
　　　　 HashMap.this.clear();
　　 }
}

public Collection values() {
　　 Collection vs = values; return (vs != null ? vs : (values = new Values()));
}

private class Values extends AbstractCollection {
　　 public Iterator iterator() {
　　　　 return newValueIterator();
　　 }
　　 public int size() {
　　　　 return size;
　　 }
　　 public boolean contains(Object o) {
　　　　 return containsValue(o);
　　 }
　　 public void clear() {
　　　　 HashMap.this.clear();
　　 }
}

public Set entrySet() {
　　 Set es = entrySet;
　　 return (es != null ? es : (entrySet = new EntrySet()));
}

private class EntrySet extends AbstractSet {
　　 public Iterator iterator() {
　　　　 return newEntryIterator();
　　 }
　　 public boolean contains(Object o) {
　　　　 if (!(o instanceof Map.Entry))
　　　　　　 return false;
　　　　 Map.Entry e = (Map.Entry)o;
　　　　 Entry candidate = getEntry(e.getKey());
　　　　 return candidate != null && candidate.equals(e);
　　 }
　　 public boolean remove(Object o) {
　　　　 return removeMapping(o) != null;
　　 }
　　 public int size() {
　　　　 return size;
　　 }
　　 public void clear() {
　　　　 HashMap.this.clear();
　　 }
}

private void writeObject(java.io.ObjectOutputStream s) throws IOException {
　　 s.defaultWriteObject();
　　 s.writeInt(table.length);
　　 s.writeInt(size);
　　 for (Iterator i = entrySet().iterator(); i.hasNext(); ) {
　　　　 Map.Entry e = (Map.Entry) i.next();
　　　　 s.writeObject(e.getKey());
　　　　 s.writeObject(e.getValue());
　　 }
}

private static final long serialVersionUID = 362498820763181265L;

private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
　　 s.defaultReadObject();
　　 int numBuckets = s.readInt();
　　 table = new Entry[numBuckets];
　　 init();
　　 size = s.readInt(); for (int i=0;
　　 for (int i=0; i<size; i++) {
　　　　　Object key = s.readObject();
　　　　　Object value = s.readObject();　
　　　　　putForCreate(key, value);
　　　}
}

int capacity() {
　 return table.length;
}
float loadFactor() {
　　 return loadFactor;
}