数组以及多维数组

2021.7.6

1.数组概述

• 数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 其中，每一个数据作一个数字严肃，每个数组元素可以听歌一个下标来访问它们

2.数组的声明和创建

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

  • 语法：

    dataType[] arrayRefVer;//首选
    

    或者：

    dataType arrarrefver[]
    

• Java语言中使用new操作符来创建数组，

  • 语法：

    dataType[] arrayRefVer = new dataType[arraySize];
    

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

• 获取数组的长度

  • 语法：

    array.length
    

          int[] nums;//声明数组
          int nums1[];//声明数组
          nums = new int[10];//给数组分配内存空间
          //或者下面一句话就可以
          int[] nums2 = new int[10];//动态初始化
          System.out.println(nums2.length);
  

3.数组三种初始化已经内存分析

• Java内存分析

  • 堆
    • 存放new的对象和数组
    • 可以被所有的线程共享，不会存放别的对象引用
  • 栈
    • 存放基本的变量类型（会包含这个基本类型的具体数值）
    • 引用对象的变量（会存放这个引用在堆里面的具体地址）
  • 方法区
    • 可以被所有的线程共享
    • 包含了所有的class和static变量

• 三种初始化

  • 静态初始化

    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;
    

  • 默认初始化

    数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每一个元素也被按照实例变量同样的方式被隐式初始化；

• 小结：

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

• 数组边界

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

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

    报错：ArrayIndexOutOfBoundsException

  • 数组是相同数据类型的有序集合

  • 数组也是对象。数组元素相当于对象的成员变量

  • 数组长度的确定后不可改变，如果越界，会报：ArrayIndexOutOfBoundsException

4.数组的使用

• 普通的for循环

  普通的for循环就是使用一个for循环来遍历一个数组的下标，然后可以通过操作数组的下标来对数组的元素进行一系列的操作哦，例如：

      public static void main(String[] args) {
          int[] nums = {1,2,3,4,5,6,7};
          for (int i = 0; i < nums.length; i++) {
              System.out.println(nums[i]);
          }
      }
  

• For-Each循环

  For-Each循环就是利用一个增强型的for循环来便利数组，相比于普通的for循环，Fro-Each循环使用数组的场景很小，一般就是快速得到一个数组的所有值，例如：

      public static void main(String[] args) {
  //        int[] nums = {1,2,3,4,5,6,7};
  //        for (int i = 0; i < nums.length; i++) {
  //            System.out.println(nums[i]);
  //        }
          for (int num : nums) {
              System.out.print(num);
          }
      }
  

  *注意：*jdk1.5以上的版本才有

• 数组作方法入参

  数组可以作为方法的参数，例如：

      public static void main(String[] args) {
          int[] nums = {1,2,3,4,5,6,7,8};
          Reverse1(nums);
      }
      //打印数组方法
      public static void PrintArray(int[] Arrays){//数组作为参数
          for (int i : Arrays) {
              System.out.print(i+" ");
          }
      }
  

• 数组作为返回值

  数组可以作为某些方法的返回值，例如：

      public static void main(String[] args) {
          int[] nums = {1,2,3,4,5,6,7,8};
          PrintArray(Reverse1(nums));
          System.out.println();
          PrintArray(Reverse2(nums));
      }
      //打印数组方法
      public static void PrintArray(int[] Arrays){
          for (int i : Arrays) {
              System.out.print(i+" ");
          }
      }
      //反转数组1
      public static int[] Reverse1(int[] Arrays){
          int[] result = new int[Arrays.length];
          for (int i = 0; i < Arrays.length; i++) {
              result[Arrays.length-(i%Arrays.length)-1] = Arrays[i];
          }
          return result;//作为返回值
      }
      //反转数组2
      public static int[] Reverse2(int[] Array){
          int[] result = new int[Array.length];
          for (int i = 0,j = Array.length-1; i < Array.length; i++,j--) {
              result[j] = Array[i];
          }
          return result;//作为返回值
      }
  

5.多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一位数组，其中每一个元素都是一个一维数组

• 二维数组

  int a[][] = new int[2][5];
  

  以上就可以看成是一个两行五列的数组

  int[][] array = {{1,2},{2,4},{4,5}}
  

  2021.7.9

冒泡排序

• 冒泡排序（Bubble Sort）是一种最简单的选择排序方法，它通过两两比较相邻记录的关键字，如果发生逆转，就进行交换，从而是关键字小的记录如气泡一般的往上浮，或者使关键字大的记录如石块一样往下沉

• 算法步骤;

  • 设数组A{1…n}是一个待排序的无序数组，首先，将第一个关键字A0与第二个关键字A2进行比较，如果满足A0>A1,则进行交换位置，然后比较A1和A2…依次类推，直到将An-1与An进行完比较之后第一次起泡排序完成。
  • 然后进行第二趟起泡排序，对前n-1个记录进行同样的排序
  • 重复上面的步骤直到没有交换记录为止，即排序结束

• 代码1：

      public static int[] BubblleSort1(int[] Arrays){
          int temp = 0;
          int flag = 1;
          int m = Arrays.length-1;
          while (m > 0 && flag == 1){
              flag = 0;
              for (int i = 0; i < m; i++) {
                  if(Arrays[i] > Arrays[i+1]){
                      flag =1;
                      temp = Arrays[i];
                      Arrays[i] = Arrays[i+1];
                      Arrays[i+1] = temp;
                  }
              }
              m--;
          }
          return Arrays;
      }
  

• 代码2：

      public  static int[] BubblleSort2(int[] Arrays){
          int temp = 0;
          //外层循环，判断要有多少次排序
          for (int i = 0; i < Arrays.length - 1; i++) {
              //内存循环，依次比较大小，然后交换位置
              for (int j = 0; j < Arrays.length-1-i; j++) {
                  if(Arrays[j] > Arrays[j+1]){
                      temp = Arrays[j];
                      Arrays[j] = Arrays[j+1];
                      Arrays[j+1] = temp;
                  }
              }
          }
          return Arrays;
      }