01.数组

1、数组、ArrayList与List

• 数组：大小固定，且对性能有严格要求的情况下使用
• ArrayList：在需要一个可以动态改变大小的列表，且主要进行尾部添加、删除或者随机访问操作时使用
• List接口：在需要一个列表，且可能根据具体情况改变实现时使用

1、数组

• 数组是存储固定大小的同类型元素的容器，一旦创建了数组，就不能改变其大小
• 数组在内存中是连续存储，查询很快，但是添加或删除元素比较慢（要移动数组中的其他元素）
• 注：如果需要更多的空间，你必须创建一个新的数组，并将旧数组的元素复制到新数组中

package com.example01;

import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i * 10;
        }
        System.out.println(Arrays.toString(arr));
        // [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
    }
}

2、ArrayList

• ArrayList是一个动态数组，可以根据需要增加和缩小其大小
• 内存中也是连续存储的，但是它可以自动调整大小以容纳更多的元素
• 但是，由于ArrayList是动态的，所以添加和删除元素的速度可能比数组慢

package com.example01;

import java.util.ArrayList;

public class Test {
    public static void main(String[] strings) {
        ArrayList<Integer> arrList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            arrList.add(i * 10);
        }
        System.out.println(arrList);
        // [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
    }
}

3、List

• List是Java集合框架的一个接口，它表示一个有序的集合（也称为序列）
• List接口有一些实现，如ArrayList、LinkedList等
• 使用List接口的好处是，你可以根据需要改变其实现
• 例如，如果你需要频繁地在列表中间添加或删除元素，你可以使用LinkedList
• 如果你需要频繁地访问元素，你可以使用ArrayList

package com.example01;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] strings) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i * 10);
        }
        System.out.println(list);
        // [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
    }
}

2、一维数组

• 动态初始化

int[] array = new int[3];
// 两种方式都可以
// int array[] = new int[3];
array[0] = 1;
array[1] = 2;
array[2] = 3;
System.out.println(array[0]);

• 静态初始化

int[] array = { 1, 2, 3, 4 };
int[] array1 = new int[] { 1, 2, 3, 4 };
System.out.println(array[2]);
System.out.println(array1[2]);

• 默认初始化

int[] array = new int[4];
System.out.println(array[2]);

3、二维数组

package day01;
import java.util.Arrays;

public class Test {
    public static void main(String[] strings) {
        int[][] array3 = { { 1, 1, 1 }, { 2, 2, 2 } };
        System.out.println(Arrays.deepToString(array3));
    }
}

• 同一维数组一样，共有4总不同形式的定义方法

int[][] array1 = new int[10][10];
int array2[][] = new int[10][10];
int array3[][] = { { 1, 1, 1 }, { 2, 2, 2 } };
int array4[][] = new int[][] { { 1, 1, 1 }, { 2, 2, 2 } };

• 不定长二维数组

int[][] array = new int[3][];
array[0] = new int[1];
array[1] = new int[2];
array[2] = new int[3];

• 获取二维数组的长度

int length1 = array.length;
int length2 = array[0].length;
// 获取二维数组的第一维长度（3）
System.out.println(length1);
// 获取二维数组的第一维的第一个数组长度（1）
System.out.println(length2);

02.数组常用方法

1、基本用法

package day01;

public class Test {
    public static void main(String[] strings) {
        String[] langs = {"python", "java", "go"};
        langs[0] = "python2";
        System.out.println( langs[0] );  // python2
        System.out.println( langs.length );  // 3
    }
}

2、遍历

• 传统方式遍历

public class Test {
    public static void main(String[] strings) {
        int[] nums = {1,2,3,4};
        for (int i =0; i< nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
}

• for-each遍历

public class Test {
    public static void main(String[] strings) {
        int[] nums = {1,2,3,4};
        for (int num : nums) {
            System.out.println(num);
        }
    }
}

3、排序

import java.util.Arrays;

public class HelloWord {
    public static void main(String[] args) {
        int[] array = { 3, 2, 1, 4, 5 };
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

4、输出

int[] array = { 1, 2, 3 };
System.out.println( Arrays.toString(array) );

5、转List

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class HelloWord {
    public static void main(String[] args) {
        String[] array = { "a", "b", "c", "d", "e" };
        List list = new ArrayList(Arrays.asList(array));
        System.out.println(list);
    }
}

6、转Set

import java.util.*;

public class HelloWord {
    public static void main(String[] args) {
        String[] array = { "a", "d", "c", "b", "e" };
        Set set = new HashSet(Arrays.asList(array));
        System.out.println(set);
    }
}

7、List转数组

import java.util.*;

public class HelloWord {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        String[] array = new String[list.size()];
        list.toArray(array);
        for (String s : array)
            System.out.println(s);
    }
}

8、数组是否包含

import java.util.*;

public class HelloWord {
    public static void main(String[] args) {
        String[] array = { "a", "b", "c", "d", "e" };
        boolean b = Arrays.asList(array).contains("a");
        System.out.println(b);  // true
    }
}

9、复制

int array[] = new int[] { 1, 2, 3, 4 };
int array1[] = new int[array.length];
System.arraycopy(array, 0, array1, 0, array.length);

10、合并

int[] array1 = { 1, 2, 3, 4, 5 };
int[] array2 = { 6, 7, 8, 9, 10 };
int[] array = org.apache.commons.lang.ArrayUtils.addAll(array1, array2);
System.out.println(Arrays.toString(array));

11、String数组转字符串

• 使用指定字符拼接

String[] array = { "a", "b", "c" };
String str = org.apache.commons.lang.StringUtils.join(array, ", ");
System.out.println(str);

12、逆序

int[] array = { 1, 2, 3, 4, 5 };
org.apache.commons.lang.ArrayUtils.reverse(array);
System.out.println(Arrays.toString(array));

13、移除

int[] array = { 1, 2, 3, 4, 5 };
int[] removed = org.apache.commons.lang.ArrayUtils.removeElement(array, 3);
System.out.println(Arrays.toString(removed));