Java数组-2022年4月17日

目录

• 数组
  • • 数组Array
    • 数组的常见异常
    • 数组的遍历
    • 数组的扩容
    • 数组类型的返回值
    • 可变长数组
    • 排序算法
    • 二维数组
    • 测试代码

数组

数组Array

ArrayList概念：一个连续的空间，存储多个相同数据类型的值

特点：

1. 类型相同

2. 长度固定

数组的创建

    数组类型[] 数组名 = new 数组类型[数组长度];
    //长度大小决定了你数组存储的大小

数组的声明和赋值：

数组的声明方式	具体声明赋值方法
先声明、分配空间	数据类型[] 数组名; 数组名 = new 数组类型[长度]；
声明并分配空间	数据类型[] 数组名 = new 数据类型[长度];
声明并赋值｛复杂版本｝	数据类型[] 数组名 = new 数据类型[]{value1,value2,....}
声明并赋值（简单版本）	数据类型 数组名[] = {value1，value2,.....}

注意：数组的下标是从0开始计数的

数组的常见异常

数组的使用： 创建数组，依次赋值，依次取值

有效下标范围: 0~（数组长度-1）

常见的数组异常就是数组下标越界：

报错： java.lang.ArrayIndexOutOfBoundsException: n ====>>此处的N表示的是你所访问的超出数组下标的无效下标

数组的遍历

• 就是从头到尾对数组每一个元素的访问
  
  可以通过下标依次进行访问，也可以通过循环来获取每个下标对应的数组中的值

//通过下标依次获取（for循环）
public void Test(){
    int i[] = {1,2,3,5,6,7,8};
    for (int i = 0; i<i.length;i++){
        System.out.println(i[i]);
    }
}

数组的扩容

扩容的思路：

1. 创建大于原数组长度的新数组；

2. 将数组中的元素依次赋值给新的数组中

赋值的方式：

循环遍历依次赋值（for）;

System.arraycopy(原数组,原始数组起始,新数组，新数组长度，长度);

java.util.Array.copyOf(原数组，新长度); //返回带有原值的新数组

数组类型的返回值

创建新数组，长度为原数组的两倍，新数组中保持原有数据，返回新数组

     public static void main(String args[]){
        int[] oa = {111,222,333,444,555,666};//0x0000A111
        int[] na = expand(oa);
        for (int i = 0;i<na.length;i++){
            System.out.println(na[i]);
        }
    }//主函数

    public static int[] expand(int[] oldArray){
        int[] newArray = new int[oldArray.length*2];
        for (int i = 0;i < oldArray.length;i++){
            newArray[i] = oldArray[i];
        }
        return newArray;
    }//数组扩容

可变长数组

    public static void printArray(int... Array){
        for (int i=0;i<Array.length;i++){
            System.out.println(Array[i]);
        }
    }//可变长数组

排序算法

    public static void bubbleSort(int[] array){
        //相邻的两个数值比较大小，互换位置
        System.out.println("bubbleSortTest=========");
        System.out.println(Arrays.toString(array));
        for (int i=0;i<array.length-1;i++){
            for (int j=0;j<array.length-1-i;j++){
                int temp = 0;
                if (array[j]>array[j+1]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
        forArray(array);
    }//冒泡排序

    public static void selectionSort(int[] array){
        //固定值与其他值依次比较大小，互换位置
        System.out.println("selectionSortTest========");
        System.out.println("原始数据值："+Arrays.toString(array));//转换成字符串输出

        for (int j = 0;j<array.length;j++){//需要经过N次对比
           int min_index = j;//假定这是最小值的下标
            for (int i=j+1;i<array.length;i++){//每轮需要对比的个数
                if (array[i]<array[min_index]){//比较前面确定的最小值和后面值的大小，如果后买的值值比面的值小就将下标进行替换
                    min_index=i;//把最小的下标转换过去
                }
            }
            if (j != min_index){//比较两个下标是否一样，一样的话就直接跳过
                int tmp = array[j];//将原始值赋值给tmp
                array[j] = array[min_index];//将最小值赋值给array[i]
                array[min_index] = tmp;//将最小值替换给tmp
            }
        }
        System.out.println("原始数据值："+Arrays.toString(array));
        forArray(array);
    }//选择排序

    public static void jdkSort(int[] array){
        //调用Java函数进行排序（java.util.Array.sort(数组名);===>默认升序）
        Arrays.sort(array);
        forArray(array);
    }//JDK排序

二维数组

概念：二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。

    public static void PrintAr2(){
        int[][] array;
        array = new int[][]{{1,2,3,4},{4,3,2,1}};
//        System.out.println(Arrays.toString(array[0]));//输出数组的内容
//        System.out.println(array[1][1]);//访问通过数组的下标进行访问{}==》代表的就是一个维度，合数组访问类似
        //遍历二位数组
        for (int i=0;i<array.length;i++){for (int j=0;j<array[i].length;j++){
        System.out.println(array[i][j]);
        }}
        }//二维数组创建和遍历

测试代码

public class demo_3 {
    public static void main(String args[]){
        int[] oa = {222,111,333,555,444,666};//0x0000A111
        int[] na = expand(oa);
//        for (int i = 0;i<na.length;i++){
//            System.out.println(na[i]);
//        }
//         printArray(oa);
//        bubbleSort(oa);
//
        selectionSort(oa);
        PrintAr2();
    }//主函数

    public static int[] expand(int[] oldArray){
        int[] newArray = new int[oldArray.length*2];
        for (int i = 0;i < oldArray.length;i++){
            newArray[i] = oldArray[i];
        }
        return newArray;
    }//数组扩容

    public static void printArray(int... Array){
        for (int i=0;i<Array.length;i++){
            System.out.println(Array[i]);
        }
    }//可变长数组

    public static void forArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println("Count is:" + array[i]);
        }
    }//遍历数组

    public static void bubbleSort(int[] array){
        //相邻的两个数值比较大小，互换位置
        System.out.println("bubbleSortTest=========");
        System.out.println(Arrays.toString(array));
        for (int i=0;i<array.length-1;i++){
            for (int j=0;j<array.length-1-i;j++){
                int temp = 0;
                if (array[j]>array[j+1]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
        forArray(array);
    }//冒泡排序

    public static void selectionSort(int[] array){
        //固定值与其他值依次比较大小，互换位置
        System.out.println("selectionSortTest========");
        System.out.println("原始数据值："+Arrays.toString(array));//转换成字符串输出

        for (int j = 0;j<array.length;j++){//需要经过N次对比
           int min_index = j;//假定这是最小值的下标
//            System.out.println(min_index);
            for (int i=j+1;i<array.length;i++){//每轮需要对比的个数
                if (array[i]<array[min_index]){//比较前面确定的最小值和后面值的大小，如果后买的值值比面的值小就将下标进行替换
                    min_index=i;//把最小的下标转换过去
                }
            }
            if (j != min_index){//比较两个下标是否一样，一样的话就直接跳过
                int tmp = array[j];//将原始值赋值给tmp
                array[j] = array[min_index];//将最小值赋值给array[i]
                array[min_index] = tmp;//将最小值替换给tmp
            }
        }
        System.out.println("原始数据值："+Arrays.toString(array));
        forArray(array);
    }//选择排序

    public static void jdkSort(int[] array){
        //调用Java函数进行排序（java.util.Array.sort(数组名);===>默认升序）
        Arrays.sort(array);
        forArray(array);
    }//JDK排序

    public static void PrintAr2(){
        int[][] array;
        array = new int[][]{{1,2,3,4},{4,3,2,1}};
//        System.out.println(Arrays.toString(array[0]));//输出数组的内容
//        System.out.println(array[1][1]);//访问通过数组的下标进行访问{}==》代表的就是一个维度，合数组访问类似
        /** 遍历二位数组*/
        for (int i=0;i<array.length;i++){for (int j=0;j<array[i].length;j++){
            System.out.println(array[i][j]);
        }}
    }//二维数组创建和遍历
}