03-Java基础-String类&数组

String类、StringBuffer 和 StringBuilder 类、int 与 String转化、数组排序 查找

String类

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。
如果需要对字符串做很多修改，那么应该选择使用StringBuffer & StringBuilder 类。

// 将此字符串与指定的对象比较
boolean equals(Object anObject)  

//将此 String 与另一个 String 比较，不考虑大小写
boolean equalsIgnoreCase(String anotherString)  

// 将此字符串是否包含另一字符串
boolean contains(String anotherString)  

// 判断此字符串是否以指定的前缀开始
boolean startsWith(String prefix)  

// 判断此字符串是否以指定的后缀结束
boolean endsWith(String suffix)  

// 判断此字符串是否为空
boolean isEmpty(String string)  

// 返回此字符串的长度 
int length()  

// 返回指定索引处的 char 值
char charAt(int index)   

// 返回指定字符在此字符串中第一次出现处的索引
int indexOf(int ch)  

// 返回指定子字符串在此字符串中第一次出现处的索引。 
int indexOf(String str)   

// 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
int indexOf(int ch, int fromIndex)  

// 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int indexOf(String str, int fromIndex)    

// 返回指定字符在此字符串中最后一次出现处的索引
int lastIndexOf(int ch)  

// 返回一个新的字符串，它是此字符串从指定位置开始截取，默认到结尾 
String substring(int beginIndex)  

// 从指定位置开始到指定位置结束，截取字符串，返回一个新字符串
String substring(int beginIndex, int endIndex)   

// 将字符串转化为字节数组
byte[] getBytes()   

// 将此字符串转换为一个新的字符数组
char[] toCharArray()  

// 将字符数组转化为字符串 
static String valueOf(char[] chs)   

// 将int类型数据转化为字符串
static String valueOf(int i)   

// 将此 String 中的所有字符都转换为小写
String toLowerCase()   

// 将此 String 中的所有字符都转换为大写
String toUpperCase()  

// 将指定字符串连接到此字符串的结尾 
String concat(String str)  

// 返回一个新的字符串，用 newChar 替换此字符串中出现的所有 oldChar 得到的。 
String replace(char oldChar, char newChar)  

String replace(String old, String new) 

// 返回一个新的字符串，去除字符串两端空格
String trim()]   

// 把这个字符串和另一个对象比较
int compareTo(Object o)   

// 按字典顺序比较两个字符串
int compareTo(String anotherString)  

StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

// 将指定的字符串追加到此字符序列
public StringBuffer append(String s)

// 将 int 参数的字符串表示形式插入此序列中
public insert(int offset, int i)

移除此序列的子字符串中的字符
public delete(int start, int end)

// 使用给定 String 中的字符替换此序列的子字符串中的字符
replace(int start, int end, String str)

// 将此字符序列反转
public StringBuffer reverse()

// 返回一个新的 String，从指定位置截取到末尾
String substring(int start)

// 返回一个新的 String，截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
String substring(int start, int end)

int 与 String转化

private static void intToString(int i){

        // 方式一
        String string1 = String.valueOf(i);      // 推荐使用

        // 方式二
        String string2 = i + "";                 // 推荐使用

        // 方式三
        Integer integer = new Integer(i);
        String string3 = integer.toString();

        // 方式四
        String string4 = Integer.toString(integer);
    }

    private static void stringToInt(String string){

        // String -- Integer -- int
        // 方式一
        Integer integer = new Integer(string);
        int i = integer.intValue();

        // 方式二
        int i1 = Integer.parseInt(string);  // 推荐使用
    }

数组

• 声明数组

dataType[] arrayRefVar;   // 首选的方法
dataType arrayRefVar[];  // 效果相同，但不是首选方法

• 创建数组

// 动态初始化，只指定长度，由系统给出初始化值
dataType[] arrayRefVar = new dataType[arraySize];  
// 静态初始化，给出初始化值，由系统决定长度
dataType[] arrayRefVar = new  dataType[] {value0, value1, ..., valuek}; 
dataType[] arrayRefVar = {value0, value1, ..., valuek}; 

• 数组的操作
  排序

// 冒泡排序
    private static int[] bubbleSort(int[] array){

        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]){
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }

// 选择排序
    private static int[] slectSort(int[] array){

        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] > array[j]){
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }

查找

// 二分法查找
    private static int getIndex(int[] array, int value){

        int min = 0;
        int max = array.length - 1;
        int mid = (min + max) / 2;

        while (value != array[mid]){
            if (value > array[mid]){
                min = mid + 1;
            }else{
                max = mid - 1;
            }
            mid = (min + max) / 2;

            if (min > max){
                return -1;
            }
        }

        return mid;
    }

• 二维数组
  多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
  动态初始化格式：
  type[][] arrayName = new type[arraylenght1][arraylenght2];

int[][] arr = new int[3][2];