【黑马程序员】StringBuffer,Array,Integer,BigInteger,Date,Calendar,集合——Java复习笔记

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

StringBuffer

(1)用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了一个字符串缓冲区类:StringBuffer供我们使用。

(2)StringBuffer的构造方法
    A:StringBuffer()
    B:StringBuffer(int size)
    C:StringBuffer(String str)
//不能把字符串的值直接赋值给StringBuffer

(3)StringBuffer的常见功能(ABCD功能的方法返回值都是StringBuffer，E功能返回的是String)

    A:添加功能 append添加  insert插入
        append()方法返回的是本身，不是新对象          

StringBuffer sb = new StringBuffer();
StringBuffer sb2 = sb.append(“hello”);
Sout(sb1+”,”+sb2);//输出hello,hello

        如果sb2也是new的 则输出 ，hello

        insert(index,str)从index位置开始插入 str变成该位置元素 该位置原有元素右移

    B:删除功能 
        deleteCharAt(index) 删除指定位置的字符并返回本身   
        delete(start,end) 删除从指定位置开始指定位置结束的内容并返回本身，删除的内容包括start不包括end

    C:替换功能 replace(start,end,str)

    D:反转功能 reverse()

    E:截取功能(注意这个返回值) 
        substring(start)
        substring(start,end) 截取后返回的是String对象,StringBuffer还是原来的内容（未被截取）

(4)String和StringBuffer相互转换
    String —> StringBuffer
        构造方法new StringBuffer(str) 或者 append()方法，建议构造方法

    StringBuffer —> String
        构造方法new String(sb)  或者 toString()方法，建议toString

(5)面试题  
    A:String,StringBuffer,StringBuilder的区别
        String是内容不可变 另外俩都是内容可变
        StringBuffer：同步的，数据安全，效率低。
        StringBuilder：不同步的，数据不安全，效率高。  
            安不安全都是指的多线程情况下，一般单线程不会有安全问题

    B:StringBuffer和数组的区别?   
        SB不管添加什么类型数据，都是作为字符串放进去的
        数组只能放同一类型的数据，是什么类型就是什么类型

(6)注意的问题：
    String是一种特殊的引用类型，作为形式参数时当做基本数据类型看，形参改变，实参不变
    StringBuffer作为形式参数若直接赋值，则形参变，实参不变。若调用了方法，则实参改变      
(7)练习
判断字符串是否为对称的  两个方法
方法1

    public static boolean isSymmetic(String s ){
        StringBuffer sb = new StringBuffer(s);
        for (int x= 0;x<sb.length()/2;x++){
            if (sb.charAt(x) != sb.charAt(sb.length()-x-1)){
                return false;
            }
        }
        return true;
    }

方法2

    public static boolean isSymmetic2(String s ){
        return new StringBuffer(s).reverse().toString().equals(s);
    }

数组高级以及Arrays工具类

(1)排序
    A:冒泡排序
        相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。        

    /**
     * 冒泡排序
     * 比较第一轮后 最大值出现在末尾,下次不用比较倒数1,2数
     * 比较第二轮后 第二大值出现在倒数第二位,下次不用比较倒数2,3数
     * ....
     * 总共比较 arr.length-1轮  每比较完一轮,下轮就少比较一次
     */
    public static int[] maoPao(int[] arr){
        for (int x = 0; x<arr.length -1 ;x++){
            for (int i = 1; i<arr.length-x;i++){
                if (arr[i] < arr[i-1]){
                    arr[i-1] = arr[i-1] ^ arr[i];
                    arr[i] = arr[i-1] ^ arr[i];
                    arr[i-1] = arr[i-1] ^ arr[i];
                }
            }
        }
        return arr;
    }

    B:选择排序
        把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。      

    /**
     * 选择排序
     * 从0开始 依次和后面的元素比较,小的往前放,一轮后最小值到了首位   比较了arr.length-1次
     * 从1开始 依次和后面的元素比较,小的往前放,一轮后第二小的值到了第二位  比较了arr.length-2次
     * ....
     * 总共比较arr.length-1轮,
     */

    public static int[] xuanZe(int[] arr){

        for (int x = 0 ; x<arr.length-1 ; x++){

            for (int i = x+1; i<arr.length;i++){
                if (arr[x] > arr[i]){     //每一轮都是用固定的位置和其他位置比较
                    arr[x] = (arr[x]+arr[i])-(arr[i]=arr[x]); //交换数据
                }
            }
        }
        return arr;
    }   

(2)查找
    A:基本查找
        针对数组无序的情况。一个一个找

    B:二分查找(折半查找)
        针对数组有序的情况(千万不要先排序再查找。无意义)   

    /**
     * 折半查找(二分查找)
     * 前提:数组有序
     * 核心:每次都找中间的元素进行比较,没找到则下次查找工作量减半
     * 注意:二分查找对无序数组无意义,要用基本查找(一个一个找)
     */

    public static int findMe(int[] arr,int key){
        arr = xuanZe(arr);
        System.out.println("排序后得:");
        System.out.println(Arrays.toString(arr));

        int min = 0 , max = arr.length-1;
        int mid = (min+max)/2;

        while (key != arr[mid]){
//            if (mid == 0 || mid == arr.length-1){     //或者min>max
//                return -1;
//            }
            if (key > arr[mid]) {
                min = mid + 1;
            }else {
                max = mid - 1;
            }
            mid = (min+max)/2;

            if (min>max){
                return -1;
            }
        }
        return mid;
    }

(3)Arrays工具类
    要掌握的方法
        把数组转成字符串：toString
        排序： sort    //底层方法是快速排序
        二分查找：binarySearch

(4)Arrays工具类的源码解析
    开发原则：只要是对象，就要判断该对象是否为null，内容是否为空

    二分查找源码：

int low = fromIndex;    //0
int high = toIndex - 1;     //arr.length-1
while (low <= high) {
    int mid = (low + high) >>> 1; //无符号右移1位即mid/2
    int midVal = a[mid];
    if (midVal < key)
        low = mid + 1;
     else if (midVal > key)
         high = mid - 1;
     else
         return mid;     // key found
}
return -(low + 1);   // key not found.

(5)练习
对字符串中的字符进行排序

    /**
     * 对字符串中的字符进行排序 选择排序冒泡排序都可以
     * @param arr
     * @return
     *  字符串转数组:toCharArray方法
     *  数组转字符串:String的构造方法 or String的valueOf方法 or Array工具类的toString方法
     */
    public static String xuanZe(char[] arr){

        for (int x = 0 ; x<arr.length-1 ; x++){

            for (int i = x+1; i<arr.length;i++){
                if (arr[x] > arr[i]){     //每一轮都是用固定的位置和其他位置比较
                    arr[x] = (char)((arr[x]+arr[i])-(arr[i]=arr[x])); //交换数据
                }
            }
        }
        return String.valueOf(arr);
    }

Integer类

(1)为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型
    byte        Byte
    short       Short
    int         Integer
    long        Long
    float       Float
    double      Double
    char        Character
    boolean     Boolean

(2)Integer的构造方法

Integer i = new Integer(100);
Integer i = new Integer(“100”); //这里的字符串必须是由数字字符组成

(3)String和int的相互转换
    A:String -- int 两种方法
        1 Integer.parseInt("100”); //重点推荐此种，记住
        2 new Integer(“100”).intValue();

    B:int -- String 四种方法
        1 String.valueOf(100);  //推荐此种方法 可把任意类型转成字符串
        2 String s = “” + 100;
        3 String s = newInteger(100).toString();
        4 String s = Integer.toString(100);

(4)其他的功能
    int范围 Integer.MAX_VALUE     MIN_VALUE

    进制转换 Integer.toBinaryString   toHexString  toOctalString 这三个方法都是十进制转其他进制，返回值都是字符串
        十进制到N进制 Integer.toString(int s,N);    2 <= N <= 36  返回值为String   
        N进制到十进制 Integer.parseInt(“1024”,N)  //要转换的数要作为字符串传进去

(5)JDK5的新特性
    自动装箱    把基本类型—>包装类类型
    自动拆箱    包装类类型—>基本类型

    把下面的这个代码理解即可：
        Integer i = 100; // JDK5以后可以这么写。原来应该是Integer i = new Integer(100);
        i += 200;  //i转int类 加完后再转回Integer
    注意：若Integer x = null;则会出现空指针异常。 所以用之前先判断是否为空

(6)面试题

Integer i = 127;
Integer i3 = 128;
Integer i2=127;
Integer i4 = 128;

i==i2;//true 
i3==i4;//false

    这样赋值，实际上编译器会编译成调用valueOf方法赋值，通过查看源码得知，对-128~127之间的数据做了数据缓冲池，如果数据在该范围内,则赋值时不创建新空间,直接从缓冲池内获取数据；若不在该范围内则new Integer()

Character

(1)Character构造方法只有一个    
    Character ch = new Character('a');

(2)要掌握的方法：(都是静态，直接通过类名调用)
    A:判断给定的字符是否是大写 isUpperCase
    B:判断给定的字符是否是小写 isLowerCase
    C:判断给定的字符是否是数字字符 isDigit
    D:把给定的字符转成大写    toUpperCase
    E:把给定的字符转成小写    toLowerCase

正则表达式

(1)就是符合一定规则的字符串

(2)常见规则
    A:字符
        x 字符 x。举例：'a'表示字符a
        \\ 反斜线字符。
        \n 新行（换行）符 ('\u000A') 
        \r 回车符 ('\u000D')

    B:字符类
        [abc] a、b 或 c（三选一） 
        [^abc] 任何字符，除了 a、b 或 c（否定） 
        [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
        [0-9] 0到9的字符都包括 

    C:预定义字符类
        . 任何字符。我的就是.字符本身，怎么表示呢? \.
        \d 数字：[0-9]
        \w 单词字符：[a-zA-Z_0-9]
            在正则表达式里面组成单词的东西必须有这些东西组成

    D:边界匹配器
        ^ 行的开头 
        $ 行的结尾 
        \b 单词边界
            就是不是单词字符的地方。
            举例：hello world?haha;xixi    

    E:Greedy 数量词 
        X? 一次或零次
        X* 零次或多次
        X+ 一次或多次
        X{n} 恰好 n 次 
        X{n,} 至少 n 次 
        X{n,m} 至少 n 次，但是不超过 m 次 

(3)常见功能：
    A:判断功能
        String类的public boolean matches(String regex)

    B:分割功能
        String类的public String[] split(String regex)

    C:替换功能
        String类的public String replaceAll(String regex,String replacement)

    D:获取功能
        Pattern和Matcher

Pattern p = Pattern.compile(“a*b”);//将匹配规则编译到Pattern对象中
Matcher m = p.matcher("aaaaab”);//通过Pattern对象得到匹配器对象并将被匹配数据传入匹配器中
boolean b =m.matches();//true   可用链式编程简化 但还是不如直接用matches方法简单

        find():查找存不存在
        group():获取刚才查找过的数据，调group前必须先调find，不然会报错    

(4)练习
    1. 分割字符串并排序然后转回字符串

        /**
         * 分割功能split案例
         * 分割字符串并排序然后转回字符串
         *
         * 分割-转int数组-排序
         */
        String s = "18 25 103 32 95 39";
        String regex = " ";//空格分割
        //split方法得到每个数字的字符串数组
        String[] ss = s.split(regex);

        //创建int数组
        int[] arr = new int[ss.length];
        //遍历String数组 并转为int放入int数组
        int i =0;
        for (String x:ss){
            System.out.print(x+" ");
            arr[i] = Integer.parseInt(x);
            i++;
        }
        //排序
        Arrays.sort(arr);
        //换行
        System.out.println();
        ///转回字符串输出
        StringBuilder sb = new StringBuilder();
        for (int x=0;x<arr.length;x++){
            if (x == arr.length-1){
                sb.append(arr[x]);
            }else {
                sb.append(arr[x]+" ");
            }
        }
        System.out.println(sb.toString());

    2. 替换功能replaceAll

        String s = "hello3149world841java09";
//        String regex = "\\d+"; //相邻数字全替换为一个星
        String regex = "\\d"; //每个数字替换一个星
        s = s.replaceAll(regex,"*");
        System.out.println(s);

    3. 获取功能

        //find
        String s = "da kjk ijqro dsaj iq rqjfa ;qieru ais dq a iiq r sad d sd ewq tr";
        String regex = "\\b\\w{3}\\b"; //要加入单词边界,这样才匹配的整个单词
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(s);

//        boolean flag = m.find(); //find方法查找有没有满足条件的子串
//        String ss = m.group();  //group获取查找到的值  调用group前必须先调find 不然会报错
//        System.out.println(ss);

        while(m.find()){    //找到就打印
            System.out.println(m.group());
        }

Math

常见方法
    A:绝对值 abs  返回值int
    B:向上取整 ceil  返回值double
    C:向下取整 floor 返回值double
    D:两个数据中的大值 max min
    E:a的b次幂 pow(a,b)  返回值double
    F:随机数 random    [0.0~1.0)
    G:四舍五入 round 返回值int
    H:正平方根 sqrt  返回值double  

练习:设计一个方法 获取任意范围的随机数

    public static int getRandom(int start,int end){
        return  (int)(Math.random()*(end-start+1)+start); //end-start+1得到范围总数 乘random得到随机数 然后再+start然随机数取值从最小值开始
    }

Random类

(1)用于产生随机数的类

(2)构造方法:
    A:Random() 默认种子，是当前时间的毫秒值，每次产生的随机数不同
    B:Random(long seed) 指定种子，每次种子相同，随机数就相同
    给定种子后，每次得到的随机数都一样

(3)成员方法:
    A:int nextInt() 返回int范围内的随机数
    B:int nextInt(int n) 返回[0,n)范围内的随机数

System

(1)系统类,提供了一些有用的字段和方法

(2)成员方法
    A:运行垃圾回收器 gc
    执行System.gc前，系统会自动调用finalize方法清除对象占有的资源，子类重写finalize方法，通过super.finalize方式可以实现从下到上的finalize方法调用，即先释放自己的资源，再去释放父类的资源

    B:退出jvm 
    exit(int) 终止当前正在运行的Java虚拟机，参数用作状态码，非0表示异常终止。一般要退出给0就行 

    C:获取当前时间的毫秒值 
    currentTimeMillis 一般应用在计算运行时间，程序运行前后各获取一次，相减得程序运行时间。

    D:数组复制(这个方法名特殊，全小写) 
    arraycopy(Object src,int srcPos,Object dest,int destPos,int length) 从数组中复制一个数组，从指定位置开始到指定位置结束
        --src 原数组; 
        --srcPos 原数组中的起始位置;
        --dest 目标数组; 
        --destPos 目标数据中的起始位置; 
        --length 要复制的数组元素的数量
        复制后目标数组的长度不会变，新数据会覆盖旧数据。

int[] arr = {11,22,33,44,55};
int[] arr2={6,7,8,9,10};
System.arrcopy(arr,1,arr2,2,2);
//打印出来arr数组不变，arr2变成{6,7,22,33,10}

BigInteger

(1)针对大整数的运算

(2)构造方法 
    BigInteger(String s)

(3)成员方法
    A:加 add
    B:减 subtract
    C:乘 mutiply
    D:除 divide
    E:商和余数 divideAndRemainder  返回的是商和余数的数组

BigDecimal

(1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)

(2)构造方法 
    BigDecimal(String s)

(3)成员方法：
    A:加减乘除同BigInteger

    B:自己保留小数几位 divide(BigDecimal bd除数,int scale商的小数有几位,int roundingMode商要应用的舍入模式)

Date/DateFormat(掌握)

 原始时间1970年1月1日0点

(1)Date是日期类，可以精确到毫秒。
    A:构造方法
        Date() 根据默认毫秒值创建日期对象
        Date(long time) 根据给定的毫秒值time创建日期对象

    B:成员方法
        getTime() 获取时间 以毫秒为单位
        setTime(long time) 设置时间

    C:日期和毫秒值的相互转换 
        日期转毫秒值  new Date().getTime();   
        毫秒值转日期  setTime(time)或new Date(time);

(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat
    A:SimpleDateFormat(String pattern) 给定模式
        yyyy-MM-dd HH:mm:ss  其他表示方式查看API

    B:日期和字符串的转换
        a:Date --> String（格式化）
            format()    
        b:String --> Date（解析）
            parse()
(3)练习:写一个程序计算你来到这个世界多少天

import java.text.ParseException;
import java.util.Scanner;

/**
 * Created by mo on 15/11/8.
 * 你来到这个世界多少天
 *
 * 出生年月日转为Date
 * getTime
 * 获取当前时间毫秒值
 * 相减再除以每天的毫秒值
 */

public class DateTest {
    public static void main(String[] args) throws ParseException {
        System.out.println(MyDays());
    }

    public static long MyDays() throws ParseException {

        System.out.println("请输入出生年月日,格式为:yyyy-MM-dd");
        Scanner sc = new Scanner(System.in);
        String birthday = sc.nextLine();

        long birth = DateUtil.stringToDate(birthday,"yyyy-MM-dd").getTime();
        long today = System.currentTimeMillis();
        return (today-birth)/86400000;
    }

    /**
     * 字符串转日期对象
     * @param date
     * @param parsePattern 被转换的日期格式
     * @return Date对象
     * @throws ParseException
     */
    public static Date stringToDate(String date,String parsePattern) throws ParseException{
        return new SimpleDateFormat(parsePattern).parse(date);
    }
}

Calendar类

(1)日历类
    装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。

(2)如何得到一个日历对象呢?
    Calendar rightNow = Calendar.getInstance(); //获取当前日历时间

    getInstance本质返回的是子类对象，Calendar是抽象类

(3)成员方法
    A:根据日历字段得到对应的值 
    int year = Calendar.getInstance().get(Calendar.YEAR); //month,date同理.month从0开始，即0表示1月

    B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值 add(Calendar.DATE,-5) //日期-5天。add方法无返回值，执行add方法后再重新获取值

    C:设置日历对象的年月日 set(int year,int month,int date)