java基础知识12_数组_排序练习：找最大值&互换位置

数组：

 数组是同一种数据类型数据的集合容器。

数组的定义格式：

• 数据类型[] 变量名 = new 数据类型[长度]；

分析数组：int[] arr = new int[50];

-左边： int[] arr：声明了一个int类型的数组变量， 变量名为arr。
        int：表示该数组容器只能存储int类型的数据。
        []：这是一个数组类型。
        arr：变量名。
-右边： new int[50]：创建了一个长度为50的int类型数组对象。
        new：创建数组对象的关键字。
        int：表示该数组对象只能存储int类型的数据。
        []：表示是数组类型。
        50：该数组最多能存储50个数据，即数组的容量。

数组的好处：

• 对分配到数组对象中的每一个数据都分配一个编号（或叫索引值、角标、下标），索引值的范围是从0开始，最大是：长度-1.

局部变量 与 成员变量：

 局部变量：如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。
 成员变量：是定义在方法之外、类之内的。

数组有一个length属性，可以查看数组的容量。例如arr.length。（注意length后不带()，带()的是方法，）

举例1：

public static void main(String[] args){
    int[] arr = new int[4];//定义一个数组arr,new是在堆内存中开辟一块空间的意思
    arr[0] = 10;
    arr[1] = 30;
    arr[2] = 50;
    arr[3] = 90;
    //利用数组的length属性，查看数组的容量
    System.out.println("数组的容量："+arr.length);
    System.out.println("arr[2]="+arr[2]);
    for(int index = 0;index<arr.length;index++){ //经常使用这种遍历的方式，输出数组中的值
        System.out.println(arr[index]);//循环，输出arr数组中的所有元素
    }
}

堆栈：

---

举例2：数组的内存分析

public static void main(String[] args){
    int[] arr1 = new int[1];
    int[] arr2 = new int[2];
    arr1[1] = 10;
    arr2[1] = 20;
    System.out.println(arr1[1]);//结果是10
}

例2的原理分析：

举例3：

public static void main(String[] args){
    int[] arr1 = new int[2];
    int[] arr2 = arr1;
    arr1[1] = 10;
    arr2[1] = 20;
    System.out.println(arr1[1]);//结果是20
}

举例4：

public static void main(String[] args){
    int[] arr1 = new int[2];
    arr1[1] = 100;
    int[] arr2 = arr1;//arr2跟arr1操作的是堆内存中同一个数组对象
    arr1[1] = 10;
    arr2[1] = 20;
    System.out.println(arr1[1]);//结果是20
}

例4的原理分析：

---

数组中常见的报错问题：

• 1、NullPointerException 空指针异常（举例5）
  原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。（引用类型变量是啥意思哩？就是除了八种基本数据类型的所有数据类型，都属于引用类型）

• 2、ArrayIndexOutOfBoundsException 索引值越界（举例6）
  原因：访问了不存在的索引值。

举例5：空指针错误NullPointerException

 public static void main(String[] args){
    int[] arr = new int[2];
    arr = null; //null意思是让该变量不要引用任何的对象，不要记录任何的内存地址。
    arr1[1] = 10;
    System.out.println(arr1[1]);//运行报错
}

例5运行报错：

例5原理分析：

---

举例6：ArrayIndexOutOfBoundsException 索引值越界

public static void main(String[] args){
    int[] arr = new int[4];
    arr[0] = 10;
    arr[1] = 30;
    arr[2] = 50;
    arr[3] = 90;
    System.out.println(arr[4]);//访问索引值为4的内存空间存储的值
}

例6运行报错：

---

数组的初始化方式

动态初始化：

数据类型[] 变量名 = new 数据类型[长度]；

静态初始化：

数据类型[] 变量名 = {元素1,,元素2,元素3,...}；

举例：

静态初始化 与 动态初始化 的选择：

• 如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。
• 如果数据一开始还不太明确，这时候就建议使用动态初始化。

举例：

public static void main(String[] args){
    int[] arr = new int[50];
    Scanner scanner = new Scanner(System.in);//new一个容器，准备向其中输入50个数据
    for(int i = 0;i<arr.length;i++){
        arr[i] = scanner.nextInt();
    }
}

---

练习：

需求1：找最大值

定义一个函数，接收一个int类型的数组对象，找出数组对象中的最大元素，返回给调用者

class Demo{
    public static void main(String[] args){
        int[] arr = {-12,-14,-5,-26,04};
        int max = getMax(arr);
        System.out.println("最大值："+max);
    }
    public static int getMax(int[] arr){
        int max = arr[0];//max用于记录最大值，默认从数组中第一个值开始取，逐个与后边的值进行对比
        for(int i = 1;i<arr.length;i++){
            if(arr[i]>max){//如果发现右边的值有元素比max大，那么max变量就记录该元素
                max = arr[i];
            }
        }
        return max;
    }
}

原理分析：

需求2：互换位置

• 选择排序（直接排序）：使用一个元素与其他的元素挨个比较一次，符合条件交换位置。

  找出数组中的最大值，并将其与数组中第一个元素调换位置。最终将数组中元素挨个对比，进行大小的依次排序。
  
  class Demo{
      public static void main(String args){
          int[] arr={12,5,17,8,9};
          selectSort(arr);
      }
      public static void selectSort(int[] arr){
          /*
          //把最大值放在首位置
          for(int i = 1;i<arr.length;i++){
              if(arr[i]>arr[0]){
                  //交换位置
                  int temp=arr[i];
                  arr[i]=arr[0];
                  arr[0]=temp;
              }   
          }
          //把老二排在第二个位置上
          for(int i = 2;i<arr.length;i++){
              if(arr[i]>arr[1]){
                  //交换位置
                  int temp=arr[i];
                  arr[i]=arr[1];
                  arr[1]=temp;
              }   
          }
          //由以上两段代码，引申出下边这段
          */
          for(int j=0;j<arr.length-1,;j++){ //控制的是轮数
              for(int i = j+1;i<arr.length;i++){ //每一轮里，找出最大值
                  if(arr[i]>arr[j]){
                      //交换位置
                      int temp=arr[i];
                      arr[i]=arr[j];
                      arr[j]=temp;
                  }   
              }
          }
  
          //遍历数组，查看效果
          System.out.print("目前的元素：");
          for(int i = 0;i<arr.length;i++){
              System.out.print(arr[i]+",");
          }
      }
  }
  运行结果：17,12,9,8,5，
  

  原理分析：
  

需求3：

• 冒泡排序：思想是使用相邻的两个元素，挨个比较一次，符合条件，交换位置。

  定义一个函数接收一个int类型的数组对象，把数组中的最大值放在数组中的最后一位。
  
  class Demo{
      public static void main(String[] args){
      }
      public static void bubbleSort(int[] arr){
          /*
          //把最大值放在最后一个位置
          for(int i = 0;i<arr.length-1;i++){  //找出一个最大值
              //相邻的元素比较
              if(arr[i]>arr[i+1]){
                  int temp = arr[i];
                  arr[i] = arr[i+1];
                  arr[i+1] = temp;
              }   
          }
          //把老二放在倒数第二个位置上
          for(int i = 0;i<arr.length-1-1;i++){  
              //相邻的元素比较
              if(arr[i]>arr[i+1]){
                  int temp = arr[i];
                  arr[i] = arr[i+1];
                  arr[i+1] = temp;
              }   
          }
          //由以上两段代码，优化为下边这段代码：
          */
          for(int j = 0;j<arr.length-1;j++){  //控制轮数
              for(int i = 0;i<arr.length-1-j;i++){  //找出一个最大值
                  //相邻的元素比较
                  if(arr[i]>arr[i+1]){
                      int temp = arr[i];
                      arr[i] = arr[i+1];
                      arr[i+1] = temp;
                  }   
              }
          }
          //遍历数组，查看效果
          System.out.print("目前的元素：");
          for(int i = 0;i<arr.length;i++){
              System.out.print(arr[i]+",");
          }
      }
  }
  

  原理分析：