java基础知识

ConcurrentHashMap和 synchronizeMap

http://blog.csdn.net/vozon/article/details/5484948

http://marlonyao.iteye.com/blog/344876

补充写在前：

String 类覆盖了Object类的equals（） 方法，而StringBuffer类没有覆盖。故String的equals只比较对象的值，StringBuffer是比较对象本身。

参考：http://www.cnblogs.com/liuyhaiying/articles/945419.html

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
 简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
 而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
 String S1 = “This is only a” + “ simple” + “ test”;
 StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
 你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
 String S1 = “This is only a” + “ simple” + “test”; 其实就是：
 String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做

在大部分情况下 StringBuffer > String
StringBuffer
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。
在大部分情况下 StringBuilder > StringBuffer

java.lang.StringBuilde
java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

通过非官方试验测试，StringBuilder和StringBuffer的测试总结如下：

1．  为了获得更好的性能，在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。当然，如果你操作的字符串长度不超过 16 个字符就不用了。

2．  相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非你能确定你的系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，否则还是用 StringBuffer 吧 J

3．  用好现有的类比引入新的类更重要。很多程序员在使用 StringBuffer 时是不指定其容量的（至少我见到的情况是这样），如果这样的习惯带入 StringBuilder 的使用中，你将只能获得 10 ％左右的性能提升（不要忘了，你可要冒多线程的风险噢）；但如果你使用指定容量的 StringBuffer ，你将马上获得 45% 左右的性能提升，甚至比不使用指定容量的 StirngBuilder 都快 30% 左右。

ArrayList和LinkedList区别

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 

    这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。 

LinkedList独有addFirst()，getFirst()，removeFirst()，addLast()，getLast()，removeLast()方法，可作为堆栈，队列，双向队列来使用

HASHTABLE, HASGMAQ，TreeMap区别

Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力.

Hashtable 与 HashMap类似,但是主要有6点不同。

1.HashTable的方法是同步的，HashMap未经同步，所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样。

2.HashTable不允许null值，key和value都不可以,HashMap允许null值，key和value都可以。HashMap允许 key值只能由一个null值，因为hashmap如果key值相同，新的key, value将替代旧的。

3.HashTable有一个contains(Object value)功能和containsValue(Object value)功能一样。

4.HashTable使用Enumeration，HashMap使用Iterator。

5.HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

6.哈希值的使用不同，HashTable直接使用对象的hashCode。

GET和POST两种提交方式的区别：

参考：http://blog.csdn.net/gideal_wang/article/details/4316691

   （1）GET提交，请求的数据会附在URL之后（就是把数据放置在HTTP协议头中），以?分割URL和传输数据，多个参数用&连接；例如：login.action?name=hyddd&password=idontknow&verify=%E4%BD%A0 %E5%A5%BD。如果数据是英文字母/数字，原样发送，如果是空格，转换为+，如果是中文/其他字符，则直接把字符串用BASE64加密，得出如： %E4%BD%A0%E5%A5%BD，其中％XX中的XX为该符号以16进制表示的ASCII。

　　POST提交：把提交的数据放置在是HTTP包的包体中。上文示例中红色字体标明的就是实际的传输数据

     因此，GET提交的数据会在地址栏中显示出来，而POST提交，地址栏不会改变

    (2)传输数据的大小：首先声明：HTTP协议没有对传输的数据大小进行限制，HTTP协议规范也没有对URL长度进行限制。

而在实际开发中存在的限制主要有：

GET:特定浏览器和服务器对URL长度有限制，例如IE对URL长度的限制是2083字节(2K+35)。对于其他浏览器，如Netscape、FireFox等，理论上没有长度限制，其限制取决于操作系统的支持。

因此对于GET提交时，传输数据就会受到URL长度的限制。

POST:由于不是通过URL传值，理论上数据不受限。但实际各个WEB服务器会规定对post提交数据大小进行限制，Apache、IIS6都有各自的配置。

 (3)安全性：

.POST的安全性要比GET的安全性高。注意：这里所说的安全性和上面GET提到的“安全”不是同个概念。上面“安全”的含义仅仅是不作数据修改，而这 里安全的含义是真正的Security的含义，比如：通过GET提交数据，用户名和密码将明文出现在URL上，因为(1)登录页面有可能被浏览器缓存， (2)其他人查看浏览器的历史纪录，那么别人就可以拿到你的账号和密码了，除此之外，使用GET提交数据还可能会造成Cross-site request forgery攻击

（4）Http get,post,soap协议都是在http上运行的
1）get：请求参数是作为一个key/value对的序列（查询字符串）附加到URL上的
        查询字符串的长度受到web浏览器和web服务器的限制（如IE最多支持2048个字符），不适合传输大型数据集同时，它很不安全
2）post：请求参数是在http标题的一个不同部分（名为entity body）传输的，这一部分用来传输表单信息，因此必须将Content-type设置为:application/x-www-form-urlencoded。post设计用来支持web窗体上的用户字段，其参数也是作为key/value对传输。
      但是：它不支持复杂数据类型，因为post没有定义传输数据结构的语义和规则。
3）soap：是http post的一个专用版本，遵循一种特殊的xml消息格式
       Content-type设置为: text/xml   任何数据都可以xml化

类的生命周期（特别是类初始化的时机）

参考：http://www.xnbing.org/?paged=2

类的装载就是通过类加载器把.class二进制文件转入jvm的方法区，并在堆区创建描述该类的java.lang.Class对象,用来封装数据。如果要获取这个Class对象可以通过实例的getClass()或者直接通过的类的静态方法.class。JVM规范允许预先加载，在预料到某个类要使用的时候就加载这个类，如果这个类不存在，也不会马上抛出异常，只有在程序主动使用这个类的时候才会抛出异常，如果这个类一直没有使用，那么就永远不会抛出异常。

  对于验证是验证加载的二进制文件是否符合规范，如有没有继承final类等。

    准备就是为静态成员分配内存空间，并设置默认值，byte short long flloat 都是0，对象类型为null，boolean类型为false.

    解析就是对于编译型常量使用直接的内存地址代替变量，如final static int a = 10;但是对于在编译的时候不能得到具体值得变量不做变换，如final static int a = Math.random()。在完成上述工作后，就是对于静态变量的初始化。

java虚拟机只有程序首次主动使用一个类或接口时，才回初始化他。只有6种活动被看做是程序对类或接口的主动使用。

  创建类的实例，途经包括：使用new 创建对象实例，clone等

   使用反射方法

   使用静态方法

   使用类或者接口的静态变量，给静态变量赋值

   创建子类

   把类声明为启动类，如: java Test01

下面是几个例子：

（1）对于final类型静态变量，如果在编译时就能计算出变量的取值，则这种变量被看做是编译时常量。java程序对类的编译时常量的使用，被看做是对类的被动使用，不会初始化类。如下例：

class Tester{

public static final int a = 2*3;

static{

print("init Tester");

}

}

public class Sample{

public static void main(String args[]){

print("a = "+Tester.a)

};

}

以上打印 a = 6 //不会打印 "init Tester"

（2） 如果编译时候不能计算出a的值，那么将会进行主动使用，就会初始化变量a所在的类。如下例：

class Tester{

public static final int a = (int) (Math.random()*10+1);

static{

print("init Tester");

}

}

a不是编译时常量，故Sample类的main方法打印 init Tester a = 81

（3） 初始化机制要求类在使用时候，对类的所有父类都必须进行初始化，但是这个并不适用于接口
a）初始化一个类的时候，并不会初始化这个类所实现的接口。
b）初始化一个接口的时候，并不会初始化父接口。
（4） 当程序访问的静态变量或者静态方法在当前类或者当前接口中定义的时候，才可以看做是对类或者接口的主动使用，例如

Class Base{

static  int a= 1;

static{print("init Base")};

static void method(){print("Base method");}

}

Class Sub extends Base{

static{print("init Sub")};

}

public class Sample{

public static void main(String args[]){

print("a="+Sub.a);

}

Sub.method();

}

输出结果为 init Base a=1 Base method

(5)类加载器classLoad的loadClass（）方法加载一个类，并不是对类的主动调用，不会导致类的初始化
例如下边的例子：

class ClassA {

     static {

         System . out . println ( "init ClassA" ) ;

     }

}

public class ClassB {

     public static void main ( String [ ] args ) throws ClassNotFoundException {

         ClassLoader loader = ClassLoader . getSystemClassLoader ( ) ;

         Class obj = loader . loadClass ( "ClassA" ) ;

         System . out . println ( "After load ClassA" ) ;

         System . out . println ( "before init ClassA" ) ;

         obj = Class . forName ( "ClassA" ) ;

     }

}

执行结果为：

After load ClassA

before init ClassA

init Class

O（n）的排序

桶式排序算法
“桶式排序算法”的代码也很简单，只要建立一个长度为max的字符数组就可以了，代码如下：
/*
函数功能：使用筒式排序法对数组进行排序，适用于元素值为较小整数 
输入变量： int a[]， 数组a
           int len，数组a的长度     
输出变量：无 
返回值： 无
*/
void Sort(int a[], int len)
{
    int max = GetMax(a, len);
    char *p = new char[sizeof(char) * max + 1];
   for (int i=0; i<=max; ++i)
        p[i] = 0;
    for (int i=0; i<len; ++i)
        ++p[a[i]];
    for (int i=0,j=0; i<=max; ++i)
    {
        while (p[i] > 0)
        {
            a[j++] = i;
            --p[i];
        }
    }
    delete []p;
}

Java垃圾回收机制：http://dev.yesky.com/178/2278678.shtml