StringBuffer的一些小整理

大家好，欢迎大家在百忙当中来到我的博客文，也许是因为各种需要到此一游，哈哈。不过来到这里不会让您失望的，此段博文是这段时间不忙的时候整理出来的，对于刚学java基础的同学非常适合。下面言归正传：

---

首先我们来看看StringBuffer的构造方法：

StringBuffer()     构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
StringBuilder(CharSequence seq)      构造一个字符串缓冲区，它包含与指定的 CharSequence 相同的字符。
StringBuffer(int capacity)      构造一个不带字符，但具有指定初始容量的字符串缓冲区。
StringBuffer(String str)       构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

下面由代码来解释一下：

 package com.zys.stringBuffer;

 public class Demo1_StringBuffer {

     public static void main(String[] args) {

         StringBuffer sb = new StringBuffer();
         System.out.println(sb.length());
         System.out.println(sb.capacity());

         StringBuffer sb2 = new StringBuffer(10);
         System.out.println(sb2.length());
         System.out.println(sb2.capacity());

         StringBuffer sb3 = new StringBuffer("heima");
         System.out.println(sb3.length());//实际字符的个数
         System.out.println(sb3.capacity());//字符串的length + 初始容量
     }
 }
 /*输出
 0,16,0,10,5,21
 */

也就是说StringBuffer有一个字符串缓冲区，其初始化容量默认值为16。其中的length()方法和capacity()方法是StringBuffer类中的方法。

其次,让我们来看看StringBuffer类中常用方法，下面代码每个方法我都抽取成一个方法，这样我觉得好理解一点点，望读者见谅：

 package com.zys.stringBuffer;

 public class Demo2_Conformity {
     /**
      * public StringBuffer insert(int offset,String str) 将字符串插入此字符序列中
      * public StringBuffer deleteCharAt(int index)删除指定元素，并返回本身
      * public StringBuffer delete(int start,int end)从指定位置到指定结束
      * public StringBuffer replace(int start,int end,String str) 替换
      * public StringBuffer reverse(); 反转
      *
      * StringBuffer的截取功能
      * public String substring(int start)从指定位置到结尾
      * public String substring(int start,int end)从指定开始位置到指定结束位置，只包含头不包含尾
      * 注意：截取功能返回值类型不在是StringBuffer类型，而是String
      *
      * String --StringBuffer 1.通过构造方法 2.通过append()方法
      * StringBuffer --String 1.通过构造方法 2.通过toString()方法 3.通过substring(0,length)
      */
     public static void main(String[] args) {
         // demo1();插入字符
         //demo2();删除字符
         //demo3();替换与反转
         //demo4();截取字符
         /*String和StringBuffer分别传参数的问题 ,String作为常量，被初始化了，将不能改变，此细节一定要注意。
          */
     }

     private static void demo4() {
         StringBuffer sb = new StringBuffer("woaiheima");
         //String str = sb.substring(0);
         //System.out.println(str);
         String str2 = sb.substring(2, 9);
         System.out.println(str2);
     }

     private static void demo3() {
         StringBuffer sb = new StringBuffer("heima");
         //sb.replace(0, 3, "bai");
         //System.out.println(sb);
         StringBuffer sb1 = new StringBuffer("我爱总复习");
         sb1.reverse();
         System.out.println(sb1);
     }

     private static void demo2() {
         StringBuffer sb = new StringBuffer();
         sb.append("heima");
         // sb.deleteCharAt(4);
         sb.delete(0, 2);
         // sb.delete(0,sb.length());
         System.out.println(sb);
     }

     private static void demo1() {
         StringBuffer sb = new StringBuffer("1234");
         sb.insert(3, "heima");
         System.out.println(sb);
     }

 }

---

下面来说一下StringBuffer StringBuilder的区别:

*StringBuffer是jdk1.0版本的，是线程安全的，但效率低
* StringBuilder是jdk1.5版本的，是线程不安全的，但效率高
* 注：可拿上厕所的例子比喻

* String StringBuffer StringBuilder
* String是一个不可变的字符序列
* StringBuffer StringBuilder是可变的字符序列

---

下面来谈一谈冒泡排序和选择排序，通过代码的方式来看：

 package com.zys.array;

 public class Demo1_Array {
     /**
      *冒泡排序：
      *分析：
      *1.创建int[]数组
      *2.写一个自定义方法，其中这里面写排序逻辑
      *3.写一个输出的方法
      *冒泡排序与选择排序类同
      */
     public static void main(String[] args) {
         int[] arr = { 22, 69, 80, 57, 13 };
         //bubbleSort(arr);
         XuanzeSort(arr);
         print(arr);
     }

     public static void XuanzeSort(int[] arr) {
         for (int i = 0; i < arr.length - 1; i++) {
             for (int j = i + 1; j < arr.length; j++) {
                 if (arr[i] > arr[j]) {
                     swap(arr, i, j);
                 }
             }
         }
     }

     public static void bubbleSort(int[] arr) {
         for (int i = 0; i < arr.length - 1; i++) {// 外循环只需比较arr.length-1就好了
             for (int j = 0; j < arr.length - 1 - i; j++) {// -1是为了防止越界异常，-i是提高效率

                 if (arr[j] > arr[j + 1]) {
                     swap(arr, i, j + i);

                 }
             }
         }
     }

     public static void print(int[] arr) {
         for (int i = 0; i < arr.length; i++) {
             System.out.print(arr[i] + " ");
         }
     }

     public static void swap(int[] arr, int i, int j) {
         int temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;
     }
 }

---

再补充一个Integer的方面的一些面试题，看下面代码：

 package com.zys.array;

 public class Demo5_Integer {
     public static void main(String[] args) {
         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(128);
         Integer i4 = new Integer(128);
         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));//true
         System.out.println("-----------");

         Integer i7 = 128;
         Integer i8 = 128;
         System.out.println(i7 == i8);//false
         System.out.println(i7.equals(i8));//true
         /*
          * -128到127是byte的取值范围，如果在这个范围取值内，自动装箱不会创建对象，而是在常量池中获取值
          * 如果是超过了byte取值范围就会创建对象
          * i > -128 && i < 127
          */
     }
 }

到此，这篇博文就到最后了，大家是不是也收获颇丰呢，我现在也是最基础的。就让我们一块走下去吧，要想改变世界，就先得改变自己。。