Java数组(3)

一维数组内存分析

（http://blog.csdn.net/jinhongliang123/article/details/7871291）

注意文中 栈内存 跟 堆内存 图示 

数组的概述

1   数组可以看成多个相同类型数据组合，对这些数据的统一管理

2   数组变量属于引用类型，数组也可以看成是对象，数组中的每一个元素相当于该对象的成员变量。

3   数组中的元素可以使任意的数据类型，包括基本类型和引用类型

 

一维数组的声明

1   一维数组的声明方式：

             type  var[] ;  或  type[] var;

2   例如：

            int a1[];

            int a2[];   double b[];

            Person[] p;         String s1[]

3   Java语言中声明数组时不能指定其长度（数组中元素的个数），例如：

            int a [5];非法

 

数组对象的创建

1   java使用关键字new创建数组对象，格式为：

                       数组名  = new   数组元素的类型（数组元素的个数）

2   例如

[java]  view plain  copy

1. public class Test{  
2.           public static void main(String[] args) {  
3.                  int[]   s;  
4.                  s = new int[5];  
5.                  for(int i = 0; i < 5; i++) {  
6.                        s[i] = 2 * i + i;   
7.     　}  
8.    }  
9. }

Java中堆内存和栈内存详解： http://www.cnblogs.com/whgw/archive/2011/09/29/2194997.html

栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。 

　　Java的堆是一个运行时数据区,类的对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 

　　栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量(,int, short, long, byte, float, double, boolean, char)和对象句柄。 

　　栈有一个很重要的特殊性，就是存在栈中的数据可以共享。 假设我们同时定义： 

　　int a = 3; 

　　int b = 3; 

　　编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3;在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4;那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4;如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量 

局部变量存储位置

[code segment-- 代码段
data segment-- 放静态数据常量
heap(堆)--  放创建出来的对象
stack(栈)-- 放临时变量]

实例（马士兵--n个人围成一圈，数三退一 ）

/*范例名称：
 * 原文件名称：
 * 要点：
 * 1. 数组：数三退一
 * 
 */

public class ArrayTest {
	public static void main(String[] args){
		boolean[] arr=new boolean[500];//500个人围成一圈
		for(int i=0;i<arr.length;i++){
			arr[i]=true;
		}
		
		int leftCount=arr.length;
		int countNum=0;
		int index=0;
		
		while(leftCount>1){
			if(arr[index]==true){
				countNum++;
				if(countNum==3){
					countNum=0;
					arr[index]=false;
					leftCount--;
				}
			}
			index++;
			if(index==arr.length){
				index=0;
			}
		}
		
		for(int i=0;i<arr.length;i++){
			if(arr[i]==true){
				System.out.println(i+"");
			}
		}
	}
}

/*范例名称：
 * 原文件名称：
 * 要点：
 * 1. 双向循环链表：数三退一（采用面向对象方式实现）
 * 2. 功能同ArrayTest
 */
public class ListTest {
	public static void main(String[] args){
		KidCircle kc=new KidCircle(500);//500
		int countNumber=0;
		Kid indexKid=new Kid();//报数孩子
		indexKid=kc.first;
		while(kc.count>1){		
			countNumber++;
			if(countNumber==3){
				kc.delete(indexKid);
				countNumber=0;
			}
			
			indexKid=indexKid.right;
		}
		System.out.println(kc.first.id+"");
	}
}

//定义孩子类
class Kid{
	int id;
	Kid left;
	Kid right;
}

//定义圈
class KidCircle{
	int count=0;//孩子数量
	Kid first,last;//起始孩子节点
	
	KidCircle(int n){
		for(int i=0;i<n;i++){
			add();
		}
	}
	
	//添加孩子
	void add(){
		Kid k=new Kid();
		k.id=count;
		if(count<=0){
			first=k;
			last=k;
			k.left=k;
			k.right=k;
		}else{
			last.right=k;
			first.left=k;
			k.right=first;
			k.left=last;
			last=k;	
		}
		count++;
	}
	//删除孩子
	void delete(Kid k){
		if(count<=0){
			return;
		}else if(count==1){
			first=last=null;
		}else{
			k.left.right=k.right;
			k.right.left=k.left;
		}
		
		if(k==first){
			first=k.right;
		}else if(k==last){
			last=k.left;
		}
		
		count--;
	}
}