数组

数组:
1、概念：一组相同类型的数据的组合
         数组也是一种引用类型，
2、名称：数组名称不是固定的，与存放的数据的类型有关。
         如:  存放一组int类型的数据，
          数组名称   int[]
       
          存放一组字符串数据
          数组名称   String[]

          存放一组Scanner类型的数据
          数组名称   Scanner[]

          存放一组字符类型的数据
          数组名称   char[]
3、元素的概念：
      数组中的每个数据，都是这个数值的元素。
4、数组的声明与初始化
     声明：元素类型[]  变量名;
           元素类型   变量名[];--不建议此写法
     变量的初始化的时机：2种
       (1)声明时直接初始化
       (2)先声明，再初始化(使用前初始化)
     数组的变量初始化：3种情况
           (1)静态初始化
          String[] names = {"A","B"};
          int[] nums = {};
       (2)动态初始化
          --规定数组长度的写法
            int[] ages = new int[length];
        其实有默认元素：
        整数类型：默认是0
        浮点数类型：默认0.0
        字符类型：默认'\u0000'
        布尔类型：默认false
        引用数据类型：默认值null

          --不规定长度的写法
        int[] ages = new int[]{};
        double[] counts = new double[]{1.2,3.14};

5、数组的长度：
     即数组元素的个数
     表示方式：变量名.length;
6、数组的下标(index):
      下标从0开始，最后一个元素的下标为：length-1;
      下标范围：0~length-1
7、数组元素的访问(查看):
      通过下标进行查看
      语法:变量名[index];
     
   元素的遍历(从头到尾依次查看)
   for(int i=0;i<变量名.length;i++){
    System.out.println(变量名[i]);
   }
8、数组元素的覆盖(赋值，替换)
      
      语法：变量名[index] = value;

9、数组间的赋值
    就是指变量之间的赋值。
    
    通过一个变量对数组的元素进行修改，
    那么与之相关的变量对应的数组的元素
    也会发生变化。
10、数组下标越界异常：
    java.lang.ArrayIndexOutOfBoundsException

    出现的原因：
        访问数组元素时的下标超出了范围
    正确范围：0~length-1
    错误下标：
           变量名[-1]
           变量名[length]

11、引用类型之Arrays
    是数组的工具类。此类提供了很多对数组操作的功能方法
    如：
    String info = Arrays.toString(数组名);
    Arrays.toString():此方法是将数组的元素
    一一拼接成字符串.
    格式如下：
       "[元素1,元素2,.....元素length-1]"

12、数组的复制
     
     数组的特点：一经创建，长度不可变。

     系统复制法：
       System.arraycopy(src,start1,des,start2,length);
       src:源数组，即被复制的数组名
       start1:源数组复制的开始下标
       des:目标数组，即复制到的数组名
       start2:目标数组复制的开始下标
       length:复制的长度

     工具类提供的复制方法:
      元素类型[] 变量名=Arrays.copyOf(src,newLength);
      src:源数组
      newLength:新数组的长度

     功能解释：从src的下标为0的元素开始复制
               复制到长度为newLength的新数组中
           新数组存放元素的开始位置为0
 =======================================================
数组的排序：
冒泡排序的基本思想：
   在要排序的数组中，对当前还未排好序的范围
   内的全部数，自上而下(自左到右)对相邻的两
   个数依次进行比较和调整，让较大的往下沉(
   或向右移)，较小的往上冒(或向左移)。即：
   每当两相邻的数比较后他们的顺序与排序要求
   相反时，就将他们互换。

冒泡排序的改进：
    对冒泡排序的常见的改进方法是 加入一个标志性的
    变量，用于标志某一轮排序过程中是否有数据交换，
    如果没有进行数据交换，则说明数据已经按照要求
    排列好，可立即结束排序，避免不必要的比较过程。
 冒泡排序的每一步详情
          第一轮：找最大值
          4>5  false  {4,5,2,3,1}
          5>2  true   {4,2,5,3,1}
          5>3  true   {4,2,3,5,1}
          5>1  true   {4,2,3,1,5}--排出5
          第二轮：找第二大
          4>2  true   {2,4,3,1,5}
          4>3  true   {2,3,4,1,5}
          4>1  true   {2,3,1,4,5}--排出4
          第三轮：找第三大
          2>3  false  {2,3,1,4,5}
          3>1  true   {2,1,3,4,5}--排出3
          第四轮：找第四大
          2>1  true   {1,2,3,4,5}--排出2 

                  for(int i=0;i<arr.length-1;i++){
            System.out.println("第"+(i+1)+"轮：");
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int t=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=t;
                }
                System.out.println(Arrays.toString(arr));
            }
        }

简单选择排序：基本思想如下
    在要排序的数组中，选择出最小(或者最大)的一
    个数与第一个位置的数交换；然后再剩下的数当
    中再找最小(或最大)的与第二个位置的数交换
    依次类推，直到第n-1个元素(倒数第二个)和第
    n个元素(最后一个数)比较为止。

    简单选择排序
          原始数据 {4,5,2,3,1};
          
          找出最小1  与4交换  {1,5,2,3,4}
          找出最小2  与5交换  {1,2,5,3,4}
          找出最小3  与5交换  {1,2,3,5,4}
          找出最小4  与5交换  {1,2,3,4,5}

           for(int i=0;i<arr1.length-1;i++){
            int min=arr1[i];
            int index=-1;
            boolean f=false;
            for(int j=i+1;j<arr1.length;j++){
                if(min>arr1[j]){
                    min=arr1[j];
                    index=j;
                    f=true;
                }
            }
            if(f){
                int t=arr1[i];
                arr1[i]=arr1[index];
                arr1[index]=t;
            }
            System.out.println(Arrays.toString(arr1));
        }
        System.out.println(Arrays.toString(arr1));
    }
工具类Arrays里的排序方法：
   Arrays.sort(数组名):对基本数据类型的数组
            与引用类型的数组都可排序

=====================================================
二维数组
概念：数组的元素依然是数组
     int[] a = {1,2,3,4}
     int[][] b={{1,2},{2,3,4,5,6},{1,2,3}}
访问： b[0]-->{1,2}
       b[1]-->{2,3,4,5,6}
       b[2]-->{1,2,3}

       b[0][0] -->1
       b[0][1] -->2
       .....
       b[1][3] -->5
       b[1][4] -->6
       ...
       b[2][1] -->2

       x={
          {1,2,3},
          {1,2,3},
      {4,5,6}
         }

       x数组的元素：都是等长的数组，类似于矩阵。

       y ={
       {1,2},
       {1,2,3},
       {1}
          }
       y数组的元素：不是等长的数组。

二维数组的初始化：
  静态初始化
      如：int[][] a = {{1},{1,2},{2,3,4}};
  动态初始化：
      (1)等长式初始化
          int[][] a = new int[3][2];
      表示a有三个元素，每个元素都是2个长度的数组。
      (2)只规定高维数组的长度
          int[][] a = new int[3][];
      表示a有三个元素，但是都是null.
      null在使用时，需要新建数组对象(长度任意)