欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java基础学习笔记13——(StringBuffer的使用,数组高级,Arrays工具类,Integer和Character等包装类)

程序员文章站 2024-03-06 21:55:32
...

1:StringBuffer(掌握)

(1)用字符串做拼接,比较耗时并且也耗内存,而这种拼接操作又是比较常见的,为了解决这个问题,Java就提供了
   一个字符串缓冲区类。StringBuffer供我们使用。
(2)StringBuffer的构造方法
    A:StringBuffer()
    B:StringBuffer(int size)
    C:StringBuffer(String str)
(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)
    D:反转功能 —— public StringBuffer reverse()
    E:截取功能(返回值是字符串) —— public String substring(int start)
                           —— public String substring(int start,int end)    
(4)StringBuffer的相关练习

A:String和StringBuffer相互转换

        String -- StringBuffer
            构造方法
        StringBuffer -- String
            toString()方法
    package cn.itcast_07;
    /*
     * 
     * 为什么我们要讲解类之间的转换:
     * A -- B 的转换
     * 我们把A转换成B,其实是为了使用B的功能
     * 我们可能要的结果是A类型,所以还得转回来
     * 
     * String 和 StringBuffer的相互转换
     */
    public class StringBufferTest {
        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);

            // StringBuffer -- String
            StringBuffer buffer = new StringBuffer("java");
            buffer.append(s);
            // 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);
        }
    }           

输出结果:
str: javahello
str2: javahello

B:字符串的拼接

    package cn.itcast_07;
    /*
     * 把数组拼接成一个字符串
     */
    public class StringBufferTest2 {
        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.itcast_07;
    import java.util.Scanner;
    /*
     * 把字符串反转
     */
    public class StringBufferTest3 {
        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:用StringBuffer的reverse()功能
            String s2 = myReverse2(s);
            System.out.println("s2:" + s2);
        }

        // 用StringBuffer的reverse()功能
        public static String myReverse2(String 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--) {
                result += chs[x];
            }
            return result;
        }
    }

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

    package cn.itcast_07;
    import java.util.Scanner;
    /*
     * 判断一个字符串是否是对称字符串
     * 例如 "abc"不是对称字符串,"aba"、"abba"、"aaa"、"mnanm" 是对称字符串
     * 
     * 分析:
     *      判断一个字符串是否是对称的字符串,我们只需要把第一个和最后一个比较,第二个与倒数最后一个比较...
     *      比较的次数为长度除以2
     */
    public class StringBufferTest4 {
        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 = isSame(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) {
            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的区别
B:StringBuffer和数组的区别?

    package cn.itcast_08;
    /*
     * 面试题:
     * 1:String,StringBuffer,StringBuilder的区别?
     * A:String是内容不可变的,而StringBuffer,StringBuilder都是内容可变的
     * B:StringBuffer是同步的,数据安全,低效率的;StringBuilder是不同步的,数据不安全,效率高
     * 
     * 2:StringBuffer和数组的区别
     * 二者都可以看做是一个容器,装其他的数据。
     * 但是,StringBuffer的数据最终是一个字符串数据
     * 而数组可以放置多种数据,但必须是同一种数据类型的
     * 
     * 3:形式参数问题
     * String作为参数传递
     * StringBuffer作为参数传递
     * 
     * 形式参数:
     *      基本类型:形式参数的改变不影响实际参数    String
     *      引用类型:形式参数的改变直接影响实际参数  StringBuffer
     * 
     * 注意:
     *      String作为参数传递,效果和基本类型作为参数传递一样
     */
    public class StringBufferDemo {
        public static void main(String[] args) {
            String s1 = "hello";
            String s2 = "world";
            System.out.println(s1 + "----" + s2);  // hello----world
            change(s1,s2);
            System.out.println(s1 + "----" + s2);  // hello----world

            StringBuffer sb1 = new StringBuffer("hello");
            StringBuffer sb2 = new StringBuffer("world");
            System.out.println(sb1 + "----" + sb2);  // hello----world
            change(sb1,sb2);
            System.out.println(sb1 + "----" + sb2);  // hello----worldworld
        }

        public static void change(StringBuffer sb1,StringBuffer sb2) {
            sb1 = sb2;
            sb2.append(sb1);
        }

        public static void change(String s1 ,String s2) {
            s1 = s2;
            s2 = s1 + s2;
        }
    }

输出结果:
hello—-world
hello—-world
hello—-world
hello—-worldworld

(6)注意的问题:
    String作为形式参数,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) {
            if(arr[mid] > value) {
                max = mid - 1;
            }else if(arr[mid] < value) {
                min = mid + 1;
            }
            if(min > max) {
                return -1;
            }
            mid = (min+max)/2;
        }
        return mid;
    }
(3)Arrays工具类
    A:是针对数组进行操作的工具类。包括排序和查找等功能。
    B:要掌握的方法(自己补齐方法)
        把数组转成字符串:
        排序:
        二分查找:
    C:把字符串中的字符进行排序
    举例:
        "edacbgf"
        得到结果
        "abcdefg"
    package cn.itcast_03;
    /*
     * 把字符串中的字符进行排序
     *          举例:"dacgebf"
     *          结果:"abcdefg"
     * 
     * 分析:
     *      A:定义一个字符串
     *      B:把字符串转换为字符数组
     *      C:把字符数组进行排序
     *      D:把排序后的字符数组转成字符串
     *      E:输出最后的字符串
     */
    public class ArrayTest {
        public static void main(String[] args) {
            // 定义一个字符串
            String s = "dacgebf";
            // 把字符串转换为字符数组
            char[] chs = s.toCharArray();
            // 把字符数组进行排序
            bubbleSort(chs);
            // 把排序后的字符数组转成字符串
            String result = String.valueOf(chs);
            // 输出最后的字符串
            System.out.println("result:" + result);
        }
        // 冒泡排序
        public static void bubbleSort(char[] chs) {
            for (int x = 0; x < chs.length - 1; x++) {
                for (int y = 0; y < chs.length - 1 - x; y++) {
                    if (chs[y] > chs[y + 1]) {
                        char temp = chs[y];
                        chs[y] = chs[y + 1];
                        chs[y + 1] = temp;
                    }
                }
            }
        }
    }
(4)Arrays工具类的源码解析
    1.public static int binarySearch(int[] a,int key) 二分查找
        // Like public version, but without range checks.
        private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                         int key) {
            int low = fromIndex;
            int high = toIndex - 1;

            while (low <= high) {
                int mid = (low + high) >>> 1;
                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.
        }

     2.public static String toString(int[] a) 把数组转成字符串
            public static String toString(int[] a) {
            if (a == null)
                return "null";
            int iMax = a.length - 1;
            if (iMax == -1)
                return "[]";

            StringBuilder b = new StringBuilder();
            b.append('[');
            for (int i = 0; ; i++) {
                b.append(a[i]);
                if (i == iMax)
                    return b.append(']').toString();
                b.append(", ");
            }
        }

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)String和int的相互转换
    A:String -- int
        Integer.parseInt("100");
    B:int -- String
        String.valueOf(100);
(4)其他的功能(了解)
    进制转换
(5)JDK5的新特性
    自动装箱    基本类型--引用类型
    自动拆箱    引用类型--基本类型

    把下面的这个代码理解即可:
        Integer i = 100;
        i += 200;
        System.out.println("ii:" + ii);
    // 通过反编译后的代码

// Integer ii = Integer.valueOf(100); // 自动装箱
// ii = Integer.valueOf(ii.intValue() + 200); // 自动拆箱,再自动装箱
// System.out.println((new StringBuilder(“ii:”)).append(ii).toString());
// Integer iii = null;

(6)面试题
    -128到127之间的数据缓冲池问题  
    package cn.itcast_06;
    /*
     * 看程序写结果
     * 
     * 注意:Integer的数据直接赋值,如果在-128到127之间,会直接从缓冲池里获取数据
     */
    public class IntegerDemo {
        public static void main(String[] args) {
            Integer i1 = new Integer(127);
            Integer i2 = new Integer(127);
            System.out.println(i1 == 12);
            System.out.println(i1.equals(i2));
            System.out.println("-----------");

            Integer i3 = new Integer(128);
            Integer i4 = new Integer(128);
            System.out.println(i3 == i4);
            System.out.println(i3.equals(i4));
            System.out.println("----------");

            Integer i5 = 128;
            Integer i6 = 128;
            System.out.println(i5 == i6);
            System.out.println(i5.equals(i6));
            System.out.println("----------");

            Integer i7 = 127;
            Integer i8 = 127;
            System.out.println(i7 == i8);
            System.out.println(i7.equals(i8));
            System.out.println("----------");
            // 通过查看源码,我们知道了,针对-128到127之间的数据,做了一个数据缓冲池,如果数据在该范围内,每次并不创建新的空间
            // 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)案例:
    统计字符串中大写,小写及数字字符出现的次数   
    package cn.itcast_03;
    import java.util.Scanner;
    /*
     * 统计一个字符串中大写字符字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
     * 
     * 分析:
     *      A:定义三个统计变量。
     *          int bigCount = 0;
     *          int smallCount = 0;
     *          int numberCount = 0;
     *      B:键盘录入一个字符串
     *      C:把字符串转换为字符数组
     *      D:遍历字符数组获取到每一个字符
     *      E:判断该字符是
     *          大写  bigCount++;
     *          小写  smallCount++;
     *          数字  numberCount++;
     *      F:输出结果即可
     */
    public class CharacterTest {
        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 + "个");
        }
    }

上一篇: MyBatis实现In查询

下一篇: