http://java.sun.com/developer/JDCTechTips/2001/tt0410.html#making

有两种主要的Collection Types
java.util.Map
java.util.SortedMap
java.util.Collection
java.util.Set
java.util.List
java.util.SortedSet

Implementations

List的三种实现

java.util.Vector
java.util.ArrayList
java.util.LinkedList

三者的异同
三者都是有序的，一般就是加入的次序。

        Vector和ArrayList内部都是用数组实现的，可以把它们想象成为一个数组。当容量不够的时候，就新建一个更大的数组，然后把现在这个数组中的所有元素都拷过去。可以想象这种实现可以很方便的直接取出你要的某个元素而不用遍历。但是如果在中间删除或者插入元素，效率就不高了。甚至每次扩容的时候，都是很影响效率的时候。

        Vector和ArrayList的区别就是Vector是线程安全的，但ArrayList不是。因为实现线程安全是有代价的，如果应用中不需要线程安全，那么就用ArrayList，如果需要线程安全那就一定要用Vector。

至于java中的LinkedList，其实在数据结构中就是双向链表。插入和删除元素都很快，但是要查找一个元素就慢了。有失必有得，如何选择，就看应用的情况了。

Map和SortedMap的几种实现

java.util.HashTable
java.util.HashMap
java.util.IdentityHashMap
java.util.WeakHashMap

        以上四种都是无序的。HashTable和HashMap的区别是HashTable是线程安全的而HashMap不是，这个关系有点像Vector和ArrayList。

        IdentityHashMap首先它是一个HashMap，不同的是，它不是根据equal()函数来判断是否重复，只要不是同一个对象，哪怕这两个对象的数据都是一样的，那么就可以add进来。

java.util.LinkedHashMap

java.uil.TreeMap

        以上两种是有序的Map，可以进行iterate，当然这是要付出效率代价的。两者不同之处，由名字便可知道，LinkedHashMap用链表来维护这个次序，而TreeMap是用二叉树来维护这个次序。

Sets和SortedSets的几种实现

java.util.HashSet
java.util.LinkedSet
java.util.TreeSet

由名字就可知道什么意思了，不多说了

Collection的选择

        需要通过一个key找到一个元素吗？
        Yes，那就用Map
        No，那就用Collection

       如果选择了一个Collection，允许重复元素吗？
       Yes，那就用List
       No，那就用Set

       然后就是决定要不要Sorted...这个就比较难决定了。
       如果常常要sort，那就直接选择sorted的类型
       如果偶尔或者根本不需要sorted，那就选择普通类型，需要sort的时候先拷到sorted的类型中sort一下。

三种Iterators

java.util.Enumeration

这个基本被Iterator替代掉了，但在某些场合，比如J2ME中还可能用到。

java.util.Iterator

用的最广泛

java.util.ListIterator

双向的Iterator，必须用在实现List的Collection上面。

PS：很多Collection提供的是Fail-Fast Iterators，就是在iterater的时候，这个Collection是不能被更改的，否则就会报出ConcurrentModificationException在多线程环境下面尤其要注意。

       在编程中，用final变量来声明一些常量，这样就不用在每个用到这个常量数字的地方打入令人厌烦的复杂数字（比如PI），只要打入这个常量名字就行了。这大家都知道，可是要注意，这种常量是在编译阶段才被替换的（所谓替换，就是把程序中用到这个常量名字的地方，用常量本身来替代）。那意味着，如果其它类用到了这个常量，如果常量的值发生了更改，那用到这个常量的类必须重新build一下，否则那个类里还是以前的值。

        如果在程序中你用到了private final static常量，并且只在某一个方法内用到，那么你应该把它的声明移到方法以内。如果被两个以上的方法用到，那么还是留在类声明里。

移入方法内部后，不用写private关键字，而且程序看起来比较简单。

Final Variables

首先写个例子

public static String someMethod(final String environmentKey){

           final String key = "env." + environmentKey;

          System.out.println("Key is :" + key);

           return (System.getProperty(key));

}

        在method中声明的final变量和常量是不同的，不同之处在于method-scoped final variables are variable。每次进入这个方法内部，这个变量就被初始化一次。当然，这些变量都是运行时进行替换，而不像常量是在编译时进行替换。

Final Parameters

将方法的parameters声明成final，可以防止，在方法体内部这个参数被篡改。很好的best practice。

Final Collections

        public final static Set VALID_COLORS; 这句语句是不是声明了一个final set？答案是NO。这只是声明了一个final引用，也就是VALID_COLORS这个引用不能被更改。

        如果重新声明一个引用指向这个对象，那么这个对象还是能够更改的，所以这并不是一个final set。那么怎样做才能真正得到一个final set呢？

public final static Set VALID_COLORS;

static{

Set temp = new HashSet();

temp.add(Color.red);

temp.add(Color.blue);

...

VALID_COLORS = Collections.unmodifiableSet(temp);

}

        在实现自己的unmodifiable collections factory的时候，除了要实现Collection，seriallizable接口以外，对于Collection中定义的写操作，要重载。方法体中可以简单地抛出UnsupportedOperationException异常。

Instance-Scoped Variables

        说白了，就是那些在对象被实例化的时候才被初始化的属性，并且是不能被修改的。那么就把他声明成final吧。

ex：private final Date creationDate =

Calendar.getInstance(TimeZone.getTimeZone("GMT")).getTime();

这么做的话，就可以防止误操作，改变这个本来不应该变的值。

Final Classes

ex:

public final class SomeClass(){

//...Class contents

}

        这样的class 不能被继承。

        还有一种方法实现，就是把它所有的构造函数都改成private的。

        这在设计模式中sigleton模式中见过，但这就限制了这个类的重用，所以取个折衷，可以把构造函数声明成protected的。

Final Method

这个很熟悉了，一个类中的某个方法如果被声明成final的，那么这个类的子类是不能override这个方法的。

Conditional Complilation

        编程的时候我们常常会使用System.out.println(".....");来显示一些程序的运行情况，但在真正交付的时候，我们并不希望这些语句被编译到class文件里面去。

        一个做法是所有这种类型的语句前面加上一个if(booleanParameter)，然后通过设置这个booleanParameter来实现要不要运行这些语句，编译器在编译的时候如果发现if里面的语句不可达，那么会将这些程序代码直接去掉。

        疑问就是这些booleanParameter放在哪里比较好和方便。作者给出的建议是在包中专门建一个类，里面存放这些静态的boolean常量，当然，命名的时候要仔细。名字要指出用在哪里。

2.RTTI——Runtime type identification，作用就是告诉你整个object是属于什么类型的。最常用的是getClass()方法。

3.只在for循环中用到的变量，就在for循环中声明和分配，不用担心会循环分配内存。

比如：

for(int i =0;i<10;i++){

String s = a[i];

}

s并不会循环new，编译器会处理，让它只在第一次分配内存。
前面编程，我还特意把s移到外面去呢……汗啊

4.switch语句中，如果在default语句中加一个break是完全没有用的。因为在那个地方的break根本就不会被执行。

5.continue

for(int idx=0;idx<1000,idx++){

if(idx==555){continue;}

}

在这个例子中，循环仅仅跳过了555，如果程序中遇到类似要跳过某个点的情况，可以这么利用continue，会减少很多代码。

6.chaining constructor

活用super()、this()等，来缩减构造函数的复杂度。

7.private for attributes

   public for public methods

   protected for helper methods

8.In Java, instances of the same class are friends and give unrestricted access to all of their properties and methods.

比如

if((obj.value==5)&&(this.value==5)){

obj.value=25;

}

这里面跳过了setter方法，直接给属性赋值，这是很危险的做法。解决的方法是无论什么方法给对象中的属性赋值都要通过setter方法。

9.对于问题代码要尽量用throw exception告知用户，因为有时候不知道代码的执行环境，如EJB等等，很多环境都是没有Console的，若是简单的System.out.println 可能解决不了问题。

DriverManager机制：java.sql核心API

DataSource机制：javax.sql可扩展API

DriverManager机制：

stetp1：注册驱动程序

（1）隐式注册Class.forName("JDBCDriverName");

（2）显示注册DriverMnager.registerDriver(new JDBCDriverName());

step 2:建立数据库连接

Connection conn = DriverManager.getConnection(URL,username,password);

//其中URL＝jdbc:driver:databasename

step3:SQL操作

DataSource机制

step1：查询数据源对象

Context ctx = new InitialContext();

DataSource ds = (DataSource)ctx.lookup(DataSourceJNDIName);

step2：获取数据库连接

Connection con = ds.getConnection();

step3：SQL操作

SQL操作

（1）使用Statement

      Statement stmt = con.createStatement();

      stmt.executeUpdate("SQL语句");

      stmt.close();

（2）使用PreparedStatement

      例子

      PreparedStatement psmt = conn.preparedStatement("INSERT INTO employee                                                  VALUES(?,?,?)");

       psmt.setString(1,"Benjamin");

       psmt.setString(2,"France");

       psmt.setInt(3,55);

       int opNum = psmt.executeUpdate();

       还可以批量处理

       psmt.setString(1,"Benjamin");

       psmt.setString(2,"France");

       psmt.setInt(3,55);

       psmt.addBatch();

       psmt.setString(1,"Rob");

       psmt.setString(2,"America");

       psmt.setInt(3,56);

       psmt.addBatch();

       int [] updateCounts = psmt.executeBatch();

关于ResultSet

ResultSet rs = stmt.executeQuery("SQL");

next()——移到下一行，如果没有了则返回false。常常放在while(rs.next)用来循环取数据

getString(String ColumnName)

absolute(int row)

beforeFist()

isAfterLast()

isBeforeFirst()

isFirst()

isLast()

refreshRow()

关于元数据

所谓元数据就是描述数据的数据，这里当然指列名等等信息了

ResultSetMetaData rsmd = rs.getMetaData();

rsmd.getColumnCount();

rsmd.getColumnName(index);

Java常量

①十进制不能以0打头（数字0除外）

②十六进制必须以0x或者0X打头

③八进制必须以0打头

④长整型必须以L结尾

⑤小数常量默认为double型，如果要将小数赋值给float变量，数字后面要加f

final关键字

final 标记的类不能被继承

final 变量是常量，不能改变

final 方法不能被子类重写

Java变量

（1）当发生隐式类型转换时，目标类型取值范围要大于源类型取值范围

（2）字符串可以使用加号同其它的数据类型相连而形成一个新的字符串

Example：

System.out.println(‘a’+1);    输出的是98

System.out.println(“”+’a’+1); 输出的是”a1”

（3）局部变量一定要进行初始化

        编译的时候可能只是警告，但在使用时就会报错

Java运算

（1）       整数之间做除法时，只保留整数部分而舍弃小数部分。

（2）       养成这样的习惯：把x==3 写成 3==x

（3）       &和&&的区别

&&称为短路表达式，意思就是&不管两边是true或者false都会算一下，而&&如果算到前面的是false，它后面就不算了，反正综合起来表达式肯定是false。

（4）       位运算

<< 左移

>> 右移

   如果最高位是0，左边移空的高位就填0，如果最高位是1，左边移空的高位就填入1

>>> 无符号右移

   不管最高位是什么，移空的高位一律填入0

右移n位就是除以2的n次方

左移n位就是乘以2的n次方

Java内存

（1）Java内存分为两种：

①栈内存：用于存放基本类型变量和对象的引用变量

②堆内存：new创建的对象和数组

（2）当堆内存中的对象没有引用指向它时，它就变成了垃圾，会被垃圾回收器回收。

Java面向对象

（1）= =常用来比较引用是否指向同一个地址

     equals()用来比较对象的内容是否一样

     对于数组有Array.equals方法

（2）finalize()方法，它相当于C++中的析构函数，但又和析构函数不一样。因为Java里面已经有垃圾回收器了，所以finalize方法不是特别重要。另外，finalize是在对象被当成垃圾从内存中释放前调用，而不是在对象变成垃圾前调用，垃圾回收器什么时候清理垃圾是不定时的，所以不要指望用finalize做什么必要的收尾工作，因为你根本无法确定它会赶在垃圾回收器之前执行。

（3）System.gc()这个语句可以显式地调用垃圾回收器回收垃圾。

Java参数传递

（1）       基本类型的变量作为实参传递，并不能改变这个变量的值

举个例子，就是main函数里面定义的一个变量，传给一个方法，改下值，其实并没有改变main函数里面那个变量而是改了那个方法自己内部的那个副本。

（2）       那如果传递的是某个对象的引用呢？

道理一样，传递的是值，这个“值”就是引用的“值”，也就是对象的内存地址，方法通过这个地址对变量进行的修改，当然就是对main函数中定义的这个变量本身的修改了。

Java内部类

A类里面定义了B类，那么B就叫做内部类，A就叫做外部类。

B可以直接访问A类的所有变量和方法，反之不成立。

B类保存了A类的this引用。

内部类可以是static的

如果内部类被声明为static，那么它可以包含static的变量，但不再能访问外部类的非static变量。

方法内定义的内部类，只能访问方法中的final变量，而不能访问临时变量，但可以访问外部类的变量。

Java异常

（1）       一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类

（2）       如果父类抛出多个异常，那么覆盖方法必须抛出那些异常的一个子集，也就是说，不能抛出新的异常。

Java线程

两种实现多线程方式

（1）       直接继承Thread

MyThread extends Thread

然后

MyThread t = new MyTread();

t.start();

t.start();

值得注意的是，无论调用start多少遍只能启动一个线程。

要实现多个线程，只能生成多个对象，分别启动线程，一个对象只能启动一个线程

（2）       实现Runnable接口

MyThread implements Runnalbe

然后

new Thread(t).start();

new Thread(t).start();

这种方法就能实现多个线程。

但这两种方法启动的多个线程又有不一样的地方：

第一种因为是生成了多个对象，所以类中声明的一些资源，比如变量等等都是各不相关的。

第二种对类中声明的资源是多个线程共享的。

所以要按需选择。

Java String和StringBuffer

String 对象不能轻易被改变，经常用的“+”其实是新生成了一个String对象，平常感觉不大，但是真的在大型应用中，对效率影响非常严重。

StringBuffer对象可以改动，一旦生成了不再变化的内容，就可以调用它的toString方法，把它转化为String对象。