黑马程序员_函数和数组

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------

1.函数

（1）函数的定义：函数就是定义在类中的具有特定功能的一段独立小程序，也称为方法。

（2）函数的格式：

修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，)

{

执行语句;

return 返回值;

}

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该值会返回给调用者。

（3）特点：

定义函数可以将功能代码进行封装

便于对该功能进行复用

函数只有被调用才会被执行

函数的出现提高了代码的复用性

对于函数没有具体返回值的情况，返回值类型用关键字void表示，

那么该函数中的return语句如果在最后一行可以省略不写。

函数的应用两个明确：

明确要定义的功能最后的结果是什么？

明确在定义该功能的过程中，是否需要未知内容参与运算

注意：

函数中只能调用函数，不可以在函数内部定义函数。

定义函数时，函数的结果应该返回给调用者，交由调用者处理

（4）函数的重载（overload）：

概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

特点：与返回值类型无关，只看参数列表(参数类型以及参数个数)。

好处：方便于阅读，优化了程序设计。

特点：  与返回值类型无关，只看参数列表

法则： 两同，一不同 ：

同一个类中方法名相同；  参数列表不同：（参数个数，参数的类型，参数顺序） 。

例如：返回两个整数的和

int add(int x,int y){return x+y;}

返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

返回两个小数的和

double add(double x,double y){return x+y;}

2.数组

（1）数组的定义：

.数组的定义
同一种类型数据的集合。相当于一个容器。可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式：int[] arr = new int[4];
int[] arr = new int[]{3,4,6,8};
int[] arr = {3,4,6,8};

（2）内存结构

java程序在运行时，需要在内存中分配空间。为了提高运算效率，把空间划分成不同区域，每个区域都有特定的处理数据方式和
内存管理方式。
栈内存：用来存储局部变量，变量使用结束后，所占的空间会自动释放。
堆内存：通过new建立的实例都存放在堆内存中，而每一个实例都有一个内存地址以及默认初始化值。如果实例不再被使用的话，
在不确定的时间会被垃圾回收器回收。
 一般数据类型的数组的默认值为null，boolean型数组的默认值是false。

（3）数组中的数组即二维数组

其实是一个一维数组，它的每一个元素又是一个一维数组),可以看做是一张表格， 在数组中再存放数组，外层数组看做是行，内层数组看做列。

姓名	年龄	性别
Will	17	男
iWiller	16	女

两行三列的表格：

new  类型 [2][3] ;

示例： int[][] i3 = new int[][3];

二维数组的初始化：

动态初始化

int[ ][ ]  arr = new int[3][2];

定义了一个二维数组，其中有 3 个一维数组，每一个一维数组中有2个元素

静态初始化

int[ ][ ]  arr = new int[][]{ {1,2},{3,4}, {5,6}};

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

（5） 数组操作时的两个异常：

ArrayIndexOutOfBoundsException: 数组角标越界异常
NullPointerException:空指针异常

（6）数组的遍历：

[java]  view plain copy

1. int[] arr = {3,6,5,1,8,9,67};  
2.         //System.out.println("length:"+arr.length);  
3.      for(int x=0; x<arr.length; x++)  
4.         {  
5.             System.out.println("arr["+x+"]="+arr[x]+";");  
6.         }  

(7)获取数组中最值

[java]  view plain copy

1. 获取最大值：  
2. public static int getMax(int[] arr)  
3.     {  
4.         int max = arr[0];  
5.   
6.         for(int x=1; x<arr.length; x++)  
7.         {  
8.             if(arr[x]>max)  
9.                 max = arr[x];  
10.         }  
11.         return max;  
12.     }  
13. 获取最小值：  
14.   
15. <pre>public static int getMin(int[] arr)  
16.     {  
17.         int min = 0;  
18.         for(int x=1; x<arr.length; x++)  
19.         {  
20.             if(arr[x]<arr[min])  
21.                 min = x;  
22.         }  
23.         return arr[min];  
24.     }  
25.   
26. </pre>  

（8）数组的排序

选择排序：

[java]  view plain copy

1. public static void selectSort(int[] arr)    
2.     {    
3.         for(int x=0;x<arr.length-1;x++)    
4.         {    
5.             for(int y=x+1;y<arr.length;y++)//外循环每循环一次，就把最小值放到最左边    
6.             {    
7.                 if(arr[x]>arr[y])    
8.                 {    
9.                     int temp = arr[x];    
10.                     arr[x] = arr[y];    
11.                     arr[y] = temp;    
12.                 }    
13.             }    
14.         }    
15.     }    

冒泡排序：

[java]  view plain copy

1. public static void bubbleSort(int[] arr)    
2. {    
3.     for(int x=0;x<arr.length-1;x++)    
4.     {    
5.         for(int y=0;y<arr.length-x-1;y++)//外循环每进行一次，内循环的比较次数就减少一次    
6.         {    
7.             if(arr[y]>arr[y+1])//每次循环，将相邻两个元素进行比较，把大的元素不断右移。    
8.             {    
9.                 int temp = arr[y];    
10.                 arr[y] = arr[y+1];    
11.                 arr[y+1] = temp;    
12.             }    
13.         }    
14.     }    
15. }  或者：  

[java]  view plain copy

1. public static void bubbleSort2(int[] arr)    
2.     {    
3.         for(int x=arr.length-1;x>0;x--)    
4.         {    
5.             for(int y=0;y<x;y++)//外循环每进行一次，内循环的比较次数就减少一次    
6.             {    
7.                 if(arr[y]>arr[y+1])//每次循环，将相邻两个元素进行比较，把大的元素不断右移。    
8.                 {    
9.                     int temp = arr[y];    
10.                     arr[y] = arr[y+1];    
11.                     arr[y+1] = temp;    
12.                 }    
13.             }    
14.         }    
15.     }    

[java]  view plain copy

1.   

（9）数组的折半查找（数组必须是有序的）

[java]  view plain copy

1. //第一种方式    
2.     public static int binSearch(int[] arr ,int key)    
3.     {    
4.         int min = 0;    
5.         int max = arr.length-1;    
6.         int mid ;    
7.         while(min<=max)//只要min小于max，继续循环    
8.         {    
9.             mid = (min+max)/2;    
10.             if(arr[mid]!=key)    
11.             {    
12.                 if(key>arr[mid])    
13.                     min = mid + 1;    
14.                 if(key<arr[mid])    
15.                     max = mid - 1;    
16.             }    
17.             else    
18.                 return mid;    
19.         }       
20.         return -1;    
21.     }    
22. //第二种方式    
23.     public static int binSearch2(int[] arr ,int key)    
24.     {    
25.         int min = 0;    
26.         int max = arr.length-1;    
27.         int mid = (min+max)/2;    
28.         while(arr[mid]!=key)//只要中间值不等于key，继续循环    
29.         {    
30.             if(key>arr[mid])    
31.                     min = mid + 1;    
32.             if(key<arr[mid])    
33.                     max = mid - 1;    
34.             mid = (min+max)/2;    
35.             if(min>max)    
36.                 return -1;    
37.         }    
38.         return mid;    
39.     }    

（10）进制转换

十进制转换为二进制

[java]  view plain copy

1. public static void toBin(int num)  
2.     {  
3.         StringBuffer sb = new StringBuffer();  
4.   
5.         while(num>0)  
6.         {  
7.             //System.out.println(num%2);  
8.             sb.append(num%2);  
9.             num = num / 2;  
10.         }  
11.   
12.         System.out.println(sb.reverse());  
13.     }  

十进制转换为十六进制

[java]  view plain copy

1. public static void toHex(int num)  
2.     {  
3.   
4.         StringBuffer sb = new StringBuffer();  
5.   
6.         for(int x=0; x<8; x++)  
7.         {  
8.             int temp = num & 15;  
9.             if(temp>9)  
10.                 //System.out.println((char)(temp-10+'A'));  
11.                 sb.append((char)(temp-10+'A'));  
12.             else  
13.                 //System.out.println(temp);  
14.                 sb.append(temp);  
15.   
16.             num  = num >>> 4;  
17.         }  
18.         System.out.println(sb.reverse());  
19.   
20.     }  

查表法十进制转换为其他进制

[java]  view plain copy

1. public static String hexadecimalTransform(int num,int base,int offset)    
2. {    
3.     if(num==0)    
4.     {    
5.         return "0";    
6.     }    
7.     char[] chs = {'0','1','2','3','4',    
8.                 '5','6','7','8',    
9.                 '9','A','B','C',    
10.                 'D','E','F'};    
11.     char[] arr = new char[32];    
12.     int pos = arr.length;    
13.     while(num!=0)    
14.     {    
15.         int temp = num&base;    
16.         arr[--pos] = chs[temp];    
17.         num = num>>>offset;    
18.     }    
19.     StringBuilder sb = new StringBuilder();    
20.     for(int x=pos;x<arr.length;x++)    
21.     {    
22.         sb.append(arr[x]);    
23.     }    
24.     return sb.toString();    
25. }    

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------