Java基础 IV数组

数组

释义：

1.相同类型的若干个数据，按照一定西安后次序排列组合而成。
2.每一个数据称作一个数组元素
3.每个数组元素可以通过一个下标来进行访问，从0开始
特点：
1.数组一旦被创建，他的长度大小（可以存储的元素个数）是不可改变的
2.一个数组内的元素必须是相同类型，不允许混合类型
3.数组中的元素可以基础类型和引用类型

数组定义

数据类型[] 名称 = new 数据类型[数字大小]；
例如：
int[] i = new int[2];
int[] i = new int[]{1,2,3}
等号左边为声明，表示要创建该名字数据类型的数组
右边为开辟内存空间，表示创建该长度(或是存储具体的值)数据类型的存储空间；
定义方式灵活，这里不穷举；

Demo

public class ArrayDemo {
    public static void main(String[] args) {
        int[] i = new int[4];
        int[] n = new int[]{12,13};
        System.out.println(i.length);//4
        System.out.println(n.length);//2
        System.out.println(n[1]);//13
    }
}

注意：

1、length获取的是数组开辟空间的长度，不管有没有赋值，只要完成数组在内存的空间开辟，即初始化，就会占用空间；
2、数组是引用类型，创建未赋值时，系统会自动初始化其值
int[] i = new int[4];
System.out.print(i[0]);
打印值为0
int 默认值为0；boolean默认为false；String 默认值为null

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

底层实现

int[] a =null; 时，程序到栈内存中，定义名字为a的空间；
a = new int[2]; 创建对象时，程序到堆内存中，开辟出长度为2，类型为int的存储空间，并且将该存储空间地址存储到栈内存名字为a的空间中；
a[0] = 1; 程序到栈内存找到a的位置，通过a的值找到堆空间地址，在根据下标，找堆空间内开辟的存储空间下的位置，把值1存储进去；
栈内存存放的是我们的变量信息；
new的都是在堆内存中开辟空间；

排序算法

冒泡排序

介绍： 从第一个位置开始，每次比较前后两个位置的值，将大（小）的赋值给下标靠后的位置，则每比完一轮，就可以获取到当前最大（最小）的值放到当前轮最后的位置，最后获取到排序的结果；
Demo

public class Bubbling {
    public static void main(String[] args) {
        int[] bub = new int[]{2, 4, 6, 8, 9, 1, 5, 3, 7};
        for (int i = 0; i < bub.length - 1; i++) {
            for (int j = 0; j < bub.length -1- i; j++) {
                if (bub[j] > bub[j + 1]) {
                    int tmp = bub[j + 1];
                    bub[j + 1] = bub[j];
                    bub[j] = tmp;
                }
            }
        }
        for (int n = 0; n < bub.length; n++) {
            System.out.println(bub[n]);
        }
    }
}

选择排序

介绍： 依次遍历数组的每一个小标位置的值，并将这个值与后续的每一个下标值比较，将大于/小于 的值赋值给当前下标值；则我们就能依次拿到排序后的每一个位置的值

Demo

public class SelectSort {
    public static void main(String[] args) {
        int[] sel = new int[]{2, 4, 6, 8, 9, 1, 5, 3, 7};
        for (int i = 0; i < sel.length - 1; i++) {
            for (int j = i; j < sel.length -1; j++) {
                if (sel[i]>sel[j+1]){
                    int tem =sel[i];
                    sel[i] = sel[j+1];
                    sel[j+1] = tem;
                }
            }
        }
        for (int n = 0; n < sel.length; n++) {
            System.out.println(sel[n]);
        }
    }
}

二维数组

释义： 二维数组可理解成，一条数组的每个小标位置上还挂着另外一条数组；即第二维的数组长度大小可以不一致；
注意： 创建时，第二维的数组长度可以先不指定，但是必须先指定第一维的长度；
Demo

public class TwoDimensional {
    public static void main(String[] args) {
        int[][] a = new int[3][];
        int[] one = new int[2];
        int[] two = new int[3];
        int[] three = new int[]{6};
        a[0] = one;
        a[1] = two;
        a[2] = three;
        a[0][0] = 1;
        a[0][1] = 2;

        a[1][0] =3;
        a[1][1] = 4;
        a[1][2] = 5;
        for (int i = 0;i< a.length;i++){
            for (int j=0;j<a[i].length;j++){
                System.out.println(a[i][j]);
            }
        }

    }
}

main函数参数数组

**注意：**args为启动时，传入的参数；即启动参数

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