小白-Java数组

数组

1. 数组的定义

  数组是相同类型数据的有序集合。
  数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
  其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。
  数组的四个基本特点：
        1.其长度是确定的。数组一旦被创建，它的大小就是不可改变的。
        2.其元素必须是相同类型，不允许出现混合类型。
        3.数组中的元素可以是任何数据类型，包括基本类型和引用类型。
        4.数组的变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

2. 数组声明创建

  首先必须声明数组变量，才能在程序中使用数组，下面是声明数组变量的语法：
        dataType[] arrayRefVar；//首选方法
        dataType arrayRefVar[]；//效果相同，但不是首选方法。
  Java语言使用new操作符来创建数组，语法：
        dataType[] arrayRefVar = new dataType[arraySize];
  数组的元素是通过索引访问的，数组索引从零开始。
  获取数组长度：arrays.length
  实例：
  public class ArrayDemo01 {
      public static void main(String[] args) {
          int[] nums = new int[10];
          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 sum = 0;
          for (int i = 0; i <nums.length ; i++) {
              sum = sum + nums[i];
          }
          System.out.println(sum);
      }
  }

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;
        数组的默认初始化：
              数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
  数组边界：
        下标的合法区间：[0，length-1]，如果越界就会报错：
        public class ArrayDemo02 {
            public static void main(String[] args) {
                int[] a = new int[2];
                System.out.println(a[2]);
            }
        }
  报错：
        ArrayIndexOutOfBoundsException：数组下标越界异常。

4. 数组的使用

  For-Each循环：
        public class ArrayDemo02 {
            public static void main(String[] args) {
                int[] arrays = {1,2,3,4,5};
                for (int array : arrays) {
                    System.out.println(array);
                }
            }
        }
  数组作方法入参：
        public class ArrayDemo02 {
            public static void main(String[] args) {
                int[] arrays = {1,2,3,4,5,6};
                printArray(arrays);
            }
            //打印数组元素
            public static void printArray(int[] arrays){
                for (int i = 0; i < arrays.length; i++) {
                    System.out.println(arrays[i]+"");
                }
            }
        }
  反转数组：
        public class ArrayDemo03 {
            public static void main(String[] args) {
                int[] arrays = {1,2,3,4,5,6};
                int[] reverse = reverse(arrays);
                printArray(reverse);
            }
            //反转数组
            public static int[] reverse(int[] arrays){
                int[] result = new int[arrays.length];
                //反转操作
                for (int i = 0,j = result.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.println(arrays[i]+"");
                }
            }
        }

5. 多维数组

  多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
  二维数组：int[][] a = new int[2][5];

6. Arrays类

  1.数组的工具类：java.util.Arrays
  2.由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
  3.Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用。
  4.具体一下常用功能：
        给数组赋值：通过fill方法。
        对数组排序：通过sort方法，按升序。
        比较数组：通过equals方法比较数组中元素值是否相等。
        查找数据元素：通过binarySearch方法能对排序好的数组进行二次查找法操作。
  实例：
  public class ArrayDemo05 {
      public static void main(String[] args) {
          int[] a = {45,1,8,6,35,97,15,24};
          System.out.println(a);
          //数组排序
          Arrays.sort(a);
          //  数组填充
          Arrays.fill(a,0);
          //打印数组元素
          System.out.println(Arrays.toString(a));
      }
  }

7. 冒泡排序

  public class ArrayDemo06 {
      public static void main(String[] args) {
          int[] a = {12,5,3,20,7,15,65,1};
          //调用完我们自己写的排序方法以后，返回一个排序后的数组
          int[] sort = sort(a);
          System.out.println(Arrays.toString(sort));
      }
      //冒泡排序
      //1.比较数组中，两个相邻的元素，如果第一个比第二个大，交换位置
      //2.每一次比较都会产生一个最大或最小的数字
      //3.下一轮可以少一次排序
      //4.依次循环，直到结束
      public static int[] sort(int[] array){
          //临时变量
          int temp = 0;
          //外层循环，判断我们这个要走多少次
          for (int i = 0; i < array.length - 1; i++) {
              //通过flag标识位较少没有意义的比较
              boolean flag = false;
              //内层循环，比较判断两个数，如果第一个比第二个大，交换位置
              for (int j = 0; j < array.length - 1 - i; j++) {
                  if (array[j+1] < array[j]){
                      temp = array[j];
                      array[j] = array[j+1];
                      array[j+1] = temp;
                      flag = true;
                  }
              }
              if(flag == flase){
                    break;
              }
          }
          return array;
      }
  }