数组的静态初始化：

1.一维数组：

int [ ] arr = { 1,2,3,4 } ;

Object [ ] arr = {   new Object ( ) , new Object ( ) , new Object ( ) , new Object ( )  } ;

注意：声明数组时，当数组元素类型为引用数据类型时，数组中既可以储存此引用数据类型，也可以储存此引用数据类型对应的子类

eg： Object [ ]  arr ={     new 任意类   }   //由于 “ Object 类是祖宗类（ java 中所有类的父类）“，所以 arr 数组中可以储存任意类型的对象，everyone ！！！

2.二维数组；

int [ ] [ ] arr = {    { 1,3} , {  2,3,6 } , {   1  } ,{  2,3,6,7  }   } ;

Object [ ] [ ] arr ={ 

                               {  new Object ( ) , new Object ( ) } ,

                               {  new Object ( )  }   ,

                               {   new Object ( ) ,new Object ( ) ,new Object ( )   } 

                             } ;  //二维数组这样写观感会更好一些，当然用一行代码也可以；

3.注意：静态初始化一定要在声明数组的同时初始化数组元素（数组的长度也会根据初始化时的元素个数而固定）

数组的动态初始化：

1.一维数组：

int [ ] arr = new int [ 打算为数组开辟 ？个 int 空间 ] ；

Object [ ] arr = new Object [ 4 ]   // 数组里 4 个 Object 空间，数组长度为 4  ，每个元素的初始值为 null ；

2.二维数组；

int [ ] [ ] arr = new int [ 二维数组里有几个一维数组 ] [ 每个一维数组里有几个元素 ] ;

Object [ ] [ ] arr = new Object [ 4 ] [ 5 ] ;  // arr 中有4个一维数组，每个一维数组的长度为5（有5个元素）；

3.注意：动态初始化不能在声明数组的同时初始化数组元素，但在访问数组中元素前一定不要忘记重新赋值数组元素（虽然不重新赋值化元素也不会报错，但此时元素装的只是个垃圾值）；

数组的遍历：

栗子是最好的老师：

 public class pra{
    public static void main(String[] args) {
        int [] arr1={1,2,3};
        System.out.println("遍历一维数组arr1：");
        printArray1(arr1);
        int [] [] arr2={ {4,5,6},{7,8,9,10},{11}};
        System.out.println("遍历二维数组arr2：");
        printArray2(arr2);
    }
    //用来遍历 int 类型一维数组的静态方法
    public static void printArray1(int [] array){
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
    //用来遍历 int 类型二维数组的静态方法
    public static void printArray2(int [] [] array){
        for(int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

运行结果：
--------------------------
遍历一维数组arr1：
1
2
3
遍历二维数组arr2：
4	5	6	
7	8	9	10	
11	

Process finished with exit code 0

数组特性：

1.数组中的各元素的内存地址是连续的；

2.每个元素占用的空间大小相同（大小取决于初始化时的数据类型）；

3.对于“ 要声明很多个相同数据类型的变量 ”的情况下，声明数组的方案是优选；

4.其实数组只是一个储存数组中第一个元素地址的容器；数组本身在栈内存中，其中的所有元素都按顺序，呈现条状储存在堆内存中；根据数组中储存的第一个元素的地址和不同的数组下标，就可以访问数组中其他的元素；

数组的 JVM 内存图：

如下图：

内存图解析：

像储存 int 这样的基本数据类型的变量 i ，就是直接储存的 “ 100 ” 的数据；

所有数组都是引用数据类型，像 int [ ]  array1 , 它储存了一串 int 数据中的第一个 int 的内存地址，地址对应的也就是堆内存中的“ 100 ”，这一串 int 数据的地址都是连续的，比如：100---0x11，5---0x12，23---0x13等等；

Person [ ]  array2 ，它储存的地址---0x22，对应的就是堆内存中“ 0x22 ”的那块空间，由于声明的是 Person 类型，所以堆内存“0x22”对应的那块空间中储存的也是地址---0x1234，这块地址对应的是 Person对象的内存空间，array2 中的其他的数组元素也是同理；

正如上图，一个数组为数组元素在堆内存中开辟的空间都是“ 条状 ” 的；

工具类方法---数组元素查找 ,排序，数组拷贝：

1.数组元素查找：

1)方法：Arrays . binarySearch ( 数组 , 数组元素 )

2)方法所在包： java . util . Arrays ;  /    java.util. * ;

3)方法返回值：若元素不存在，则返回 ” -1 “ ，若元素存在，则返回元素的数组下标；

4)栗子是最好的老师：

import java.util.Arrays;
public class pra {
    public static void main(String[] args) {
        int [] a={5,6,1,8,4};
        int index=Arrays.binarySearch(a,8);
        System.out.println(Arrays.binarySearch(a,8)==-1?"该元素不存在":"该元素的下标是："+index);
    }
}

运行结果：
----------------------
该元素的下标是：3

Process finished with exit code 0

2.排序：

1)方法：Arrays . sort( 数组 )

2)方法所在包： java . util . Arrays ;   /    java . util . * ;

3)作用：将数组中的元素按从小到大排序 ；

4)栗子是最好的老师：

import java.util.Arrays;
public class pra {
    public static void main(String[] args) {
        int [] a={5,6,1,8,4};
        Arrays.sort(a);
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

运行结果：
------------------------------
1
4
5
6
8

Process finished with exit code 0

3.数组拷贝；

1)方法：System . arraycopy ( 数组1，数组1起点下标，数组2，数组2起点下标，拷贝长度 ) ;

2)作用：以数组1起点下标，作为复制位置起点，以数组2起点下标，作为粘贴位置起点，拷贝长度作为拷贝元素个数；

3)栗子是最好的老师：

public class pra {
    public static void main(String[] args) {
        int []arr1={1,2,3};
        int []arr2=new int [5];
        System.out.println("未接收拷贝数据的arr2：");
        for (int i=0;i<arr2.length;i++){
            System.out.println(arr2[i]);
        }
        System.arraycopy(arr1,0,arr2,0,arr1.length);
        System.out.println("接收了拷贝数据的arr2：");
        for (int i=0;i<arr2.length;i++){
            System.out.println(arr2[i]);
        }
    }
}

运行结果：
-----------------------------
未接收拷贝数据的arr2：
0
0
0
0
0
接收了拷贝数据的arr2：
1
2
3
0
0

Process finished with exit code 0

4)注意：实际拷贝的不是拷贝对象，而是拷贝对象的地址 ；

二分法查找：

1.概念：建立在对数组排序的基础上，查找数组中某一元素；

2.优点：降低了" 查找数组某一元素 "代码执行的复杂程度，使查找时间大幅度缩减；

3.栗子是最好的老师：

//先导包：(当然也可以写成:import java.util.*;)
import java.util.Arrays;
public class pra {
    public static void main(String[] args) {
        int [] a={5,6,1,8,4};
        Arrays.sort(a);
        int index=Arrays.binarySearch(a,8);
        System.out.println(Arrays.binarySearch(a,8)==-1?"该元素不存在":"该元素的下标是："+index);
    }
}

运行结果：
----------------------
该元素的下标是：4

Process finished with exit code 0

注意：输出结果中的数组下标是指排序后的新数组的数组下标；

随笔：

1.对于要直接使用的方法来说，加上 static ，就十分方便了（不需要创建对象），比如上文中的遍历数组的方法；

2.可以直接向遍历数组的方法中传递一个静态数组：

printArray1 (  new int [ ] {   1,2,3  }  )  ;