1 数组作为参数
 
我们可以将数组作为参数，传入到函数中，其实就像我们main函数中 public void main(String [] args){};就是用数组作为函数参数；
 
又如，
 
 
 
 
  

   [java] 
    view plain
     copy
    
   
   
  
 
 
 
 
public class ArrayPar  
{  
    public static void printArray(int [] array)  
    {  
        for(int i=0;i<array.length;i++)  
 
            System.out.print(array[i]+"  ");  
    }  
}  
 
 我们可以这样调用 ArrayPar.printt(new int[ ]{3,2, 5,67});调用数组 
这里的new int[ ]{3,2,5,67};他也是一种创建数组的方法，只是这种方法创建出来的数组是没有名字的，所以叫匿名数组。很多时候在只使用一次的时候可以使用匿名数组的方法法，类似的还有匿名类。
 
Java uses pass-by-value to pass arguments to a method. There are important differences
 between passing the values of variables of primitive data types and passing arrays.
 ■ For an argument of a primitive type, the argument’s value is passed.
 ■ For an argument of an array type, the value of the argument is a reference to an array;
 this reference value is passed to the method. Semantically, it can be best described as
 pass-by-sharing, i.e., the array in the method is the same as the array being passed.
 So if you change the array in the method, you will see the change outside the
 method.
 
 
java 使用值传参（pass_by_value）的方式来传递函数参数，只是值传递方式在处理原始数据类型参数与引用类型参数时候有不同，如果一个参数是原始数据类型，那么参数变量的值传递进去。如果是引用类型，是传进了引用变量的值（也就是说，只是将指向数据的引用的值给传进去了，也就是被调用的函数新建的空间放的是这个引用的值，那么也就是也指向了数组存在的内存），所以同样是值传递，引用类型的传入的当然是引用变量的值，指向了同一数组，那么函数内对数组进行的修改在函数退出后依旧是有效的。
 
例子：
 
 
 
 
  

   [java] 
    view plain
     copy
    
   
   
  
 
 
 
 
public class ArrayPar  
{  
    public static void main(String [] args)  
    {  
        int x=1;  
        int y[]={1,2,3};  
        change(x,y);  
        System.out.println("x="+x+",y[0]="+y[0]);  
    }  
    public static void change(int num,int [] array)  
    {  
        num=100;  
        array[0]=100;  
    }  
}  
 
 
图形表示：
 

 
 
这里同时注意一下，当我们用new 以及malloc这些的内存空间是在堆上heap，而像我们被调用的函数中使用的这些变量等在栈上。在调用changes时候，x的值被传入，在被调用的函数中重新开辟一个空间来放这个基本数据类型参数，但是int [ ] y ，将y传入其实就是传入了引用，在被调用的函数的栈上只会开辟一个空间来存放这个引用，所以被调用的函数与调用者 中两个引用指向堆上同一块内存。
 

 
 
2 数组做为函数返回值
 
 
 
 
  

   [java] 
    view plain
     copy
    
   
   
  
 
 
 
 
public static<span style="color:#ff0000;"> int []</span> reverse(int [] array)  
{  
    int [] result=new int[array.length]  
    for(int i=0;i<array.length;i++)  
    {  
        result[i]=array[lenght-i];  
    }  
    return result;
}  
 
 在将数组作为函数返回值时候如上红色标出的，就是在函数名字前加上返回值类型是int [ ] 表示返回一个int型数组，在函数体内最后返回是result这样的函数引用。 

 
 
Case Study: Counting the Occurrences of Each Letter
 
write a program to count the occurrences of each letter in an random array of  lower  characters.
 
那么我们可以怎么做呢？
 
1）首先是要产生一个随机char数组  creatArray();（是否记得前边说过产生[a,a+b)之间的一个随机数 为  a+Math.random()*b,是否记得我们创建过获取任意字符的一个类？）
 
2) 创建一个数组 int [ ] count,长度26,准备来存放各个字母的计数
 
3）对数组进行循环 ， 每读取一个字母ch，则 count[ch-'a']++;
 
 
 
 
  

   [java] 
    view plain
     copy
    
   
   
  
 
 
 
 
class RandomChar  
{  
    public static char getRandomChar(char ch1,char ch2)  
    {  
        return (char)(ch1+Math.random()*(ch2-ch1+1));  
    }  
    public static char getLowerCaseLetter()  
    {  
        return getRandomChar('a','z');  
    }  
    public static char getUpperCaseLetter()  
    {  
        return getRandomChar('A','Z');  
    }  
    public static char getDigitalLetter()  
    {  
        return getRandomChar('0','9');  
    }  
    public static char getRandomLetter()  
    {  
        return getRandomChar('\u0000','\uFFFF');  
    }  
}  
public class CountOccur  
{  
    public static void main(String [] args)  
    {  
         char [] array=CreateArray();  
         int [] count = new int[26];  
         for(int i=0;i<array.length;i++)  
         {  
             count[array[i]-'a']++;  
         }  
         for(int i=0;i<count.length;i++)  
         {  
            System.out.print((char)(i+'a')+": "+count[i]+"    ");  
            if((i+1)%10==0) System.out.println();  
         }  
           
           
    }  
    //产生一个100个元素的小写随机数组  
    public static char[] CreateArray()  
    {  
        char [] a=new char[100];  
        for(int i=0;i<a.length;i++)  
        {  
            a[i]=RandomChar.getLowerCaseLetter();  
        }  
        return a;  
    }  
}  
 
 

 

 

 
 
3 可变长度参数列表
 
You can pass a variable number of arguments of the same type to a method. The parameter in
 the method is declared as follows:
 typeName... parameterName
 In the method declaration, you specify the type followed by an ellipsis Only one vari-
 able-length parameter may be specified in a method, and this parameter must be the last para-
 meter. Any regular parameters must precede it.
 Java treats a variable-length parameter as an array. You can pass an array or a variable
 number of arguments to a variable-length parameter. When invoking a method with a variable
 number of arguments, Java creates an array and passes the arguments to it
 
 
我们可以传递类型相同，但个数可以变化的参数到函数中，如果有这个需求的话，这时候我们只需要在形式参数中使用 typename...parameterName就可以达到这个目的，要注意，在这里声明的该变长参数必须是最后一个参数，任何常规参数必须在他之前，也就是说你可以有 MethodName(char b, double c, int ... nums) 这样的形式即int ... nums必须在最后一个位置，你不能将int ... nums 声明在参数参数列表的非最后位置。
 
java将可变长参数当做数组对待。可以将一个数组或者可的参数个数传递给该参数（注意，我们这里说该参数就是 typeName ... parameterName这整个结构），无论哪种形式，java会创建一个数组并把参数传给他，注意这里体会原文说的When invoking a method with a variable
 number of arguments， java Create an array and passes the arguments to it,也就是说，如果你是传入几个变长的变量，那么在调用时候java先将创建一个数组来装这几个实际参数，然后再执行调用的函数，如果本身我们传入一个数组，其实他并不会创建一个新的数组来装，还是一样像上面指向了已经分配的数组空间，所以在被调用的函数中对数组的改变在退出时候还是有效的（这是我用例子试了下体会到的）
 
 
 
 
  

   [java] 
    view plain
     copy
    
   
   
  
 
 
 
 
public class VariablePar  
{  
    public static void main(String [] args)  
    {  
        int array[]={1,4,7,2,0};  
        System.out.println("max="+findMax(array));  
        ifChange(array);  
        System.out.println("array[0]="+array[0]);  
        ifChange(1,45,33);  
    }  
    public static int findMax(int ... nums)  
    {  
        if(nums.length==0)   
        {  
            System.out.println("No argumment passed");  
            return -1;  
        }  
        int max=nums[0];  
        for(int i=1;i<nums.length;i++)  
        {  
            if(max<nums[i]) max=nums[i];  
        }  
        return max;  
    }  
    //测试这里究竟是新创建一个数组还是相当于把引用传进来而已  
    public static void ifChange(int ... nums)  
    {  
        nums[0]=100;  
    }  
}  
 
 这里，我们从findMax中看到，他不用先说明 什么就可以直接使用nums.lenght 说明确实java是完全将这类型的参数当做一个数组来处理了，二在ifChange中，我们看到输出的是array[0]=100,说明我们在调用ifChange(array)时候并不是重新创建一个新的数组，而是还是一样像前边的传入了引用，被调用者还是指向了相同的数组空间。但是在ifChage(1,45,33)这个调用时候，java就会先new int[ ]{1,45,33} 这样，然后形参nums再指向它，其实这样返回后应该就不会改变了1的值吧？

调用有参函数时需要提供实参，实参可以是常量，变量或者表达式，数组元素就相当于变量，因此数组元素可以用作函数实参，但是不能用作函数形参（因为在函数被调用时临时分配存储单元，不可能为一个数组单独分配存储单元数）数组名可以做实参和形参，但此时传递的是数组第一个元素的地址；
 
用一个一维数组内放N个学生的成绩，求平均成绩；
 #include<stdio.h>
 #define N 10
 int main()
 {
 float average(float array[N]); //函数的声明
 float score[10],aver;
 int i;
 printf(“enter 10 scores:\n”);
 for(i=0;i<N;i++)
 scanf("%f",&score[i]);
 printf("\n");
 aver=average(score); //调用average函数
 printf(“average score is %5.2f\n”,aver);
 return 0;
 }
 
float average(float array[N]) //定义average函数
 {
 int i;
 float aver,sum=array[0];
 for(i=1;i<N;i++)
 sum=sum+array[i]; //累加学生的成绩
 aver=sum/N; //求N个学生总成绩的平均值
 return(aver); //以aver作为函数的返回值
 }
 
注意;
 1.用数组名做函数参数时应在主调函数和北调函数中分别定义数组，如在该程序中array是形参数组名，score是实参数组名，应分别在函数中有定义
 2.由于数组名代表的只是数组首元素的地址因此当实参向形参传递值时 ，形参数组首元素（array【0】）和实参数组首元素（score【0】）具有同一地址，共站同一存储空间，具有相同的值
 
欢迎使用Markdown编辑器
 
你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。
 
新的改变
 
我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：
 
全新的界面设计 ，将会带来全新的写作体验；
在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
全新的 KaTeX数学公式 语法；
增加了支持甘特图的mermaid语法 功能；
增加了 多屏幕编辑 Markdown文章功能；
增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
增加了 检查列表 功能。
 
功能快捷键
 
撤销：Ctrl/Command + Z
 重做：Ctrl/Command + Y
 加粗：Ctrl/Command + B
 斜体：Ctrl/Command + I
 标题：Ctrl/Command + Shift + H
 无序列表：Ctrl/Command + Shift + U
 有序列表：Ctrl/Command + Shift + O
 检查列表：Ctrl/Command + Shift + C
 插入代码：Ctrl/Command + Shift + K
 插入链接：Ctrl/Command + Shift + L
 插入图片：Ctrl/Command + Shift + G
 
合理的创建标题，有助于目录的生成
 
直接输入1次#，并按下space后，将生成1级标题。
 输入2次#，并按下space后，将生成2级标题。
 以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。
 
如何改变文本的样式
 
强调文本 强调文本
 
加粗文本 加粗文本
 
标记文本
 
删除文本
 
 
 
引用文本
 
 
H2O is是液体。
 
210 运算结果是 1024.
 
插入链接与图片
 
链接: link.
 
图片: 
 
带尺寸的图片: 
 
当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。
 
如何插入一段漂亮的代码片
 
去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.
 
// An highlighted block
var foo = 'bar';
 
生成一个适合你的列表
 
项目 
  
项目 
    
项目
 
 
 
项目1
项目2
项目3
 
 计划任务
 完成任务
 
创建一个表格
 
一个简单的表格是这么创建的：
 
项目
Value
电脑
$1600
手机
$12
导管
$1
设定内容居中、居左、居右
 
使用:---------:居中
 使用:----------居左
 使用----------:居右
 
第一列
第二列
第三列
第一列文本居中
第二列文本居右
第三列文本居左
SmartyPants
 
SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：
 
TYPE
ASCII
HTML
Single backticks
'Isn't this fun?'
‘Isn’t this fun?’
Quotes
"Isn't this fun?"
“Isn’t this fun?”
Dashes
-- is en-dash, --- is em-dash
– is en-dash, — is em-dash
创建一个自定义列表
 
 
 
  Markdown
  
 

  Text-to-
  HTML conversion tool
 
 
 
  Authors
  
 

  John
 
 
 

  Luke
 
 
 
如何创建一个注脚
 
一个具有注脚的文本。
 
注释也是必不可少的
 
Markdown将文本转换为 HTML。
 
KaTeX数学公式
 
您可以使用渲染LaTeX数学表达式 KaTeX:
 
Gamma公式展示 $\Gamma (n)=(n-1)!\forall n\in \mathbb{N}$ 是通过欧拉积分
 
$$\Gamma (z)={\int }_0^{\infty }{t}^{z-1}{e}^{-t}dt.$$
 
 
 
你可以找到更多关于的信息 LaTeX 数学表达式here.
 
 
新的甘特图功能，丰富你的文章
 

 
 
关于 甘特图 语法，参考 这儿,
 
UML 图表
 
可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：:
 

 
 
这将产生一个流程图。:
 

 
 
关于 Mermaid 语法，参考 这儿,
 
FLowchart流程图
 
我们依旧会支持flowchart的流程图：
 

 
 
关于 Flowchart流程图 语法，参考 这儿.
 
导出与导入
 
导出
 
如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。
 
导入
 
如果你想加载一篇你写过的.md文件或者.html文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
 继续你的创作。
 
 
 
 
mermaid语法说明 ↩︎
 
注脚的解释 ↩︎
 
 

要确定一个一维数组需要知道什么信息？一个数组的首地址，另一个是数组的长度。这样就可以唯一的确定一个数组了，因为数组是连续存放的，只要知道数组的首地址和数组的长度就能找到这个数组中所有的元素，那么只要传递这两个信息即可。而一维数组的数组名就表示着一维数组的首地址。所以只需要传递数组名和数组长度这两个参数就可以将数组从主调函数传入被调函数中。
 
当数组名作为函数的实参时，形参列表中也应定义相应的数组（或用指针变量），且定义数组的类型必须与实参数组类型一致，如果一旦出错。但是形参中定义的数组无需指定数组的长度，而是再定义一个参数用于传递数组的长度，所以在传递实参的时候，数组名和数组长度也只能用于两个分开传递，而不能写在一起。因为即使写在一起，系统在编译时也只是检查数组名，并不会检查数组长度，所以数组长度要额外定义一个变量进行传递。
 
#include<stdio.h>
int AddArray(int array[], int n);
int main(void)
{
	int a[] = {1,2,3,4,5,6,7,8};
	int size = sizeof(a) / sizeof(a[0]);
	printf("sum = %d\n", AddArray(a, size));
	return 0;
}
int AddArray(int array[], int n)
{
	int i, sum = 0;
	for(i=0; i<n; ++i)
	{
		sum += array[i];
	}
	return sum;
}
 

 有人可能会说，实参数组a占32字节&#x

指针数组 
 

 首先从名字就可以知道这是一个数组，是存放指针的数组。
 

 先看几种指针数组：
 

 
 
int *arr1[10];
char *arr2[5];
char **arr3[6];
因为 [ ] 的优先级是高于 * 的，所以数组名会先于 [ ] 相结合组成数组。 再于 int * / char *类型结合，组成存放该类型的数组。
 

 
 
 
 

 
 
 

 
 
 
 

 指针数组因为存放的都是指针所以不管是 int *   char * 还是 char ** 其大小都是四个字节。
 
 
 

 
 
 
数组指针 
 
从名字看就知道是指针，是指向一个数组的指针。
 
 
int (*p)[10];
char (*p)[10];
由数组指针知道 [ ] 的优先级是高于 *  的，所以用（）来提升指针先结合。 
 
 
int (*p)[10];  //  是一个指向10个整形的一维数组的指针
char (*p)[10]; //  是一个指向10个字符型的一维数组的指针
 
 
数组的存储方式
 


 

 
因为指向的是一个数组，所以大小由数组决定 

 
 
函数指针
 

 指向函数的指针，通俗的说也就是函数的地址
 

 
void(*pfun)();
 
 

  pfun 先和*结合，说明pfun是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void
 
 
 

  也就是说 其可以保存函数的地址
 
 
 

 
 
 

 
 
 

 
 
 
函数指针数组
 

 
int (*parr[3])();
 parr先与 [ ]结合，说明是一个数组，再与*结合，说明数组存放的是指针，指针都指向的是函数
 

 函数指针数组的使用（转移表）
 

 例子：计算器
 

 
#include<stdio.h>

int add( x, y)
{
	return x + y;
}
int sub(x,y)
{
	return x - y;
}
int mul(x,y)
{
	return x * y;
}
int div(x,y)
{
	return x / y;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*parr[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
	while (input)
	{
		printf("*******************************\n");
		printf("***** 1.add         2.sub *****\n");
		printf("***** 3.mul         4.div *****\n");
		printf("*******************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input > 0 && input < 5))
		{
			printf("输入你要计算的数：\n");
			scanf("%d  %d", &x, &y);
			ret = (*parr[input])(x, y);
		}
		else
			printf("输入有误！\n");
		printf("%d\n", ret);
	}
	return 0;
}
 

 输出结果：
 

 
 
 

 
 
 
指向函数指针数组的指针 
 
这是一个指针，指向一个数组，这个数组是一个函数指针数组，数组中的元素都是函数指针
 
定义方式：
 
 
#include<stdio.h>
void test(const char *str)
{
	printf("%s\n", str);
}
int main()
{
	void (*pfun)(const char*) = test;
	//函数指针pfun
	void (*pfunArr[5])(const char* str);
	//函数指针的数组pfunArr
	void (*(*ppfunArr)[10])(const char* str) = &pfunArr;
	//指向函数指针数组pfunArr的指针ppfunArr
	return 0;
}