java基础知识补充一

一.String类：

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看笔记部分解析）。

如果需要对字符串做很多修改，那么应该选择使用StringBuffer & StringBuilder 类
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。

String s1 = "abc";            // 常量池
String s2 = new String("abc");     // 堆内存中
System.out.println(s1==s2);        // false两个对象的地址值不一样。
System.out.println(s1.equals(s2)); // true

通过 new 关键字来生成对象是在堆区进行的，而在堆区进行对象生成的过程是不会去检测该对象是否已经存在的。因此通过 new 来创建对象，创建出的一定是不同的对象，即使字符串的内容是相同的。

a.连接字符串
string1.concat(string2); string1+ string2

String：字符串常量，字符串长度不可变。Java中String 是immutable（不可变）的。用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。

StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用 StringBuffer，如果想转成 String 类型，可以调用 StringBuffer 的 toString() 方法。Java.lang.StringBuffer 线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。

StringBuilder：字符串变量（非线程安全）。在内部 StringBuilder 对象被当作是一个包含字符序列的变长数组。

基本原则：

如果要操作少量的数据用 String ；
单线程操作大量数据用StringBuilder ；
多线程操作大量数据，用StringBuffer。

1、返回字符串长度
length(), 返回的是int类型的值。

2、判断字符串是否为空
判断是否为空的条件是，字符串长度等于0，方法名称是isEmpty()。返回的是布尔型值，true或者false两个值

3.根据索引，获取字符串中一个字母
例如如果要判断两个字符串相等。肯定要两个字符串字母一一取出来，然后去比较。这个取出来的过程就需要用到charAT(int index)方法，如果找到就返回这个字母。
s1.charAt(1)

4.判断两个字符串是否相等
利用equals（）方法
s1.equals(s2)

5.startsWith(String prefix, int toffset)
判断这个字符串是否以xxx开头，这个经常用来定位文件中某一行。然后才进行其他操作，例如替换字符。

6.endsWith(String suffix)
判断这个字符串是否以xxx结尾

7.indexOf(int ch) Hello
返回某一个字母的下标索引。
s1.indexOf('l'))

8. subSequence(int beginIndex, int endIndex)
   得到该字符串的一个子字符串。
   s1.subSequence(1,4)) 左闭右开

9.concat(String str)
新字符串拼接到原字符串后面。类似我们采用str1+str2效果。
s1.concat( "world"));

10. String replace(char oldChar, char newChar)
    字符串中字符替换，替换全部符合匹配的。
    s1.replace("e","p"));

11. contains(CharSequence s)
    判断是否包含某些字符串
    s1.contains("l"));

12. split(String regex, int limit)
    字符串切割，工作中经常用到。存在问题，需要线下学习下

二、StringBuffer和StringBuilder
StringBuilder和StringBuffer有什么区别呢？这个在面试中也经常被问道。就一句话，StringBuffer和StringBuilder的方法基本上是一样的，唯一的区别是StringBuffer是线程安全的，而StringBuilder不是。
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

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

package basedemo;

public class StringBufferDemo {
    private static final int ITERATIONS = 100000;
    //参考StringBuffer.java中的 initial capacity of 16 characters.
    private static final int BufferSize = 16;

    private void concatString(){
        System.out.print("comcatString -> ");
        long startTime = System.currentTimeMillis();
        String concat = "";

        for(int i = 0; i< ITERATIONS; i++){
            concat += i % 10;
        }

        long endTime = System.currentTimeMillis();
        System.out.print("length: "+ concat.length());
        // 统计循环整个过程时间
        System.out.println(" time: "+ (endTime - startTime));
    }

    //StringBuffer
    private void concatStringBuffer(){
        System.out.print("concatStringBuffer -> ");
        long startTime = System.currentTimeMillis();
        StringBuffer concat = new StringBuffer();

        for(int i=0; i< ITERATIONS; i++){
            concat.append(i % 10);
        }

        long endTime = System.currentTimeMillis();
        System.out.print("length: "+ concat.length());
        System.out.println(" time: "+ (endTime - startTime));
    }

    //StringBuilder
    private void concatStringBuilder(){
        System.out.print("concatStringBuilder -> ");
        long startTime = System.currentTimeMillis();
        StringBuilder concat = new StringBuilder();

        for(int i=0; i< ITERATIONS; i++){
            concat.append(i % 10);
        }

        long endTime = System.currentTimeMillis();
        System.out.print("length: "+ concat.length());
        System.out.println(" time: "+ (endTime - startTime));
    }

    public static void main(String args[]){
        String str = new String("Hello ");
        str += "BeiJing";

        StringBuffer strb = new StringBuffer("Hello ");
        strb.append("BeiJing");

        StringBuilder strd = new StringBuilder("Hello ");
        strd.append("BeiJing");

        StringBufferDemo st = new StringBufferDemo();
        System.out.println("Iterations:" + ITERATIONS);
        System.out.println("Buffer:" + BufferSize);

        st.concatStringBuffer();
        st.concatString();
        st.concatStringBuilder();

    }
}

输出：

结论就是，从操作效率来看：StringBuilder > StringBuffer > String。 所以，如果不考虑线程安全角度，尽量多用StringBuilder来操作字符串的修改。

三、Arrays类
数组类，Java中提供了一个数组常见操作方法的类Arrays.java。其实前面也说过，String其实源码中就是用一个char[]数组来存储的，也是属于数组的范围。
1、数组的创建和元素遍历

package basedemo;

public class ArraysDemo {
    public static void main(String[] args) {
        //基础数据类型数组
        int[] num = new int[12];
        //引用数据类型
        String[] st =new String[100];
        //先声明
        int[] array;
        array = new int[10];

        //声明后直接赋值
        int[] a ={40, 20, 50, 10, 60, 30};

        //输出数组每个元素的位置。值
        System.out.println("第一种遍历方法");
        for (int i = 0; i <a.length ; i++) {
            System.out.println(i+ "\t" +a[i]);

        }

        System.out.println("第二种遍历方法");
        for (int x:a){
            System.out.print("\t" +x);
        }
    }
}

2、数组中元素查找和替换和排序

package basedemo;

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

public class ArraysDemo2 {
    public static void main(String[] args) {
        int[] a ={40, 20, 50, 90, 50, 30};
        //根据索引得到元素
        int b= Array.getInt(a,2);
        System.out.println("得到下标为2的数："+b);

        Array.set(a,2,80);
        System.out.println("把下标为2的元素修改为80" + Arrays.toString(a));

        Arrays.sort(a);
        System.out.println("数组排序,从小到大" +Arrays.toString(a));

        //从大到小排序，前提是利用前面已经排序好的元素
        int le = a.length;
        for (int i = 0; i <le/2 ; i++) {
            int temp = a[i];
            a[i] = a[le-1-i];
            a[le-1-i] = temp;
        }
        System.out.println("逆序后："+ Arrays.toString(a));

        //比较两个数组是否相等
        int[] c = {10,20,30,40,70};
        System.out.println(Arrays.equals(a,c));
    }
}