Java(数组、数组的排序)

2020-01-13

数组（引用类型）

  作用：提供一个存储空间，存储同类型的数据元素的集合（数字、字符串）；
  声明定义：变量类型[] 数组名；或者 变量类型 数组名[]；
  分配空间：数组名 = new 数据类型[长度]；
        变量类型[] 数组名 = new 数据类型[长度]；
  数组赋值： 数组名[] = 值;
            变量类型[] 数组名 = new 数据类型[长度]{值1,值2,值3...,值n};
            变量类型[] 数组名 = {值1,值2,值3...,值n};
     例如： 
     int array[] = new int[4];
            array[0] = 60;
            array[1] = 70;
            array[2] = 80;
     array[3] = 90;
     for (int i = 0; i < 4; i++) {
        System.out.println(array[i]);
     } 

数组用到的关键字：length

  用法：数组名.length

数组例题

  public class Demo02 {
      public static void main(String[] args) {
      //给长度为20的数组随机赋值1-10
           int[] arr = new int[20];
          for (int i = 0; i <arr.length ; i++) {
              Random ra = new Random();
              int x = ra.nextInt(10)+1;
              arr[i] =x;
              System.out.println(arr[i]);
          }
    //求数组中最大值max
          for (int i = 0; i   <arr.length-1 ; i++) {
              int max;
              if(arr[i]>arr[i+1]){
                  max =arr[i];
                  arr[i] = arr[i+1];
                  arr[i+1] = max;
              }
          }
          System.out.println("数组最大值为："+arr[arr.length-1]);
    //求数组中最小值min
          for (int i = 0; i <arr.length- 1; i++) {
              int min;
              if(arr[i]<arr[i+1]){
                  min =arr[i];
                  arr[i] = arr[i+1];
                  arr[i+1] = min;
              }
          }
          System.out.println("数组最小值为："+arr[arr.length-1]);
    //求数组中所有数字的平均值avg
          int sum=0;
          for (int i = 0; i < arr.length; i++) {
              sum +=arr[i];
          }
          System.out.println("平均值为："+(double)sum/arr.length);
          System.out.println("总和为："+sum);
      }
      }

排序算法

  冒泡排序：前一个数和后一个数进行比较，如果比它大，就交换位置
        例如：
          public static void main(String[] args) {
          int[] arr = {18, 58, 65, 78, 88, 98};
          int temp;
          for (int i =1 ; i <arr.length ; i++) {
              for (int j = 0; j <arr.length-i ; j++) {
                  if (arr[j] > arr[j + 1]) {
                      temp = arr[j];
                      arr[j] = arr[j + 1];
                      arr[j + 1] = temp;
                  }
              }
         }
                for (int i = 0; i <arr.length ; i++) {
                    System.out.print(arr[i]+"  ");
                }
                }

函数排序：调用Util包下Arrays类下的方法

        Arrays类里面可以调用sort方法，进行递增排序，可用toString直接输出排序数组；
        例如：
                int[] arr = {98, 78, 88, 58, 18, 68};
          //对数组进行升序排序
                Arrays.sort(arr);
          //方法一：循环输出
                for (int i = 0; i <arr.length ; i++) {
                    System.out.print(arr[i]+"  ");
          }
          //方法二：toString方法直接输处
                System.out.println(Arrays.toString(arr));

选择排序：

  需要两层for循环，外循环i变量，内循环j变量；通过比较array[i]和array[j]
  第一趟：i=0；j=1；array[0] 和 array[1] 比较，如果array[0] 大于 array[1],则用一个容器temp用来交换这两个值。
        接着i=0，j=2；array[0] 和 array[2]  比较，如果arrat[0] 大于 array[2]，则用容器temp交换这两个值。
        。。。
  第二趟：i=1;j=2;......
  

  例如： 
     //对数组进行选择排序（值排序）
          int[] arr = {98, 78, 88, 58, 18, 68};
          int temp = 0;
          for (int i = 0; i <arr.length ; i++) {
              for (int j = i+1; j <arr.length ; j++) {
                  if(arr[j]<arr[i] ){
                      temp    =  arr[i];
                      arr[i] =arr[j];
                      arr[j] = temp;
                  }
              }
              }
          for (int j = 0; j <arr.length ; j++) {
              System.out.print(arr[j]+"  ");
          }
  

    //选择排序；下表交换        
            public static void main(String[] args) {
                int[] arr = {98, 78, 88, 58, 18, 68};
                int temp = 0;
                for (int i = 0; i < arr.length - 1; i++) {
                    int min = i;
                    for (int j = i + 1; j < arr.length; j++) {
                        if (arr[min] > arr[j]) {
                            min = j;
                            System.out.println(min);
                        }
                    }
                    if (min != i) {
                        temp = arr[i];
                        arr[i] = arr[min];
                        arr[min] = temp;
                    }
                        }
                        for (int i = 0; i < arr.length; i++) {
                            System.out.print(arr[i] + "  ");
                        }
                    }

二维数组

    常见的多维数组是二维数组，二维数组是由多个一维数组组成，每个一维数组都是二维数组的元素，二维数组的长度是一维数组的个数。

  二维数组的声明：变量类型[][] 数组名 = new 变量类型 [二维数组的长度][一维数组的长度];//注意：一维数组的长度不一定是一样，会留空；
        例如：创建一个二维数组Student，里面有三个学生，每个学生都有姓名和年龄。
              
  二维数组的打印：需要遍历，嵌套for循环；第一个for循环的变量代表二维数组的下标，第二个for循环的变量代表一维数组的长度。                      
     // 例如：创建一个长度是4的二维数组，其中的元素分别是{1},{1,2},{1,2,3},{1,2,3,4}
                int[][] barr=new int[][]{{1},{1,2},{1,2,3},{1,2,3,4}};
               //遍历二维数组
                for (int i = 0; i < barr.length; i++) {//i表示二维数组下标 //barr.length表示二维数组的长度
                    for (int j = 0; j < barr[i].length; j++) {//一维数组的长度//num[i].length在一维数组里受i的影响
                        System.out.print(barr[i][j] +"  ");
                    }
                }