---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
数组的常见操作
1.遍历
class ArrayDemo
{
public static void main(String[] args)
{
//数组的操作：获取数组中的元素，通常会用到遍历
//int[]arr = new int[3];
int[]arr = {3,6,4,1,9,6,0};
//数组中有一个属性可以直接获取到数组元素个数：length。
//使用方式：数组名称.length
/*
for(int x=0; x<arr.length; x++)
{
System.out.println("arr["+x+"]="+arr[x]+";");
}
*/
printArray(arr);
}//定义一个打印数组的方法(函数)
public static void printArray(int[] arr)
{
System.out.print("[");//为了输出的结果好看，这里直接输出一个正括号
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)//只要x不等于数组的最后一个元素，就输出一个数组元素和一个逗号
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}小结：length:可以直接获取数组元素的个数或者长度。
2、获取最值
给定一个数组{5,1,6,4,2,8,9}
1.获取数组中的最大值，以及最小值。
获取数组中的最大值。
思路：
1.获取最值需要进行比较，每一次比较都会有一个较大的值，因为该值不确定，通过一个变量进行临存。
2.让数组中的每一个元素都和这个变量中的值进行比较，如果大于了变量中的值，就用该变量记录较大值。
3.当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。
步骤：
1.定义变量，初始化为数组中任意一个元素即可。
2.通过循环语句对数组进行遍历。
3.在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；
需要定义一个功能来完成，以便提高函数复用性。
1.明确结果，数组中的最大值
2.未知内容，一个数组，int[]
*/
class ArrayTest
{
public static int getMax(int[] arr)
{
int max = arr[0];
for(int x=1; x<arr.length; x++)//之所以将x定义为1，是为了少比较一次
{
if(arr[x]>max)
max= arr[x];
}
return max;
}
//获取最值的另一种方法
//可不可以将临时变量初始化为0呢？可以，这种方式，其实是在初始化为数组中任意一个角标。
public static int getMax_2(int[] arr)//将需要操作的数组传递进来int[]arr
{
intmax = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
max= x;
}
return arr[max];
}
public static void main(String[] args)
{
int[]arr = {5,1,6,4,2,8,9};
int max = getMax(arr);
System.out.println("max="+max);
}
}小结：程序中定义的max,其实是可以定义两种方法的，第一种就是直接赋值为数组中的一个元素，即arr[0]，这样返回值就直接得到的是一个元素；第二种方法就是可以将其定义为数组元素中的一个角标，也就是arr[max],这样获取的值在经过arr数组封装后也能得到相应结果。通俗的说就是可以将max定义为数组中的元素或者角标。
3、常见排序方法
3.1选择排序法
对给定数组进行排序：{5,1,6,4,2,8,9}
class ArrayTest2
{
//定义一个排序方法：选择排序法
//选择排序：内循环结束一次，最值出现在头角标的位置上。
public static void selectSort(int[] arr)
{
//由于不需要比较到最后一个元素，因此这里可以将其长度-1，减少一次比较,提高效率
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x]=arr[y];
arr[y]= temp;
}
}
}
}
//冒泡排序
public static void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length-1; x++)
{
for(int y=0;y<arr.length-x-1; y++)//-x：让每一次比较的元素逐渐减少，-1：避免角标越界
{
if(arr[y]>arr[y+1])
{
/*
int temp = arr[y];
arr[y]= arr[y+1];
arr[y+1]= temp;
*/
swap(arr,y,y+1);
}
}
}
}
//发现无论什么排序，都需要对满足条件的元素进行位置置换
//所以可以吧这部分相同代码提取出来，单独封装成一个函数
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a]= arr[b];
arr[b]= temp;
}
public static void main(String[] args)
{
int[]arr = {5,1,6,4,2,8,9};
//排序前
printArray(arr);
//排序
//selectSort(arr);
bubbleSort(arr);
//排序后
printArray(arr);
//Arrays.sort(arr);//java中已经定义好了一种排序方法，开发时就用这种排序方法
}
//定义一个遍历数组的方法
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}选择排序：头元素与后面的元素一一比较，也就是内循环结束一次，最值出现在头角标位置上；接着头元素自增，循环与后面的元素进行比较，即可得到排序结果。大圈套小圈，尖朝下，改变内循环初始值
冒泡排序：相邻的两个元素进行比较，如果符合条件就换位。大圈套小圈，尖朝上，改变内循环条件
4、数组的查找操作：折半查找
练习：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的，如何获取该元素在数组中的位置？
class ArrayTest4
{
//定义功能，获取key第一次出现在数组中的位置，如果返回是-1，那么代表该key在数组中不存在。
public static int getIndex(int[] arr,int key)
{
int min=0;//定义需要插入未知的初始化角标
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return-1;//由于数组中不存在-1这个角标，因此返回-1则说明该数组中没有这个元素，即表示错误
}
//折半查找：提高效率，但是必须要保证数组是有序的数组
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min= 0;
max= arr.length-1;
mid= (min+max)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min= mid+1;
elseif(key<arr[mid])
max= mid-1;
if(min>max)
return -1;
mid= (max+min)/2;//循环确定中间值的大小
}
return mid;
}
//折半的第二种方式
public static int halfSearch_2(int[] arr,int key)
{
int min=0,max = arr.length-1,mid;
while(min<=max)
{
mid= (min+max)/2;
if(key>arr[mid])
min= mid+1;
elseif(key<arr[mid])
max= mid-1;
else
return mid;
}
return -1;
}
public static void main(String[] args)
{
int[]arr = {3,5,6,7,8,9};
//int index = getIndex(arr,0);
int index = halfSearch_2(arr,6);
System.out.println("index="+index);
}
}面试题：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的，如何获取该元素在数组中的位置？
解答：可以通过折半查找的方法，确定需要插入的数的角标，继而将原本返回为-1的那句改成min即可
public static int halfSearch_2(int[]arr,int key)
{
int min=0,max = arr.length-1,mid;
while(min<=max)
{
mid= (min+max)/2;
if(key>arr[mid])
min= mid+1;
elseif(key<arr[mid])
max= mid-1;
else
return mid;
}
return min;//返回的这个min就是需要插入的数的角标
}需要值得注意几点的是，在折半查找的方法中，首先就是需要确定要折半的数组是有序的，其次，在定义好一个标记key后，与折半的最大、小值相比较，继而突出折半的原理，而在查找的过程中，还需将中间值角标mid=(min+max)/2一次，防止出现死循环。
5、进制转换
class ArrayTest5
{
public static void main(String[] args)
{
//toBin(6);
toHex(60);
}
//十进制-->二进制
public static void toBin(int num)
{
//定义一个容器，用于存储数据
StringBuffer sb = new StringBuffer();
while(num>0)
{
sb.append(num%2);//将num%2的值添加到容器中
num = num/2;
}
System.out.println(sb.reverse);//将得到的数据反转
}
//十进制-->十六进制
publicstatic void toHex(int num)
{
//定义一个容器，用于存储数据
StringBuffer sb = new StringBuffer();
for(int x=0; x<8; x++)//由于取的是最低4位，而在十六进制中有4组八位，因此这里的x<8
{
inttemp = num & 15;//之所以num&15,是为了得到其最低4位
if(temp>9)
//System.out.println((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
else
//System.out.println(temp);
sb.append(temp);
num= num >>> 4;//无符号往右移4位
}
System.out.println(sb.reverse());
}
}//查表法
class ArrayTest6
{
public static void main(String[] args)
{
toHex(60);
}
/*
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后的值作为索引去查建立好的表，就可以找对应的元素。
这样比-10+‘A’简单得多
这个表该怎么建立呢？可以通过数据的形式来定义。
*/
public static void toHex(int num)
{
char[]chs = {'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
//定义一个临时容器
char[]arr = new char[8];
int pos = arr.length;
//for(intx=0; x<8; x++)
while(num!=0)
{
int temp = num & 15;
//System.out.println(chs[temp]);
arr[--pos]= chs[temp];
num= num >>> 4;
}
//存储数据的arr数组遍历
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]+",");
}
}
}class ArrayTest6
{
public static void main(String[] args)
{
//toHex(60);
toBin(6);
}
/*
十进制-->二进制
*/
public static void toBin(int num)
{
//定义一个二进制表
char[]chs = {'0','1'};
//定义一个临时容器
char[]arr = new char[32];
//定义一个操作数组的指针
int pos = arr.length;
while(num!=0)
{
int temp = num & 1;
arr[--pos]= chs[temp];
num= num >>> 1;
}
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
}
/*
十进制-->十六进制
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后的值作为索引去查建立好的表，就可以找对应的元素。
这样比-10+‘A’简单得多
这个表该怎么建立呢？可以通过数据的形式来定义。
*/
public static void toHex(int num)
{
char[]chs = {'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
//定义一个临时容器
char[]arr = new char[8];
int pos = arr.length;
//for(int x=0; x<8; x++)
while(num!=0)
{
int temp = num & 15;
//System.out.println(chs[temp]);
arr[--pos]= chs[temp];
num= num >>> 4;
}
//存储数据的arr数组遍历
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]+",");
}
}
}class ArrayTest7
{
public static void main(String[] args)
{
//toBin(6);
//toBa(60);
toHex(60);
}
/*
十进制-->二进制
*/
public static void toBin(int num)
{
trans(num,1,1);
}
/*
十进制-->八进制
*/
public static void toBa(int num)
{
trans(num,7,3);
}
/*
十进制-->十六进制
*/
public static void toHex(int num)
{
trans(num,15,4);
}
public static void trans(int num,int base,int offset)
{
if(num==0)
{
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];
intpos = arr.length;
while(num!=0)
{
int temp = num & base;
arr[--pos]= chs[temp];
num= num >>> offset;
}
//直接将pos的值赋值给x
for(int x = pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
}
}
6、二维数组[][]
格式1：int[][] arr = new int[3][2];
解析：
(1)定义了名为arr的二维数组；
(2)二维数组中有3个一维数组
(3)每个一维数组中有2个元素
(4)一维数组的名称分别为arr[0],arr[1],arr[2]
格式2：int[][] arr = new int[3][];
(1)二维数组中有3个一维数组
(2)每个一维数组都是默认初始化值null
(3)可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
(1)定义一个名称为arr的二维数组
(2)二维数组中有三个一维数组
(3)每一个一维数组中具体元素也都已初始化
arr[0] = {3,8,2};
arr[1] = {2,7};
arr[2] = {9,0,1,6};
(4)第三个一维数组的长度表示方式：arr[2].length;
class Array2Demo
{
public static void main(String[] args)
{
/*
int[]arr = new int[3];//一维数组
int[][]arr = new int[3][4];//定义了名称为arr的二维数组，二维数组中有
//3个一维数组，每一个一维数组中有四个元素。
int[]][]arr = new int[3][];
arr[0]= new int[3];
arr[1]= new int[1];
arr[2]= new int[2];
System.out.println(arr.length);//打印是二维数组的长度：3
System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度
*/
int[][]arr = {{1,4,5,6},{2,5,6,3},{77,8,5,4}};
int sum = 0;
for(int x=0;x<arr.length; x++)
{
for(int y=0;y<arr[x].length; y++)
{
sum= sum+arr[x][y];
}
}
System.out.println("sum="+sum);
}
}一维、二维数组的常见写法：
一维数组：int[] x; intx[];
二维数组：int[][] y; int y[][]; int[]y[];
详细请查看：http://edu.csdn.net
1010
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
