数组的定义与使用

---

1.数组基本用法

// 数组的定义

数组本质上就是让我们能 “批量” 创建相同类型的变量； 在 Java 中, 数组中包含的变量必须是相同类型。

//创建数组

// 动态初始化 数据类型[ ] 数组名称 = new 数据类型 { 初始化数据 };

// 静态初始化 数据类型[ ] 数组名称 = { 初始化数据 }

//数组的使用

int[] arr = {1, 2, 3};
// 获取数组长度
System.out.println("length: " + arr.length); // 执行结果: 3
// 访问数组中的元素
System.out.println(arr[1]); // 执行结果: 2
System.out.println(arr[0]); // 执行结果: 1

注意：

java.lang.ArrayIndexOutOfBoundsException  //数组越界异常

java.lang.NullPointerException  //空指针异常

//数组的遍历

for遍历

int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

foreach遍历

int[] arr = {1, 2, 3};
for (int x : arr) {
    System.out.println(x);
}

---

2.数组作为方法的参数

//理解引用类型

public static void main(String[] args) { 
 int[] arr = {1, 2, 3}; 
 func(arr); 
 System.out.println("arr[0] = " + arr[0]); 
} 
public static void main(String[] args) {
    int num = 0;
    func(num);
    System.out.println("num = " + num);
}
public static void func(int x) {
    x = 10;
    System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0
public static void func(int[] a) { 
 a[0] = 10; 
 System.out.println("a[0] = " + a[0]); 
} 
// 执行结果
a[0] = 10 
arr[0] = 10

所谓的 “引用” 本质上只是存了一个地址,Java 将数组设定成引用类型, 这样的话后续进行数组参数传参,其实只是将数组的地址传入到函数形参中,这样可以避免对整个数组的copy。

//JVM内存区域划分

程序计数器 (PC Register):
只是一个很小的空间, 保存下一条执行的指令的地址.

虚拟机栈(JVM Stack):
重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[ ] array这样的存储地址的引用就是在这里保存.

本地方法栈(Native Method Stack):
本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量,在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.

堆(Heap):
JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存.

方法区(Method Area):
用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据.方法编译出的的字节码就是保存在这个区域.( * jdk1.7开始 String str = “hello” 中的hello，它从方法区挪到了堆 )*

如图

//数组作为方法的返回值

//数组作为返回值 将数组扩大二倍 要求不能修改原数组
class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] ahh = transform(arr);
        array(ahh);
    }
    public static void array(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static int[] transform(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i] * 2;
        }
        return ret;
    }
}

// 学习Arrays类当中的方法

 * Arrays.toString(); // [ ]
 * Arrays.copyOf();  //
 * Arrays.copyOfRange();   //拷贝部分数组[ )
 * Arrays.binarySearch();    //二分
 * Arrays.equals();   //判断数组是否相同
 * Arrays.fill(array,9);    //数组的填充
 * Arrays.fill(array,2,7,88);   //[2,7)下标填充为88
 * Arrays.sort(array);    //将数组进行排序

//数组的拷贝

1、for循环去拷贝
2、System.arraycopy
3、Arrays.copyOf
4、数组名.clone(); clone是Object的方法 返回一个副本 数组名->你要拷贝的数组

---

3.经典数组练习

//数组的逆置

public class Test{
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void reverse(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
    }
}

//二分法

public class Test{

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int ahh = binarySearch(array,3,0,array[array.length-1]);
        System.out.println(ahh);
    }
    public static int binarySearch(
            int[] array,int key,int left,int right) {
        if (left > right) {
            return -1;
        }
        int mid = (left + right) >> 1;
        if (array[mid] == key) {
            return mid;
        }else if(array[mid]>key){
            return binarySearch(array, key, left, mid-1);
        }else{
            return binarySearch(array, key, mid+1,right);
        }
    }
}

//冒泡排序

//冒泡排序优化版
public class Test{

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

    public static void bubbleSort(int[] array){
        boolean thing = true;//判断
        for (int i = 0; i <array.length-1 ; i++) {//趟数
            thing = true; //每一趟都有可能
            for (int j = 0; j <array.length-1-i ; j++) {//次数
                if(array[j]>array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    thing = false;
                }
            }
            if(thing){
                break;
            }
        }
    }
}

---