函数：
特点：
1，程序中一段独立的小程序。
2，该程序实现了独立功能。
3，被调用才会被执行。
4，可以被重复使用。
如何定义一个函数呢？
1，明确该功能运算后的结果。其实是为了明确函数的返回值类型。
2，明确该功能实现过程中，是否有未知内容参与运算。其实是为了明确函数的参数列表。
int add(int x,int y)
{
return x+y;
}
main()
{
int x = add(4,5);
System.out.println("x="+x);
}
注意：对于一个功能没有具体返回值的时候，用void来表示。这时函数内可以不用书写return语句。
函数的特性：重载。
定义：一个类中，可以存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
通常在功能时，如果功能一致那么没有必要定义过多的功能名称，用同一个即可。
在该功能实现的时候所需的参数有不同。
int add(int x,int y)
{
return x+y;
}
int add(int x,int y,int z)
{
return x+y+z;
}
main()
{
add(3,4,6);
}
/*
需求：
思路：
*/
boolean compare(int x,int y)
{
/*
if(x==y)
return true;
else
return false;
*/
//return (x==y)?true:false;
return x==y;
}
注意：
定义函数时，建议函数内的代码不过长，将函数的多个小功能进行再次的函数封装。
---------------------------------------------
数组：
定义：同一类型数据的集合。
定义格式：
1，元素类型[] 数组名称 = new 元素类型[数组长度];
2，元素类型[] 数组名称 = {3,4,1,6};
好处：可以数组中的元素进行编号。从0开始。
什么时候使用数组呢？
当元素较多时，为了便于操作，需要将这些元素进行临时存储。那么数组就是该临时存储的一种体现形式。
也可以称之为容器。
为了操作数组中的元素，明确元素的个数。数组实体提供了一个属性length.
int[] arr = new int[2];
在内存中分配情况。
1，在堆内存中建立一个数组实体，并划分了两个元素空间。
并将这个两个空间进行了默认初始化。
2，在栈内存中定义一个数组类型的变量arr。
3，将堆内存中的数组实体的内存地址值赋给了变量arr。
4，arr就指向了该数组实体。
基本数据类型和引用数据类型的区别：
基本数据类型是将数据存入变量中。
引用数据类型存放的是实体的地址，用来引用实体。
该实体可以被多个引用所指向。
栈内存：
存放的是局部变量，当该局部变量作用的范围结束时，该变量会自动释放。
堆内存：
存放的是数组和对象，也就是实体。
1，每一个实体都有内存地址值。
2，该内存中的变量都有默认初始化值。
3，垃圾回收机制回收。
数组在使用时需要注意的事项：
1，数组角标越界异常：ArrayIndexOutOfBoundsException
当使用到数组中不存在的角标时，就会发生该异常。注意，该异常出现的运行时期。
2，空指针异常:NullPointerException.
当引用数据类型值为null时，还在操作实体，就会发生该异常。
----------------------
数组的常见操作：
1，遍历。通常要获取数组中的元素，都需要遍历动作。
获取元素原理：其实就是通过角标，以及角标的不断变化。
2，获取最值。
思路：
这些元素都需要比较，而且比较时，需要将比较大的记录下来。
当都比完时，最后记录的那个就是最值。
步骤：
1，定义一个变量记录住比较大的值。那么该变量在定义时，如何初始化呢？
初始化为数组中的任意一个元素即可。或者初始化为数组中的任意一个角标即可。
2，需要元素自动的比一下。使用到了循环结构。
在循环过程中加入条件。只要有比该变量大的值就将其记录。
/*
获取整形数组最大的值。
*/
public static int getMax(int[] arr)
{
int max = arr[0];
for(int x=1; x<arr.length; x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}
/*
获取整形数组最小的值。
*/
public static int getMin(int[] arr)
{
int min = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
3，排序。
选择排序：
原理：指定一个位置，不断的使用该位置上的元素与其他元素进行比较。
如果满足条件，进行元素的换位，继续使用该位置元素进行下一次比较。
特点：内循环结束一次，在起始位出现最值。
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; x++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
private static void swap(int[] arr,int x,int 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++)
{
for(int y=0; y<arr.length-x-1; y++)
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
}
实际开始时，如果用到了排序，要使用java提供的方式，Arrays.sort(arr);//默认就是升序的。
4，查找。
1.获取指定数据在数组中的第一次出现的位置。
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
2,对于一个有序的数组这样的查找是低效的。
为了提高效率，来了一个折半查找。
前提：必须是有序的数组。
思路：
通过头角标和尾角标的和除以2，取中间角标的元素进行比较。
如果要找元素大于中间角标元素，那么查找范围减少到一半，再次在剩下一半中继续折半。
但这时头角标或者尾角标在变化。
public static int halfSearch(int[] arr,int key)
{
int max,min,mid;
max = arr.length-1;
min = 0;
mid = (max+min)/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 int halfSearch(int[] arr,int key)
{
int max,min,mid;
max = arr.length-1;
min = 0;
while(min<=max)
{
mid = (max+min)/2;
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
----------------------------------------
二维数组：
其实就是数组中的数组。
格式：int[][] arr = new int[3][];
System.out.println(arr[0]);//null
arr[0] = new int[2];
System.out.println(arr[0])//该数组的哈希值。
arr[1] = new int[3];
arr[2] = new int[1];
int[] arr = {{20,30,12,89},{4,21,6}};
int sum = 0;
for(int x=0; x<arr.length; x++)
{
for(int y=0; y<arr[x].length; y++)
{
sum = sum + arr[x][y];
}
}
System.out.println("sum="+sum);
int[] x,y[];//int[] x; int[][] y; int[] x ;
x = y[0];
x[0] = y[0];
x[0] = y;
x = y;
