java基础学习之函数、数组

1、函数

1、函数的定义

函数是定义在类中有特定功能的一小段程序，也称方法。定义格式：

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

{

执行语句;

return 返回值;

}

2、功能

定义函数可以对功能代码进行封装，提高代码的复用性，减少代码的重复度，提升程序的可读性。函数只有被调用时才会执行。

3、函数的重载

同一个类中可以允许出现同一个函数名的多个函数，只要他们的参数不同即可，函数重载即是函数名相同，参数不同，参数的顺序不同也叫做参数不同。

重载实例：

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}

下面这一句不是重载：

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

在同一个类中函数名参数相同，但是返回值不同，这个会引起混乱，是不允许存在于一个类中的。

2、一维数组

1、定义方法

int[] arr = new int[5];
int[] arr1 = {1,2,3};
int[] arr2 = new int[]{1,2,3};
int arr3[] = new int[3];

这四种方法都可以。

2、内存分配

如果这个数组是在方法中定义一句int[] arr = new int[5];，那么他的内存分配如下：



并且默认情况下，数组元素的值为0，内存是连续的。

3、常见异常

①、越界

int[] arr = new int
4000
[5];
System.out.println(arr[5]);

②、空指针

int[] arr = null;
System.out.println(arr[5]);

4、获取最值

public int getMax(int[] arr){
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]>max)  //最小值这里改为小于就可以
max = arr[i];
}
return max;
}

5、简单排序（从小到大）

①、选择排序（将小的放在前面）

思路：从第一个数开始，不停与后面的数比较，随小就放在第一位，然后类似的第二个数，直到倒数第二个数与最后一个数比完后，排序完成。

public static void sort1(int[] arr){
//从第一个数到倒数第二个数
for (int i = 0,temp = 0; i < arr.length-1; i++) {
//与后面一个数到最后一个数比较
for (int j = i+1; j < arr.length; j++) {
if(arr[i] > arr[j]){
//顺序交换
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}

②、冒泡排序（将大的放在后面）

思路：从标号0开始将前一个数和后一个数比较，大的放后面，然后标号加1，再比，比到最后两个一轮结束，然后从标号0开始比到倒数第二个和倒数第三个。。。。最后从标号0开始和标号1比，比完排序完成

public static void sort2(int[] arr){
for (int i = 0,temp =0 ; i < arr.length-1; i++) {
for (int j = 0; j <arr.length - i - 1 ; j++) {
if(arr[j]>arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}

6、进制转化（将十进制转化为其他进制并且用数组保存）

思路：写一个映射表，包含了字符0到字符A总共16个字符，对于二进制每次与上1取出最后一位，保存这个位到数组，然后右移一位，继续与，整个过程通过循环实现，循环结束的条件是十进制的数为0.对于转八进制和十六进制的思路一样，只是十六进制每次与15，右移4位，八进制与7，右移三位。

public static void changeSystem(int num,int base,int offset){
char[] cc = new char[32];
int i = 0;
//当需要转化的数不为0
while(num != 0){
//保存对应的位
cc[i++] = table[num&base];
//将这个数右移
num = num >>>offset;
}
for (int j= i-1; j >= 0; j--) {
System.out.println(cc[j]);
}
}
//转二进制
public static void toBinary(int num){
changeSystem(num,1,1);
}
//转十六进制
public static void toHex(int num){
changeSystem(num,15,4);
}
//转八进制
public static void toOctal(int num){
changeSystem(num,7,3);
}

7、折半查找

思路：用三个变量保存标号，一个是min初始指向0，一个值max默认指向最后一个数，mid等于min+max的和的一半，然后循环中不同比较要找的值和mid指向的值是否相等，相等就返回，大于min的标号等于mid右移一位，再算mid比，如果小于就将max指向mid左边一位，再比，等到min的值大于max的时候，循环退出。

public static int indexOfValue(int num,int[] arr){
int max = arr.length - 1;
int min = 0;
int mid = (max + min)/2;
//min小于max才比较，否则退出，
while(min <= max){
if(num > arr[mid]){
min = mid + 1;
mid = (max + min)/2;
}else if (num <arr[mid]) {
max = mid - 1;
mid = (max + min)/2;
}else {
return mid;
}
}
return -1;
}

8、折半查找可以用于有值要插入到有效数组里面求插入位置的情况

思路：利用上面的折半查找，如果插入的值原来的数列有，那么直接返回mid即可，如果没有就返回min举个例子，在3和5之间插入4，这个时候，min和max都指向了3，那么4和三比大于，那么min加1，退出循环，这个时候的min正好就是需要标号：

public static int getIndexOfInsert(int num,int[] arr){
int max = arr.length - 1;
int min = 0;
int mid = (max + min)/2;
while(min <= max){
if(num > arr[mid]){
min = mid + 1;
mid = (max + min)/2;
}else if (num <arr[mid]) {
max = mid - 1;
mid = (max + min)/2;
}else {
return mid;
}
}
return min;
}

2、二维数组

1、定义格式

二维数组其实就是数组中的数组，一个数组有三个格子，然后每个格子里面又存了一个数组。

定义格式：

int[][] arr = new int[3][2];
int[][] arr = new int[3][];
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

除了这三格式外，还可以将前面的[]任意移动如：int[] arr[] int arr[][]都可以。

第一种定义方法表示定义了一个二维数组，三行两列，第二个定义方法是定义了一个二维数组，三行，列还没有定义，也就是，这个二维数组分为三个一位数组，arr[0] 指向null，arr[1],指向null，arr[2]指向null；第三种情况表示，arr[0] = {3,8,2},arr[1]={2,7},arr[2]={9,0,1,6}.

2、内存分配