LeetCode数据结构探索（java）二：数组和字符串

数组和字符串的一些知识
1.数组a[]的长度：a.length; 字符串a的长度: a.length（）;

2.字符串a转字符数组s[]的方法: char[] s = a.toCharArray();

3.字符串用"", 字符用’’;

4.String s = “hello”;
在字符串s后面添加字符串： s = s+“world”; 则s变为"hello world";
在字符串s前面添加字符串：String adds = “lcc”; s = adds+s; 则s变为"lcc hello";

5.字符串s反转的方法:String reverse= new StringBuffer(s).reverse().toString();

6.java中的字符串是不可变的，即定义后便不能更改，若想要更改，可以转化为字符数组。
定义为字符串而进行修改时，会报错：

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        String s1 = "Hello World";
        s1[5] = ',';
        System.out.println(s1);
    }
}

定义为字符串而需要更改时，可转化为数组：

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        String s = "Hello World";
        char[] str = s.toCharArray();
        str[5] = ',';
        System.out.println(str);
    }
}

7.字符串实际上是一个Unicode数组，所以可以进行大部分数组的操作，但也有区别。
字符串可以进行的额外操作：

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        String s1 = "Hello World";
        // 1. concatenate 连接操作
        s1 += "!";
        System.out.println(s1);
        // 2. find  找到元素“o”第一次和最后一次出现的下标位置
        System.out.println("The position of first 'o' is: " + s1.indexOf('o'));
        System.out.println("The position of last 'o' is: " + s1.lastIndexOf('o'));
        // 3. get substring  输出字符串s1从下标6到下标10的元素
        System.out.println(s1.substring(6, 11));
    }
}

8.字符串进行连接操作的时间复杂度问题：

在 Java 中，由于字符串是不可变的，因此在连接时首先为新字符串分配足够的空间，复制旧字符串中的内容并附加到新字符串。
因此，总时间复杂度将是：
5 + 5 × 2 + 5 × 3 + … + 5 × n
= 5 × (1 + 2 + 3 + … + n)
= 5 × n × (n + 1) / 2,
也就是 O(n2)。
如果你经常必须连接字符串，最好使用一些其他的数据结构，如 StringBuilder 。 以下代码以 O(n) 的复杂度运行。

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        int n = 10000;
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < n; i++) {
            str.append("hello");
        }
        String s = str.toString();
    }
}

9.定义，遍历数组的方法：

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        // 1. Initialize   定义数组
        int[] a0 = new int[5];
        int[] a1 = {1, 2, 3};
        // 2. Get Length   获取数组长度
        System.out.println("The size of a1 is: " + a1.length);
        // 3. Access Element  
        System.out.println("The first element is: " + a1[0]);
        // 4. Iterate all Elements  遍历数组的第一种方法
        System.out.print("[Version 1] The contents of a1 are:");
        for (int i = 0; i < a1.length; ++i) {
            System.out.print(" " + a1[i]);
        }
        System.out.println();      
        //   ***遍历数组的第二种方法***
        System.out.print("[Version 2] The contents of a1 are:");
        for (int item: a1) {
            System.out.print(" " + item);
        }
        System.out.println();
        // 5. Modify Element   更改数组元素
        a1[0] = 4;
        // 6. Sort    把数组元素按从小到大进行排序
        Arrays.sort(a1);
    }
}

10.数组具有固定的容量，我们需要在初始化时指定数组的大小。有时它会非常不方便并可能造成浪费。大多数编程语言都提供内置的动态数组，它仍然是一个随机存取的列表数据结构，但大小是可变的。例如，在 C++ 中的 vector，以及在 Java 中的 ArrayList。下面是动态数组的用法，可以在eclipse上运行并且修改部分代码体会一下：

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        // 1. initialize   定义
        List<Integer> v0 = new ArrayList<>();
        List<Integer> v1;                           // v1 == null
        // 2. cast an array to a vector   
        Integer[] a = {0, 1, 2, 3, 4};
        v1 = new ArrayList<>(Arrays.asList(a));
        // 3. make a copy
        List<Integer> v2 = v1;                      // another reference to v1    v2是v1的另一个表示
        List<Integer> v3 = new ArrayList<>(v1);     // make an actual copy of v1     v3是v1的一个copy
        // 3. get length  获取v1长度的方法
        System.out.println("The size of v1 is: " + v1.size());;
        // 4. access element   获取v1中的元素的方法
        System.out.println("The first element in v1 is: " + v1.get(0));
        // 5. iterate the vector  遍历v1的两种方法
        System.out.print("[Version 1] The contents of v1 are:");
        for (int i = 0; i < v1.size(); ++i) {
            System.out.print(" " + v1.get(i));
        }
        System.out.println();
        System.out.print("[Version 2] The contents of v1 are:");
        for (int item : v1) {
            System.out.print(" " + item);
        }
        System.out.println();
        // 6. modify element  修改v2的元素是会改变v1中的元素的
        v2.set(0, 5);       // modify v2 will actually modify v1
        System.out.println("The first element in v1 is: " + v1.get(0));
        // 修改v3的元素是不会改变v1中的元素的
        v3.set(0, -1);   
        System.out.println("The first element in v1 is: " + v1.get(0));
        // 7. sort   **排序的方法**
        Collections.sort(v1);
        // 8. add new element at the end of the vector   添加元素
        v1.add(-1);    		 //是添加在数组前面，即数组下标为0的位置
        v1.add(1, 6);		//是添加在数组下标为1的位置，然后后面的元素下标全部后移一位
        // 9. delete the last element   //删除元素
        v1.remove(v1.size() - 1);  
    }
}