黑马程序员_Java基础_函数,数组,常用排序

一，函数的相关知识点

1，函数也称为方法，函数是定义在类中的具有特定功能的一段代码块。函数之间不能相互包含，也就是不能再函数内部定义函数，但是函数之间可以相互调用。

基本格式:

修饰符  返回值类型   函数名（参数类型  形式参数1，参数类型  形式参数2，...）  {

语句；

return 返回值；

}

当返回值是void类型时，return语句可以省略。关于java中方法的使用，我的总结是多敲代码就自然而然的理解了，在所有的java程序中都离不开方法的使用，其好处是对功能进行了封装，可以重复使用某一个功能，提高代码的复用。只要记住基本格式，使用时自然不成问题。

2，关于函数的一个很重要知识点也就是函数的重载，函数的重载包括构造函数的重载和普通方法的重载。

函数的重载是指，函数的参数名相同，但是参数列表不同，参数列表包括参数类型和参数的个数不同。要特别注意的一点是，函数的重载与函数的返回值类型没有关系，当两个函数的返回值类型不同，参数列表也不相同的时候，这两个函数是重载的。当函数返回值类型不同，参数列表相同时，函数没有重载，并且这两个函数是不能共存的。

例子：给定函数：void show(int a,double b,char c) {}  判断下面那些函数与给定函数重载了。

(1)，void show(int x,double y,char z) {} 没有，与给定函数相同

(2)，int show(int a,char c,double b) {} 重载了，参数类型与给定函数参数类型不同，重载与返回值类型无关

(3)，void show(int a,char c,double b) {} 重载了，重载与函数返回值类型无关

(4)，boolean show(int a,char c) {} 重载了，参数个数不同，重载与返回值类型无关

(5)，void show(int a) {} 重载了，参数个数不同

(6)，int show(int a,double b,char c) {} 没有重载，参数列表相同，返回值类型与函数重载无关。该函数不能和给定函数共存。

二，数组的相关知识点

1，数组就是同一类型的数据的集合，可以看成是一个容器。数组中的每个元素都有各自的编号，并且编号是从0开始的。

2，数组的格式：

（1）元素类型[]   数组名 = new 数组名[数组长度]

示例：int[] arr = new int[5]

（2）元素类型[]   数组名 = new 数组名[] {元素，元素，元素，...}

示例：int[] arr = new int[] {1,2,3,4,5}

int[] arr = {1,2,3,4,5}

3，数组的基本特点：

（1）长度固定，一旦被创建它的长度就是不可改变的。

（2）元素类型必须是相同类型，不允许出现混合类型；

 （3）数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。

（4）数组的变量属于引用类型，数组也可以看做是对象，数组中的每个元素相当于数组的成员，java中的对象时在对内存中的，因此数组无论是原始类型还是引

用类型，本身是在堆内存中的。

4，数组的常见操作：

（1）获取数组的最值，以最大值为例：

public class Demo1 {
	public static void main(String[] args) {
		int[] arr = new int[] {4,5,7,8,4,5,6};
		int max = getMax(arr);
		System.out.println(max);
	}

	private static 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;
	} 
	
	//使用重载可以获取double类型数组的最大值
	private static double getMax(double[] arr) {
		double max = arr[0];
		for(int i=1;i<arr.length;i++) {
			if(arr[i]>max) {
				max = arr[i];
			}
		}
		return max;
	}
}

（2）对数组的选择排序：

public class SelectSort {
	
	public static void main(String[] args) {
		int[] arr = new int[] {4,5,7,8,4,5,6};
		sop(arr);
		sort(arr);
		sop(arr);
	}

	//遍历排序
	public static void sort(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			for(int j=i+1;j<arr.length;j++) {
				if(arr[j]<arr[i]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}
	
	//打印结果,用逗号隔开
	public static void sop(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			if(i!=arr.length-1)
				System.out.print(arr[i] + ",");
			else
				System.out.println(arr[i]);
		}
	}
}

（3）数组的冒泡排序：

public class BubbleSort {

	//冒泡排序的原理是相邻的两个元素进行比较，如果符合条件则换位
	public static void main(String[] args) {
		int[] arr = new int[] {4,5,7,8,4,5,6,10,18,3,4};
		sop(arr);
		sort(arr);
		sop(arr);
	}

	//遍历排序
	public static void sort(int[] arr) {
		for(int i=0;i<arr.length-1;i++) {
			for(int j=0;j<arr.length-i-1;j++) {
				if(arr[j]>arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
	
	//打印结果,用逗号隔开
	public static void sop(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			if(i!=arr.length-1)
				System.out.print(arr[i] + ",");
			else
				System.out.println(arr[i]);
		}
	}

}

（4）数组的排序在实际开发中常用的是使用Arrays的静态方法，Arrays.sort(数组)，可以实现排序。

（5）数组的查找法(普通查找和折半查找)：

public class Search {

	public static void main(String[] args) {

		int[] arr = {4,5,7,8,9,11};
		//System.out.println(commonSearch(arr,8));
		System.out.println(binarySearch(arr,10));
	}
	//折半查找法
	public static int binarySearch(int[] arr,int value) {
		int start = 0;
		int end = arr.length-1;
		while(start<=end) {
			int mid = (start+end)/2;
			if(arr[mid]>value)
				end = mid - 1;
			else if(arr[mid]<value)
				start = mid + 1;
			else
				return mid;
			
		}
		return start;
	}
	//普通查找方法
	/*public static int commonSearch(int[] arr,int value) {
		for(int i=0;i<arr.length;i++) {
			if(arr[i] == value)
				return i;
		}
		return -1;
	}*/
}

（6）查表法实现进制之间的转换

class Converse 
{
	public static void main(String[] args) 
	{
		//toBin(-6);
		toBin(6);
		//toHex(-60);
		//toOcto(60);
	}

	/*
	十进制-->二进制
	*/
	public static void toBin(int num)
	{
		trans(num,1,1);
	}

	/*
	十进制-->八进制
	*/
	public static void toOcto(int num)
	{
		trans(num,7,3);
	}
	/*
	十进制-->十六进制
	*/
	public static void toHex(int num)
	{
		trans(num,15,4);
	}

	public static void trans(int num,int base,int offset)
	{

		if(num==0)
		{
			System.out.println(0);
			return ;
		}
		//查表法：将所有的元素临时存储起来。建立对应关系。
		char[] chs = {'0','1','2','3'
					,'4','5','6','7'
					,'8','9','A','B'
					,'C','D','E','F'};
		char[] arr = new char[32];

		int pos = arr.length;

		while(num!=0)
		{
			int temp = num & base;
			arr[--pos] = chs[temp];
			num = num >>> offset;
		}

		for(int x=pos; x<arr.length; x++)
		{
			System.out.print(arr[x]);
		}

		return ;
	}
}

（7）将数组中所有的元素逆序，如：int[] arr = new int[] {2,5,4,1,3,4}  逆序后：{4,3,1,4,5,2}

public class Test2 {

	public static void main(String[] args) {
		int[] arr = new int[] {2,5,4,1,3,4};
		sop(arr);
		reverse(arr);
	}

	//将第一个元素与最后一个元素进行互换位置，然后将第一个元素角标增一，最后一个元素角标减一，循环交换，知道两角表相同循环结束
	private static void reverse(int[] arr) {
		for(int start=0,end=arr.length-1;start<end;start++,end--) {
			int temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
		}
		sop(arr);
	}

	//遍历打印结果
	private static void sop(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			if(i != arr.length-1)
				System.out.print(arr[i] + ",");
			else
				System.out.println(arr[i]);
		}
	}
}

三，二维数组的使用

1，二维数组可以理解为数组的数组，即在一维数组中存储的元素是一位数组。

2，格式：

（1）int[][] arr = new int[3][2]

含义是：定义了一个名称为arr的二维数组，二维数组中有3个一维数组，每一个一维数组有2个元素。

一维数组分别是：arr[0],arr[1],arr[2]

（2）int[][] arr = int[3][]

含义是：二维数组中有3个一维数组

一位数组的初始化值都默认为null

可以分别对这3个数组分别初始化：arr[0] = new int[3]; arr[1] = new int[2];int arr[2] = new int[5];