——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
函数：
函数就是定义在类中的具有特定功能的一段独立小程序，函数也称为方法。
函数格式：
修饰符 返回值类型 函数名(参数类型 形式参数1；参数类型 形式参数2)
{
执行语句;
return 返回值;
}
1. 返回值类型：函数运行后的结果的数据类型
2. 参数类型：是形式参数的数据类型
3. 形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数
4. 实际参数：传递给形式参数的具体数值
5. return：用于结束函数
6. 返回值：该值会返回给调用者
函数的特点
- 定义函数可以将功能代码进行封装。
- 便于对该功能进行复用。
- 函数只有被调用才会被执行。
- 函数的出现提高了代码的复用性。
P.S.
- 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写，或者写上return;。
- 函数中只能调用函数，不可以在函数内部定义函数。否则，编译时期就会报错。
- 定义函数时，函数的结果应该返回给调用者，交由调用者处理。
函数的重载：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的好处：
方便于阅读，优化了程序设计。
P.S.
- 重载与返回值类型无关，只看参数列表。
- java是严谨性语言，如果函数调用出现不确定性，会编译失败。
class FunctionDemo{
public static void main(String[] args){
System.out.println(add(3,4));
System.out.println(add(3.0,4.0));
System.out.println(add(3,4,5));
}
//加法运算，两个整数的和
public static int add(int a, int b){
return a + b;
}
//加法运算，两个小数的和
public static double add(double a, double b){
return a + b;
}
//加法运算，三个整数的和
public static int add(int a, int b,int c){
return add(a,b) + c;
}
}数组
数组就是同一种类型数据的集合。其实，数组就是一个容器。
数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：需要一个容器，但是不明确容器的具体数据。
元素类型[] 数组名 = new 元素类型[元素个数];
格式2：需要一个容器，存储已知的具体数据。
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
内存的划分：
- 寄存器。
- 本地方法区。
- 方法区。
- 栈内存。
- 堆内存。
栈内存：
同于存储局部变量、基本类型的变量和对象的引用变量，数据使用完会自动释放所占空间。
一个函数分配一个栈内存空间，该栈内存空间中数据可以共享。
堆内存：
数组和对象，通过new建立的实例都存放在堆内存中，每一个实体都有内存地址值，实体中的变量都有默认初始化值，实体不再使用时，会在不确定的时间内被垃圾回收器回收
方法区：
存放的是整个程序中唯一的元素，如class和静态变量，代码、函数的解析也是在此进行
数组的引用放在栈内存中，实体数据存储在堆内存中。引用指向实体数据。
数组排序：
选择排序：
使用嵌套循环的方式，让头角标上的元素按顺序分别与后面的元素进行比较，符合条件就调换位置，使得头角标始终为较小或较大的元素，这为第一圈，第一圈完成后最值位于头角标处。
第二圈由第二位的元素与后面的元素进行比较，第二圈完成后第二最值位于第二位置上……以此类推循环直到只剩下最后位，排序完成。
选择排序最值在头位。
public static void selectSort(int[] arr)
{
for (int x=0; x<arr.length-1 ; x++)//第(x+1)圈循环
{
for(int y=x+1; y<arr.length; y++)//在第(x+1)圈时让第x角标位上的元素分别与后面元素进行比较
{
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++)//第(x+1)圈循环
{
for(int y=0; y<arr.length-x-1; y++)//在第(x+1)圈时让0角标位元素开始与相邻元素进行比较，到（数组长度-x-1）角标处结束
{
if(arr[y]<arr[y+1])//符合条件就调换位置
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}实际开发中，有Arrays.sort(arr)可以直接进行数组排序
折半查找：
提高效率，但是必须要保证该数组是有序的数组。
思路：
- 设置三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为（max+min）/2。
- 查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
- 如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。设置max = mid - 1，mid = (max + min)/2，重复第1、2步的操作。
- 如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。设置min = mid + 1，mid = (max + min)/2，重复第1、2步的操作。
- 如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值，此时返回-1。
class ArrayDemo{
public static void main(String[] args) {
int[] arr= {13,15,19,28,33,45,78,106};
int index = binarySearch(arr,78);
System.out.println("index = " + index);
}
public static int binarySearch(int[] arr, int key){
int max,min,mid;
min = 0;
max =arr. length - 1;
mid = (max + min)/2;
//判断中间值是否为要找的数
while(arr[mid] !=key){
//不是的话，判断key在哪个区域
if(key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
//如果max<min，说明key不存在于数组中，返回-1
if(max < min)
return -1;
//再找出该区域的中间值
mid = (max + min)/2;
}
return mid;
}
}int x = Arrays.binarySearch(arr,190);//java提供好的一个进行折半查找的功能。开发时使用这个。
进制转换：
十进制转十六进制
查表法：
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)
{
//&15得到最后4个二进制位的值
int temp = num & 15;
//System.out.println(chs[temp]);
//4个二进制位刚好是1个十六进制位，可以得到十六进制位的最后一位
arr[--pos] = chs[temp];
//把数右移4位，再得到接下来的值
num = num >>> 4;
}
System.out.println("pos="+pos);
//存储数据的arr数组遍历。
for(int x=pos;x<arr.length; x++)
{
System.out.print(arr[x]+",");
}
}二维数组：
二维数组[][]
格式1：
int[][] arr = new int[3][2];
- 定义了名称为arr的二维数组。
- 二维数组中有3个一维数组。
- 每一个一维数组中有2个元素。
- 一维数组的名称分别为arr[0], arr[1], arr[2]。
- 给第一个一维数组第一个脚标位赋值为78写法是：arr[0][1] = 78;。
- arr存储的是二维数组的初始地址，arr[0]、arr[1]、arr[2]存储的是一维数组的初始地址。
class Array2Demo
{
public static void main(String[] args){
int[][] arr = new int[3][2];
//直接打印二维数组
System.out.println(arr);
//直接打印二位数组中的角标为0的一维数组
System.out.println(arr[0]);
//直接打印二维数组中的角标为0的一维数组的角标为0的元素
System.out.println(arr[0][0]);
}
}格式2：
int[][] arr = new int[3][];
二维数组中有3个一维数组，每个一维数组都是默认初始化值null，可以对这个三个一维数组分别进行初始化。
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
格式3：
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组，二维数组中的有三个一维数组，每一个一维数组中具体元素也都已初始化。
第一个一维数组 arr[0] = {3,8,2};，第二个一维数组 arr[1] = {2,7};，第三个一维数组 arr[2] = {9,0,1,6};。
第三个一维数组的长度表示方式：arr[2].length;。
/*
求二维数组所有元素的和
*/
class Array2Demo
{
public static void main(String[] args){
int sum = 0;
int[][] arr = {{3,1,7},{5,8,2,9},{4,1}};
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);
}
}