java基础学习总结-1

之前自学过java，深知自学的痛苦，并且自学的效果也不理想，现在想来有以下两个原因：

一、刚开始学习热情是很高，但是没几天就感觉很枯燥，坚持不下来了，过段时间听说某某找到工作了，工资很高，又有了热情，重新捡起来又从头开始学，以此周而复 始，浪费了经历，水平还总是停留在Hello World。。。。

二、学习的时候只是一味的看视频，看懂了就过去了，没有实际的操作，就算是实际操作了，也是依葫芦画瓢，一行一行抄的，并没有真正的弄明白，又或者是当时明白了，学过   之后没有再复习想过，由于学的周期很长，前面学习的很容易忘掉。

现在将java基础再回顾，感觉毕老师的视频太牛了，诙谐幽默，不宜瞌睡，哈哈。。。总结如下：

前期准备：

1、java是夸平台的，运行需要 java运行环境（JRE）它包括JVM和java的核心类库。

2、安装JDK（已经包含JRE）配置环境变量

      JAVA_HOME：JDK安装路径

      path：%JAVA_HOME%\bin（配置的目的是在任意的路径下都能执行java命令，javac编译工具等等）

      classpath：虚拟机先查找classpath，然后再查找当前目录来执行将要执行的文件。

基础语法：

 1、break：跳出当前循环，作用于选择结构和循环结构。如：switch和for

       continue：只能用于循环结构，结束本次循环，继续下次循环。

       break、continue 单独存在时下面不能有语句。

2、    switch语句选择的类型有四种：byte,short,int,char

switch(变量){

 case 值:要执行的语句;

    break;

...

...

 default:要执行的语句;

}

3、函数里面不能定义函数，只能调用函数。

4、函数重载：函数名相同，函数的参数列表不同，与返回值类型无关。

5、数组：

java内存结构：

java程序在运行时，需要在内存中分配空间，为了提高效率，对空间进行了不同区域的划分，每片区域有特定的数据处理方式和内存管理方式。一共划分了5块区域。

①栈内存：对于存储局部变量，数据使用完，所占内存会自动释放掉。

②堆内存：数组和对象，通过new建立的实例都存放在堆内存中。

      每一个实例都有内存地址值。

    实体中的变量都有默认的初始值。

    实体不在被使用，会在不确定的时间内被垃圾回收器回收。

③方法区

④本地方法区

⑤寄存器

定义数组：

int[] x = new int[3];或者int x[] = new int[3];或者int x[] = new int[]{2,3,4};

这里定义了一个数组，其中x 是局部变量所以会放在栈内存中，new出来的空间放在了堆内存中，由x指向堆内存。

int[] x = new int[3];

int[] y = x;

y[1] = 2;则x[2] = 2;因为x和y指向同一堆内存中的区域。因为只是将x的地址值赋给了y。

关于数组的例子：

1、选择和冒泡排序：

/**
 * @Description: 排序
 * @Author:yujian.zhang
 * @Since:2012-8-2 上午11:38:41
 * @Version:1.1.0
 */
public class Sort {

	public static void main(String[] args) {
		int[] arry = { 4, 3, 9, 6, 5, 8, 10 };
		// 排序前
		printArray(arry);
		// 选择排序 从大到小
		selectSort(arry);
		printArray(arry);
		// 冒泡排序 从小到大
		bubbleSort(arry);
		printArray(arry);
	}

	// 选择排序 从大到小
	public static void selectSort(int[] arry) {
		for (int i = 0; i < arry.length - 1; i++) {
			for (int j = i + 1; j < arry.length; j++) {
				if (arry[i] < arry[j]) {
					int temp = arry[i];
					arry[i] = arry[j];
					arry[j] = temp;
				}
			}
		}
	}

	// 冒泡排序 从小到大
	public static void bubbleSort(int arry[]) {
		for (int i = 0; i < arry.length - 1; i++) {
			for (int j = 0; j < arry.length - i - 1; j++) {
				if (arry[j] > arry[j + 1]) {
					int temp = arry[j];
					arry[j] = arry[j + 1];
					arry[j + 1] = temp;
				}
			}
		}
	}

	// 打印结果
	public static void printArray(int arry[]) {
		for (int x = 0; x < arry.length; x++) {
			if (x < arry.length - 1) {
				System.out.print(arry[x] + ",");
			} else {
				System.out.println(arry[x]);
			}
		}
	}

}

2、折半查找：

/**
 * @Description: 折半查找
 * @Author:yujian.zhang
 * @Since:2012-8-3 上午12:28:49
 * @Version:1.1.0
 */
public class HalfSearch {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arry = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
		int x = halfSearch(arry, 0);
		System.out.println(x);
	}

	public static int halfSearch(int[] arry, int key) {
		int min, max, mid;
		min = 0;
		max = arry.length - 1;
		mid = (min + max) / 2;
		while (key != arry[mid]) {
			if (key > arry[mid]) {
				min = mid + 1;
			} else {
				max = mid - 1;
			}
			mid = (max + min) / 2;
			if (min > max) {
				return -1;
			}
		}
		return mid;
	}

}

3、十进制转换成二进制和十六进制：

/**
 * @Description: 十进制转换成二进制和十六进制
 * @Author:yujian.zhang
 * @Since:2012-8-3 下午3:34:08
 * @Version:1.1.0
 */
public class Change {

	public static void main(String[] args) {
		// 二进制
		toBin(3);
		// 十六进制
		toHex(60);
	}

	/**
	 * 二进制
	 * 
	 * @param num
	 */
	public static void toBin(int num) {
		StringBuffer sbf = new StringBuffer();

		while (num != 0) {
			sbf.append(num % 2);
			num = num / 2;
		}
		System.out.println(sbf.reverse());
	}

	/**
	 * 十六进制
	 * 
	 * @param num
	 */
	public static void toHex(int num) {
		char[] chr = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
				'B', 'C', 'D', 'E', 'F' };
		// 临时容器
		char[] temp = new char[8];
		int pos = temp.length;
		while (num != 0) {
			int tempNum = num & 15;
			temp[--pos] = chr[tempNum];
			num = num >>> 4;
		}
		for (int x = pos; x < temp.length; x++) {
			System.out.print(temp[x]);
		}
	}
}