1、 数组使用常见的错误：
Array Index Out Of Bounds Exception:操作数组时，访问到了数组中不存在的角标。
Null Pointer Exception:空指针异常：当引用没有任何指向值，为null的情况，该引用还在用于操作实体。
2、 数组的遍历及length的使用：例Day41.java
class Day41
{
publicstatic void main(String[] args)
{
//数组的操作：获取数组中的元素，通常会用到遍历
/*int[] arr=new int[3];
System.out.println("arr["+0+"]="+arr[0]+";");*/
int[] arr={3,8,9,4,6,45,78};
System.out.println(arr);//该语句输出的是数组arr在内存中的地址，不是数组存放的值。
//数组中的一个属性可以直接获取到数组元素个数：length
//使用方法：数组名称.length=
System.out.println("length:"+arr.length);
for(int x=0;x<arr.length;x++)
{
System.out.println("arr["+x+"]="+arr[x]+";");
}
printArray(arr);
}
//定义功能：用于打印数组中的元素，元素间用逗号隔开，且最后不带逗号
publicstatic void printArray(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
System.out.println();
}
}
输出数组中的最值：例Day42.java
/*
给定一个数组{5,1,6,4,2,8,9}
获取数组中的最大值，以及最小值
*/
class Day42
{
/*
获取数组中的最大值
思路：
1、获取最值需要进行比较，每一次比较都会有一个较大的值。因为该值不确定，通过一个变量进行临时存储。
2、让数组中的每一个元素都和这个变量中的值进行比较。如大于了变量中的值，就用该变量记录较大值。
3、当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。
步骤：
1、定义变量，初始化为数组中任一元素即可。
2、通过循环语句对数组进行遍历。
3、在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量。
需要定义一个功能来完成，以便提高复用性：
1、明确结果：数组中的最大元素 int
2、未知内容：一个数组 int[]
*/
//方法一：获取最大的值
publicstatic int getMax(int[] arr)
{
int max=arr[0];
for(int x=1;x<arr.length;x++)
{
if(arr[x]>max)
max=arr[x];
}
return max;
}
//方法二：通过获取最大值得角标来得到最大值
publicstatic int getMax2(int[] arr)
{
int max=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
//获取最小值
publicstatic int getMin(int[] arr)
{
int min=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}
//获取double类型数组的最大值。因为功能一直，所以定义相同函数名称 ，以重载形式存在
/* publicstatic double getMax(double[] arr)
{
}
*/
publicstatic void main(String[] args)
{
int[] arr={5,1,6,4,2,8,9};
int max=getMax2(arr);
System.out.println("max="+max);
int min=getMin(arr);
System.out.println("min="+min);
}
}
排序算法中，排序最快的是希尔排序，效率最高
在开发中会用JAVA中已有的排序语句：Arrays.sort();
用选择排序的方法有序输出数组的元素：例Day43.java
/*
给定一个数组{5,1,6,4,2,8,9}
进行从小到大的排序
选择排序：内循环结束一次，最值出现头角标位置上
JAVA中直接提供的排序的方法：Arrays.sort(arr);不过需要添加包中的类
*/
class Day43
{
public static voidselectSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)//该语句中的x<arr.length-1是比较
//到倒数第二个数即可，剩下一个不用比较了
{
for(inty=x+1;y<arr.length;y++)//其中y=x+1就是避免比较相同角标的两个数
{
if(arr[x]>arr[y])//从小到大排序只需在此改成if(arr[x]<arr[y])即可
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
public static voidmain(String[] args)
{
int[] arr={5,1,6,4,2,8,9};
printArray(arr);//排序前输出原数组元素
selectSort(arr);
printArray(arr);//排序后输出有序数据
}
public static voidprintArray(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
}
冒泡排序的方法：例Day44.java
/*
给定一个数组{5,1,6,4,2,8,9}用冒泡法进行排序
冒泡排序：相邻的两个元素进行比较，如果符合条件换位。
冒泡法的最值出现在最后位。
*/
class Day44
{
publicstatic void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(inty=0;y<arr.length-x-1;y++)//每比较一轮数组的长度都会减一也就是-x；其中-1是避免(y+1)角标越界
{
if(arr[y]>arr[y+1]) //排序中，都需要交换数据的位置，所以，可以把这个功能另写成一个函数
{
swap(arr,y,y+1);
/*inttemp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;*/
}
}
}
}
publicstatic void swap(int[] arr,int a,int b) //交换位置功能的函数
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
publicstatic void printArray(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
publicstatic void main(String[] args)
{
int[] arr={5,1,6,4,2,8,9};
printArray(arr);//输出排序前原数组
bubbleSort(arr);
printArray(arr);//排序后的数据
}
}
算法中交换位置在堆中进行，比较占内存，可以添加变量，改成在栈中比较，最后只交换一次位置，对于较多数据排序时节省内存。
折半查找及插入数据：例Day45.java
/*
给定一个数组{5,1,6,4,2,8,9，2，18,16,14}
用折半查找的方法，找到相应数据的角标
折半查找，提高效率，但必须保证数据是有序的
*/
class Day45
{
publicstatic int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
//排序成有序的数据才能折半查找
publicstatic void sort(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(inty=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
inttemp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
System.out.print(arr[x]+"");
}
System.out.println();
}
//折半查找
publicstatic int halfSearch(int[] arr,int key)
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(max+min)/2;
while(arr[min]!=key)
{
if(key>arr[mid])
min=mid+1;
elseif(key<arr[mid])
max=mid-1;
mid=(max+min)/2; //多次折半
if(min>max) //数据不存在的情况
return -1;
}
return mid;
}
//第二种折半查找的方法
publicstatic int halfSearch2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(max+min)>>1; //相当于mid=(max+min)/2;
if(key>arr[mid])
min=mid+1;
elseif(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
//基于折半的，插入数据
publicstatic int getIndex2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(max+min)>>1; //相当于mid=(max+min)/2;
if(key>arr[mid])
min=mid+1;
elseif(key<arr[mid])
max=mid-1;
else
return mid;
}
return min; //返回最小角标的位置
}
//定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表key在数组中不存在
publicstatic void main(String[] args)
{
int[] arr={5,1,6,4,2,8,9,18,16,14};
int index=getIndex(arr,2);
System.out.println("index="+index);
System.out.print("原数组为：");
for(int x=0;x<arr.length;x++)
{
System.out.print(arr[x]+"");
}
System.out.println();
System.out.print("排序后的数组为：");
sort(arr);
System.out.println(halfSearch(arr,16));
System.out.println(halfSearch2(arr,18));
System.out.println(getIndex2(arr,3));
}
}
进制之间的转换：例Day46.java
class Day46
{
publicstatic void main(String[] args)
{
toBin(6);
System.out.println(Integer.toBinaryString(60)); //直接输出60的二进制数
toHex(60);
}
/*
十进制-二进制
*/
publicstatic void toBin(int num)
{
StringBuffer sb=new StringBuffer(); //该语句有存储数据的功能
while(num>0)
{
sb.append(num%2); //向sb中添加数据的方法
num=num/2;
}
System.out.println(sb);
System.out.println(sb.reverse()); //反向输出数据的功能
}
/*
十进制-十六进制
10进制数转换成二进制，再和15即1111&的运算，再右移，重复该动作的运算
*/
publicstatic void toHex(int num)
{
StringBuffer sb=new StringBuffer();
for(int x=0;x<8;x++) //总共32位，分成4个位&一次，最多&8次，所以x<8
{
inttemp=num&15;
if(temp>9)
//System.out.print((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
else
//System.out.print(temp);
sb.append(temp);
num=num>>>4;
}
System.out.println(sb.reverse());
}
}
用数组存储数据，并用查表法解决“十进制-十六进制”的问题：Day47.java
/*
用查表法的方法解决十六进制的问题
这种方法，没有局限了，可以计算出负数的十六进制
*/
/*
01 2 3 4 5 6 7 8 9 A B C D E F ===十六进制中的元素
01 2 3 4 5 6 7 8 9 10 11 12 13 14 15
查表法：将所有的元素临时存储起来，建立对于关系。
每一次&15后的值作为索引去查建立好的表，就可以找对应的元素。
这样比(temp-10+'A')要简单
怎样建立表？
可以通过数据的形式来定义
*/
class Day47
{
publicstatic void main(String[] args)
{
toHex(60);
System.out.println();
toBin(-6);
}
publicstatic void toHex(int num)
{
char[] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
/*可以通过StringBuffer reverse来完成存储数据和反转输出数据的动作，
也可以用学习过数组的方式实现该功能
*/
//定义一个临时容器
char[] arr=new char[8]; //因为是十六进制的，所以要定义成char型的
int pos=arr.length; //定义一个pos指针变量。
while(num!=0)
{
inttemp=num & 15;
//System.out.println(chs[temp]);
arr[--pos]=chs[temp]; //从数组的最大位开始存，也就是倒这存&后的数据，这样就可以直接正向输出
num=num>>>4;
}
System.out.println("pos="+pos);
//存储数据的arr数组遍历
for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]+",");
}
}
//定义二进制表
publicstatic void toBin(int num)
{
char[] chs={'0','1'};
//定义一个临时容器
char[] arr= new char[32];
//定义一个操作数组的指针
int pos=arr.length;
while(num!=0)
{
inttemp=num & 1;
arr[--pos]=chs[temp];
num=num>>>1;
}
for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]);
}
}
}
3、 二维数组[] []，即数组中的数组
格式一：int[] []arr=new int[3] [2];
定义了名称为arr的二维数组，数组中有3个一维数组，每一个一维数组中有2个元素，一维数组的名称分别为arr[0]，arr[1]，arr[2]；给第一个一维数组[1]角标位赋值78写法是：arr[0][1]=78;
格式二：int[] [] arr=new int[3] [];
二维数组中有3个一维数组，每个一维数组都是默认初始化值null；可以对三个一维数组分别进行初始化：
arr[0]=newint[3];
arr[1]=newint[1];
arr[2]=newint[2];
判读下面的是否正确：
int[] x; int x[]; //定义一维数组
int[][] y; int y[] []; int[] y[]; //定义一个二维数组
int[] x,y[]; //x是一维，y是二维 即int[] x; int[] y[];
① x[0]=y; //error前者是一个元素，后者是一个二维数组
② y[0]=x; //yes 把后者的一维数组赋值给前者
③ y[0][0]=x; //error 后者是一个数组，不可赋给一个元素
④ x[0][0]=y; //error
⑤ y[0][0]=x[0]; //yes 两个都是元素
⑥ x=y; //error
Day48.java
/*
优化进制之间的转化
*/
class Day48
{
public static void main(String[] args)
{
toBin(6);
System.out.println();
toBa(60);
System.out.println();
toHex(60);
}
publicstatic void trans(int num,int base,int offset) //其中base是&的数，offset是移动的位数
{
if(num==0) //当为0是，不需要下面的运行，所以可以直接return
{
System.out.println(0);
return;
}
char[] chs={'0','1','2','3', '4','5','6','7','8','9','A','B', 'C','D','E','F'};
char[] arr=new char[32];
int pos=arr.length;
while(num!=0)
{
inttemp=num & base;
arr[--pos]=chs[temp];
num=num>>>offset;
}
for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]);
}
}
//十进制-->二进制
publicstatic void toBin(int num)
{
trans(num,1,1);
}
//十进制-->八进制
publicstatic void toBa(int num)
{
trans(num,7,3);
}
//十进制-->十六进制
publicstatic void toHex(int num)
{
trans(num,15,4);
}
}
Day49.java
/*
关于二维数组
*/
class Day49
{
publicstatic void main(String[] args)
{
int[] arr1=new int[3]; //一维数组
int[][] arr2=new int[3][4];//定义名称为arr的二维数组
//二维数组中有3个一维数组，每个一维数组中有四个元素
System.out.println(arr2[0][1]); //输出的是该位置的默认值0
int[][] arr3=new int[3][];
System.out.println(arr3[0]); //输出的是null
arr3[0]=new int[3];
arr3[1]=new int[1];
arr3[2]=new int[2];
System.out.println(arr3.length); //打印的是二维数组的长度 ：3
System.out.println(arr3[0].length);//打印二维数组中的第一个一维数组长度
/*
二维数组求和
*/
int[][] arr4={{1,2,4},{3,6},{5,5}};
int sum=0;
for(int x=0;x<arr4.length;x++)
{
for(inty=0;y<arr4[x].length;y++)
{
sum=sum+arr4[x][y];
}
}
System.out.println("sum="+sum);
}
}
3386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
