Java语言基础之数组

（一）什么是数组

                   1、概念：一组相同类型的数据的组合
                         数组也是一种引用类型，
                   2、数组名称不是固定的与存放的数据的类型有关。

举例：     

如：存放一组int类型的数据。，
    数组名称   int[]

    存放一组字符串数据
    数组名称   String[]

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

    存放一组字符类型数据
    数组名称   char[]

（二）数组元素

           元素的概念：
           数组中的每个元素都是这个数组的元素。

           修改数组中的元素

            /*将arr2的第一个元素更改为一千*/
                         arr2[0] = 1000;
                         for (int i = 0;i<arr2.length ;i++ ){
                               System.out.print(arr2[i]+"\t");
                          }

（三）数组的声明与初始化

            

声明：
        元素类型[]  变量名;
            元素类型[] 变量名[];-------不建议使用此写法

    初始化：
        是指第一次赋值
          变量的初始化时机：两种
            (1)声明时直接初始化
            (2)先声明在初始化 （使用前初始化）
          数组的变量初始化：三种情况
             (1)静态初始化
             String[] namas = {};
             int[] nums = {};
             (2)动态初始化
             --规定数组长度的写法
            int[] args = new int[length]
            其实有默认元素：
            整数类型：默认是0
            浮点书类型：默认是0.0
            字符类型：默认'\u0000'
            布尔类型：默认是false
            引用数据类型：默认值null
             --不规定数组长度的写法
            double counts  = new double []{1,2,3,4,5.7}

（四）数组的循环遍历

           使用for循环进行遍历

           举例：

                   /* 使用for循环进行遍历 */
                     for(int i=0;i<arr1.length;i++){
                          System.out.println(arr1[i]);

（五）数组的长度

    即数组元素的个数
    表示方式：变量名.length;

           length属性： 
                      - length表示数组的大小，即最多能够容纳多少个元素 
                      - length并不表示实际容纳元素的个数，因为数组初始化的null也会被计数

（六）数组的下标

                  下标从零开始，最后一个元素的下标为：length-1；
                  下标范围：0~length-1

（七）数组元素的访问（查看）
    通过下标进行查看
    语法：变量名[index]

（八）数组元素的覆盖（赋值，替换）
    语法：变量名[index] = value;

（九）数组间的赋值
    就是指变量之间的赋值
    通过一个变量对数组的元素进行修改
    那么与之相关的变量对应的数组的元素也会发生变化
        如：
               int[] a = {1,2,3};
               int[] b = a;
               通过b修改元素，a对应的数组也跟着改变
        
（十）数组下标越界异常
    出现的原因：
        访问数组元素时的下标超出了范围
        数组下标越界异常，编译器检查不出来此异常
        运行时才会出现，出现的结果造成了程序的中断结束。
        正确范围：0~length-1
        错误下标：变量名[-1]
              变量名[100]
      例：
    int[] scores = {1,2,10,100};
        System.out.println(Arrays.toString(scores));
        //创建5个长度的布尔数组fs
        boolean[] fs = new boolean[5];
        System.out.println(Arrays.toString(fs));

        //查看fs数组的第六个元素
        System.out.println(fs[5]);
        /* 数组下标越界异常，编译器检查不出来此异常
           运行时才会出现，出现的结果造成了程序的中断结束。
        */    

（十一）引用类型之Arrays

数组的工具类：Arrays
    使用步骤：
    1:导包
    2:调用其功能
    是数组的工具类。此类提供了很多对数组操作的功能和方法
    如：
    String info = Arrays.toString(数组名)
    Arrays.toString()：此方法是将数组元素一一拼接成字符串

（十二）数组的复制

    工具类的复制功能，此功能有扩容或缩容的效果。

    数组的特点：一经创建长度不可变。

    系统复制法：
        System.arraycopy(src,start,des,start2,length);
        src：表示原数组，及被复制的数组
        start1：原数组复制到的数组名

    工具类提供的复制方法：
        元素类型[] 变量名 = Arrays.copyOf(src,newLlength);

        功能解释：从原数组的下表为0的元素开始复制
            复制到长度为newLength的新数组中
            新数组存放元素的开始位置为0

数组学习的练习代码：

public class TestDemo01{
    public static void main(String[]args){
        /*
        定义一个字符数组chs，储存a~z
        
        定义一个int数组score用于存储这是个学生的成绩，成绩使用随机数[90,100]
        */

        /*定义一个字符数组chs，储存a~z*/
        char chs [] = new char[26];
        for(int i = 0;i<chs.length;i++ ){
            chs[i] = (char)(i+97);
            System.out.print(chs[i]+" ");
        }
        System.out.println();
        System.out.println("-------------分割线------------");
        /*定义一个String数组names存储10个学生的姓名，*/
        String names[] = new String[10];
        for(int i = 0;i<names.length;i++){
        names [i] = "小"+(i+1);
        System.out.print(names[i]+" ");
        }
        System.out.println();
        /*定义一个int数组score用于存储这是个学生的成绩，成绩使用随机数[90,100]*/
        System.out.println("-------------分割线------------");
        int scores[] = new int [10];
        for(int i=0; i<scores.length;i++ ){
            scores [i] = (int)(Math.random()*11+90);
            System.out.print(scores[i]+" ");
        }
        System.out.println();
        System.out.println("-------------分割线------------");
        int value = (scores[0]+scores[1]+scores[2]+scores[3]+scores[4]+scores[5]+scores[6]+scores[7]+scores[8]+scores[9])/10;
        System.out.println(value);
    
    }
} 

（十三）数组的排序

数组的排序：
冒泡排序的基本思想：
   在要排序的数组中，对当前还未排好序的范围
   内的全部数，自上而下(自左到右)对相邻的两
   个数依次进行比较和调整，让较大的往下沉(
   或向右移)，较小的往上冒(或向左移)。即：
   每当两相邻的数比较后他们的顺序与排序要求
   相反时，就将他们互换。

冒泡排序的改进：
    对冒泡排序的常见的改进方法是 加入一个标志性的
    变量，用于标志某一轮排序过程中是否有数据交换，
    如果没有进行数据交换，则说明数据已经按照要求
    排列好，可立即结束排序，避免不必要的比较过程。
 冒泡排序的每一步详情
          第一轮：找最大值
          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 

简单选择排序：

基本思想如下:
    在要排序的数组中，选择出最小(或者最大)的一
    个数与第一个位置的数交换；然后再剩下的数当
    中再找最小(或最大)的与第二个位置的数交换
    依次类推，直到第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}

工具类Arrays里的排序方法：
   Arrays.sort(数组名):对基本数据类型的数组
            与引用类型的数组都可排序