JavaSE实战——jdk配置，数组及其应用，栈和堆内存图解

转载请声明出处：http://blog.csdn.net/zhongkelee/article/details/43239355

说在前面

       期末考试已经结束，以前大四的时候Java学得比较杂乱，想借着寒假的时间，系统地学习一下JavaSE的编程。我之所以把博客分类为JavaSE，就是想记录自己的学习过程。后面还会有JavaEE，希望能够有所坚持，有所收获。也和大家一起分享学习和编程的乐趣。

Java的三种技术架构:

JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；

JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；

JAVAME: Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 

JDK、JRE安装及配置

      Java具有良好的跨平台性(见下图)，只要在需要运行Java应用程序的操作系统上，先安装一个Java虚拟机(JVM)即可。JRE = JVM + Java核心类库，JDK = JRE + Java开发工具。

      JDK下载地址，点此即可下载到。配置环境变量及验证配置完成如下图所示。

    环境变量配置3种方法：
        a.一劳永逸法：path=H:\lichunchun_download\JDK1.8\bin;
        b.技巧法：新建 JAVA_HOME=H:\lichunchun_download\JDK1.8  然后 path=%JAVA_HOME%\bin;
        c.临时法：只在当前窗口有效，set path=H:\lichunchun_download\JDK1.8\bin;%path%  可以使用set path查看配置结果，使用set path=清空所有path配置。

    javac命令和java命令：

    要知道java是分两个部分的：一个是编译，一个是运行。

    javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。生成了jvm可以识别的字节码文件。也就是.class文件，也就是java的运行程序。

    java：负责运行的部分，会启动jvm，加载运行时所需的库，并对class文件进行执行。一个文件要被执行，必须要有一个执行的起始点，这个起始点，就是main函数。

Java内存划分

      在说数组之前，有必要说明Java对内存空间的划分，分为五个部分：栈、堆、方法区、本地方法区、寄存器。其中：
    a. 寄存器：给CPU使用。
    b. 本地方法区：和系统底层方法相关，比如Windows本地方法，native关键字修饰。
    c. 栈内存：存储的都是局部变量（函数中定义的变量、函数上的形参、语句中的变量）。只要在方法中定义的变量都是局部变量。局部变量都有所属，属于某一方法。 一旦变量的生命周期结束，该变量就被释放。      
    d. 堆内存：存储的都是实体(对象)。凡是用new创建的，都在堆内存里面，开辟一片空间，创建一个对应的实体。每一个实体都有一个首地址值。对象在堆内存中存在的目的就是为了存储（封装）成员变量（数据）的。堆内存的变量都有默认初始化值。不同数据类型不一样。int-0,  double-0.0,  boolean-false,  char-'\u0000', 引用数据类型-null。当实体不再使用时（即没有变量对其引用，指向该对象时），就会被垃圾回收机制处理，后面博客的多线程中会讲到。

    e. 方法区：后续博客说到对象的创建过程、静态变量时，会详解。

Java数据类型

    基本数据类型：byte, short, int, long, float, double, char, boolean.

    引用数据类型：array, class, interface.

一维数组

    一维数组有如下定义格式：

    int[] arr = new int[3];  //new：在堆内存中进行了空间的开辟。

（先执行等号右边，在堆内存创建实体；再执行等号左边，栈内存创建arr局部变量，将实体首地址赋值给它）

    int[] arr = new int[]{34,12,57};
  
    int[] arr = {34,12,56,67,43,78};

    例如，针对第一种定义方法，可以把 arr 局部变量看成是引用型变量，存储的是在堆内存中实体的首地址。默认值为null。堆内存的数组实体中的每个元素的初始值为0。示意图如下：

一维数组的应用

       这里我主要实现了数组的一些基本方法，下面的代码中，分别利用一维数组进行了：数组求和、求最值、排序、查找、数组反转、新元素插入点获取，以及无符号整型变量的进制转换。虽然这些简答方法可以通过直接查找JDK API文档，调用现成的方法解决问题，当然实际开发也就是这么做的。但是学习思想还是有用的。代码如下：

import java.lang.*;
import java.util.*;
class ArrayTest{
	public static void main(String[] args){
		int[] arr = {32,45,2,4,56,78,43,1,3};
		int[] arr1 = {54,34,56,7,84,43,5,13};
		int[] arr2 = {32,34,54,6,53,71,8,934,57,23};
		int[] arr3 = {2,3,5,6,14,23,34,56,88};
		System.out.println("------------------------\narr[]:");
		printArray(arr);
		System.out.println("选择排序：");
		selectSort(arr);
		printArray(arr);
		System.out.println("------------------------\narr1[]:");
		printArray(arr1);
		System.out.println("冒泡排序：");
		bubbleSort(arr1);
		printArray(arr1);
		System.out.println("------------------------\n实际开发：");
		System.out.println("Arrays.sort(arr);");//Arrays静态类中的静态方法，可以直接通过类名调用，这个类位于java.util包中
		
		int sum = add(arr);
		int max = getMax(arr);
		System.out.println("------------------------");
		System.out.println("sum of arr = "+sum);
		System.out.println("------------------------");
		System.out.println("max of arr = "+max);	
		System.out.println("========================");
		
		System.out.println("arr2[]:");
		printArray(arr2);
		System.out.println("------------------------\narr3[]:");
		printArray(arr3);
		System.out.println("------------------------");
		
		int locate = searchKey(arr2, 8);
		int locate1 = binarySearch(arr3, 88);
		System.out.println(8+" in arr2[] is located in "+locate);
		System.out.println("------------------------");
		System.out.println(88+" in arr3[] is located in "+locate1);
		System.out.println("------------------------\n反转arr3:");
		reverse(arr3);
		printArray(arr3);
		System.out.println("------------------------\narr4[]:");
		int[] arr4 = {2,4,12,32,45,57,67,70};
		printArray(arr4);
		int index = binarySearch_2(arr4, 3);
		System.out.println("index of inserting 3 to arr4 = "+index);
		System.out.println("------------------------\n实际开发: ");
		System.out.println("Arrays.binarySearch(arr, 3);");
		System.out.println("========================");
		System.out.println("60的进制转换：");
		int num = 60;
		String str_bin = toBinary(num);
		String str_oct = toOctal(num);
		String str_hex = toHex(num);
		System.out.println("bin:"+str_bin);
		System.out.println("oct:"+str_oct);
		System.out.println("hex:"+str_hex);
		System.out.println("-------------------------\n实际开发：");
		System.out.println("bin: Integer.toBinaryString(num)");
		System.out.println("oct: Integer.toOctalString(num)");
		System.out.println("hex: Integer.toHexString(num)");
		System.out.println("-------------------------");
	}
	public static int add(int[] arr){ //数组求和
		int sum = 0;
		for (int x = 0; x < arr.length; x++){
			sum += arr[x];
		}
		return sum;
	}	
	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 getMax_2(int[] arr){ //数组求最值(方法二)
		int max = 0;
		for (int x = 1; x < arr.length; x++){
			if (arr[x] > arr[max]){
				max = x;
			}
		}
		return arr[max];
	}
	public static void selectSort(int[] arr){ //选择排序
		for (int x = 0; x < arr.length-1; x++){
			for (int y = x+1; y < arr.length; y++){
				if (arr[x] > arr[y]){
					swap(arr, x, y);
				}
			}
		}
	}
	public static void bubbleSort(int[] arr){ //冒泡排序
		for (int x = 0; x < arr.length-1; x++){
			for (int y = 0; y < arr.length-1-x; y++){
				if (arr[y] > arr[y+1]){
					swap(arr, y, y+1);
				}
			}
		}
	}
	public static int searchKey(int[] arr, int key){ //遍历查找
		for (int x = 0; x < arr.length; x++){
			if (arr[x] == key)
				return x;
		}
		return -1;//-1, 代表的是角标不存在的情况。
	}
	public static int binarySearch_1(int[] arr, int key){ //二分查找(方法一)
		/*二分查找，前提：数组必须是有序的。*/
		int min, max, mid;
		min = 0;
		max = arr.length-1;
		mid = (min+max)>>1;
		while (arr[mid] != key){
			if (arr[mid] > key)
				max = mid-1;
			else if (arr[mid] < key)
				min = mid+1;
			if (min > max)
				return -1;
			mid = (min+max)>>1;
		}
		return mid;
	}
	public static int binarySearch(int[] arr, int key){ //二分查找(方法二)
		int min, max, mid;
		min = 0;
		max = arr.length-1;
		while (min <= max){
			mid = (min+max)>>1;
			if (arr[mid] > key)
				max = mid-1;
			else if (arr[mid] < key)
				min = mid+1;
			else
				return mid;
		}
		return -1;
	}
	public static void reverse(int[] arr){ //数组反转
		for (int start=0, end=arr.length-1; start<end; start++, end--){
			swap(arr, start, end);
		}
	}
	public static int binarySearch_2(int[] arr, int key){ //插入位置
		int min, max, mid;
		min = 0;
		max = arr.length-1;
		while (min <= max){
			mid = (min+max)>>1;
			if (arr[mid] > key)
				max = mid-1;
			else if (arr[mid] < key)
				min = mid+1;
			else
				return mid;
		}
		return min;//直接返回插入位置
		//return -(1+min);//和Arrays.binarySearch结果一致
	}
	public static void swap(int[] arr, int a, int b){ //交换数组两个元素
		/*注意是三个参数，不是两个，否则无法交换*/
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	public static void printArray(int[] arr){ //打印数组
		for (int x = 0; x < arr.length; x++){
			if (x != arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]);
		}
	}
	
	public static String toBinary(int num){
		return trans(num, 1, 1);
	}
	public static String toOctal(int num){
		if (num == 0)//后面学到string流时，会说到，比较trans()结果和"0"的关系，进行判断。
			return trans(num, 7, 3);
		else
			return "0"+trans(num, 7, 3);
	}
	public static String toHex(int num){
		if (num == 0)
			return trans(num, 15, 4);
		else
			return "0x"+trans(num, 15,4);
	}		
	public static String trans(int num, int base, int offset){
		if (num == 0)
			return "0";
		char[] chs = {'0','1','2','3',
				'4','5','6','7',
				'8','9','A','B',
				'C','D','E','F'};
		char[] arr = new char[32];
		int index = arr.length;
		while (num != 0){
			int temp = num & base;
			arr[--index] = chs[temp];
			num = num >>> offset;
		}
		return toString(arr, index);
	}
	public static String toString(char[] arr, int index){
		String temp = "";
		for (int x = index; x < arr.length; x++){
			temp = temp + arr[x];
		}
		return temp;
	}
}

     运行结果如下图所示：

二维数组

    二维数组有如下两种定义格式：

    int[][] arr = new int[3][2];

    int[][] array = new int[3][];

    array[0] = new int[3];
    array[1] = new int[1];
    array[2] = new int[2];

      例如，分别对上述两种定定义方式进行分析，其中，定义一里面的一维数组长度均为2，确定的；定义二里面的一维数组长度一开始没有指定，此时 arr[0] = null; 之后才分别new的一维实体。示意图如下：

二维数组应用

    二维数组一般用在坐标、矩阵的应用中。这里我只简单示意一下求和方法。代码如下：

class Array2Test{
	public static void main(String[] args){
		System.out.println("----------------------");
		/*二维数组*/
		int[][] arr = new int[3][2];
		System.out.println(arr);//[[I@1db9742//二维数组实体
		System.out.println(arr[0]);//[I@106d69c//一维数组实体
		System.out.println(arr[0][0]);//0//一维数组中的元素
		arr[1][1] = 99;
		/*
			[[I@1db9742 //二维数组
			其中，@右边的是哈希值，存储的是实体在内存中存放的位置。有哈希值，必然有实体。
				  @左边是[[，表明是二维数组实体，I代表类型是整数int。
		*/
		System.out.println("----------------------");
		
		/*
		int[][] array = new int[3][];
		System.out.println(array);//[[I@52e992
		System.out.println(array[0]);//null
		System.out.println(array[0][0]);//NullPointerException
		*/
		
		int[][] array = new int[3][];
		array[0] = new int[3];
		array[1] = new int[1];
		array[2] = new int[2];
		/*array[1][2] = 34;*///ArrayIndexOutOfBoundsException
		array[0][1] = 89;
		array[2][1] = 44;
		System.out.print("array length:");
		System.out.println(array.length);/*二维数组的长度*/
		System.out.print("array[2] length:");
		System.out.println(array[2].length);/*某一个一维数组的长度*/
	
		int[][] arr1 = {{23,45,6},{34,52},{1}};
		int sum = add(arr1);
		System.out.println("sum = "+sum);
		System.out.println("----------------------");
	}
	public static int add(int[][] arr){ //二维数组求和
		int sum = 0;
		for (int x = 0; x < arr.length; x++){
			for (int y = 0; y < arr[x].length; y++){
				sum += arr[x][y];
			}
		}
		return sum;
	}
}

    运行结果如下图所示：

很简单吧，好了，这部分的内容就到这儿啦。有问题请联系我：lichunchun4.0@gmail.com

转载请声明出处：http://blog.csdn.net/zhongkelee

 

源码下载