java笔记9----java中的数组

IT_4古月

已于 2022-01-21 12:03:28 修改

阅读量326

点赞数

分类专栏： java 文章标签： java 开发语言后端

于 2022-01-20 20:20:15 首次发布

本文链接：https://blog.csdn.net/qq_43303414/article/details/122609257

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

java数组

什么是数组？

数组（Array）是有序的元素序列。 [1] 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便，把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1] 这些有序排列的同类数据元素的集合称为数组。

上面时百度百科上对数组的解释，我们可以理解为：

数组是将具有相同数据类型的数据有序的组合在一起的集合，这样的集合就是我们的数组。

数组的定义格式

数据类型对象名称 [] = new 数据类型[数组长度];

数据类型 [] 对象名称 = new 数据类型[数组长度];

如：

/**
 * @author hgw
 * @date 2022年01月20日18:11
 **/
public class Test {
    public static void main(String[] args) {
        int arr[] = new int[5];       //new创建一个int类型的数组对象，并且开辟五个数组空间
        int[] arr2 = new int[5];
        int arr3[] = {1, 2, 3, 4, 56};     //创建一个int类型的数组对象，并直接开辟空间给数组赋值
        //下标        0  1  2   3  4    因为数组是一个有序的集合，数组的每个值都有对应的下标如：arr[0]的值为1对应下标为0，arr[1]的值为2对应的下表为1，数组的起始是从0开始的0，1，2，3......
    }
}

数组可以分为动态数组和静态数组

静态数组：数组创建的过程中直接开辟空间并且对数组进行复制操作。

/**
 * @author hgw
 * @date 2022年01月20日18:30
 **/
public class Test2 {
    public static void main(String[] args) {
        int arr[] = {1, 2, 3, 4, 56};
        String strs[] = new String[]{"星期一","星期二","星期三","星期四","星期五"};
    }
}

动态数组：暂时还没有往数组里存放数据，只是给数组开辟了空间，后面根据我们的需求用的时候再进给数组进行赋值操作

/**
 * @author hgw
 * @date 2022年01月20日18:30
 **/
public class Test2 {
    public static void main(String[] args) {        
        //动态数组
        int arr[] = new int[100];               //声明数组，并给数组开辟空间
        for (int i = 0; i < arr.length; i++) {  //通过循环给数组进行赋值操作    arr.length 获取位置数组的长度空间
            arr[i] = i;                         //给数组赋值
        }
        //使用for循环对数组进行遍历操作
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

上面使用数组名称.length可以获取数组的长度
System.out.print(arr[下标])根据小标输出某个数组元素
如果输出的数组下标元素不存在则会出现下面数组越界这个异常
ArrayIndexOutOfBoundsException

数组案例：

数组排序案例：

/**
 * @author hgw
 * @date 2022年01月08日17:21
 **/
public class SortUtil {
    /**
     * 冒泡排序  一个一个对比，先找出最大的放到最后
     * @author hgw
     * @date 2022/1/8 17:34
     * @param arr
     * @return int[]
     */
    public  static  int[] bubbleSort(int[] arr){
        for (int end = arr.length; end > 0 ; end--){
            for (int begin = 1; begin < end; begin++) {
                if (arr[begin] < arr[begin - 1]) {
                    int temp = arr[begin - 1];
                    arr[begin - 1] = arr[begin];
                    arr[begin] = temp;
                }
            }
        }
        return arr;
    }
    /**
     * 选择排序
     * @author hgw
     * @date 2022/1/8 18:00
     * @param arr
     * @return int[]
     */
    public  static  int[] chooseSort(int[] arr){
        for (int start = 0; start < arr.length; start++) {
            //定义一个变量 记录当前最小的下标
            int minIndex = start;
            //跟数组当中第一个元素之后每一个进行比较   找出最小的元素
            for (int next = start+1; next <= arr.length-1; next++) {
                //如果后面的值    有比前面的的要小    更新最小的下标
                if (arr[next] < arr[minIndex]) {
                    minIndex = next;
                }
            }
            //每次循环，把最小的下标找出来
            //把最小的角标与初始角标进行交换
            int temp = arr[minIndex];
            arr[minIndex] = arr[start];
            arr[start] = temp;
        }
        return arr;
    }

    /**
     * 插入排序
     * @author hgw
     * @date 2022/1/10 9:09
     * @param arr
     * @return int[]
     */
    public  static  int[] insertionSort(int[] arr){
        int i, j, t, h;
        for (i = 1; i < arr.length; i++) {
            t = arr[i];
            j = i - 1;
            while (j >= 0 && t < arr[j]) {
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = t;
        }
        return arr;
    }
}

数组查找案例：

使用二分法对查找数组中的目标元素。

/**
 * @author hgw
 * @date 2022年01月08日19:42
 **/
public class SearchUtil {
    /**
     * 二分法查找
     * @author hgw
     * @date 2022/1/8 19:51
     * @param arr
     * @param target
     * @return int
     */
    public static int binarySearch(int[] arr,int target) {
        //记录当前最小的下标和最大的下标
        int low = 0;
        int hight = arr.length-1;
        if (arr[low] > target || arr[hight] <target){
            return -1;
        }
        while (low<=hight){
            //计算中间值
            int mid = (low + hight) / 2;
            if (target == arr[mid]){
                return mid;
            }else if (target < arr[mid]){
                hight = mid -1;
            }else if (target > arr[mid]){
                low = mid +1;
            }
        }
        return -1;
    }
}

二维数组

二维数组可以理解为是一个数组中包含着多个数组

/**
 * @author hgw
 * @date 2022年01月20日19:53
 **/
public class Test3 {
    public static void main(String[] args) {
        //这是一个二维数组：二维数组可以理解为是一个二维数组下面有多个一维数组
        int arr[][] = new int[][]{{123},{12},{1,2,3,4,5,6}};
        int arr3[] = new int[]{1,2,3};
        int arr4[] = new int[]{1,2};
        int arr5[] = new int[]{1,2,3,4,5};
        //这个数组等于上面直接定义的二维数组，可以对比理解为是一个二维数组中包含多个一维数组
        int arr2[][] = new int[][]{arr3,arr4,arr5};

        //二维数组遍历使用双层for或者快速遍历，因为数组存在多行多列
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j] + "\t");
            }
            System.out.println();
        }

        //快速遍历
        /* 
        * 快速遍历格式：
        * for (数据类型 变量: 数据){
        *     循环体
        * }
        *  */
        for (int[] a: arr2
             ) {
            for (int b: a
                 ) {
                System.out.print(b + "\t");
            }
            System.out.println();
        }

    }
}

可变参数

最后还有一个可变参数问题

/**
 * 可变参数
 * @author hgw
 * @date 2022年01月20日20:12
 **/
public class Test4 {
    public static void main(String[] args) {
        int num = sum(1,2,3);
        System.out.println(num);
    }
    /**
     * 求n数之和方法
     * @author hgw
     * @date 2022/1/20 20:15
     * @param num 数组
     * @return int 数据类型
     */
    public static int sum(int...num) {      //这块就是说的可变参数，括号内可以防止多个形参，实质是一个数组
        int sum = 0 ;
        for (int i = 0; i < num.length; i++) {
            sum += num[i];
        }
        return sum;
    }
}