黑马程序员--函数与数组

一、函数

(1)定义：定义在类中，有特定功能的一段小程序。

(2)函数的格式：
修饰符 返回值类型 函数名(形参类型 形式参数1,形参类型 形式参数2...)
{
函数体;
reutrn 返回值;
}
A:修饰符public static
B:返回值类型程序最终结果的数据类型
C:函数名其实就是函数的名称,方便我们调用。
D:参数
形参类型数据类型
形式参数就是接收实际参数的变量
实际参数就是实际参与操作的变量(常量)
E:函数体就是按照正常的逻辑完成功能的代码。
F:返回值就是程序的最终结果
G:reutrn 返回值哪里调用程序，return就把结果返回到哪里。
(3)函数的特点：
A:函数与函数之间是平级关系。不能在函数中定义函数。
B:运行特点函数只有被调用才执行。  

(4)函数的调用

A:有明确返回值
a:单独调用   一般没有意义。
b:输出调用   但是如果想拿结果继续操作，就有问题了。所以，不好。
c:赋值调用   推荐方式。
B:void类型
单独调用

下面是例子说明：

[java] view plaincopy

1. public class HanShuDemo {    
2.     
3.     public static void main(String[] args) {    
4.         int x=3;    
5.         int y=7;    
6.        
7.         show(x,y);   //单独调用    
8.             
9.         System.out.println(show(x,y));  //输出调用    
10.             
11.         int z=show(x,y);   //复制调用    
12.         System.out.println(z);    
13.             
14.     }    
15.     //写一个函数，求两个数的和  （函数之间是平级关系）    
16.     public static int show(int a,int b){    
17.         int c=a+b;    
18.         //返回值    
19.         return c;    
20.     }    
21. }    

(5)函数的重载
A:函数名相同,参数列表不同(个数不同,对应的类型不同)。
 与返回值类型无关。
B:举例：
public static int sum(int a,int b){...}
public static int sum(int a,int b,int c){...}
public static int sum(float a,float b){...}

二、数组

(1)概念     

(1)数组是存储同一种类型的多个元素的容器。
    (2)好处：数组中的元素会被自动从0开始编号，方便我们获取。

 

(2)一维数组的格式

       

格式：
A:int[] arr = new int[3];
B:int arr[] = new int[3];
C:int[] arr = new int[]{1,2,3};
D:int[] arr = {1,2,3};

        其中：new是用来在堆内存中产生一个容器实体。

数组也被称为引用数据类型。在内存中的分配如下图：

注：1、System.out.println(arr);得到的结果是一个哈希值，也叫地址值。

        2、数组在堆内存开辟空间后，就有默认的初始化值。如：int默认0；boolean默认false。

内存小知识：

        Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

        栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

        堆内存：1、数组和对象，通过new建立的实例都存放在堆内存中。

                      2、每一个实体都有内存地址值。

                      3、实体中的变量都有默认初始化值。

                      4、实体不在被使用，会在不确定的时间内被垃圾回收器回收。

 

(3)数组操作常见问题

     1、数组脚标越界异常(ArrayIndexOutOfBoundsException)。例：

                int[] arr = new int[2];

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

               访问到了数组中的不存在的脚标时发生。

     2、空指针异常(NullPointerException)。例：

               int[]arr = null;

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

                 arr引用没有指向实体，却在操作实体中的元素时。

 

(4)数组中的数组（多维数组）

   下面主要讲二维数组。       

格式：
A:int[][] arr = new int[3][2];
B:int[][] arr = new int[3][];
C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

二维数组在内存中的分配情况示例：

 

(5)数组常见操作

1、数组遍历：

 获取数组中的所有元素

下面是数组遍历求和的应用

[java] view plaincopy

1. public class ShuZuDemo {    
2.     public static void main(String[] args) {    
3.         int[] in={34,54,32,56};    
4.         int sum=0;    
5.         //下面实现数组的遍历    
6.         for (int i : in) {      //增强for    
7.             //求和    
8.             sum+=i;    
9.         }    
10.         System.out.println(sum);    
11.     }    
12. }    

2、数组的查找

下面是查找的实现程序

[java] view plaincopy

1. public class ShuZuDemo {  
2.     public static void main(String[] args) {  
3.         int[] in={34,54,32,56};  
4.         int ii=564;  
5.         int sum=-1;  
6.         //遍历数组  
7.         for(int x=0;x<in.length;x++){  
8.             //判断并输出  
9.             if(in[x]==ii){  
10.                 sum=x;  
11.                 System.out.println(sum);  
12.             }  
13.         }  
14.         if(sum==-1){  
15.             System.out.println("要查找的数据不存在");  
16.         }  
17.         }  
18. }  

3、 数组排序：

        常见的排序方式：冒泡排序和选择排序。在Java已经定义好了一种排序方式，在开发使用中，直接调用即可。排序的方式有很多，其中最快的排序方式为希尔排序。

下面是选择和冒泡两种排序方式的程序：

选择排序：

[java] view plaincopy

1. public class ShuZuDemo {  
2.     public static void main(String[] args) {  
3.         int[] in={34,54,32,56,54};  
4.         int sum=-1;  
5.         //遍历数组  
6.         for(int x=0;x<in.length;x++){  
7.             for(int y=0;y<in.length;y++){  
8.                 //元素比较,大的放后面  
9.                 if(in[x]<in[y]){  
10.                     sum=in[x];  
11.                     in[x]=in[y];  
12.                     in[y]=sum;  
13.                 }  
14.             }  
15.         }  
16.         //遍历数组  
17.         for (int i : in) {  
18.             System.out.println(i);  
19.         }  
20.         }  
21. }  

冒泡排序：

[java] view plaincopy

1. public class ShuZuDemo {  
2.     public static void main(String[] args) {  
3.         int[] in={34,54,32,56,54};  
4.         int sum=-1;  
5.         //遍历数组  
6.         for(int x=0;x<in.length-1;x++){  
7.             for(int y=0;y<in.length-1-x;y++){  
8.                 //元素比较,大的放后面  
9.                 if(in[y]>in[y+1]){  
10.                     sum=in[y];  
11.                     in[y]=in[y+1];  
12.                     in[y+1]=sum;  
13.                 }  
14.             }  
15.         }  
16.         //遍历数组  
17.         for (int i : in) {  
18.             System.out.println(i);  
19.         }  
20.         }  
21. }