数组
数组:存放多个数据的集合
一维数组声明
方式:
type var[]或type[] var;
例如:
int a[];
int[] a1;
double b[];
Mydate[] c;//对象数组
一维数组初始化
- 动态初始化:数组声明且为数组元素分配空间与赋值的操作分开进行。(可以后赋值)
int[] arr=new int[3];
arr[0]=3;
arr[1]=9;
arr[2]=8;
int[] ii=new int[4];//声明一个能放4个int类型数据的数组
int[] arr=new int[]{4,2,7,1,3,5};
int[] arr0=arr; //也可以这样赋值
- 静态初始化:在定义数组的同时就为数组元素分配空间并赋值。
int a[]=new int[]{3.9,8};
int[] a={3,9,8};
int[] 110=new int[]{1,2,3,4};//声明一个存放了1.2.3.4这四个数的数组
数组元素的引用
- 定义并用运算符new为之分配空间后,才可以引用数组中的每个元素;
- 数组元素的引用方式:数组名【数组元素下标】
- 数组元素下标可以是整型常量或整型表达式。如a[3],b[i],c[6*i];
- 数组元素下标从0开始;长度为n的数组合法下标取值范围:0–>n-1;如:int a[] =new int[3];可引用的数组元素为a[0],a[1],a[2].
- 每个数组都有一个属性length指明它的长度,例如: a.length指明数组a的长度(元素个数)
- 数组一旦初始化,其长度不可变的。
String[] strs=new String[]{"c","a","b"};//数组内地元素都有一个引用的元素下标,这个下标是个数字,数字是从左到右从0开始
System.out.println(str[1]);//a
System.out.printn("str的数组长度是:"+strs.length);//3
int[] ii=new int[2];//使用动态初始化的时候,数组的元素会有默认值,数字类型的默认值为0,对象的默认类型是null
System.out.println(ii[0]);//0
int[] ii=new int[4];
System.out.println(ii[0]); //0
ii[0]=2;//再次赋值
System.out.println(ii[0]);//2
多维数组
一维数组中的每一个元素都是一个数组,这样的数组就是二维数组
int[][] ii=new int[][]{
(1,2),(3,4)
};
二维数组[ ][ ]:数组中的数组 |
---|
格式1(动态初始化):int[ ][ ] arr=new int[3][2]; |
---|
定义了一个名称为arr的二维数组 |
二维数组中有3个一维数组 |
每一个一维数组中有两个元素 |
一维数组的名称分别为arr[0],arr[1],arr[2] |
给定一个一维数组1脚标位赋值位78的写法是:arr[0][1]=778; |
格式2(动态初始化):int[ ][ ]arr =new int[3][ ]; |
int[][] ii0=new int[2][3];//第一维部分的长度是2,第二维也就是第一维的每个元素的长度是3
{
(1,23,4),
(2,4,6)
}
二维数组中有3个一维数组 |
---|
每个一维数组都是默认初始化值null(注意:区别于格式1) |
可以对这个三个一维数组分别进行初始化 |
arr[0]=new int[3];arr[1]=new int[1];arr[2]=new int[2]; |
注意:int[ ]arr =new int[ ][3];//非法 |
int[][] ii1=new int[2][];//只定义第一维的长度,第二维不定义
格式2(静态初始化):int[ ][ ] arr=new int[ ][ ]{{3,8,2},{2,7},{9,0,1,6} |
---|
定义一个名称位arr的二维数组,二维数组中有三个一维数组 |
每一个一维数组中具体元素也都已经初始话 |
第一个一维数组arr[0]={3,8,2}; |
第二个一维数组arr[1]={2,7}; |
第三个一维数组arr[1]={9,0,1,6}; |
第三个一维数组的长度表示方式:arr[2].length; |
- 注意特殊写法情况:int[] x,y[]; x是一维数组,y是二维数组
- java中多维数组不必都是规则矩阵形式
int[][] ii=new int[][]{
(1,2),//第0个元素
(4,3)//第一个元素
};
Ststem.out.println(ii[1][0]);//4
练习题
获取arr数组中所有元素的和。使用for的嵌套循环即可
j\i | j=0 | j=1 | j=2 | j=3 |
---|---|---|---|---|
i=0 | 2 | 8 | 2 | |
i=1 | 2 | 7 | ||
i=2 | 9 | 0 | 1 | 6 |
int[][] arr=new int[][]{
(2,8,2),
(2,7),
(9,0,1,6)
};
int length=arr.length;//获取数组的一维的长度
int res=0;
for(int i=0;i<length;i++){
int arr0[]=arr[i]; //赋值
int llen=arr0.length;//二维数组的长度
for(int j=0;j<llen;j++){
System.out.println(arr[j]);//282279016
res+=arr0[j];//
}
}
System.out.println(res);//38
简化后:
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
res+=arr[i][j];
}
}
声明:int[],x,y[],一下选项允许通过编译的是:
- x[0]=y; //false x[0]是 具体数值,y是一个二维数组
- y[0]=x; //true y[0]是 一维数组 ,x是一维数组
- y[0][0]=x;//false y[0][0]是具体的数值,x是一维数组
- x[0][0]=y;//fasle x[0][0]不存在,y是二维数组
- y[0][0]=x[0];//true y[0][0]是具体的数值,x[0]是具体的数值
- x=y; //false x是一维数组,y是二维数组
一维数组:int[ ] x或者int x[ ]
二维数组:int[ ][ ] y或者int[ ] y[ ] 或者int y[ ][ ]
数组中涉及的常见算法
- 求数组元素的最大值,最小值,总和,平均数
int[] arr=new int[]{4,2,7,1,3,5};
//max
int max=arr[0];//假设arr[0]为最大值
//min
int min=arr[0];//假设arr[0]为最小值
//sum总和
int sum=0;
for(int i=0;i<arr.length;i++){
if(max<arr[i]{
max=arr[i];//存放目前的最大值
}
if(min>arr[i]){
min=arr[i];//存放目前的最小值
}
sum+=arr[i];
}
System.out.println("max:"+max);
System.out.printn("min:"+min);
System.out.println("sum:"+sum);
System.out.println("平均数:“+(sum?arr.length));//求平均数
- 数组的复制(不是赋值),反转
int[] arr=new int[]{4,2,7,1,3,5};
int[] copy=new int[arr.length];//声明一个长度与arr一样的数组
for(int i=0;i<arr.length;i++){ //复制
copy[i]=arr[i];//遍历arr,把arr的每一个元素按照顺序拿出来,给copy的每一个元素赋值,这里的i就是copy和arr数组的元素下标
}
//反转
//考虑声明一个数组temp,temp的长度与arr的长度一致,我们倒着循环arr,正着给temp元素赋值。
//temp[0]=arr[5]……temp[3]=arr[2],temp[4]=arr[1]temp[5]=arr[0]
//temp就是arr的倒序的数组,然后再把temp赋值arr(arr=temp)
//一个数组的最后一个元素,它的下标等于数组的长度-1,元素的下标从0开始
int[] temp=new int[arr.length];
int k=0;//这个就是temp的元素下标
for(int i=arr.length-1;i>=0;i--){
temp[k]=arr[i];
k++;
}
arr =temp;
for(int i=0;i<arr.length;i++){
System.out.prinln(arr[i]);
}
- 数组元素的排序
- 插入排序
- 直接插入排序,拆半插入排序,Shell排序
- 交换排序
- 冒泡排序,快速排序(或分区交换排序)
- 选择排序
- 简单选择排序,堆排序
- 归并排序
- 基数排序
- 插入排序
冒泡排序
排序思想:相邻两元素进行比较,如有需要则进行交换,每完成一次循环就将最大元素排在最后(如从小到大排序),下一次循环是将其他的数进行类似的操作。
//将 4,7,3,1倒序交换
//4,7,3,1
//4,3,7,1
//4,3,1,7 第一轮得到最大的数字
//3,4,1,7
//3,1,4,7 第二轮得到除最后一个数字之外的最大的数字
//1,3,4,7 第三轮得到除最后两个数字之外的最大的数字
int[] arr=new int[]{4,7,3,1};
int temp=0;
for(int i=0;i<arr.length-1;i++){//外层循环是循环轮次,轮次循环的次数是数组长度-1
for(int j=0;j<arr.length-1-i;j++){//每一轮次的数字对比 排序,每轮次的循环依次是4,3,2,轮次长度-1-i
if(arr[j]>arr[j+1]){//如果要是两个相邻的元素,前面的大于后面,前后两个值交换
//正序与倒序排序,其他的都是一致的,在判断两个相邻的元素在声明情况下做交换不一样
//如果是正序,前面大于后面,交换
//如果是倒序,前面小于后面,交换
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
数组操作常见问题
编译时,不报错!!!
数组下标越界异常(ArrayindexOutOfBoundsException) |
---|
int[ ] arr=new int[2]; |
System.out.prinln(arr[2]); |
访问到了数组中的不存在的脚标时发生 |
空指针异常(NullPointerException) |
---|
int[] arr=null; |
System.out.println(arr[0]); |
arr引用没有指向实体,却在操作实体中的元素时 |
作业
使用简单数组
- 创建一个名为TestArray的类,在main()方法中声明array1和array2两个变量,他们是int[]类型的数据。
- 使用大括号{},把array1初始化为8个素数:2,3,5,7,11,13,17,19
- 显示array1的内容
- 赋值array2变量等于array1,修改array2中的偶索引元素,使其等于索引值(如array[0],array[2]=2)。打印出array1
- 思考:array1和array2什么关系?
- 拓展:修改题目,实现array2对array1数组的复制
public class TestArray{
public static void main(String[] args){
int[] array1=new int[]{2,3,5,7,11,13,17,19};
int[] array2=new int[]{};
for(int i=0;i<array1.length;i++){
System.out.print(array1[i]+"\t");
}
System.out.println("");
array2=array1;
for(int j=0;j<array2.length;j++){
if(j%2==0){
array2[j]=j;
}
System.out.print(array2[j]+"\t");
}
}
//复制
/* int array2=new int[array1.length];
int k=0;
for(int i=0;i<array1.length;i++){
array2[k]=array1[i];
k++;
}*/
}