java 11StringBuffer、数组排序、Arrays

StringBuffer 类

 String str="abc";  //"abc"
       str+="ccc";  //ccc //abcccc
      str+="dddd";  //"ddddd"   abccccddddd

​ 字符串一旦定义，长度就不能改变,在执行上述代码时需要定义五个字符串，浪费内存空间。

​ StringBuffer线程安全的可变字符序列，长度可变的字符序列，相当于一个字符容器，可以不断地往容器中追加字符。

StringBuffer（）构造一个其中不带字符的字符串缓冲区，初始容量为16个字符。

• 创建一个空的字符容器

  StringBuffer a = new StringBuffer（）；

  往容器中追加字符（超过容量自动扩容），返回的还是原来的那个容器对象。

  StringBuffer sb = new StringBuffer();
  StringBuffer sb2 = sb.append("abc");
  System.out.println(sb==sb2);//true
  

  获取容器的容量

  int capacity = a.capacity（）；

  获取容器的长度

  int length = a.length（）；

• 构建时，可以指定字符容器的容量

  StringBuffer a = new StringBuffer（capacity：100）；

• 构建时，可以往容器中放入字符串

  StringBuffer a = new StringBuffer（“afgg”）；

  重写了toString（）方法，然后把容器中的数据转换成字符串返回：

  图:

• StringBuffer 里面的数据也是编有索引的

  insert（0，“eeee”）； 在容器中的指定位置插入数据，返回的还是原来的容器。在原数据前面加
  

• 根据指定索引，删除容器中的单个字符，返回的还是容器本身。
  

• 根据起始索引和终止索引，删除容器中的一部分内容，返回的还是容器本身。
  

• indexOf（“a”）;查找容器中该字符串第一次出现的索引，如果查找不到返回-1
  

• 根据起始索引和终止索引替换容器中的一部分内容，返回的还是容器本身。

  

• 反转，返回的还是容器本身。
  

• 根据起始索引和终止索引截取，返回值是String而不是容器本身了
  

• 将String类型转为StringBuffer类型：

  

• 将StringBuffer类型转为String类型：
  

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

  StringBuilder 可变字符序列。线程不安全的，效率高。

数组排序

把数组中无序的元素通过交换移动等方式是数组中的元素变成有序序列。

• 冒泡排序

  冒泡排序：数组中的元素两两比较，大的元素，往后放，经过一轮比较后，最大的元素在最后。

• 选择排序

• 插入排序

  直接插入排序：从第二个元素，每次哪一个元素插入之前的序列中，使其仍保持有序

• 希尔排序

  又称为缩小增量排序，是直接插入排序的一种优化，效率更高。

  基本思想:先将原表按增量h分组，每个子文件按照直接插入法排序。同样，用下一个增量h/2将文件再分为子文件，在直接插入法排序。知道h=1是整个文件排好序。

  • 代码实现

  public static void main(String[] args) {
      int[] arr = {2, 5, 8, 23, 14, 75, 1, 5, 10, 2};
      int h = 5;
      while (h >= 1) {
          for (int i = h; i <= arr.length - 1; i++) {
              for (int j = 0; j < i; j++) {
                  if (arr[j] > arr[i]) {
                      int t = arr[i];
                      arr[i] = arr[j];
                      arr[j] = t;
                  }
              }
          }
          h=h/2;
      }
      System.out.println(Arrays.toString(arr));
  }
  

• 快速排序

  • 思路：取出一个元素，将数组中比它小的元素放在它左边，将数组中比它大的元素放在它右边，之后再让左边 和右边的新数组重复上述操作，最终就会得到有序数组。
  • 具体操作：

  挖坑填数：
    1.将基准数挖出形成第一个坑。
    2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
    3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
    4.再重复执行2，3两步骤。
  

  • 代码实现：

  public class MyTest {
      public static void main(String[] args) {
          int[] arr={20,20,6,8,9,1,2,3,4,90,100,3,0,-1,-2,6,9};
          KuaiSu.kuaisu(arr,0,arr.length-1);
          System.out.println(Arrays.toString(arr));
      }
  }
  

  public class KuaiSu {
      private KuaiSu() {
      }
  
      public static void kuaisu(int[] arr, int start, int end) {
          if (start < end) {
              int index = getIndex(arr, start, end);
              kuaisu(arr, start, index - 1);
              kuaisu(arr, index + 1, end);
          }
      }
      private static int getIndex(int[] arr, int start, int end) {
          int i = start;
          int j = end;
          int x = arr[i];
          while (i < j) {
              while (i < j && x <= arr[j]) {
                  j--;
              }
              if (i < j) {
                  arr[i] = arr[j];
                  i++;
              }
              while (i < j && x > arr[i]) {
                  i++;
              }
              if (i < j) {
                  arr[j] = arr[i];
                  j--;
              }
          }
          arr[i] = x;
          return i;
      }
  }
  

  • 结果：

• 查找该元素在数组中第一次出现的索引

  • 基本查找：从头开始挨个查找

  • 二分查找

    前提：数组元素有序

    拿这个元素，跟中间索引对应的那个元素比大小。1.如果相等 直接返回 中间索引 centerIndex 2.如果要找的元素比中间索引对应的元素小 maxIndex=centerIndex-1

    3.如果要找的元素比重甲索引对应的元素大 minIndex=centerindex+1 再确定中间索引 比较 实在找不到返回-1。

    public static void main(String[] args) {
        int[] arr = {20, 20, 6, 8, 9, 1, 2, 3, 4, 90, 100, 3, 0, -1, -2, 6, 9};
        Arrays.sort(arr);//[-2, -1, 0, 1, 2, 3, 3, 4, 6, 6, 8, 9, 9, 20, 20, 90, 100]
        int index = Arrays.binarySearch(arr, -1);//1
        System.out.println(index);
    

Arrays 类

Java给我们提供了一个工具类，可以方便的对数组进行操作。

• 比较

  //比较两个数组中的元素是否一样。
  public static void main(String[] args) {
      int[] arr = {20, 20, 6, 8};
      int[] arr2 = {20, 20, 6, 8};
      boolean b = Arrays.equals(arr, arr2);
      System.out.println(b);//true
  
  }
  

• 复制

    static int[] copyOf ( int[] original, int newLength)复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
          static int[] copyOfRange ( int[] original, int from, int to)复制旧数组中的指定范围间的几个元素到新数组中
          int[] arr = {20, 20, 6, 8,20,30,50,60};
          int[] ints = Arrays.copyOf(arr, 3);
          System.out.println(Arrays.toString(ints));//[20, 20, 6]
  
          
          //3 起始索引，6 终止索引 含头不含尾
          int[] ints1 = Arrays.copyOfRange(arr, 3, 6);
          System.out.println(Arrays.toString(ints1));//[8, 20, 30]
  
      }
  }