bilibiliJava学习数组

1.数组是什么，为什么要有数组

数组是一块连续的存储空间，存储的是相同数据类型的元素

通过数组来组织这些数据

int a1 = 1;
int a2 = 2;
int a3 = 3;
int[] array = {1,2,3};

数组的下标（索引）是从0开始的，即数组的下标（索引）第一个是0，结束位置下标是n-1

例子:

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

会抛出异常Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3

这个是数组长度超出

想得到数组长度的代码如下：

int len = array.length;
System.out.println(len);

2.数组的初始化

//直接赋值，静态初始化
int[] array1 = {1,2,3};
//动态初始化
//             new type[]{dates};
int[] array2 = new int[]{1,2,3,4};
//只分配了内存，不赋初始值
int[] array3 = new int[10];

只分配内存，不赋初始值，里面的值全是0，boolean类型默认是false。

3.数组的使用及其打印

import java.util.Arrays;

public class Array {
    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        System.out.println(array[1]);
        array[1] = 99;
        System.out.println(array[1]);
        //打印数组
        int[] array1 = {1,2,3};
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + " ");
        }
        System.out.println();

        // 数组当中数据类型定义的变量 : 数组名
        //for each（增强for循环）      for循环能拿到下标，for each拿不到下标
        int[] array2 = {1,2,3};
        for (int x : array2){
            System.out.print(x +" ");
        }
        System.out.println();

        //toString将数组转变为字符串然后返回
        String ret = Arrays.toString(array2);
        System.out.println(ret);
    }

2
99
1 2 3 
1 2 3 
[1, 2, 3]
 

题目1创建一个int类型的数组，元素个数为100，并把每个元素依次设置为1-100

import java.util.Arrays;

public class Array2 {
    public static void main(String[] args) {
        int[] array = new int[100];
        for (int i = 0; i < array.length; i++) {
            array[i] = i+1;

        }
        System.out.println(Arrays.toString(array));
    }
}

题目2实现一个方法printArray，以数组为参数，循环访问数组中的每个元素，打印每个元素的值

import java.util.Arrays;

public class Array {
    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        System.out.println(array[1]);
        array[1] = 99;
        System.out.println(array[1]);
        //打印数组
        int[] array1 = {1,2,3};
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + " ");
        }
        System.out.println();

        // 数组当中数据类型定义的变量 : 数组名
        //for each（增强for循环）      for循环能拿到下标，for each拿不到下标
        int[] array2 = {1,2,3};
        for (int x : array2){
            System.out.print(x +" ");
        }
        System.out.println();

        //将数组转变为字符串然后返回
        String ret = Arrays.toString(array2);
        System.out.println(ret);
    }

4.数组内存，它是一个引用变量

int[] array = {1,2,3}; 

直接System.out.print(array);

他得出的简单来说就是一个地址,不会得出1,2,3

例子：

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

    int[] array3 = array;
    array3[1] = 99;
    System.out.println(Arrays.toString(array));
    System.out.println(Arrays.toString(array3));
}

得出的结果

[1, 2, 3, 4]
[1, 99, 3, 4]
[1, 99, 3, 4]

 因为array2它的栈所指向的也是0x13，他赋值直接给0x13上序号2的值改变了，所以array也会变

即array2这个引用，指向了array这个引用所引用的对象

注意：一个引用不能指向多个对象

而引用类型的空值是null，下述代码的结果就是null

public static void main(String[] args) {
    int[] array = null;
    System.out.println(array);
}

例子1：

public class Array {

    public static void fun(int[] array){
        array = new int[10];
    }

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

    }

在这个例子中得出的结果是[1, 2, 3, 4]

修改了形参自己的指向

int[] array = {1,2,3,4};
fun(array);

在int数组后，进入fun函数中吧int[] array = {1,2,3,4}的地址0x13给了函数fun，

但是进入函数以后，又把这个array分配了一个地址到了new int[10],把地址给了0x98。

实参没变，上面形参变了。

System.out.println(Arrays.toString(array));

这个打印的是实参的值，实参不会发生改变的

 例子2：

public static void fun2(int[] array){
    array[0] = 33;
}

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

}

在该函数中得出的结果是[33,2,3,4]

修改了指向对象里面的值

这个是，int[] array = {1,2,3,4},然后进入到函数中，函数int[] array接收了外面实参的地址，随后把实参下标为0的给他改了，所以的出的是[33,2,3,4]

注意：

所谓这个“引用”，本质上只是存了一个地址，java将数组设计为引用类型，这样的话后续进行数组参数传参，其实只是将数组的地址传入到函数形参中，这样可以避免整个数组的拷贝（数组可能比较长，那么拷贝的开销就会很大）

5.作为函数的返回值

public static int[] func3(){
    int[] tmp = {1,2,3,4,5,6,7};
    return tmp;
}

public static void main(String[] args) {
    int[] ret = func3();
    System.out.println(Arrays.toString(ret));
}

6.交换

public static void swap(int[] array){
    int tmp = array[0];
    array[0] = array[1];
    array[1] = tmp;
}
public static void main(String[] args) {
    int[] tmp = {1,2};
    System.out.println("交换前" + tmp[0] + tmp[1]);
    swap(tmp);
    System.out.println("交换后" + tmp[0] + tmp[1]);
}

交换前12
交换后21

 7.打印出斐波那契数列的前n项

public static int[] fib(int n){
    if(n == 0){
        return null;
    }
    int[] array = new int[n];
    array[0] = array[1] = 1;
    for (int i = 2; i < n; i++) {
        array[i] = array[i-1] + array[i-2];

    }
    return array;
}

public static void main(String[] args) {
    int[] array = fib(10);
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
}

8.小总结

1.数据对象是在堆上的

2.引用变量目前是在main函数里的，它属于局部变量，当函数结束就会回收内存