数组：
数组的操作：获取数组中的元素，通常会用到遍历。
①获取数组中的最大值、最小值
步骤：1、定义变量，初始化为数组中的任意一个元素即可。
2、通过循环语句对数组进行遍历。
3、在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；
需要定义一个功能来完成，以便提高复用性。
1、明确结果，数组中的最大元素。int
2、未知内容：一个数组。int[]
public static int getMax(int[] arr) {
int max = arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>max)
max = arr[i];
}
return max;
}
②获取最大值的另一种方式
可不可以将临时变量初始化为0呢？可以，这种方式，其实是在初始化为数组中的任意一个角标。
public static int getMax_2(int[] arr) {
int max = 0;
for(int i=0;i<arr.length;i++){
if(arr[i]>arr[max])
max = i;
}
return arr[max];
}
选择排序：
内循环结束一次，最值出现在头角标位置上。
public static void selectSort(int[] arr){
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;
}
}
}
}
排序：selectSort(arr);、bubbleSort(arr);
Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序，要使用该句代码。
查找：
//定义功能，获取key第一次出现在数组中的位置，如果返回-1，代表key在数组中不存在。
public static int getIndex(int[] arr,int key ){
for(int x = 0;x<arr.length;x++){
if(arr[x]==key){
return x;
}
}
return -1;
}
折半查找：提高效率，但是必须保证该数组是有序的数组。
public static int halfSearch_2(int arr[],int key){
int min = 0,max = arr.length-1,mid;
while(min<=max){
mid = (max+min)/2;
if(key>arr[mid]){
min = mid +1;
}else if(key<arr[mid]){
max = mid -1;
}else
return mid;
}
return -1;
}
//练习:有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的，如何获取该元素在数组中的位置。
public static int getIndex_2(int[] arr,int key){
int min = 0,max = arr.length-1,mid ;
while(min<=max){
mid = (max+min)/2;
if(key>arr[mid]){
min = mid +1;
}else if(key<arr[mid]){
max = mid -1;
}else
return mid;
}
return min;
}
进制转换：
/*十进制-->二进制*/
public static void toBin(int num){
StringBuffer sbBuffer = new StringBuffer();
while(num > 0){
sbBuffer.append(num%2);
num = num / 2;
}
System.out.println(sbBuffer.reverse());
}
/*查表法：十进制-->二进制*/
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]);
}
}
/*十进制-->十六进制*/
public static void toHex(int num){
StringBuffer sb = new StringBuffer();
for(int x=0;x<8;x++){
int temp = num & 15;
if(num>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;//无符号右移四位
}
System.out.println(sb.reverse());
}
/* 0 1 2 3 4 5 6 7 8 9 A B C D E F ＝＝十六进制中的元素
* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
* 查表法：将所有的元素临时存储起来。建立对应的关系
*每一次&15后的值作为索引去查建立好的表。就可以找对应的元素。
*这样比-10+‘A’简单的多。这个表怎么建立呢？可以通过数组的形式来定义。
*发现终于出结果了，但是是反着的。想要正过来呢？可以通过StringBuffer reverse功能来完成。
*但是这个工具还没有学习，所以可以使用学习过的容器：数组来完成存储。*/
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;
while( num!= 0){
int temp = num & 15;
// System.out.println(chs[temp]);
arr[--pos] = chs[temp];
num = num >>> 4;
}
System.out.println("pos="+pos);
for(int x=pos;x<arr.length;x++){
System.out.print(arr[x]+",");
}
}
二维数组：二维数组的遍历
int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int sum = 0;
for(int x=0;x<arr.length;x++){
for(int y=0;y<arr[x].length;y++){
sum += arr[x][y];
}
}
System.out.println("sum = "+ sum);
}
二维数组的声明：//定义名称为arr的二维数组，二维数组中有3个一维数组每一个一维数组中有4个元素
int[][] arr1 = new int[3][4];
int[][] arr = new int[3][];
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
|
|
收藏
淘帖
踩
