黑马程序员——StringBuffer类

------- android培训、java培训、期待与您交流！ ----------

StringBuffer类

 StringBuffer是线程安全的可变字符序列。

线程安全：安全的效率比较低，因为每次都要判断。

StringBuffer有一个替代类，StringBuilder，它有StringBuffer的所有方法，但是由于它不执行同步所以速度更快，优先选择使用StringBuilder,而StringBufer要执行同步，线程安全，但是效率低，速度慢，每次都要判断

 

StringBuffer的构造方法：

StringBuffer（）初始容量为16个字符

StringBuffer sb=new StringBuffer();

      System.out.println(sb.capacity());//初始容量

给定容量：

StringBuffer sb=new StringBuffer(10); //给定容量

      System.out.println(sb.capacity());

 

StringBuffer sb=new StringBuffer("黑马");

      System.out.println(sb.length());//实际字符个数

      System.out.println(sb.capacity());//字符串的长度+加初始容量

添加功能：append

StringBuffer sb=new StringBuffer();

      StringBuffer sb2=sb.append(true);

      StringBuffer sb3=sb.append("heima");

      StringBuffer sb4=sb.append(100);

      System.out.println(sb);

      System.out.println(sb2);

      System.out.println(sb3);

      System.out.println(sb4);

结果都相同，当在堆内存创建一个对象，然后就改变这个对象的内容，不会重新创建对象如下所示

StringBuffer sb=new StringBuffer();

      System.out.println(sb);

      sb.append(true);

      System.out.println(sb);

      sb.append("heima");

      System.out.println(sb);

      sb.append(100);

      System.out.println(sb);

insert插入：

StringBuffer sb=new StringBuffer("nihao");

      sb.insert(3, "heima");

      System.out.println(sb);//结果：nihheimaao

删除功能：deleteCharAt(int index),delete(int start,int end)

StringBuffer sb=new StringBuffer("nihao,nihaoma");

      sb.deleteCharAt(4);

      System.out.println(sb);

      sb.delete(2,3);

      System.out.println(sb);

结果：niha,nihaoma删除了第四个索引值

nia,nihaoma删除了第二个到第三个索引值

清空缓冲区：sb.delete(0,sb.lenth())

 

StringBuffer的替换和反转：

StringBuffer sb=new StringBuffer("heima");

      sb.replace(0, 3, "bai");

      System.out.println(sb);//把hei替换成bai

      sb.reverse();

      System.out.println(sb);把baima反转

StringBuffer的截取功能：

sb.substring(start);返回String

      sb.substring(start,end)返回String

StringBuffer sb=new StringBuffer("heima");

      String s=sb.substring(3);

      System.out.println(s);

 

StringBuffer和String相互转换：

通过构造方法，String转换为Stringbuffer,

StringBuffer sb=new StringBuffer("heima");

      System.out.println(sb);

通过append方法

StringBuffer sb=new StringBuffer();

      sb.append("heima");

      System.out.println(sb);

 

Stringbuffer转换为string类：

通过构造方法：

StringBuffer sb=new StringBuffer();

      sb.append("heima");

      String s=new String(sb);

      System.out.println(s);

通过toString方法：

StringBuffer sb=new StringBuffer();

      sb.append("heima");

      System.out.println(sb.toString());

还可以通过subString:

StringBuffer和StringBuilder的区别：

他们的方法是一样的

StringBuffer效率低，线程安全

StringBuilder效率高，线程不安全

 

String和StringBuffer作为参数来传递

基本数据类型的值传递，不改变其值

引用数据类型值传递，改变其值

 

冒泡排序：

//冒泡排序，轻的上浮，重的下降

      int[] arr={24,35,63,24,33,34};

      sort(arr);

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

         System.out.print(arr[i]+"");

      }

   }

 

   public static void sort(int[] arr) {

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

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

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

                int temp=arr[j];

                arr[j]=arr[j+1];

                arr[j+1]=temp;

            }

         }

      }

   }

选择排序：

用一个索引位置上的元素，依次其它位置的比较，小的在前面，大的在后面

public static void main(String[] args){

      int[] arr={24,35,63,24,33,34};

      sort(arr);

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

         System.out.print(arr[i]+"");

      }

     

   }

 

   public static void sort(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]){

                int temp=arr[i];

                arr[i]=arr[j];

                arr[j]=temp;

            }

         }

      }

   }

二分查找：

 public static void main(String[] args){

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

      int a=getIndex(arr, 55);

      System.out.println(a);

   }

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

      int min=0;

      int max=arr.length-1;

      int mid=(min+max)/2;

      while(arr[mid]!=value){

//       System.out.println("测试代码");

         if(arr[mid]<value){

            min=mid+1;

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

            max=mid-1;

         }

         mid=(min+max)/2;

         if(min>max){

            return -1;

         }

      }

      return mid;

   }

 

Arrays类方法：

toString转换为字符串

int[] arr={34,34,6,75,54,34};

      String s= Arrays.toString(arr);

      System.out.println(s);

sort():排序

int[] arr={34,34,6,75,54,34};

       Arrays.sort(arr);

       String s =Arrays.toString(arr);

      System.out.println(s);

binarySearch查找：如果没有查到，返回“-插入点-1”

int[] arr={34,34,6,75,54,34};

      Arrays.sort(arr);

      System.out.println(Arrays.toString(arr));

      int i=Arrays.binarySearch(arr, 54);

      System.out.println(i);

 

 

包装类：

Integer，它提供了一些方法，可以在int类型和其它类型之间的相互转换，

int的MAX_VALUE,表示2的31次方-1，MIN_VALUE表示-2的31次方，分别表示整形的最大值和最小值。

Integer in=new Integer(100);把int类型变为包装类

      System.out.println(in);

      Integer in2=new Integer("199");把字符串类型变为包装类，如果传入的不是数字字符串，那么会报格式异常

      System.out.println(in2);

转换：

int到String :

int i=100;

      String s1=100+"";方法一，推荐使用

      String s2=String.valueOf(i);方法二推荐使用

     

      Integer in=new Integer(i);方法三

      String s3=in.toString(i);

     

      String s4=Integer.toString(i);方法四

String 到int:

String s="100";

      Integer in=new Integer(s);方法1

      int n=in.intValue();

     

      int i2=Integer.parseInt(s);方法二，推荐使用

基本数据类型包装类共有八种，其中七种都提供了parseXXX的方法来转换成整形；只有char的包装类没有parse这个方法。因为char只有一个字符，但是有一个tochararray可以把字符串转换成字符数组。

注意：

Integer i1=127;自动装箱，把int转换为integer

      Integer i2=127;

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

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

     

      Integer i3=128;

      Integer i4=128;

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

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

答案：true

true

false

true

原因：-128到127是byte的取值范围，如果在这个范围内，可以自动装箱，如果超出这个范围，就会新创建对象；