javaSE第十三天

第十三天    76

1. StringBuffer(掌握)    76

(1)说明:    77

(2)StringBuffer的构造方法    77

(3)StringBuffer的常见功能    77

(4)StringBuffer的练习(做一遍)    78

(5)面试题    82

(6)注意的问题:    83

2. 数组高级以及Arrays(掌握)    83

(1)排序    83

A:冒泡排序    83

B:选择排序    83

(2)查找    84

A:基本查找    84

B:二分查找(折半查找)    85

(3)Arrays工具类    86

3. Integer(掌握)    88

(1)说明:    88

(2)Integer的构造方法    89

(3)String和int的相互转换    89

(4)其他的功能(了解)    89

(5)JDK5的新特性    89

(6)面试题    90

4. Character(了解)    90

(1)Character构造方法    90

(3)案例:    91

 

第十三天

1. StringBuffer(掌握)
    (1)说明:

用字符串做拼接,比较耗时并且也耗内存,而这种拼接操作又是比较常见的,

为了解决这个问题,Java就提供了

     一个字符串缓冲区类。StringBuffer供我们使用。

为线程安全的可变字符序列

    (2)StringBuffer的构造方法

        A: public StringBuffer() :无参构造方法(默认容量16个字符)

        B: public StringBuffer(int capacity) :指定容量的字符串缓冲区对象

        C: public StringBuffer(String str) :指定字符串内容的字符串缓冲区对象

(理论容量 = 字符串长度 + 默认容量16个字符)

    (3)StringBuffer的常见功能

        A:添加功能

public StringBuffer append(String str) :

可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

public StringBuffer insert(int offset, String str) :

在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

        B:删除功能

public StringBuffer deleteCharAt(int index):

删除指定位置的字符(只删除一个字符),并返回缓冲区本身

public StringBuffer delete(int start, int end)

删除从指定位置开始到到指定结束位置的内容,并返回缓冲区本身

        C:替换功能

public StringBuffer replace(int start, int end, String str):

start 开始到endstr 进行替换

        D:反转功能

            public StringBuffer reverse():字符串反转

        E:截取功能(注意这个返回值)

注意:截取的子串返回给一个新串,原串没有被改变

            public String substring(int start)

public String substring(int start, int end)

F:其他方法:

public int capacity() : 返回当前容量。理论值

public int length(): 返回长度(字符数)。实际值

    (4)StringBuffer的练习(做一遍)

        A:String和StringBuffer相互转换?

            String -- > StringBuffer

                方式1:通过构造方法

方式2:通过append方法

            StringBuffer --> String

                方式1:通过构造方法

方式2:通过 toString() 方法

/*

* 为什么我们要讲解类之间的转换:

* A -- B的转换

* 我们把A转换为B,其实是为了使用B的功能。

* B -- A的转换

* 我们可能要的结果是A类型,所以还得转回来。

*

* StringStringBuffer的相互转换?

*/

public class MainDemo {

    public static void main(String[] args) {

        // String --- StringBuffer

        String s = "hello";

        // 注意:不能把字符串的值直接赋值给StringBuffer

        // StringBuffer sb = "hello";

        // StringBuffer sb = s;

        // 方式1:通过构造方法

        StringBuffer sb = new StringBuffer(s);

        // 方式2:通过append()方法

        StringBuffer sb2 = new StringBuffer();

        sb2.append(s);

        System.out.println("sb:" + sb);

        System.out.println("sb2:" + sb2);

        System.out.println("---------------");

 

        // StringBuffer --- String

        StringBuffer buffer = new StringBuffer("java");

        // String(StringBuffer buffer)

        // 方式1:通过构造方法

        String str = new String(buffer);

        // 方式2:通过toString()方法

        String str2 = buffer.toString();

        System.out.println("str:" + str);

        System.out.println("str2:" + str2);

    }

}

 

        B:字符串的拼接

            

/*

* 需求:把数组拼接成一个字符串

*/

public class MainDemo {

    public static void main(String[] args) {

        // 定义一个数组

        int[] arr = { 44, 33, 55, 11, 22 };

 

        // 定义功能

        // 方式1:用String做拼接的方式

        String s1 = arrayToString(arr);

        System.out.println("s1:" + s1);

 

        // 方式2:StringBuffer做拼接的方式

        String s2 = arrayToString2(arr);

        System.out.println("s2:" + s2);

    }

 

    // StringBuffer做拼接的方式

    public static String arrayToString2(int[] arr) {

        StringBuffer sb = new StringBuffer();

 

        sb.append("[");

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

            if (x == arr.length - 1) {

                sb.append(arr[x]);

            } else {

                sb.append(arr[x]).append(", ");

            }

        }

        sb.append("]");

 

        return sb.toString();

    }

 

    // String做拼接的方式

    public static String arrayToString(int[] arr) {

        String s = "";

 

        s += "[";

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

            if (x == arr.length - 1) {

                s += arr[x];

            } else {

                s += arr[x];

                s += ", ";

            }

        }

        s += "]";

 

        return s;

    }

}

 

        C:把字符串反转

package cn.itcast01;

 

import java.util.Scanner;

/*

* 需求:把字符串反转

*/

public class MainDemo {

    public static void main(String[] args) {

        // 键盘录入数据

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入数据:");

        String s = sc.nextLine();

 

        // 方式1:用String做拼接

        String s1 = myReverse(s);

        System.out.println("s1:" + s1);

        // 方式2:用StringBufferreverse()功能

        String s2 = myReverse2(s);

        System.out.println("s2:" + s2);

    }

 

    // StringBufferreverse()功能

    public static String myReverse2(String s) {

        // StringBuffer sb = new StringBuffer();

        // sb.append(s);

 

        // StringBuffer sb = new StringBuffer(s);

        // sb.reverse();

        // return sb.toString();

 

        // 简易版

        return new StringBuffer(s).reverse().toString();

    }

 

    // String做拼接

    public static String myReverse(String s) {

        String result = "";

 

        char[] chs = s.toCharArray();

        for (int x = chs.length - 1; x >= 0; x--) {

            // char ch = chs[x];

            // result += ch;

            result += chs[x];

        }

 

        return result;

    }

}

 

        D:判断一个字符串是否对称

import java.util.Scanner;

/*

* 需求:判断一个字符串是否是对称字符串

* 例如"abc"不是对称字符串,"aba""abba""aaa""mnanm"是对称字符串

*

* 分析:

*         判断一个字符串是否是对称的字符串,我只需要把

*             第一个和最后一个比较

*             第二个和倒数第二个比较

*             ...

*         比较的次数是长度除以2

*/

public class MainDemo {

    public static void main(String[] args) {

        // 创建键盘录入对象

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串:");

        String s = sc.nextLine();

 

        // 一个一个的比较

        boolean b = isSame(s);

        System.out.println("b:" + b);

 

        // 用字符串缓冲区的反转功能

        boolean b2 = isSame2(s);

        System.out.println("b2:" + b2);

    }

 

    // 用字符串缓冲区的反转功能

    public static boolean isSame2(String s) {

        return new StringBuffer(s).reverse().toString().equals(s);

    }

 

    // public static boolean isSame(String s) {

    // // 把字符串转成字符数组

    // char[] chs = s.toCharArray();

    //

    // for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {

    // if (chs[start] != chs[end]) {

    // return false;

    // }

    // }

    //

    // return true;

    // }

 

    // 一个一个的比较

    public static boolean isSame(String s) {

        boolean flag = true;

 

        // 把字符串转成字符数组

        char[] chs = s.toCharArray();

 

        for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {

            if (chs[start] != chs[end]) {

                flag = false;

                break;

            }

        }

 

        return flag;

    }

}

 

    (5)面试题

        小细节:

            StringBuffer:同步的,线程安全的、数据安全,效率低。

            StringBuilder:不同步的,数据不安全,效率高。

        A:String,StringBuffer,StringBuilder的区别?

答:

1. String:长度和内容不可变

2. StringBuffer 和 StringBuilder 都是长度和内容可变的

3.String Buffer 是同步的,数据安全,效率低,;而StringBuilder是不同步的,数据不                 安全,效率搞

        B:StringBuffer和数组的区别?

答:

二者都可以看着是一个容器,都可以装其他的数据

但是呢,StringBuffer 的数据最终是一个字符串数据,

而数据可以放置多种数据,但必须都是同一种数据类型

    (6)注意的问题:

        1. String作为形式参数,效果和基本类型作为形式参数传递是一样的

形式参数的改变不影响实际参数

  1. StringBuffer作为形式参数。赋值不改变实际值,但是调用其方法进行的值更改,则

    会改变实际值

    

2. 数组高级以及Arrays(掌握)
    (1)排序

        A:冒泡排序

            相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处

同理,其他的元素就可以排好。

            注意:第一次比较完之后,下一次比较的时候,就会减少一个元素的比较

            

public static void bubbleSort(int[] arr) {

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

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

                if (arr[y] > arr[y + 1]) {

                    int temp = arr[y];

                    arr[y] = arr[y + 1];

                    arr[y + 1] = temp;

                }

            }

        }

    }

 

            

        B:选择排序

            把0索引的元素,和索引1以后的元素都进行比较,第一次完毕,

最小值出现在了0索引。同理,其他的元素就可以排好。

            

            

public static void selectSort(int[] arr) {

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

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

                if (arr[y] < arr[x]) {

                    int temp = arr[x];

                    arr[x] = arr[y];

                    arr[y] = temp;

                }

            }

        }

    }

 

    (2)查找

        A:基本查找

            使用场景:针对数组无序的情况(从头找到尾)

            

            

public static int getIndex(int[] arr, int value) {

        int index = -1;

 

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

            if (arr[x] == value) {

                index = x;

                break;

            }

        }

        return index;

    }

 

        B:二分查找(折半查找)

            应用场景:针对数组有序的情况

            注意事项:针对无序的数组,进行先排序,后查找,是有问题的?

答:因为数组本身是无序的,所以这种情况下不能使用二分查找

所以你先排序了,但是你排序的时候已经改变了该数组最初是的元素索引

            

public static int binarySearch(int[] arr, int value) {

        // 定义最小索引

        int min = 0;

        // 定义最大索引

        int max = arr.length - 1;

        // 计算中间索引

        int mid = (min + max) / 2;

        // 拿中间索引的值和被查找的值进行比较

        while (arr[mid] != value) {

            // 如果中间索引的值 比 被查找的值大了

            // 则最大索引 = 原中间索引 - 1

            if (arr[mid] > value) {

                max = mid - 1;

                // 如果中间索引的值 比 被查找的值小了

                // 则最小索引 = 中间索引 + 1

            } else if (arr[mid] < value) {

                min = mid + 1;

            }

            // 加入判断(如果没有该值的处理)

            if (min > max) {

                return -1;

            }

 

            mid = (min + max) / 2;

        }

 

        return mid;

    }

 

    (3)Arrays工具类

        A:是针对数组进行操作的工具类。包括排序和查找等功能。

        B:要掌握的方法(自己补齐方法)

            1:public static String toString(int[] a) : 把数组转成字符串

            2:public static void sort(int[] a) : 对数组进行排序

3:public static int binarySearch(int[] a, int key):二分查找,返回查找值的索引    

  1. Arrays工具类的源码解析

    Public static String toString(int[] a) 的源码分析

    public static int binarySearch(int[] a, int key)源码分析

     

    public static String toString(int[] a)源码分析

    public static void sort(int[] a) 底层是快速排序,知道就可以了。有空看,有问题再问我

    public static int binarySearch(int[] a,int key)

    开发原则:

        只要是对象,我们就要判断该对象是否为null

     

    int[] arr = { 24, 69, 80, 57, 13 };

    System.out.println("排序前:" + Arrays.toString(arr));

    // 这是源码

        public static String toString(int[] a) {

            // a -- arr -- { 24, 69, 80, 57, 13 }

     

            if (a == null)

                return "null"; // 说明数组对象不存在

            int iMax = a.length - 1; // iMax=4;

            if (iMax == -1)

                return "[]"; // 说明数组存在,但是没有元素。

     

            StringBuilder b = new StringBuilder();

            b.append('['); // "["

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

                b.append(a[i]); // "[24, 69, 80, 57, 13"

                if (i == iMax)

                    // "[24, 69, 80, 57, 13]"

                    return b.append(']').toString();

                b.append(", "); // "[24, 69, 80, 57, "

            }

        }

    public static int binarySearch(int[] a, int key)源码分析

     

    int[] arr = {13, 24, 57, 69, 80};

    System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));

     

    // 源码

        public static int binarySearch(int[] a, int key) {

            // a -- arr -- {13, 24, 57, 69, 80}

            // key -- 577

            return binarySearch0(a, 0, a.length, key);

        }

    private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {

            // a -- arr -- {13, 24, 57, 69, 80}

            // fromIndex -- 0

            // toIndex -- 5

            // key -- 577

     

            int low = fromIndex; // low=0

            int high = toIndex - 1; // high=4

     

            while (low <= high) {

                int mid = (low + high) >>> 1; // mid=2,mid=3,mid=4

                int midVal = a[mid]; // midVal=57,midVal=69,midVal=80

     

                if (midVal < key)

                    low = mid + 1; // low=3,low=4,low=5

                else if (midVal > key)

                    high = mid - 1;

                else

                    return mid; // key found

            }

            return -(low + 1); // key not found.

        }

     

        (5)把字符串中的字符进行排序

            举例:

                "edacbgf"

                得到结果

                "abcdefg"

     

    3. Integer(掌握)

        (1)说明:

    为了让基本类型的数据进行更多的操作,Java就为每种基本类型提供了对应的包装类类型

            byte         Byte

            short        Short

            int            Integer

            long        Long

            float        Float

            double        Double

            char        Character

            boolean        Boolean

        (2)Integer的构造方法

            A: Integer i = new Integer(100);

            B: Integer i = new Integer("100");

                注意:这里的字符串必须是由数字字符组成

        (3)Stringint的相互转换

            A:String --> int

                Integer.parseInt("100");

            B:int --> String

                String.valueOf(100);

        (4)其他的功能(了解)

            一、进制转换

    1:public static String toBinaryString(int i) :二进制

    2:public static String toOctalString(int i) :八进制

    3:public static String toHexString(int i) : 十六进制

    1. 进制数的范围:

      范围:2 - 36

      因为:只有 0 -9 a - z 36个数字和字母

      三、十进制 到 其他进制

      1: public static String toString(int i, int radix):

      参数说明:i :表示10进制值

      Radix:表示进制

      例如:Integer.toString(100, 8);    表示把 10进制的100 转成 8进制

    Integer.toString(100, 16); 表示把 10进制的100 转成16进制

    1. 其他进制 到 十进制

      1:public static int parseInt(String s, int radix)

      例如: Integer.parseInt("100", 2); 表示把二进制的100转成10进制

      Integer.parseInt("67", 8); 表示把8进制的67转成10进制

        (5)JDK5的新特性

            自动装箱    基本类型--包装类型

            自动拆箱    包装类型--基本类型

    注意一个小问题:

    在使用,Integer x = null; 代码会出现 NullPointException异常

    建议:先判断是否为 null, 然后再使用

            

            把下面的这个代码理解即可:

                

    Integer i = 100;

            i += 200;

            // 通过反编译后的代码

            // Integer ii = Integer.valueOf(100); //自动装箱

            // ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱,再自动装箱

            // System.out.println((new StringBuilder("ii:")).append(ii).toString());

     

        (6)面试题

            结论:对Integer类型的数据直接赋值的时候,如果在-128 127 之间的,

    会直接从缓冲池里面获取数据,否则重新创建一个Integer对象并返回

    /*

             * 看程序写结果

             *

             * 注意:Integer的数据直接赋值,如果在-128127之间,会直接从缓冲池里获取数据

             */

            Integer i1 = new Integer(127);

            Integer i2 = new Integer(127);

            System.out.println(i1 == i2);//false

            System.out.println(i1.equals(i2));//true

            System.out.println("-----------");

     

            Integer i3 = new Integer(128);

            Integer i4 = new Integer(128);

            System.out.println(i3 == i4);//false

            System.out.println(i3.equals(i4));//true

            System.out.println("-----------");

     

            Integer i5 = 128;

            Integer i6 = 128;

            System.out.println(i5 == i6);//false

            System.out.println(i5.equals(i6));//true

            System.out.println("-----------");

     

            Integer i7 = 127;

            Integer i8 = 127;

            System.out.println(i7 == i8);//true 关键点

            System.out.println(i7.equals(i8));//false

     

            // 通过查看源码,我们就知道了,针对-128127之间的数据,做了一个数据缓冲池,如果数据是该范围内的,每次并不创建新的空间

            // Integer ii = Integer.valueOf(127);

     

    4. Character(了解)

        (1)Character构造方法    

            Character ch = new Character('a');

        (2)要掌握的方法:(自己补齐)

            A:判断给定的字符是否是大写字符    

                public static boolean isUpperCase(char ch)

            B:判断给定的字符是否是小写字符

                public static boolean isLowerCase(char ch)

            C:判断给定的字符是否是数字字符

                public static boolean isDigit(char ch)

            D:把给定的字符转成大写字符

                public static char toUpperCase(char ch)

            E:把给定的字符转成小写字符

                public static char toLowerCase(char ch)

        (3)案例:

            统计字符串中大写,小写及数字字符出现的次数

            

    import java.util.Scanner;

    /*

    * 统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。

    (不考虑其他字符)

    *

    * 分析:

    *         A:定义三个统计变量。

    *             int bigCont=0;

    *             int smalCount=0;

    *             int numberCount=0;

    *         B:键盘录入一个字符串。

    *         C:把字符串转换为字符数组。

    *         D:遍历字符数组获取到每一个字符

    *         E:判断该字符是

    *             大写    bigCount++;

    *             小写    smalCount++;

    *             数字    numberCount++;

    *         F:输出结果即可

    */

    public class MainDemo {

        public static void main(String[] args) {

            // 定义三个统计变量。

            int bigCount = 0;

            int smallCount = 0;

            int numberCount = 0;

     

            // 键盘录入一个字符串。

            Scanner sc = new Scanner(System.in);

            System.out.println("请输入一个字符串:");

            String line = sc.nextLine();

     

            // 把字符串转换为字符数组。

            char[] chs = line.toCharArray();

     

            // 历字符数组获取到每一个字符

            for (int x = 0; x < chs.length; x++) {

                char ch = chs[x];

     

                // 判断该字符

                if (Character.isUpperCase(ch)) {

                    bigCount++;

                } else if (Character.isLowerCase(ch)) {

                    smallCount++;

                } else if (Character.isDigit(ch)) {

                    numberCount++;

                }

            }

     

            // 输出结果即可

            System.out.println("大写字母:" + bigCount + "");

            System.out.println("小写字母:" + smallCount + "");

            System.out.println("数字字符:" + numberCount + "");

        }

    }

     

     

posted @ 2016-09-15 11:12  runningto  阅读(221)  评论(0编辑  收藏  举报