Java基础--数组_怎么便历数组外层-CSDN博客

本文链接：https://blog.csdn.net/Gona_Shrimp/article/details/70141789

1.数组
定义：数组是存储同一种数据类型多个元素的集合，也就是存储相同类型数据的容器。
数组既可以存储基本类型，也可以存储引用类型
格式：
A:数据类型[] 数组名;
int[] arr;
int类型的数组 arr
B:数据类型数组名[];
int arr[];
int类型的 arr[]
初始化：
Java中的数组必须先初始化,然后才能使用。
所谓初始化
就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
a.动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
数据类型[] 数组名 = new 数据类型[数组长度];
b.静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化：数据类型[] 数组名 = {元素1,元素2,…};
获取数组元素：数组名[索引]；
数组常见的两个异常
a. ArrayIndexOutOfBoundsException:数组索引越界异常
访问了不存在的索引
b. NullPointerException:空指针异常
引用已经不再指向堆内存，变量可能为null
数组的便历：输出数组中的每个元素
数组遍历标准格式：
for(int x=0; x<数组名.length; x++) {
System.out.println(数组名[x]);
}
2.二维数组
定义：元素为一维数组的数组。
动态初始化方式一（指定有多少个长度相同的一维数组）：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示有多少个一维数组
n表示一维数组中有多少个元素
动态初始化方式二（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：
数据类型[][] 变量名 = new 数据类型[m][];
注：m这个数据必须给出，后面的数据可以不给
二维数组的静态初始化
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

public class arrayarraydemo {
//  二维数组的遍历
    public static void main(String[] args) {
//      定义一个静态数组
        int [][]arr1={{1,2},{1,2,3},{21,4,5},{23,45,5}};
//      定义一个含有三个一维数组的二维数组，一维数组有4个元素
        int [][]arr=new int[3][4];
//      定义一个含有三个一维数组的数组
        int [][]arr2=new int[3][];
        showarray(arr1);
    }
    public static void showarray(int arr1[][]){
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j]+" ");
            }
        }
    }

}

3 .冒泡排序
基本规则：相邻两个比较，大的放后面第一次排序完毕最大的元素在索引最大处，依此类推。
代码实现

public class bubblesort {
    public static void main(String[] args) {    
        int []a={1,223,34,532,64,8,56};
        bubbleSort(a);
        printArray(a);
    }
    public static void bubbleSort(int[] a){
    //冒泡排序方法，外层循环控制大的轮回，内层循环进行相邻两个元素比较把大的在//后面第一次轮回结束最大的元素在最后一位。
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j]>a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }               
            }
        }
    }
    //构造一个遍历数组的方法
    public static void printArray(int[] a){
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            if(i==a.length-1){
                System.out.print(a[i]);
            }
            else{
                System.out.print(a[i]+",");
                 }
        }
        System.out.println("]");
    }
}

4.选择排序
基本规则：从0索引处开始依次与后面的比较，第一次结束后最小的位于0索引处，依次进行
代码实现

public class selectSort {
    public static void main(String[] args) {
        int []arr={1,24,5,34,6,367,434,378};
        printArray(arr);
    }
    //选择排序
    public static void selectSort(int []arr){
        //使用两个for循环嵌套，假设i为最小数，用它跟数组中其他元素比较，
        //如果有比他小的就交换位置
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length; j++) {
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=arr[i];      
                }
            }
        }
    }
    //写一个遍历数组的方法
    public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                System.out.print(arr[i]);
            }else{System.out.print(arr[i]+",");
            ]
        }
        System.out.print("]");
    }
}