【JAVA】笔记（7）--- 数组精讲
数组的静态初始化：
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};
域名tln("遍历一维数组arr1：");
printArray1(arr1);
int [] [] arr2={ {4,5,6},{7,8,9,10},{11}};
域名tln("遍历二维数组arr2：");
printArray2(arr2);
}
//用来遍历 int 类型一维数组的静态方法
public static void printArray1(int [] array){
for(int i=0;i<域名th;i++){
域名tln(array[i]);
}
}
//用来遍历 int 类型二维数组的静态方法
public static void printArray2(int [] [] array){
for(int i=0;i<域名th;i++){
for (int j=0;j<array[i].length;j++){
域名t(array[i][j]+"\t");
}
域名tln();
}
}
}
运行结果：
--------------------------
遍历一维数组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 ; / 域名. * ;
3)方法返回值：若元素不存在，则返回 ” -1 “ ，若元素存在，则返回元素的数组下标；
4)栗子是最好的老师：
import 域名ys;
public class pra {
public static void main(String[] args) {
int [] a={5,6,1,8,4};
int index=域名rySearch(a,8);
域名tln(域名rySearch(a,8)==-1?"该元素不存在":"该元素的下标是："+index);
}
}
运行结果：
----------------------
该元素的下标是：3
Process finished with exit code 02.排序：
1)方法：Arrays . sort( 数组 )
2)方法所在包： java . util . Arrays ; / java . util . * ;
3)作用：将数组中的元素按从小到大排序 ；
4)栗子是最好的老师：
import 域名ys;
public class pra {
public static void main(String[] args) {
int [] a={5,6,1,8,4};
域名(a);
for (int i=0;i<域名th;i++){
域名tln(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];
域名tln("未接收拷贝数据的arr2：");
for (int i=0;i<域名th;i++){
域名tln(arr2[i]);
}
域名ycopy(arr1,0,arr2,0,域名th);
域名tln("接收了拷贝数据的arr2：");
for (int i=0;i<域名th;i++){
域名tln(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 域名.*;)
import 域名ys;
public class pra {
public static void main(String[] args) {
int [] a={5,6,1,8,4};
域名(a);
int index=域名rySearch(a,8);
域名tln(域名rySearch(a,8)==-1?"该元素不存在":"该元素的下标是："+index);
}
}
运行结果：
----------------------
该元素的下标是：4
Process finished with exit code 0注意：输出结果中的数组下标是指排序后的新数组的数组下标；
随笔：
1.对于要直接使用的方法来说，加上 static ，就十分方便了（不需要创建对象），比如上文中的遍历数组的方法；
2.可以直接向遍历数组的方法中传递一个静态数组：
printArray1 ( new int [ ] { 1,2,3 } ) ;
