黑马程序员_基础知识（2）

android培训、java培训、期待与您交流！

 

数组

 

数组的定义：同一种类型数据的集合，其实数组就是一个容器。

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1：

元素类型[] 数组名  = new元素类型[元素个数或者数组长度] ;

Int[] arr = new int[5] ;

格式2：

元素类型[] 数组名 = new元素类型[]{元素，元素,...} ；

Int[] arr = new int[]{3,5,1,7} ;

Int[] arr = {3,5,1,7} ;

 

栈：数据使用完毕，会自动释放。只要是局部变量都在栈内存里面（开辟空间）。

堆里面存放的就是对象，实体。

堆内存中的每一个实体都有一个存放位置

 

说明：

提问：数组声明的疑问。

在数组的声明上为什么要写上一个null呢？如"int score[] = nulll ;"。

回答：null表示引用数据类型的默认值。

在数据类型划分上，数组属于引用数据类型，那么对于引用数据类型来说，其默认值是null，表示暂时还没有任何指向的堆内存空间。

提示：堆栈内存的解释。

数组操作中，在栈内存中保存的永远是数组的名称，只开辟了栈内存空间的数组是永远无法使用的，必须有指向的堆内存才可以使用，要想开辟新的堆内存则必须使用关键字new，然后只是将此堆内存的使用权交给了对应的栈内存空间，而且一个堆内存空间可以同时被多个栈内存空间所指向，即一个人可以有多个名字，一个具体的人就相当于堆内存，名字就相当于栈内存。

 

 

选择排序：内循环结束一次，最值出现在头角标位置上。

public static void SelectSort(int[] arr){

for(int i=0;i<arr.length;i++){

for(int j=i+1;j<arr.length-1;j++){

if(arr[i]>arr[j]){

  

//int temp = arr[i] ;

//arr[i] = arr[j] ;

//arr[j] = temp ;  //注释的这三句话用swap(arr,i,j)来代替

swap(arr,i,j) ;

}

}

}

}

冒泡排序：

public static void bubbleSort(int[] arr){

for(int i=0;i<arr.length-1;i++){

for(int j=0;j<arr.length-x-1;j++){  //-x：让每一次比较的元素减少，-1：避免角标越界。

if(arr[j]<arr[j+1]){

//int temp = arr[j] ;

//arr[j] = arr[j+1] ;

//arr[j+1] = temp ;//注释的这三句话用swap(arr,j,j+1)来代替

  swap(arr,j,j+1) ;

}

}

}

}

 

发现无论什么排序，都需要对满足条件的元素进行位置置换。所以可以把这部分相同的代码提取出来，单独封装成一个函数。

public static void swap(int[] arr,int a,intb){

int temp = arr[a] ;

arr[a] = arr[b] ;

arr[b] = temp ;

}

 

数组中的查找操作：

 

折半查找，提高效率，但是必须要保证该数组是有序的数组。

 

public static void halfSearch(int[] arr,intkey){

int main,max,mid ;

min =0 ;

max = arr.lemgth-1 ;

mid = (min+max)/2 ;

while(arr[mid]!=key){

if(key>arr[mid]){

  min= mid+1 ;

}else if(key<arr[mid]){

max = mid-1 ;

}

if(min>max){

return -1 ;

}

mid = (max+min)/2 ;

}

return mid ;

}

 

折半查找的第二种方式：

public static void halfSearch_2(int[]arr,int key){

int min = 0,max = arr.length-1,mid ;

while(min<=max){

mid = (max+min)>>1 ;

if(key>arr[mid]){

min = mid+1 ;

}else if(key<arr[mid]}{

max = mid -1 ;

}else{

return mid ;

}

}

return -1 ;

}

 

十进制--->二进制

public static void toBin(int num){

StringBuffer sb = new StringBuffer() ;

While(num>0){

sb.append(num%2) ;

num = num/2 ;

}

System.out.println(sb.reverse()) ;

}

 

十进制---->十六进制

public static void toHex(int num){

StringBuffer sb = new StringBuffer() ;

for(int x=0;x<8;x++){

int temp = num&15 ;

 if(temp>9){

 sb.append((char)t(emp-10+'A')) ;

 }else{

 sb.append(temp) ;

          }

num = num>>>4 ;

  }

System.out.println(sb.reverse()) ;

}

 

查表法(十进制--->十六进制)：将所有的元素临时存储起来，建立对应关系，每一次&15后的值都作为所以去查建立好的表，就可以找到对应的元素。

这个表怎么建立呢？

可以通过数据的形式来定义。

发现终于出结果了，但是是反着的。先要正过来呢？可以通过StringBuffer 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  可以看成是下标

public static void toHex_2(int num){

char[] arr = new char[8] ;

int pos = arr.length ;

char[] chars ={'1','2'.,'3','4','5','6','7','8','9','A','B','C','D','E','F'} ;

while(num!=0){

int temp = num&15 ;

arr[--pos] = chars[temp] ;

num = num>>>4 ;

}

System.out.println("pos="+pos) ;

for(int x=pos;x<arr.length;x++){

System.out.println(arr[x]) ;

}

}

 

查表法求：十进制--->二进制

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 trans(int num,intbase,int offset){

if(num==0){

System.out.println(0) ;

return ;

}

char[] chars ={'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){

int temp = num&base ;

arr[--pos] = chars[temp] ;

num = num>>>offset ;

}

for(int x=pos;x<arr.length;x++){

System.out.println(arr[x]) ;

}

}

 

用优化后的进制转换方法直接调用就行了：

十进制--->二进制：

public static void toBin(int num){

 trans(num,1,1) ;

}

十进制--->十六进制

public static void toHex(int num){

 trans(num,15,4) ;

}

十进制--->八进制

public static void toEight(int num){

trans(num,7,3) ;

}

 

简单的介绍二维数组。

int[][] arr = new int[3][] ;  //定义了名称为arr的二维数组，二维数组中有3个一位数组。

arr[0] = new int[3] ;//定义二维数组中的第一个元素（一位数组）的长度

arr[1] = new int[1] ;//定义二维数组中的第二个元素（一位数组）的长度

arr[2] = new int[2] ;//定义二维数组中的第三个元素（一位数组）的长度

arr.length --->二维数组的长度3

arr[0].length--->二维数组中第一个一位数组长度。

 

int[][] arr ={{3,5,1,7},{2,3,5,8},{6,1,8,2}} ;

//遍历二维数组

for(int x=0;x<arr.length;x++){

for(int y=0;y<arr[x].length;y++){

System.out.print(arr[x][y]) ;

}

System.out.println() ;}