2021-06-13课堂笔记

2021-06-13 课堂笔记

数组

• 数组是同一类型数据的有序集合
• 其中每个数据称为数组的元素，每个元素可以通过一个下标来访问它们

数组声明创建

• 首先必须声明数组变量，才能在程序中使用数组。比如

  dataType[] arrayReVar;//首选的方法
  或
  dataType arrayRefVar[];//效果相同，非首选
  

• java语言使用new操作符来创建数组，语法如下：

  dataType[] arrayRefVar = new dataType[arraySize];//必须声明数组的容量
  

• 数组的元素是通过索引访问的，数组索引从0开始

• 获取数组长度：

  arrays.length
  

for循环的快捷输入

100.for或fori

三种初始化

• 静态初始化

  int[] a = {1,2,3};
  Man[] mans = {new Man(1,1),new Man(2,2)};
  

• 动态初始化

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

• 数组的默认初始化

  • 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
  • 数组创建后每个元素初始值为0/null，赋值是新值覆盖了初始值

数组的四个基本特点

• 其长度是确定的。一旦被创建，容量不可变
• 其元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属于引用类型，数组也可看成对象，每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组边界

• 下标的合法区间：[0，length-1]，如果越界就会报错

  public static void main(String[] args){
  int[] a = new int[2];
  System.out.println(a[2]);
  }
  

• ArrayindexOutOfBoundsException:数组下标越界异常！

• 小结

  • 数组是相同数据类型(数据类型可以为任意类型)的有序集合
  • 数组也是对象，数组元素相当于对象的成员变量
  • 数组长度是确定的，不可变。如越界，会报错

示例1

package com.kuang.array;

public class ArrayDemo01 {
    //变量的类型 变量名 = 变量的值 ；
    //数组类型
    public static void main(String[] args) {
        int[] nums;//1、声明

        nums = new int[10];//2、创建

//        int[] nums2 = new int[20];//成熟的写法，声明+创建
        //3、给数组赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;//假如第十个元素未赋值，（int）即为0，（string）即为null

        System.out.println(nums[0]);
        System.out.println(nums[9]);

        //计算所有元素的和
        //获取数组长度
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {//i = 0和数组nums的排序从0开始相对应
            sum = sum + nums[i];
        }
        System.out.println("总和为："+ sum);
    }
}

示例2

package com.kuang.array;

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //打印全部的数组元素
        System.out.println(arrays[0]);
        System.out.println(arrays[1]);
        System.out.println(arrays[2]);
        System.out.println(arrays[3]);
        System.out.println(arrays[4]);

        System.out.println("==========");
        //试用循环来输出
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);

        }
        System.out.println("==========");

        //计算所有元素的和
        int sum = 0;
        for (int j = 0; j < arrays.length; j++) {
            sum = sum + arrays[j];

        }
        System.out.println("sum="+sum);

        System.out.println("==========");
        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i] > max){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);

    }
}

示例3

package com.kuang.array;

public class ArraysDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};


//        //JDK1.5，省去下标，增强型for循环
//        //适合打印输出，但要操作其中元素就不太方便
//        for (int array : arrays) {//第一个array代表数组内的每一个元素，第二个arrays代表数组
//            System.out.println(array);
//        }

//        printArray(arrays);//写好方法，这里直接使用，选择该方法的使用对象，比如针对arrays这个数组

        int[] reverse = reverse(arrays);
        printArray(reverse);

    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //关键在于如何反转
        for (int i = 0,j = arrays.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
    //写一个方法
    //用于打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

数组使用（示例见上文）

• 普通的for循环
• For-Each循环
• 数组作方法入参
• 数组作返回值

关于为什么我写的反转数组最后一个数会变成0？

注意事项：

1. 快捷注释ctrl+/
2. 大括号小括号的使用，在数组中，大括号内是具体的元素，小括号内是元素的序号
3. 代码的位置、层次，比如输入行应在循环外
4. for循环中，a++和++a的区别：不影响逻辑的情况下，尽量使用++a，两者输出的结果相同，运行时间有差别，计算量较大时a++明显耗时更长。因为a++需要一个临时变量去存储返回自增前的值，导致需要先申请一段内存空间，将值放入，不使用了才是释放。