• 三、数组


    1.数组的说明:
    数组(array):数的组合。-->多个相同数据类型的变量的组合
    目的:为了方便在内存中,对多个变量进行统一的管理。

    2.一维数组的声明与初始化
    正确的方式:
    //1.1数组的声明
    int scores[];
    String[] names;
    //1.2 初始化
    //静态初始化:数组的初始化和数组元素的赋值是同时进行的。
    scores = new int[]{60,70,80,90,100};
    //动态初始化:数组的初始化和数组元素的赋值是分开进行的。
    names = new String[4];

    int[] arr1 = {1,2,3};//简化写法:类型推断

    错误的声明方式:
    // int[] arr1 = new int[3]{1,2,4};

    // int[3] arr1 = new int[]{1,2,4};

    // int[] arr2;
    // arr2 = {1,2,3};

    3.一维数组元素的引用:通过下角标的方式调用。角标从0开始,到 数组的长度-1结束。
    names[0] = "张扬";
    names[1] = "杨睿";
    names[2] = "司马旭升";

    4.数组的属性:length:数组的长度
    //总结:不管是静态初始化,还是动态初始化,一旦数组初始化完成,其长度就是确定的!且其长度不可变!

    5.一维数组的遍历
    for(int i = 0;i < scores.length;i++){
    System.out.println(scores[i]);
    }

    6.一维数组元素的默认初始化值
    1 整型数组:byte、short、int、long的默认数组元素的初始化值都为:0
    2 浮点型数组:float、double 的默认数组元素的初始化值都为:0.0
    3 字符型数组:char的默认数组元素的初始化值都为:'u0000' 或 0 (不要理解为:'0')
    4 布尔型数组:boolean的默认数组元素的初始化值都为:false
    5 引用数据类型数组:数组、接口、类的默认数组元素的初始化值为:null

    7.一维数组的内存结构

    1.如何理解二维数组?

    1.数组本身属于引用数据类型
    2.数组的元素,可以基本数据类型,也可以是引用数据类型。

    3.二维数组的理解:一维数组中的元素,恰好又是一维数组。

    2.二维数组的声明与初始化
    正确的初始化方式:
    //1.1静态初始化
    String[][] arr1 = new String[][]{{"张扬","13200001111"},{"杨睿","13300001111"},{"杨飞","13400001111"}};
    //1.2动态初始化1
    int[] arr2[] = new int[3][2];
    //1.2动态初始化2
    int[][] arr3 = new int[3][];
    arr3[0] = new int[3];
    arr3[1] = new int[2];
    arr3[2] = new int[4];


    错误的初始化方式:
    // int[][] arr4 = new int[3][2]{{3,2},{3,2},{4,3}};
    // int[3][2] arr5 = new int[][]{{3,2},{3,2},{4,3}};


    3.如何引用二维数组元素:通过下角标的方式进行数组元素的调用
    System.out.println(arr1[1]);//地址值
    System.out.println(arr1[1][0]);

    4.二维数组的属性:length
    System.out.println(arr1.length);//3
    System.out.println(arr1[0].length);//2

    5.遍历二维数组元素
    for(int i = 0;i < arr1.length;i++){

    for(int j = 0;j < arr1[i].length;j++){
    System.out.print(arr1[i][j] + " ");
    }

    System.out.println();

    }


    6.二维数组元素的默认初始化值
    1.如果调用的是二维数组元素a,而元素a仍然是数组,根据元素a的数组元素的类型,决定其内部元素的默认初始化值。与一维数组的规定相同。
    2.如果输出元素a,其值决定于是否初始化过。如果初始化过,则输出其地址值。如果没初始化过,则值为null.

    short[][] arr1 = new short[3][2];
    System.out.println(arr1[0][1]);//0
    System.out.println(arr1[0]);//[S@15db9742
    System.out.println(arr1);//[[S@6d06d69c

    7.二维数组的内存结构

    1.针对于数值型的数组:
    求最大值、最小值、总和、平均值等
    2.数组的赋值与复制
    int[] array1,array2;
    array1 = new int[]{1,2,3,4};
    //赋值:
    array2 = array1;//将array1地址值赋给array2,array1和array2就指向堆空间中同一个数组
    //复制:重新创建一个数组array3,并将array1中的数据复制到array3中。
    int[] array3 = new int[array1.length];
    for(int i = 0;i < array1.length;i++){
    array3[i] = array1[i];
    }
    3.数组元素的反转
    //反转方式一:
    // for(int i = 0,j = arr1.length - 1;i < j;i++,j--){
    // String temp = arr1[i];
    // arr1[i] = arr1[j];
    // arr1[j] = temp;
    // }

    //反转方式二:
    // for(int i = 0;i < arr1.length / 2;i++){
    // String temp = arr1[i];
    // arr1[i] = arr1[arr1.length - 1 - i];
    // arr1[arr1.length - 1 - i] = temp;
    // }
    4.数组中指定元素的查找:①线性查找:普遍适用性 ②二分法查找:使用前提:数组是有序的。
    //线性查找
    String value = "CCC";
    int i = 0;

    for(;i < arr1.length;i++){
    if(arr1[i].equals(value)){
    System.out.println("找到指定元素,索引为:" + i);
    break;
    }
    }

    if(i == arr1.length){
    System.out.println("未找到指定元素");

    }

    //二分法查找:要求此数组必须是序的。
    int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
    boolean isFlag = true;
    // int number = 256;
    int number = 25;
    int head = 0;//首索引位置
    int end = arr3.length - 1;//尾索引位置
    while(head <= end){
    int middle = (head + end) / 2;
    if(arr3[middle] == number){
    System.out.println("找到指定的元素,索引为:" + middle);
    isFlag = false;
    break;
    }else if(arr3[middle] > number){
    end = middle - 1;
    }else{//arr3[middle] < number
    head = middle + 1;
    }
    }

    if(isFlag){
    System.out.println("未找打指定的元素");
    }
    5.数组的排序算法
    选择排序
    直接择排序、堆排序
    交换排序
    冒泡排序、快速排序
    插入排序
    直接插入排序、折半插入排序、Shell排序
    归并排序
    桶式排序
    基数排序

    理解:
    1)衡量排序算法的优劣:
    1.时间复杂度:分析关键字的比较次数和记录的移动次数
    2.空间复杂度:分析排序算法中需要多少辅助内存
    3.稳定性:若两个记录A和B的关键字值相等,但排序后A、B的先后次序保持不变,则称这种排序算法是稳定的。

    2)内部排序 与 外部排序

    冒泡排序的实现:--需要能手写出来

     1 //实现冒泡排序:从小到大
     2         for(int i = 0;i < arr.length - 1;i++){
     3 
     4         for(int j = 0;j < arr.length - 1 - i;j++){//比较相邻的两个元素的值所需要的索引
     5             if(arr[j] > arr[j + 1]){
     6                 int temp = arr[j];
     7                 arr[j] = arr[j + 1];
     8                 arr[j + 1] = temp;
     9             }
    10         }

    Arrays工具类的使用

     1         int[] arr1 = {1,2,2,34,5,6};
     2         int[] arr2 = {2,1,2,34,5,6};
     3         //1.equals():比较两个数组的元素,是否完全相同。
     4         boolean b = Arrays.equals(arr1, arr2);
     5         System.out.println(b);
     6         
     7         //2.toString():输出显示数组的具体的元素
     8         System.out.println(arr1);//地址值
     9         System.out.println(Arrays.toString(arr1));
    10         
    11         //3.将数组的所元素重新赋值,赋值为参数2的值
    12 //        Arrays.fill(arr1, 10);
    13 //        System.out.println(Arrays.toString(arr1));
    14         
    15         //4.sort():排序,底层使用的是快速排序实现的。
    16         Arrays.sort(arr1);
    17         System.out.println(Arrays.toString(arr1));//[1, 2, 2, 5, 6, 34]
    18         
    19         //5.binarySearch():使用二分法,在数组中查找指定元素的索引。前提:要求此数组是序的。
    20         int index = Arrays.binarySearch(arr1, 55);
    21         System.out.println(index);

    数组的常见异常

     1         //1.数组角标越界异常:ArrayIndexOutOfBoundsException
     2         int[] arr1 = new int[10];//角标:0-9
     3         
     4         arr1[0] = 10;
     5         arr1[9] = 20;
     6         
     7 //        arr1[10] = 30;
     8 //        arr1[-1] = 1;
     9         
    10         //2.空指针异常:NullPointerException
    11         //举例1:
    12 //        int[] arr2 = new int[10];
    13 //        arr2 = null;
    14 //        System.out.println(arr2[0]);//空指针异常
    15         
    16         //举例2:
    17 //        int[][] arr3 = new int[3][];
    18 //        System.out.println(arr3[0]);//null
    19 ////        arr3[0] = new int[]{1,2,3};
    20 //        System.out.println(arr3[0][0]);//空指针异常
    21         
    22         //举例3:
    23         String[] arr4 = new String[4];
    24         System.out.println(arr4[0].toString());
  • 相关阅读:
    链表详解自带代码
    队列
    单词翻转
    表达式求值
    一元多项式
    循环链表
    学生成绩管理系统
    双向循环链表
    双向链表
    静态链表
  • 原文地址:https://www.cnblogs.com/-hongchen/p/7469209.html
Copyright © 2020-2023  润新知