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;
}
递归方式:编程时不推荐使用,占内存,效率低。