1.如何定义一个数组
1.1数组的声明
String[] names;
int scores[];
1.2初始化
第一种：静态初始化：初始化数组与给数组元素赋值同时进行
names= new String[]{"周爽","郭强强","俞乾龙"};
第二种：动态初始化，初始化数组与给数组元素赋值分开进行
scores= new int[4];
//注意:int[] myInt={12,13,14};这样写也可以
但是 int[] myInt1;
myInt1=new int []{12,1,3,14};//这样写可以
myInt1={12,1,3,14};//这样写不可以
2.如何调用相应的数组元素，通过数组元素的下角标的方式来调用
3.数组的长度：通过数组的length属性。（数组一旦初始化，它的长度是不可变的）
System.out.println(names.length);//3
System.out.println(scores.length);//4
4.如何遍历数组
for(int i=0;i<names.length;i++){
System.out.println(names.length);
}
对于基本数据类型的变量创建的数组：
1.对于byte short int long 而言，创建数组以后，默认值为0
int[] scores= new int[4];
scores[0]=89;
scores[3]=90;
for(int i=0;i<scores.length;i++){
System.out.println(score[i]);
}
2.对于float double而言，默认值为0.0
float[] f=new float[3];
f[0]=1.2F;
for(int i=0;i<f.length;i++){
System.out.println(f[i]);
}
3.对于char而言,默认为空格
char[] c=new char[3];
for(int i=0;i<c.length;i++){
System.out.println(c[i]);
}
4.对于boolean而言，默认为false
boolean[] b=new boolean[3];
for(int i=0;i<b.length,i++){
System.out.println(b[i]);
}
5.对于引用类型的变量构成的数组而言，默认初始化值为null,以String为例
String[] strs=new String[4];//String:现成的类
strs[0]="AA";
strs[1]="BB";
strs[3]="DD";
for(int i=0;i<strs.length;i++){
System.out.println(strs[i]);
}
System.out.println();
Person[] pers=new Person[3];//自定义的类
for(int i=0;i<pers.length;i++){
System.out.println(pers[i]);
}
class Person{
}
【多维数组】
1.二维数组的初始化
int[] score1=new int[10];
int[][] score2;
String[][] names;
score2=new int[][]{{1,2,3},{3,4,5,},{6}};//静态初始化
names=new String[6][5];//动态初始化的方式一
names=new String[6][];//动态初始化的方式二
names[0]=new String[5];
names[1]=new String[4];
names[2]=new String[7];
names[3]=new String[5];
names[4]=new String[8];
names[5]=new String[5];
//错误的初始化方式
//names=new String[][];
//names=new String[][5];
2.如何来引用具体的某一个元素
int[][] i=new int[3][2];//int[] i[]=new int[3][2];
i[1][0]=90;
i[2][1]=100;
3.数组的长度
//二维数组的长度，length属性
System.out.println(i.length);//3
System.out.println(i[0].length);//2
System.out.println(names.length);//6
System.out.println(names[4].length);//8
4.如何遍历二维数组
for(int m=0;m<scores2.length;m++){//控制行数
for(int n=0;n<scores2[m].length;n++){
System.out.println(scores2[m][n]+" ");
}
System.out.println();
}
5.内存结构
【数组的常见异常】
1.数组下标越界的异常：java.lang.ArrayIndexOutOfBoundsException
int[] i=new int[10];
//int[0]=90;
//i[10]=99;
for(int m=0;m<=i.length;m++){//应去掉等号
System.out.println(i[m]);
}
2.空指针的异常：NullPointerException
第一种：
boolean[] b=new boolean[3];
b=null;//相当于把b在栈里的地址值（堆里面有三个boolean型值，b在栈里的地址值指向堆的首地址）改成了null，即指针为消失，找不到b[0]的位置了
System.out .println(b[0]);
第二种：
String[] str=new String[4];
//str[3]=new String("AA");//str[3]="AA";//可以改成这样，除非给他赋上一个值
System.out.println(str[3].toString());//str[3]相当于一个字符串的对象，本身的对象值为null,在堆里str[3]没有指针的存在，这时候不能调用方法
第三种：
int[][] j=new int[3][];
j[2][0]=12;//一定要有真实的地址值，没赋值前是null,找不到第三行第一列在哪
【定义数组时要注意】
int[] x,y[];
//int[] x ;//一维
//int[] y[];//二维
y=new int[3][2];
x=y[0];
x[0]=y[1];//错误，x[0]是int型的值，y[1]是int型数组
一维数组：int[]x 或者int x[]
二维数组：int[][]y 或者 int[] y[] 或者int y[][]
【二维数组的练习之杨辉三角】
int[][] yangHui=new int[10][];
//1.数组初始化
for(int i=0;i<yangHui.length;i++){
yangHui[i]=new int[i+1];
}
//2.显式的为二维数组的每个元素赋值int[] x,y[];
//int[] x ;//一维
//int[] y[];//二维
y=new int[3][2];
x=y[0];
x[0]=y[1];//错误，x[0]是int型的值，y[1]是int型数组
一维数组：int[]x 或者int x[]
二维数组：int[][]y 或者 int[] y[] 或者int y[][]
【二维数组的练习之杨辉三角】
int[] x,y[];
//int[] x ;//一维
//int[] y[];//二维
y=new int[3][2];
x=y[0];
x[0]=y[1];//错误，x[0]是int型的值，y[1]是int型数组
一维数组：int[]x 或者int x[]
二维数组：int[][]y 或者 int[] y[] 或者int y[][]
【二维数组的练习之杨辉三角】
for(int i=0;i<yangHui.length;i++){
for(int j=0;j<yangHui[i].length;j++){
yangHui[i][0]=yangHui[i][i]=1;
if(i>1&&j>0&&j<i){
yangHui[i][j]=yangHui[i-1][j]+yanghui[i-1][j-1];
}
}
}
//遍历二维数组
for(int i=0;i<yangHui.length;i++){
for(int j=0;j<yangHui[i].length;j++){
System.out.print(yangHui[i][j]+“\t”)
}
System.out.println();
}
【数组中涉及的常见算法】
- 求数组元素的最大值、最小值、平均数、总和等
//最大值
int max=arr[0];
for(int i=1;i<arr.length;i++){
if(max<arr[i]){
max=arr[i];
}
}
System.out.print(“数组的最大值为 ：”+max);
//最小值
int min=arr[0];
for(int i=1;i<arr.length;i++){
if(min>arr[i]){
min=arr[i];
}
}
System.out.print(“数组的最小值为 ：”+min);
//总和
int sum=0;
for(int i=0;i<arr.length;i++){
sum+=arr[i];
}
System.out.println(“总和为：”+sum);
//平均数
int avg=0;
avg=sum/arr.length;
System.out.println(“平均值为：”+avg);
2.数组的复制、反转
//数组的复制
int[] array1,array2;
array1=new int[]{2,3,5,,7,11,13,17,19}
array2=array1;//值传递，传递的是变量的值（0x5566）
//【可以打印System.out.println(array1);
System.out.println(array2);
打印出来的是两者的地址值，且两者地址值相等】
正确的做法是：
int[] array1,array2;
array1=new int[]{2,3,5,,7,11,13,17,19}
array2=new int[array1.length];
for(int i=0;i<array2.length;i++){
array2[i]=array1[i];
}
//数组的反转
1for(int i=0;i<arr.length/2;i++){//arr的数组长度不管是奇数还是偶数都可以用i<arr.length/2
int temp=arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=temp;
}
2for(int x=0,y=arr.length-1;x<y;x++,y--){
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
3.数组元素的排序
冒泡排序
//使用冒泡排序使数组元素从小到大排列
for(int i=0;i<arr.length-1;i++){//需要控制的循环的轮数，外层循环一次，就取出来剩下元素的最大值
for(int j=0；j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){//若要从大到小排列，则只需将大于号改成小于号
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.println(“排序以后：”);
//遍历
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+”\t”);
}
直接选择排序
//使用直接选择排序使数组元素从小到大排列
for(int i=0;i<arr.length-1;i++){
for(int j=i;i<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
System.out.println(“排序以后：”);
//遍历
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+”\t”);
}
优化：先默认当此交换中的小值是最小的，当发现后面的交换中有更小的值，则用t记住这个新的更小的值，当整个内层执行完后它确实是最小的值，判断此时的t是不是当初的i,如果不是，那么交换，这样相当于每次循环都只交换了一次
/使用直接选择排序使数组元素从小到大排列
for(int i=0;i<arr.length-1;i++){
int t=i;//默认i处是最小的
for(int j=i;i<arr.length;j++){
//一旦在i后发现存在比其小的元素，就记录那个元素的下角标
if(arr[t]>arr[j]){
t=j;
}
}
if(t!=i){
int temp=arr[t];
arr[t]=arr[i];
arr[i]=temp;
}
System.out.println(“排序以后：”);
//遍历
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+”\t”);
}
还可以调用Arrays工具类：Arrays.sort(arr);