java常用类解析

一、Object：所有类的父类
  1.toString():通常重写，因为默认返回"类名@hashCode"。
  2.getClass():返回Class对象，对于同一个类而言，此对象只有一个。
  3.hashCode()：返回调用该对象的散列码值，相等的对象必须有相同的散列码，有相同散列码的对象不一定相等。
  4.equals()：默认比较对象的地址，等价于"=="，假如需要比较内容，要求对其重写。
              重写equals()方法一般要求重写hashCode()方法，目的是为了维护hashCode()方法的
              常规协定，该协定声明相等对象必须具有相等的散列码值。


二、时间相关：Date，Calendar，TimeZone，SimpleDateFormat
   1.返回Date类型的String格式，格式为2014-11-20
    public static String dateToString(Date date) {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);
        String riqi = sdf.format(date);
        return riqi;
    }

   2.UTC转换为本地日期字符串,删除时间,默认日期 1970-01 格式:1970-01 ,注意转换后不保留时间部分和具体天数，
     public static String UTCToLocalDate(Date value) {
           if (value == null)
           value = getDefaultDate();
           SimpleDateFormat timeFormat = new SimpleDateFormat("yyyy-MM",
           Locale.CHINA);
           String str = timeFormat.format(value);
           return str;
     }
      public static Date getDefaultDate() {
           Date date = new Date(0L);
           return date;
     }

   3.本地日期格式字符串转换为UTC,默认日期 1970-01-01 格式:1970-01,注意由于不包含时间，所以默认时间为本地时间00:00:00
     public static Date localDateToUTC(String value) {
          if (value == null || value.isEmpty())
             return getDefaultDate();
          Date date;
          try {
             SimpleDateFormat timeFormat = new SimpleDateFormat("yyyy-MM",Locale.CHINA);
             date = timeFormat.parse(value);
          } catch (ParseException e) {
                 date = getDefaultDate();
          }
          return date;
         }
      public static Date getDefaultDate() {
         Date date = new Date(0L);
         return date;
      }


三、Math、Random、BigDecimal
   BigDecimal用于精确计算，不会丢失精度。
   BigDecimal d=BigDecimal.valueOf(double dou);//将double转换为BigDecimal类型


四、UUID类的应用：产生一个随机字符串


五、包装类：理解类中的池化思想
   有池：Byte，Short，Integer，Long，Character，String（非包装类，引用类型）
   无池：Boolean，Float，Double
   public void doInt(){
         Integer t1=127;//自动封箱
         Integer t2=127;//自动封箱,从池中取
         System.out.println(t1==t2);//true

         Integer t3=129;//超出范围，new Integer(129)
         Integer t4=129;//超出范围，new Integer(129)
         System.out.println(t3==t4);//false

         Integer t7=Integer.valueOf(127);
         Integer t8=Integer.valueOf(127);
         System.out.println(t7==t8);//true

         Integer t5=Integer.valueOf(129);
         Integer t6=Integer.valueOf(129);
         System.out.println(t5==t6);//false
   }


六、String/StringBuilder/StringBuffer
   1.String：长度不可变的固定字符串，线程安全
      1·重写了toString()和equals()方法。
      2·构造方法
         1》String(char[] chars)
         2》String(String str)
         3》更多构造方法参考api文档
      3·一系列常用方法

   2.StringBuilder：长度可变，线程不安全
      1·重写了toString()，没有重写equals()方法。
      2·构造方法
         1》StringBuilder():默认开辟空间为16个字符大小
         2》StringBuilder(int cap):字符大于16时建议调用此方法
         3》StringBuilder(CharSequence seq)：构造一个字符串生成器，包含与指定的 CharSequence 相同的字符。
                                             该字符串生成器的初始容量为 16 加上 CharSequence 参数的长度。
         4》StringBuilder(String str)：构造一个字符串生成器，并初始化为指定的字符串内容。该字符串生成器的
                                       初始容量为 16 加上字符串参数的长度。
      3·一系列常用方法

   3.StringBuffer：线程安全的StringBuilder
      1·重写了toString()，没有重写equals()方法。
      2·构造方法：与StringBuilder对应
      3·一系列常用方法

   4.String、StringBuffer、StringBuilder的联系与区别 

        String、StringBuffer和StringBuilder在本质上都是字符数组，不同的是，在进行连接操作时，String每次返回一个新的String实例，而StringBuffer和StringBuilder的append方法直接返回this，所以这就是为什么在进行大量字符串连接运算时，不推荐使用String，而推荐StringBuffer和StringBuilder。

        如果在多线程环境可以使用StringBuffer进行字符串连接操作，单线程环境使用StringBuilder，它的效率更高。

七、String的理解（参考各种面试题）
        String s1="abc";
        Stirng s2="abc";//从池中取
        System.out.println(s1 == s2);//true

        String s3=new String("abc");
        Stirng s4=new String("abc");
        System.out.println(s3 == s4);//false

        String s5=new String("abc");
        Stirng s6="abc";
        System.out.println(s5 == s6);//false

        String s7="abc";
        Stirng s8=new String("abc");
        System.out.println(s7 == s8);//false

        String a = "a1";    
        String b = "a" + 1;    
        System.out.println(a == b); //true

        String a = "a1";    
        String b = "1";    
        String c = "a" + b;  
        System.out.println(a == c);//false

        String a = "ab";    
        final String bb = "b";   
        String b = "a" + bb;    
        System.out.println(a == b); //true,final说明bb始终指向”b“，不能把其他对象的引用给bb，所以在编译期bb的值是确定的,"a" + bb的值也是确定的
       
        String a = "ab";    
        final String bb = getBB();    
        String b = "a" + bb;    
        System.out.println(a == b);//false,编译期不能确定,在运行期才能确定,因此会产生StringBulder对象,通过toSring()返回一个String的引用 

    private static String getBB() {    
       return "b";    
    } 

    public class Test {  
    private static String a = "ab";       
    public static void main(String[] args) {   
        //打印false，true， static数据放在方法区中 
        String s1 = "a";    
        String s2 = "b";    
        String s = s1 + s2;    
        System.out.println(s == a);    
        System.out.println(s.intern() == a);    
    }   
    }  

    public class Test {  
    private static String a = new String("ab");       
    public static void main(String[] args) {  
        //打印false,false，true。
        String s1 = "a";    
        String s2 = "b";    
        String s = s1 + s2;    
        System.out.println(s == a);    
        System.out.println(s.intern() == a);    
        System.out.println(s.intern() == a.intern());    
    }    
    }  
   

八、String的本质
   String实质是字符数组，两个特点：1、该类不可被继承；2、不可变性(immutable)。


九、String的定义方法
        常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。常量池还具备动态性，运行期间可以将新的常量放入池中，String类的intern()方法是这一特性的典型应用。虚拟机为每个被装载的类型维护一个常量池，池中为该类型所用常量的一个有序集合，包括直接常量(string、integer和float常量)和对其他类型、字段和方法的符号引用（与对象引用的区别？读者可以自己去了解）。

String的定义方法归纳起来总共为三种方式：

     1.使用关键字new，如：String s1 = new String("myString");
     2.直接定义，如：String s1 = "myString";
     3.串联生成，如：String s1 = "my" + "String";

三种方式分析：（分析可能是错误的）
        第一种方式通过关键字new定义过程：在程序编译期，编译程序先去字符串常量池检查，是否存在“myString”,如果不存在， 则在常量池中开辟一个内存空间放“myString”；如果存在的话，则不用重新开辟空间，保证常量池中只有一个“myString”常量，节省内存空间。然后在内存堆中开辟一块空间存放new出来的String实例，在栈中开辟一块空间，命名为“s1”，存放的值为堆中String实例的内存地址，这个过程就是将引用s1指向new出来的String实例。各位，最模糊的地方到了！堆中new出来的实例和常量池中的“myString”是什么关系呢？
        第二种方式直接定义过程：在程序编译期，编译程序先去字符串常量池检查，是否存在“myString”，如果不存在，则在常量池中开辟一个内存空间存放“myString”；如果存在的话，则不用重新开辟空间。然后在栈中开辟一块空间，命名为“s1”，存放的值为常量池中“myString”的内存地址。常量池中的字符串常量与堆中的String对象有什么区别呢？为什么直接定义的字符串同样可以调用String对象的各种方法呢？
      
三个问题：
     1.堆中new出来的实例和常量池中的“myString”是什么关系呢？
     2.常量池中的字符串常量与堆中的String对象有什么区别呢？
     3.为什么直接定义的字符串同样可以调用String对象的各种方法呢？   


参考资料：http://blog.csdn.net/gjanyanlig/article/details/6803481
         http://www.iteye.com/topic/774673
         http://my.oschina.net/xiaohui249/blog/170013

         http://www.jianshu.com/p/c7f47de2ee80

        http://blog.csdn.net/briup_acmer/article/details/41900069