03 API,正则,日期类

 03 API,正则,日期类

####03.01 String类
    * String类的方法
    indexOf() ; lastindexOf() ; charAt() ; endsWith() ; length() ; equals() ; 
    isEmpty() ; startsWith() ; contains() ; toLowerCase() ; toUpperCase() ; valueOf() ;
    toCharArray() ; replace() ; split() ; substring() ; trim() ; 

####03.02 String类的常见面试题
    * 1.判断定义为String类型的s1和s2是否相等
        * String s1 = "abc";                 // 常量池中没有就创建，有就直接用
        * String s2 = "abc";
        * System.out.println(s1 == s2);   // true 都是指向常量池                    
        * System.out.println(s1.equals(s2));   //true        
    * 2.下面这句话在内存中创建了几个对象?
        * String s1 = new String("abc");      //在常量池和堆中都有，而在堆中相当于副本,所以是创建了2个对象。            
    * 3.判断定义为String类型的s1和s2是否相等
        * String s1 = new String("abc");     //堆中的        
        * String s2 = "abc";    //常量池中的
        * System.out.println(s1 == s2);     //false ,一个记录的是堆内存中的,一个是记录的是常量池中的,地址值不相同    
        * System.out.println(s1.equals(s2));   //对象的属性相同,true
    * 4.判断定义为String类型的s1和s2是否相等
        * String s1 = "a" + "b" + "c";
        * String s2 = "abc";
        * System.out.println(s1 == s2);      // true , java中有常量优化机制    如:byte b = 3 + 4; 在编译时就变成了7,常量优化机制
        * System.out.println(s1.equals(s2));  // true 
    * 5.判断定义为String类型的s1和s2是否相等
        * String s1 = "ab";    //常量池
        * String s2 = "abc";   //常量池
        * String s3 = s1 + "c";   //先在StringBuffer或StringBuilder相加,然后通过toString转换,再赋地址值给s3
        * System.out.println(s3 == s2);  //false 
        * System.out.println(s3.equals(s2)); // true
        * Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。字符串串联是通过        StringBuilder（或 StringBuffer）类及其 
            append 方法实现的。字符串转换是通过 toString 方法实现的

####03.03 StringBuffer类
* A:StringBuffer类概述
    * 通过JDK提供的API，线程安全的可变字符序列    //线程安全效率会低一些。
* B:StringBuffer和String的区别
    * String是一个不可变的字符序列           //可以通过+来改变，而StringBuffer不可以。
    * StringBuffer是一个可变的字符序列    //用自己的方法来对本缓冲器操作
* C: 初始容量是16个字节，从jdk5.0开始，为该类补充了一个单线程使用的等价类，StringBuilder类，不安全，速度更    快。

####03.04 StringBuffer和String的相互转换
* A:String -- StringBuffer
    * a:通过构造方法        //StringBuffer stb = new StringBuffer("abc");
    * b:通过append()方法    //StringBuffer stb = new StringBuffer(); stb.append("abc");
* B:StringBuffer -- String
    * a:通过构造方法  
               StringBuffer stb = new StringBuffer("heima");
           String st = new String(stb);    //String可以接收StringBuffer                 
    * b:通过subString(0,length);
    * c:通过toString()方法 
           StringBuffer stb = new StringBuffer("heima");
           String s = stb.toString();

####03.05 StringBuffer和StringBuilder的区别
    StringBuffer和StringBuilder的区别
     * StringBuffer是jdk1.0版本的,是线程安全的,效率低
      * StringBuilder是jdk1.5版本的,是线程不安全的,效率高

      String和StringBuffer,StringBuilder的区别
     * String是一个不可变的字符序列 ; StringBuffer,StringBuilder是可变的字符序列
     * String可以用+进行操作 ; StringBuffer要通过方法
     * String重写了equals()方法 ; StringBuffer没有重写equals()方法
     * String虽然是引用数据类型,但作为参数传递时不改变;StringBuffer作为参数传递时会改变

####03.06 基本类型包装类的概述
* A:为什么会有基本类型包装类
    * 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
* B:常用操作
    * 常用的操作之一：用于基本数据类型与字符串之间的转换。
* C:基本类型和包装类的对应
        byte             Byte
        short            Short
        int            Integer
        long                Long
        float                Float
        double            Double
        char            Character
        boolean            Boolean

####03.07 JDK5的新特性自动装箱和拆箱
* A:JDK5的新特性
    * 自动装箱：把基本类型转换为包装类类型
    * 自动拆箱：把包装类类型转换为基本类型
* B:案例演示
    * JDK5的新特性自动装箱和拆箱
    * int i1 = 100;
    * Integer i2 = new Integer(i1); //将基本数据类型包装成对象，装箱
    * Integer i2 = 100;//自动装箱
    * int z = i3 + 200; //自动拆箱，和int类型的数据相加
* C:注意事项
    * 在使用时，Integer i4 = null   
    * int y = 100 +i4;  //底层i4调用intValue,但i4是null，null调用方法时，就会出现NullPointerException。
    * 建议先判断是否为null，然后再使用。

####03.08 Integer的面试题
*Integer的面试题,看程序写结果        
        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2);   //false
        System.out.println(i1.equals(i2));  //true
        System.out.println("-----------");
    
        Integer i3 = new Integer(197);
        Integer i4 = new Integer(197);
        System.out.println(i3 == i4);   //false
        System.out.println(i3.equals(i4));  //true
        System.out.println("-----------");
    
        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);   //true
        System.out.println(i5.equals(i6));  
        System.out.println("-----------");
    
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);  //false
        System.out.println(i7.equals(i8));
***-128到127是byte的取值范围，在这个范围内，自动装箱就不会新创建对象，而是从常量池取；
   如果超过byte范围就会再新创建对象。

####03.09 正则表达式
* A:字符类
    * [abc] a、b 或 c（简单类） 
    * [^abc] 任何字符，除了 a、b 或 c（否定） 
    * [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
    * [0-9] 0到9的字符都包括
* B:预定义字符类
    * . 任何字符。
    * \d 数字：[0-9]
    * \w 单词字符：[a-zA-Z_0-9]
    * \s 空白字符: [ \r\n\f\x0B\t]  \f翻页  \x0b竖直
* C:Greedy 数量词 
    * X?  X，一次或一次也没有
    * X*  X，零次或多次(0次到多次)
    * X+  X，一次或多次
    * X{n}  X，恰好 n 次 
    * X{n,}  X，至少 n 次 
    * X{n,m}  X，至少 n 次，但是不超过 m 次 

####03.10 练习题
需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
     * 1,将字符串切割成字符串数组
     * 2,将字符串转换成数字并将其存储在一个等长度的int数组中
     * 3,排序
     * 4,将排序后的结果遍历并拼接成一个字符串
    public static void main(String[] args) {
        String st = "91  27   46 38 50 56";
        String[] sArr = st.split("[ ]+");
        int[] arr = new int[sArr.length];
        for (int i = 0; i < sArr.length; i++) {
            arr[i] = Integer.parseInt(sArr[i]);
        }
        Arrays.sort(arr);
        for (int i : arr) {
            System.out.print(i+" ");
        }
        
        System.out.println("\n"+"---------------------");
        
        StringBuilder stb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            stb.append(arr[i]).append(" ");
        }
        System.out.println(stb);
    }

####03.11 练习题
* 校验qq号码.
    * 1:要求必须是5-15位数字
    * 2:0不能开头
    * 3:必须都是数字
public static void main(String[] args) {
        System.out.println(checkQQ("012345"));    //非正则表达式实现
        System.out.println(checkQQ("112345"));    //非正则表达式实现
        System.out.println(checkQQ("11a345"));
        
        String regex = "[1-9]\\s+\\d{4,14}";   //正则来做 
        String regex1 = "[1-9][0-9]{4,14}";   //正则来做 
        System.out.println("1  55386898765430".matches(regex));
        System.out.println("155386898765430".matches(regex1));
    }
    public static boolean checkQQ(String qq){ //定义一个方法来实现
        boolean flag = true;
        if(qq.length() >= 5 && qq.length()<= 15){
            if(!qq.startsWith("0")){
                char[] arr = qq.toCharArray();
                for (int i = 0; i < arr.length; i++) {
                    char ch = arr[i];
                    if(!('0'<=ch && ch <= '9')){
                        flag = false;
                        break;
                    }
                }
            }else{
                flag = false;
            }
        }else{
            flag =false;
        }
        return flag;
    }

####03.12 BigInteger类的概述和方法使用  math包
* A:BigInteger的概述
    * 可以让超过Integer范围内的数据进行运算
* B:构造方法
    * public BigInteger(String val)
* C:成员方法
    * public BigInteger add(BigInteger val)
    * public BigInteger subtract(BigInteger val)
    * public BigInteger multiply(BigInteger val)
    * public BigInteger divide(BigInteger val)
    * public BigInteger[] divideAndRemainder(BigInteger val)  //除数和余数

####03.13 BigDecimal类的概述和方法使用 math包
* A:BigDecimal的概述
    * 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
    * 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
    * 不可变的、任意精度的有符号十进制数。
* B:构造方法                                   
    * public BigDecimal(String val)     
* C:成员方法
    * public BigDecimal add(BigDecimal augend)
    * public BigDecimal subtract(BigDecimal subtrahend)
    * public BigDecimal multiply(BigDecimal multiplicand)
    * public BigDecimal divide(BigDecimal divisor)
* D:案例演示
    * BigDecimal类的构造方法和成员方法使用
    *   BigDecimal b1 =new BigDecimal(2.0);
        BigDecimal b2 =new BigDecimal(1.1);
        System.out.println(b1.subtract(b2)); //虽然位数多了，但还是达不到要求，开发中不推荐使用。
        
        BigDecimal b11 =new BigDecimal("2.0");
        BigDecimal b22 =new BigDecimal("1.1");
        System.out.println(b11.subtract(b22)); //通过在构造中传人字符串的方式，开发中推荐。
        
        BigDecimal b111 = BigDecimal.valueOf(2.0);  //valueOf()静态方法
        BigDecimal b222 = BigDecimal.valueOf(1.1);
        System.out.println(b111.subtract(b222));  //这种方式开发中也是推荐的 

####03.13 Date,DateFormat,Calendar
* 算一下你来到这个世界多少天?
     * 分析:
     * 1,将生日字符串和今天字符串存在String类型的变量中
     * 2,定义日期格式化对象
     * 3,将日期字符串转换成日期对象
     * 4,通过日期对象获得时间毫秒值
     * 5,将两个时间毫秒值相减除以1000,再除以60,再除以60,再除以24得到天
    public static void main(String[] args) throws ParseException {
        String birthday = "1983年07月08日";
        String today = "2088年6月6日";            
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        
        Date d1 = sdf.parse(birthday);      //时间字符串转换成日期对象
        Date d2 = sdf.parse(today);
        
        long time = d2.getTime() - d1.getTime();
        
        System.out.println(time / 1000 / 60 / 60 / 24 );
    }

* 键盘录入任意一个年份，判断该年是闰年还是平年
      * 1,键盘录入年Scanner
     * 2,创建Calendar c = Calendar.getInstance();
     * 3,通过set方法设置为那一年的3月1日,注意月份是0-11.
     * 4,将日向前减去1
     * 5,判断日是多少天,如果是29天返回true否则返回false
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("输入一个年份,看是平年还是闰年");
            int num = sc.nextInt();
            System.out.println(""+getYear(num));
        }
    }
    private static boolean getYear(int year) {  //定义方法
            //创建Calendar c = Calendar.getInstance();
        Calendar c = Calendar.getInstance();
            //设置为那一年的3月1日
        c.set(year, 2, 1);
            //将日向前减去1
        c.add(Calendar.DAY_OF_MONTH, -1);
            //判断是否是29天
        return c.get(Calendar.DAY_OF_MONTH) == 29;
    }

* 计算从今天算起,100天以后是几月几号,并格式化成xxxx年x月x日的形式打印出来.
     * 1.调用Calendar类的add()方法计算100天后的日期
     * 2.调用Calendar的getTime()方法返回Date类型对象
     * 3.使用FULL格式的DateFormat对象,
     * 4.使用format()方法格式化Date对象
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, 2);

        Date date = calendar.getTime();   //System.out.println(date);  //Thu Jan 21 21:38:07 CST 2016

        DateFormat df = DateFormat.getDateInstance(DateFormat.FULL); 
                  //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日  HH:mm:ss");  
        
        String string = df.format(date);
        System.out.println(string);   //2016年1月22日 星期五
    }

* Date和Calender类有什么区别和联系?
    Date类用来表示某个特定的瞬间，能够精确到毫秒。而在实际应用中，往往需要把一个日期中的年、月、日等信息单独返回进行显示或处理，这个类中的大部分方法都已被标记过时。Calender类基本取代了Date类，该类中定义了一系列用于完成日期和时间字段操作的方法。 
    Calendar的getTime()方法,返回一个表示Calendar时间值的Date对象 ; 同时Calendar有一个setTime(Date date)方法,将Date对象表示的时间值设置给Calendar对象，通过这两个方法就可以完成Date和Calendar对象之间的转换。