Java基础-数组（五）

一、数组的概述

1. 数组是相同类型数据的有序集合
2. 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
3. 其中，每一个数据称作一个数组的元素，每个数组元素可以通过一个下标来访问它们。

4. 使用数组的原因：

• 没有数组：存在多个变量，需要声明多个变量的名称，这些名称之间没有什么关系和规律。想访问所有的变量，就比较困难。
• 规律的。可以通过容器名称结合位置数字的方式，访问到某个变量。非常容易的访问所有的变量。通过有规律的索引，来访问没有规律的元素。

二、数组声明创建

2.1 数组的定义：

元素的数据类型[] 数组名称 = new 元素的数据类型[数组容器的大小];

2.2 理解数组

2.3 创建与声明

public class ChuangJian_Daniel {
    public static void main(String[] args) {
        int [] array;//声明一个数组
        array = new int[10];//创建一个数组
        //int [] array = new int[10];//声明创建数组   
        array [0] = 0;
        array [1] = 1;
        array [2] = 2;
        array [3] = 3;
        array [4] = 4;
        array [5] = 5;
        System.out.println(array[3]);
        int sum = 0;
        for (int i = 0; i < array.length; i++) {//array.length 表示数组的长度
            sum+=array[i];
        }
        System.out.println("sum="+sum);
    }
}

运行结果为：

2.4 jvm 内存分析

1. jvm是执行java程序的容器，空间很大，需要划分不同的区域：不同的功能，需要使用不同特点的区域来完成.主要分为：栈内存、堆内存、方法区
2. 栈内存：用于执行方法，每个方法单独的分配一段空间，称为栈帧，把给方法分配内存空间，形象的称为“进栈”。特点：先进后出
3. 堆内存：用于存储数组、对象等数据量较大的数据。一般都是引用数据类型。
4. 方法区：用于存储类的字节码对象，存储常量、存储静态变量

Java内存分析

2.5 三种初始化

2.5.1 静态初始化

 int [] a = {1,2,3};
 Man[] mans = {new Man(1,1),new Man(2,2)};

2.5.2 动态初始化

 int[] a = new int[2];
 a[0]=1;
 a[1]=2;

2.5.3 数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

public class ChuShiHua_Daniel {

    public static void main(String[] args) {
        //静态初始化
        int [] num1 = {1,2,3,4,5,6};
        System.out.println(num1[3]);

        //动态初始化
        int[] num2 = new int[10];
        num2[2] = 4;

        System.out.println(num2[2]);
        System.out.println(num2[3]);//默认初始化
    }
}

运行结果为：

2.6 数组的四个基本特点

2.7 数组的边界

三、数组使用

3.1 For-Each循环

public class ShuZuPuTong_Daniel {

    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //数组的遍历
        for (int i = 0; i < arrays.length; i++) {

            System.out.println(arrays[i]);
        }

        //数组求和
        int sum = 0;
        for (int i = 0; i < arrays.length ; i++) {

            sum+=arrays[i];
        }
        System.out.println("sum="+sum);
        //数组求最大值
        int max = arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if(arrays[i] > max){

                max = arrays[i];
            }
        }
        System.out.println("最大值为："+max);
    }
}

运行结果为：

3.2 数组作方法入参

3.3 数组作返回值

public class FanZhuan_Daniel {
    public static void main(String[] args) {

        //数组的反转
        int[] arr = {1,2,3,4,5,6};
        System.out.println("反转前");
        printArray(arr);//调用打印数组的方法
        for(int i = 0,j = arr.length-1;i < j;i++,j-- ){//做数组的反转操作
            int temp = arr[i];//交换数组中的值
            arr[i] = arr[j];
            arr[j] = temp;
        }
        System.out.println("反转后");
        printArray(arr);//调用打印数组的方法
    }
    //打印数组的方法
    public static void printArray(int[] arr){
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

运行结果为：

四、多维数组 （不常用，了解）

public class ErWei_Daniel {
    public static void main(String[] args) {
        int [][] arr = {{1,2,3},{3,4,5},{2,4},{2}};

        for (int i = 0; i < arr.length; i++) {

            for (int j = 0; j <arr[i].length ; j++) {

                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("------------------");
        System.out.println(arr[2][1]);
    }
}

运行结果为：

五、Arrays类（拓展）

public class Arrays_Daniel {

    public static void main(String[] args) {
         int[] a = {12,222,3342,22,33,674557,33,2,264536};
        //System.out.println(a);//[I@1b6d3586
      //  System.out.println(Arrays.toString(a));//Arrays的toString（）方法
		//Arrays.sort(); //数组排序
        printArray(a);
    }
    //也可以自己自定义数组方法  重复造轮子
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {

            if(i == 0){
                System.out.print("[");
            }
            if(i == a.length-1){
                System.out.print(a[i]+"]");
            }else{
                System.out.print(a[i]+",");
            }
        }
    }
}

运行结果为：

冒泡排序

public class MaoPao_Daniel {
    public static void main(String[] args) {

            int [] a = {12,1222,223,23,21243,2,21};
        //冒泡排序
        //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
        //2.每一次比较，都会产生一个最大，或者最小的数字
        //3.下一次可以少一次排序
        //4.一次循环，直到结束
        int[] sort = sort(a);//调用自己的排序，返回一个数组

        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        boolean flag  = true;//优化
        //外层循环，判断我们这个要走多少次；
        for(int i = 0;i <array.length-1;i++){
            for (int j = 0;j < array.length-1-i;j++){
                if(array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] =temp;
                    flag = true;
                }
            }
            //优化
            if(flag == false){
                break;
            }
        }
        return array;
    }
}

运行结果为：

六、稀疏数组（拓展）

6.1 稀疏数组的介绍

稀疏数组视频