Java StringBuffer/StringBuilder

package com.company;

import java.lang.reflect.Array;
import java.util.Arrays;

/*
 * Java StringBuffer 和 StringBuilder 类
 *
 * 当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
 * 和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
 *
 * 由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
 *
 * Java 数组
 * 声明数组变量
 * dataType[] arrayRefVar;   // 首选的方法
 * dataType arrayRefVar[];  // 效果相同，但不是首选方法
 * 创建数组
 * arrayRefVar = new dataType[arraySize];
 * 一、使用 dataType[arraySize] 创建了一个数组。
 * 二、把新创建的数组的引用赋值给变量 arrayRefVar。
 *
 * dataType[] arrayRefVar = new dataType[arraySize];//数组变量的声明，和创建数组可以用一条语句完
 * dataType[] arrayRefVar = {value0, value1, ..., valuek};
 *
 * For-Each 循环:它能在不使用下标的情况下遍历数组。
 *  语法格式如下：
 * for(type element: array)
 * {
 *   System.out.println(element);
 * }
 * 数组作为函数的参数 数组可以作为参数传递给方法。
 *
 * 多维数组
 * 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：
 *
 * String str[][] = new String[3][4];
 *
 * 多维数组的动态初始化（以二维数组为例）
 *  1. 直接为每一维分配空间，格式如下：
 * type[][] typeName = new type[typeLength1][typeLength2];
 * int a[][] = new int[2][3];
 *
 * Arrays 类
 * java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
 *
 * 给数组赋值：通过 fill 方法。
 * 对数组排序：通过 sort 方法,按升序。
 * 比较数组：通过 equals 方法比较数组中元素值是否相等。
 * 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
 *
 * */
public class StringBuffer {

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(10);
        sb.append("西贝大军");
        System.out.println(sb);
        sb.append("!!!!!");
        System.out.println(sb);
        sb.insert(2, "你好哈");
        System.out.println(sb);
        sb.delete(2, 4);
        System.out.println(sb);

        //数组
        int size = 3;//定义数组大小
        double[] myList = new double[size];
        myList[0] = 1;
        myList[1] = 33;
        myList[2] = 2.2;
        //计算所有元素和
        double total = 0;
        for (int i = 0; i < size; i++) {
            total = total + myList[i];

        }
        System.out.println(total);

        double[] testV1 = {11, 22, 3.4, 55.3, 44};
        // 打印所有数组元素
        for (int i = 0; i < testV1.length; i++) {
            System.out.println("testV1 打印所有数组元素" + testV1[i]);
        }

        // 查找最大元素
        double max = testV1[0];
        for (int i = 0; i < testV1.length; i++) {
            if (testV1[i] > max) max = testV1[i];
        }
        System.out.println("testV1 查找最大元素" + max);


        //For-Each
        for (double element : testV1) {
            System.out.println("For-Each" + element);
        }

        int[] intArray = {11, 22, 333, 444};
        Arrays.fill(intArray, 1, 2, 3121212);
        Arrays.sort(intArray);
        System.out.println("new intArray:"+Arrays.toString(intArray));
        printArray(intArray);

        int[] intArray2 = {33,22,111,333,666};
        int[] intarray3 = intArray2.clone();
        System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):"  + Arrays.equals(intArray, intArray2));
        System.out.println("比较数组元素是否相等:Arrays.equals(intarray3, intArray2):"  + Arrays.equals(intarray3, intArray2));


        //多维数组
        String[][] moreArray = new String[2][];
        moreArray[0] = new String[3];
        moreArray[1] = new String[3];
        moreArray[0][0] = "a";
        moreArray[0][1] = "b";
        moreArray[0][2] = "b";
        moreArray[1][0] = "A";
        moreArray[1][1] = "B";

        System.out.println(Arrays.toString(moreArray));
        System.out.println(Arrays.toString(moreArray[0]));
        System.out.println(Arrays.deepToString(moreArray));

    }


    //数组可以作为参数传递给方法。
    public static void printArray(int[] array) {
        for (int element : array) {
            System.out.println("array :" + element);
        }

    }
}