Java总结-函数和数组

函数：
	特点：
	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;