Day06（数组，二维数组，栈和堆）

一、数组：存放同一种数据类型元素的集合，也可以看作是一个容器

       1、 特点：

            （1）元素的数据类型一致，可以存放基本数据类型，也可以存放引用数据类型

            （2）数组的长度是固定的。数组是存储同一种数据类型多个元素的集合。

            （3）数组有下标：0---length-1

       2、 数组的定义格式：

           （1）数据类型[] 数组名;（推荐使用第一种）

           （2）数据类型 数组名[];

         3、数组的初始化方式：

              （1）动态初始化：在定义时候只给定数组的长度，值是由系统默认给出的

          语句定义格式：数据类型[] 数组名 = new 数据类型[元素的个数];

         举例：int[] arr = new int[3];

           表示的是定义一个长度为3并且元素是int类型的一维数组

               （2）静态初始化：在定义的时候，就手动给出元素值

     语句定义格式：数据类型[] 数组名 = new 数据类型[] {元素值1,元素值2,……};

     简化格式：数据类型[] 数组名 = {元素值1,元素值2……};

                （3）Java在数组中提供了一个类似于下标的说法，我们可以通过下标获取到该下标位置上的元素，这个下标有一个专业的叫法：索引（index）,从左往右编码，从0开始

//定义一个数组静态初始化

int[] arr = {100,200,300,400};

System.out.println(arr);

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr[3]);

4、数组中常见的错误：

      （1）ArralndexOutOfBoundsException:5 数组索引越界异常，访问不该访问的索引。

      （2）NullPointerException 空指针异常

public static void main(String[] args){

   //定义一个数组，静态初始化

    int[] arr = {11,22,33,44,55};

    System.out.println(arr);

    System.out.println(arr[0]);

    System.out.println(arr[1]);

     System.out.println(arr[2]);

     System.out.println(arr[3]);

      System.out.println(arr[4]);

//     System.out.println(arr[5]);

        arr = null;

         System.out.println(arr[0]);

    }

}

5、数组遍历（依次输出数组中的每一个元素）

public class ArrayDemo7{

     public static void main(String[] args){

      //定义一个数组并动态初始化

//    int[] arr = new int[3]{11,22,33};

//注意动态初始化不能与静态初始化混合使用！！

      int[] arr = new int[8];

      //手动获取每个元素并赋值

      arr[0] = 11;

      arr[1] = 22;

      arr[2] = 33;

      arr[3] = 44;

      arr[4] = 55;

      arr[5] = 66;

      arr[6] = 77;

      arr[7] = 88;

      System.out.println(arr[0]);

      System.out.println(arr[1]);

      System.out.println(arr[2]);

      System.out.println(arr[3]);

      System.out.println(arr[4]);

      System.out.println(arr[5]);

      System.out.println(arr[6]);

      System.out.println(arr[7]);

//    System.out.println(arr[8]);

      System.out.println("=========用for循环改进=========");

      for(int i = 0;i <= 7;i++){

          System.out.println(arr[i]);

       }

       System.out.println("========用for循环改进2=========");

       /*由于上面的数组我们一眼就可以数清有多少个元素，所以在循环的时候，可以确定一个范围，但是呢在真正的开发中，数组中的元素远远不止这些，可能会有很多，这时候我们再去数的话，不仅会数错，而且消耗大量时间，那么怎么办？我想要用for循环，那就必须得确定一个范围，如果有一个办法可以获取数组的长度就好了，Java中数组提供了一个属性供我们使用，可以获取数组的长度，这个属性叫做：length，使用格式：数组名.length,当长度可以确定后，佛如、循环的索引范围就能确定了：length-1

*/

        int[] arr2 = {1,5,15,1,164,2341,56,41,5,1,54,5,156,4,541,5,61,51,56,1,21,6,1,561,23,1,56};

//      int length = arr2.length;

//      System.out.println(length);

//       [1,5,15,……]

         for(int i = 0;i<arr2.length;i++){

             if(i==0){

                 System.out.println("[" + arr2[i] + ",");

             }else if(i == arr2.length-1){

                  System.out.println(arr2[i] + "]");

             }else {

                   System.out.println(arr2[i] + ",");

              }

       }

        // \r\n是windows中的换行符

        System.out.println("\r\n===========将打印数组封装成一个方法============");

         printArray(arr2);

}

//定义遍历数组的方法

//返回值类型：void

//参数类型 int[] arr

public static void printlnArray(int[] arr){

     for(int i = 0;i<arr.length;i++){

         if(i==0){

             System.out.println("[" + arr[i] + ",");

         }else if(i==arr.length-1){

              System.out.println(arr[i] + "]");

          }else {

               System.out.println(arr[i] + ",");

           }

        }

     }

}

6、数组元素的逆序排列（就是把元素对调）

public class ArrayDemo9{

    public static void main(String[] args){

        int[] arr = {43,31,123,1,21};//========>{21,1,123,31,43}

        System.out.println("数组逆序之前：");

        printArray(arr);

        //将0索引位置的元素与length-1位置上的元素进行交换

        //将1索引位置的元素与length-1-1位置上的元素进行交换

        //直到length/2

        int temp = arr[0];

        arr[0] = arr[arr.length-1];

        arr[arr.length-1] = temp;

        int temp2 = arr[1];

        arr[1] = arr[arr.length-1-1]

        arr[arr.length-1-1] = temp2;

        //调用方法遍历数组

        System.out.println("\r\n数组逆序之后：");

        printArray(arr);

        System.out.println("\r\n============用for循环改进实现数组逆序1：==============");

        int niXuArray1 = niXu(arr);

        printArray(niXuArray1);

//      System.out.println("\r\n===========用for循环改进实现数组逆序2（创建新的数组）========");

//      int[] niXuArray2 = niXu2(arr);

//      printArray(niXuArray2);

        System.out.println("\r\n==========用for循环改进实现数组逆序3（定义指针）");

        int[] niXuArray3 = niXu3(arr);

        printArray(niXuArray3);

}

//    定义方法实现数组的逆序（方法3）指针

//    返回值类型：int[]

//    参数列表：int[] Array

public static int[] niXu3(int[] array){

    for(int start=0,end = array.length-1;start<=end;start++,end--){

         int temp = array[start];

         array[start] = array[end];

         array[end] = temp;

     }

      return array;

}

//   定义方法实现数组逆序（方法2）

//   返回值类型：int[]

//   参数列表：int[] array

//    这种方式不推荐：

//               1、由于创建了新的数组，开辟了新的堆内存空间，这样会造成内存资源浪费

//               2、题目本来的意思，在原数组上做逆序

public static int[] niXu2(int[] array){

    int[] arr2 = new int[array.length];

    for(int i =array.length-1;i>=0;i--){

        arr2[arr2.length-1-i] = array[i];

     }

     return arr2;

}

//         实现数组逆序的方法（方法1）

//         返回值类型：int[]

//         参数列表：int[] array

public static int[] niXu(int[] array){

    for(int index = 0;index<array.length/2;index++){

        int temp = array[index];

        array[index] = array[array.length-1-index];

        array[array.length-1-index] = temp;

     }

      return array;

}

7、数组遍历： 获取的长度的属性：length

                      使用格式：数组名.length

//    定义遍历数组的方法

//     返回值类型：void

//     参数列表：int[] arr

public static void printArray(int[] arr){

    for(int i = 0;i<arr.length;i++){

        if(i==0){

            System.out.print("[" +arr[i]+ ",");

         }else if(i==arr.length-1){

            System.out.print(arr[i] + "]");

          }else {

              System.out.print(arr[i]+ ",");

           }

    }

}

8、数组查表法（根据键盘录入索引，查找对应星期）

import java.util.Scanner

public class ArrayDemo10{

    public static void main(String[] args){

         String[] week = {"星期一","星期二","星期三","星期四","星期五"，"星期六"，"星期日"};

         //创建键盘录入对象

         Scanner sc = new Scanner(System.in);

         boolean flag = true;

         while (flag){

             System.out.println("请入数据（1-7）：");

             int numeber sc.nextInt();

             if (number >= 1 & numbei<7){

                 System.out.println(week[number - 1]);

             }else if (number == 0);{

                 flag = flase;

              }else {

                  System.out.println("输入的数据有误，请重新输入！");

               }

         }

     }

}

9、数组元素查找（查找指定元素第一次在数组中出现的索引）

举例：{12,32,12,43,53,32,100,12} 32在数组中第一次出现的索引为1

import java.util.Scanner;

public class ArrayDemo11 {

   public static void main(String[] args){

   // 定义一个数组并静态初始化

    int[] arr = {12,32,12,43,53,32,100,12};

    // 创建键盘录入对象

    Scanner sc = new Scanner(System.in);

     System.out.println("请输入你要查找的元素：");

     int number = sc.nextInt();

     for(int i = 0;i<arr.length;i++){

           if(arr[i]==number){

               System.out.println(number+ "2在数组中第一次出现的索引为"+i);

               //  正确的做法是查找到对应元素后，应该结束整个循环

               break；

            }

            if(i==arr.length-1 && arr[arr.length-1]!= number){

                 System.out.println("您要查找的元素" +number+ "不在数组中！")；

             }

          }

      }

}

二、栈和堆

     1、 JVM将内存划分成的5各部分

栈：局部变量和方法的调用

堆：new出来的东西都在堆里面

方法区：（面向对象的时候讲解）

本地方法区：(后面讲)

寄存器：（后面讲）

局部变量：定义在方法或方法内部的变量，称之为局部变量

【】定义一个数组并赋值：

int[] arr = new int[3];

System.out.println(arr);

System.out.println(arr[0]);   0 

System.out.println(arr[1]);   0

Sysrem.out.println(arr[2]);   0

 【】定义两个数组并赋值：

//定义第一个数组

int[] arr1 = new int[3];

arr1[0] = 11;

arr1[1] = 22;

arr1[2] = 33;

System.out.println(arr1);

System.out.println(arr1[0]);

System.out.println(arr1[1]);

System.out.prntln(arr1[2]);

//定义第二个数组

int arr2 = new int [4];

arr2[0] = 100;

arr2[1] = 200;

arr2[2] = 300;

System.out.println(arr2);

System.out.println(arr2[0]);

System.out.println(arr2[1]);

System.out.println(arr2[2]);

 【】两个数组共用一个地址：

//定义第一个数组

int[] arr1 = new int[3];

arr1[0] = 11;

arr1[1] = 22;

arr1[2] = 33;

System.out.println(arr1);

System.out.println(arr1[0]);     11 

System.out.println(arr1[1]);     22

System.out.println(arr1[2]);     33

//定义第二个数组的时候把第一个数组的地址赋值给第二个数组

 int[] arr2 = arr1;

arr2[0] = 100;

arr2[1] = 200;

System.out.println(arr1);

System.out.println(arr2);

System.out.println(arr1[0]);    100

System.out.println(arr1[1]);    200

System.out.println(arr1[2]);    33

三、二维数组：元素由一维数组组成的数组

      定义格式一：

        数据类型[][] 数组名 = 数据类型[m][n];

        m:表示的是有多少个一维数组

        n：表示的一维数组的个数

举例：int[][] arr = new int[3][2];

         表示的是定义一个有3个长度为2的一维数组组成的二维数组

         定义格式二：

        数据类型[][] 数组名 = new 数据类型[m][];

        m：表示的是有多少个一维数组

举例： int[][] arr = new int[4][];

        定义格式三：

          数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2,……},{元素1,元素2,元素3……}……};

           简化格式：数据类型[][] 数组名 = {{元素1,元素2,……},{元素1,元素2,元素3,……}……}

注意：

//定义一个二维数组使用格式一做初始化

int[][] arr = new int[3][2]

System.out.println(arr);

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

//想获取第一个一维数组中的第一个元素怎么办呢？

//首先，得获取第一个一维数组

//  int[] array1 = arr[0];

//  然后通过索引获取第一个元素

//   System.out.println(array1 [0]);

System.out.println(arr[0][0]);

System.out.println(arr[0][1]);

System.out.println(arr[1][0]);

System.out.println(arr[1][1]);

System.out.println(arr[2][0]);

System.out.println(arr[2][1]);

二维数组内存图：

  1、以下几种写法也是二维数组

            数据类型[] 数组名[];

            数据类型 数组名[][];

  2、格式3不能与格式1、格式2混合使用

           错误格式： int[][] arr = new int[2][]{{1,2},{3,1,2}};

3、二维数组的二遍历

例：数加科技

          十三期：小王，小李  十四期：小明，小刘，小张    十五期：小虎，小宇，小旺，小凯

十六期：小火，小杨，小爱，小周

public class Array2Demo4{

    public static void main(String[] args){

        //定义一个二维数组表示是一个数加科技

        String[][] shujia = {{"小王","小李"}，{"小明","小刘","小张"},{"小虎","小宇","小旺","小凯"},{"小火","小杨","小爱","小周"}};

         for (int i = 0;i < shujia.length;i++){

//            System.out.println(shujia[i]);

              //外层循环遍历到的是每一个一维数组

              //要想获取每个一维数组中的元素，再进行一次for循环遍历

              System.out.println("第" + (i + 1) + "个数组：");

               for (int j = 0;j < shujia[i].length; j++){

                    System.out.println(shujia[i][j]);

                   if(j == shujia[i].length-1){

                       System.out.print(shujia[i][j] + "]");

                   }else if(j == 0) {

                       System.out.print("[" + shujia[i][j] + ",");

                   }else {

                        System.out.print(shujia[i][j] + ",");

                    }

                 }

                 //每次内循环结束表示打印完一个一维数组，换行

                 System.out.println();

             }

    }

}

例：公司销售额求和

      某公司按照季度和月份统计的数据如下：单位（万元）

      第一季度：22，66，44

      第二季度：77，33，88

      第三季度：25，45，65

      第四季度：11，66，99

public class Array2Demo5{

     public static void main(String[] args){

        //定义一个二维数组表示是一个公司，每个季度相当于一个一维数组作为二维数组的元素传入

      int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

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

      //定义一个变量统计销售额

      int sum = 0;

      for (int i = 0;i<arr.length;i++){

          for(int j=0;j < arr[i].length;j++){

             sum = sum + arr[i][j];

          }

       }

        System.out.println("该公司的年销售额为：" + sum);

   }

}