排序、查找、内存分配、函数重载

 

Java中的变量类型

 

分为基本数据类型和引用数据类型。

基本数据类型：整数型（byte，short、int 、long）、浮点型（float、double） 布尔型（boelean）、字符型（char）

Byte类型（1字节）、short（2字节）、int（4字节）、long（8字节）、float（4字节）、double（8字节）。char 类型2个字节。

引用数据类型：类、接口、数组等。引用数据类型的大小统一为4个字节。

函数的重载（overloading）：

函数重载的几种形式：

（1）      参数个数不同（2）参数个数相同，但是类型不同

Jvm 会根据函数参数的不同来自动调用相应的重载函数

注意：函数重载的形式不能使参数完全相同，返回值不同，这样会造成函数调用的不确定性。

public class OverloadTest {
	//两个整型相加
	public static int add(int x,int y)
	{
		return x+y;
	}
	//三个整型相加
	public static int add(int x,int y,int z)
	{
		return x+y+z;
	}
	//两个double相加
	public static double add(double x,double  y)
	{
		return x+y;
	}
	public static void main(String[] args) {
		System.out.println(add(1,2));
		System.out.println(add(1,2,3));
		System.out.println(add(3.14,5.18));

	}

}

Java中的内存

Java把内存划分成了两种：一种是栈内存，另一种是堆内存。

栈内存：分配基本类型的变量和对象的引用变量

堆内存：用来存放由new创建的对象和数组。在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。当堆内存中的对象或者数组不再被任何引用变量所引用时，就会变成垃圾，但是不会被立即释放，要等到自动垃圾回收器运行才会被释放，这也是Java占内存的一个原因。

数组

Int [] x = new int[100];这句话的执行过程

1、  在栈内存中分配一个4个字节的空间给引用变量x；并赋值为NULL。

2、  在堆内存中创建一个数组，并且分配100个整型单元。

3、  将数组第一个单元的地址赋值给x.

数组使用过程中的两个常见异常：

NullPointerException 空指针异常。出现此异常，通常是没有给引用变量赋值就使用该引用变量。

ArrayIndexOutOfBoundsException数组越界异常。出现此异常，通常是使用了不存在的数组角标。

二维数组：java中的二维数组就是数组的数组。每一个一维数组的首个元素都是一个一维数组的引用。

两个操作数组的函数：

System.arraycopy(source, 0, dest, 0, x);将source数组的0到x的内容复制到dest数组中。

Arrays.sort(array)将array数组中的元素进行升序排序。

小面试题及技巧

1、最有效率的方式算出2乘以8等于几？

 

classOperateTest 
{
public static void main(String[] args) 
{
System.out.println(2<<3);//位运算
	}
}

2、对两个整数变量的值进行互换(不需要第三方变量)

（1）这种方式不要用，如果两个整数的数值过大，会超出int范围，会强制转换。数据会变化。

a = a + b; 
b = a -b; 
a = a -b; 

（2）开发时使用第三方变量的形式，因为阅读性强。

int c ;
c = a;
a = b;
b = c;

（3）面试的时候用。当一个数与另一个数异或运算两次还是同一个数。

a = a ^ b; 
b = a ^ b;
a = a ^ b; 

排序

选择排序

思路：

1、 第一个元素跟后面的元素依次相比较，如果第一个元素大于后面的元素，换位，如果大于或等于，不作任何操作。

2、 第二个元素跟后面的元素相比较，具体操作同步骤1.依次进行，直到arr.length-1；

3、 得到排序后的数组。

注意：进行一趟选择排序后，最小的元素会在第一个，进行第二趟之后，次小的会在第二个……

/*
	 * 选择排序的思路：
	 * 1、第一个元素依次跟后面所有元素比较，如果大于，则交换，如果不大于，则什么也不做。
	 * 这样一趟排序后，最小的会在第一个。
	 * 2、从第二个元素开始依次跟后面的元素相比较，两趟排序后，次小的会在第二个。。。以此类推。。。。
	 */
	public static void selectSort(int[]arr)
	{
		for(int i = 0;i<arr.length;i++)
		{//外循环从第一个元素开始，依次与后面的元素比较
			for(int j = i+1;j<arr.length;j++)
			{//内循环，从第i+1个元素开始，依次与第i个比较
				if(arr[i]>arr[j])
					swap(i,j,arr);
			}
		}
	}
	

冒泡排序

思路：

1、 从第一个元素至最后一个元素，每一个元素跟相邻的后一个元素相比较，如果前面的元素大于后面的元素，换位，其他，不进行任何操作。

2、 从第一个元素至倒数第二个元素，每一个元素相邻的后一个元素相比较，步骤同1.

3、 得到排序后的数组。

注意：冒泡排序一趟排序后的结果为最大的元素在最后一个，两趟排序之后，次大的在第二个……

/*
	 * 冒泡排序的思路
	 * 1、从第一个元素开始每一个元素都与它的后一个元素相比较，如果大于，则交换，如果不大于，则什么也不做
	 * 这样一趟排序之后，最大的元素在最后
	 * 2、从第一个元素开始直至倒数第二个元素（因为一趟排序后最大的已经在最后，不必参与比较），
	 * 每一个元素都与它后面的元素相比较，两趟排序之后，次大的会在倒数第二个。
	 * 
	 */
	public static void bubbleSort(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])
					swap(j,j+1,arr);
			}
		}
	}

折半查找

/*
	 * 折半查找的思路：
	 * 条件：必须是已经排序好的数组。
	 * 1、先假设数组已经升序排序完毕，首先将中间元素与待查找元素相比，如果大于中间元素，查找上半部分
	 * 若小于中间元素，查找下半部分。
	 * 2、依次类推，直至找到。
	 */
	//折半查找，返回key在数组中的角标
	public static int binarySearch(int []arr,int key)
	{
		int mid ,min,max;
		min = 0;
		max = arr.length;
		mid = (min+max)/2;
		while(min<max)
		{
			if(key>arr[mid])			
				min = mid+1;			
			else if(key <arr[mid])		
				max = mid-1;
			mid = (min+max)/2;
			if(key == arr[mid])
				break;
		}
		if(min >= max )
			return -1;
		return mid;
	}

递归方式实现：

//折半查找-递归实现方式
	public static int binarySearchByRecursion(int[]arr,int min,int max,int key)
	{//这里出现了StackOverflowError：栈溢出错误。
		/*个人猜想：一旦调用此递归函数查找一个数组中不存在的数时，此递归就找不到出口了，
		 * 	因而进入反复的递归调用，直至临时变量充满整个栈内存，致使内存不足，程序出现此错误。
		 * 程序修正：将if(min>=max) return -1;语句调到函数前段，应该先判断初始条件min<max这一原则
		 * 程序才能往下进行。因此，应归为逻辑错误。
		 */
		if(min>=max)
			return -1;
		int mid = (min + max)/2;
		if(key == arr[mid])
			return mid;
		else if(key<arr[mid])
			return binarySearchByRecursion(arr,min,mid-1,key);
		else if(key>arr[mid])
			return binarySearchByRecursion(arr,mid+1,max,key);
		//if(min>=max)
		//	return -1;
		return -1;
	}

递归方式：编程时不推荐使用，占内存，效率低。