数组：一堆数放到一起

数组相当于一堆数方到一起。那么查看数组元素循环是必不可少的。

int[] newArray={1,2,3}; 

名词：newArray --数组变量      {1，2，3} --数组对象       1，2，3 --数组元素

声明数组:  类型[]  数组名；例如：int[] array;  String[] strall;

注意:1.数组变量是引用了具体数组对象

2.数组元素是自动初始化的，自动初始化为"零"值。零值包括0(整型)，0.0(浮点型)，\u0000(char)，false(boolean)，null(引用类型)

初始化数组:

java中的初始化分为两种方式：动态数组和静态数组

//声明和初始化一个数组

int[] array = new int[5];    //动态初始化，声明了一个长度为5的数组

array[0] = 1 ; //初始化值

int[] array1 = new int[1,2,3,4,5]; //静态初始化

int[] array2 = {1,2,3,4,5} //静态初始化，只能在声明数组变量时使用

数组元素的访问:通过数组元素角标操作数组(角标从0开始)

数组对象的大小是固定的，长度为n，则角标范围是[0~(n-1)]，注意不能角标越界。可以使用.length获取数组长度。

int[] arr = {1,2,5,8,7};

//获取第一个数

arr[0];

//获取第三个数b并接收，

int num = 0;

num = arr[2];

遍历数组

对于一个数组，想要获取其中的数据，可以通过循环下角标来获取。

例如：  对于数组：int[] numbers = {1,5,9,7,8,9};

//获取数组长度

int len = numbers.length;

//通过for循环遍历数组

for(int i = 0; i < len; i++){

System.out.print("数组元素："+numbers[i])

}

因为数组中的数据都是任意存储的，可以对数组进行排序操作

数组排序:

1.冒泡排序：对于一组要排序的元素列，依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面，依次换位，直到比较到最后两个数，全部排序完成

 

 代码实现：

//声明数组

int array[] ={23,12,9,45,55,2,99,3};

//对原数组进行遍历

for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]+" ");
    }

//冒泡排序,相邻的两个数进行比较

//外循环，控制循环次数

for(int i = 0;i<array.length;i++){

//第一次比较时，最后的数据不需要和自身比较，则需要比较的数-1，每比较依次，

//减少一个需要参与比较的数，那么对于内嵌for循环来说：条件-(1+每循环一次的一个数)

int len = array.length-1-i;

//内循环。控制需要参与比较的数

   for(int j = 0; j<len;j++){

        //根据角标操作数据比较大小

       if(array[j] >array[j+1] ){

       //相邻的两个数换位置，需要定义一个"小板凳",才能空出原来的位置

      //定义的小板凳

       int  nullDesk = array[j];

      //换位

      array[j] = array[j+1];

      array[j+1] = nullDesk;  

     }

   }

}

//冒泡排序成功后载遍历数组

2.选择排序：每一个数据与它之后的数据进行比较，每一次从待排序的数据元素中选出最大(小)的一个元素，存放到在序列的起始位置，知道全部待排序的数据元素排完。

 代码实现：

//声明数组

int array[] ={23,12,9,45,55,2,99,3};

//对原数组进行遍历

for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]+" ");
    }

//选择排序，每一个数据与它之后数据比较

//外循环，控制循环次数

for(int i = 0; i < array.length;i++){

    //内循环，每次都与自身之后的数据比较，对于内循环来说，从i+1开始循环

   for(int j = i+1; j<array.length;j++){

   //比较原理同上

   if(array[i] > array[j]){

  int nullDesk = array[i];

 array[i] = array[j];

array[j] = nullDesk;

    }

  }

}

//排序之后遍历数组

查角标

普通查找：在遍历数组过程中，判断数组中是否存在该值，如果存在，将角标返回

//查询99的角标

int  fin = 99;

//声明变量接收角标

int index = -1;

for(int i =0; i<array.length;i++){

       if(fin == array[i]){

    index = i;

    }

   }

System.out.println("角标为"+index);

折半二分查找：加快效率

//要查询的数

int numm = 99;

//查询到的角标

int indexx = -1;

//声明最小角标

int min = 0;

//声明最大角标

int max = array.length - 1;

//折半值

int mid = (max+min)/2;

//while循环

while(true){

//如果值大于中间值，折半后最小值为中间角标+1

  if(numm > array[mid]){

  min = mid + 1;

  }

//如果值小于中间值，折半后最大值为中间角标-1

 if(numm < array[mid]){

 max = mid -1;

 }

//如果折半后最小值大于最大值，发生错误，终止运行

if(min > max){

System.out.println("数据发生了错误");

break;

}

//折半进行查找

mid = (max+min)/2;

if(numm == array[mid]){

//查找到赋值indexx

indexx = mid;

break;

}

}

System.out.println("折半二分查到的角标"+indexx);

数组的扩容：

对给定的数组插入一个新的数据，最好能拍序后插入数据，这样可以准确获取要插入的数据在原数组中的角标，其他数据后移即可。

代码实现：

//声明要插入的数据 

int a = 101;

//声明一个新的数组，供插入一个数据

int[] newArray = new int[array.length+1];

//获取新数组的最大角标

int newIndex = newArray.length;

//找到要插入的数据在新数组中的角标

for(int i = 0; i<newarray,length;i++){

if(a<newArray[i]){

  newIndex = i;

   break;

}

}

//将新的数组插入新数组

//之前数据全部前移一位，这样角标newIndex空出来了，

for(int i = newArray.length-1;i>newIndex;i--){

newArray[i] = newArray[i-1];

}

//将空出的角标位置的值修改为要插入的a

newArray[newIndex] = a;

扩展：二维数组

    int[][]  a = new int[3][];
    int[] a1 = {56,89,23,45,70};
    int[] a2 = {65,23,89,20};
    int[] a3 = {10,50,90};
    a[0] = a1;
    a[1] = a2;
    a[2] = a3;
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a[i].length; j++) {
            for (int w = j+1; w < a[i].length; w++) {
                if(a[i][j]>a[i][w]){
                    int temp = a[i][j];
                    a[i][j] = a[i][w];
                    a[i][w] = temp;
                }
            }