Java基础03-数组

# 数组的定义

定义：相同数据类型的有序集合
通过下标进行访问（下标是从0开始）
数组的一旦创建大小就被确定

通过.length能够获取到数组的长度
```javascript
public class NewArray {
    public static void main(String\[\] args) {
        //声明 ， 创建数组
        //int\[\] arr;声明
        //数组类型  数组名称 = new 数组类型【数组大小】
        int\[\] arr = new int\[10\];
        //第二种创建数组的方式
        //int arr2\[\]  = new int\[10\];
        arr\[0\]=1;
        arr\[1\]=2;
        arr\[2\]=3;
        arr\[3\]=4;
        arr\[4\]=5;
        arr\[5\]=6;
        arr\[6\]=7;
        arr\[7\]=8;
        arr\[8\]=9;
        arr\[9\]=10;


        //计算arr和的大小
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr\[i\];
        }
        //第二种for循环
        int sum2=0;
        for(int i:arr){
            sum2+=i;
        }
        System.out.println(sum2);
        System.out.println("arr\[10\]的和是："+sum);
    }
}
```创建数组时的内存状态：
先创建一个栈，栈内元素在堆中开辟一个空间存储数据


# 数组的静态初始化与动态初始化，默认初始化

```javascript
public static void main(String\[\] args) {
    //数组的静态初始化
    int\[\] arr = {1,2,3,4};
    System.out.println("arr\[0\]="+arr\[0\]);
    //数组的动态初始化：包含默认初始化
    int\[\] arrr = new int\[10\];
    arrr\[0\]=1;
    System.out.println("arrr\[0\]="+arrr\[0\]);
    //默认初始化的值，int类型的默认值
    System.out.println("arrr\[1\]="+arrr\[1\]);


}
```

# 数组的四个基本特点

1.  其长度是确定的。数组一旦被创建，他的大小是不可以改变的。
2.  其元素必须是相同类型，不允许出现混合类型
3.  数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4.  数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

# 数组的边界问题

下标越界：


# 数组的使用

```javascript
public class ArrayDemo02 {
    public static void main(String\[\] args) {
        //数组的操作
        int\[\] arr = {1,2,3,4,5,6};
        print(arr);
        reversal(arr);


    }
    //打印数组
    public static void print(int\[\] arr){


        for(int a:arr){
            System.out.println(a+"  ");
        }
    }
    //数组反转
    public static void reversal(int\[\] arr){
        int\[\] reversal = new int\[arr.length\];
        for (int i = 0,j=arr.length-1; i <arr.length ; i++,j--) {
            reversal\[j\]=arr\[i\];
        }
        for (int r:reversal) {
            System.out.print(r+"  ");
        }
    }

```

# 多维数组---数组中存了一个数组（数组的嵌套）

```javascript
public class ArrayDemo03 {
    public static void main(String\[\] args) {
        //创建一个二维数组，遍历
  //前面为行 后面为列
        int\[\]\[\] arr = {{1,2},{3,4},{5,6},{7,8}};
        print(arr);
    }
    //遍历二维数组
    public static void print(int\[\]\[\] arr){
        //两层for循环嵌套
        for(int i=0;i<arr.length;i++ ){
            System.out.println();
            for (int j = 0; j <arr\[i\].length ; j++) {
                System.out.print(arr\[i\]\[j\]+"  ");
            }
        }
    }


}
```

# Arrays类方法的一些使用---具体查看API文档

```javascript
public class ArraysDemo01 {
    public static void main(String\[\] args) {
        int\[\] a = {98,65,31,4,9,5,6,598,661,6,164,4984984,651,5156,498,46,1};


        //使用Arrays类中的方法对数组进行操作


        //对数组的打印
        System.out.println(Arrays.toString(a));


        //对数组的排序--自带打印方法
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));


        //对数组进行填充
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
    }

```

# 冒泡排序

```javascript
public class SortDemo01 {
    public static void main(String\[\] args) {
        int\[\] arr = {4564,98489,456,4,564689,4,44,654564,5,1,15,4984,94,1,54,984,684,56,4,4,984,56,1654,8,489,4};
        int\[\] a = sort(arr);
        System.out.println(Arrays.toString(a));
    }


    //冒泡排序
    public static int\[\] sort(int\[\] arr){
        //定义一个标志flag对冒泡排序进行优化
        boolean flag=false;


        //定义一个零时变量
        int temp;
        //对多少个数进行排序，每循环一次必找出一个最大数或一个最小数
        for (int i = 0; i < arr.length-1 ; i++) {
            //还有多少 个数未进行排序
            for (int j = 0; j < arr.length-1-i; j++) {
                //相邻两个数进行比较
                if (arr\[j\]>arr\[j+1\]){//更改大于号便可以更改升序降序
                    temp = arr\[j\];
                    arr\[j\] = arr\[j+1\];
                    arr\[j+1\] = temp;
                    //若进入判断则赋值为true
                    flag = true;
                }


            }
            //数组有序时不进行比较---flag=false时跳出循环
            if (!flag){
                //跳出循环，排序结束
                break;
            }
        }
        return arr;
    
```

来源：【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili