java数组
数组：相同类型数据的有序集合
(1)数组：是引用数据类型；
(2)new：关键字，在堆内存开辟空间；
成员变量（堆内存）：有默认值
局部变量（栈内存）：没有默认值，使用之前一定手动赋值；
(3)引用变量赋值：
int[] arr1={6,7,8};
int[] arr2=arr1;//引用变量，把arr1的值赋给arr2;
arr1和arr2指向的是堆内存的同一块空间。
数组特性：数组的特性：相同类型数据的有序集合
(1)数组的定义：int[] scoreArr=new int[10];
(2)数组是引用数据类型：scoreArr是引用类型的变量，new关键字在堆内存里开辟空间。
(3)如何访问数组元素呢？数组是有顺序的，下标（索引）顺序。索引编号从0开始，到【数组元素的个数-1】。最大索引:数组长度-1。
scoreArr[0]=97;
数组名[索引值]；
(4)数组的元素类型必须和声明的类型一致，数组里元素类型是相同的，不能是混合类型。
(5)数组可以是:基本数据类型和引用数据类型(如String)。
(6)数组的长度:scoreArr.length;
数组名.length;
(7)数组长度一旦声明，就固定了。
(8)数组元素有默认值：
int:0;
double:0.0;
char:‘u0000’;
boolean:false;
String:null;—>引用数据类型的数组，默认值都是null。
数组初始化：
静态初始化：数组的声明，分配空间，赋值在一条语句里；
int[] scoreArr=new int[]{1,2,3,4,5};
int[] scoreArr={1,2,3,4,5};
2.动态初始化：数组的声明，分配空间，赋值【不】在一条语句里；
int[] scoreArr;//声明一个数组变量；
scoreArr=new int[5];//分配空间；
//给数组元素赋值； scoreArr[0]=1; scoreArr[1]=5; scoreArr[2]=5; 3.默认初始化：int[] scoreArr=new int[10];
数组声明的多种方法：
int[] scoreArr=new int[10];
int scoreArr[]=new int[10];
int[][] scoreArr;
int scoreArr[][];
int[] scoreArr[];
遍历数组
普通for循环 通过表历数组索引遍历数组
int[] array=new int[]{1,2,3,23,42,23253,1233,21341,21};
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
for-each循环： (1)jdk1.5引入；
(2)优点：简单；
(3)缺点：不能进行与索引有关的操作；
(4)如果只需遍历数组，用for-each循环
int[] array=new int[]{1,2,3,23,42,23253,1233,21341,21};
for (int i:array
) {
System.out.println(i);
}
数组常见异常
数组越界异常：(1)java.lang.ArrayIndexOutOfBoundsException: 6:
int[] scoreArr;
scoreArr=new int[5];//分配空间；
//给数组元素赋值；
scoreArr[0]=1;
scoreArr[1]=5;
scoreArr[2]=5;
//java.lang.ArrayIndexOutOfBoundsException: 6:数组越界异常。
System.out.println(scoreArr[6]);
空指针异常： java.lang.NullPointerException
int[] scoreArr1=null;//声明一个数组变量；
System.out.println(scoreArr1.length);// java.lang.NullPointerException;
数组查询
(1)按【索引】查询；效率高，数组在内存中分配的是【连续的】空间；
找到索引为i的元素的地址=首地址+每个元素所占的空间大小*索引值；
//定义一个数组；
int[] scoreArr={97,85,96,99,59,60,99,100,95,65};
//(1)查第6位同学的分数；
System.out.println(scoreArr[5]);
(2)按【值】查询：效率低，
从头开始依次查每个元素；
1.可能查到；
2.可能查不到；
3.如果数组是有序的，可以用二分法查询。
//定义一个数组；
int[] scoreArr={97,85,96,99,59,60,99,100,95,65};
//查询有没有100分；
int index=-1;
for(int i=0;i
}
数组修改
按索引修改
(1)按【索引】修改；效率高，数组在内存中分配的是【连续的】空间；
找到索引为i的元素的地址=首地址+每个元素所占的空间大小*索引值；
//定义一个数组；
int[] scoreArr={97,85,96,99,59,60,99,100,95,65};
//(1)修改第6位同学的分数；
scoreArr[5]=100;
System.out.println(scoreArr[5]);
按值修改
(2)按【值】修改：效率低，
从头开始依次查每个元素；符合条件的元素修改。
//(2)修改:把59分提成60分；
int index=-1;
for(int i=0;i
int[] scoreArr={150,99,59,100,120};
//1.首先得到59的索引；为2;
int index=2;
//2.index为2的之前的元素不变；
//3.index为2之后的元素：后一个元素的值赋给前一个元素；
for(int i=index;iindex;i--)
{
a[i]=a[i-1];
}
a[index]=59;
数组优缺点
数组的优点：
按索引查询，效率高；
数组的缺点：
(1)按数值查询，效率低；
(2)长度固定；
(3)模拟添加和删除，效率低；可能会引起大量元素的位移。
Arrays工具类;
//定义一个一维数组；
int[] arr={52,87,33,96,59};
Arrays.sort(arr);//{33,52,59,87,96};
//如果要查的值在数组里存在，返回的是索引值；如果不存在，返回-(应该存在的索引位置+1);
int index=Arrays.binarySearch(arr,60);
System.out.println(index);
int[] arr2={33,52,59,87,96};
System.out.println(Arrays.equals(arr,arr2));//比较数组内容，元素的内容和顺序都得一致；
//Arrays.fill(arr,10);//数组元素全部变成10;
//Arrays.fill(arr,0,2,10);//索引范围：含头不含尾；
int[] arr3=Arrays.copyOf(arr, 10);
二维数组
定长二维数组： int[][] scoreArr=new int[3][4];
不定长二维数组： //定义一个二维数组；
int[][] scoreArr=new int[3][];//先指定第一维度的长度；
//给二维数组赋值；
scoreArr[0]=new int[3];//给第二维度分配空间；
scoreArr[0][0]=98;
scoreArr[0][1]=97;
scoreArr[0][2]=99;
scoreArr[1]=new int[4];//给第二维度分配空间；
scoreArr[1][2]=89;
scoreArr[1][3]=80;
scoreArr[2]=new int[5];//给第二维度分配空间；
//遍历二维数组；双重循环；
for(int i=0;i
int[] arr={30,25,40,15,100,60,20};
//排序;
for(int i=1;iarr[j+1]){
int temp=0;
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
冒泡排序2： //定义一个数组；
int[] arr={30,25,40,15,100,60,20};
//排序;
for(int i=1;iarr[j+1]){
int temp=0;
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
