JavaSE--内存与数组

重学JavaSe后的补充
JavaSE–内存与对象
Java面向对象总结
Java基础总结

1.Java的内存：

Java中的内存可以划分为五个模块：

①栈内存(Stack)：

保存的是一块堆内存的空间地址，每一块栈内存只能够保留一块堆内存地址。方法的运行一定要在栈当中运行。

②堆内存(Heap)：

保存每一个对象的属性内容，即对象的真正数据。堆内存需要用关键字new才可以开辟。堆内存都有地址值：16进制。

③方法区(Method Area)：

存储.class相关信息，包含方法的信息。

④本地方法栈(Native Method Stack)：

与操作系统相关。

⑤寄存器(pc Register)：

与CPU相关。

2.数组

1）数组是什么：

int i1,i2,...i100，一共写100个变量
这样写有点繁琐，数组的出现就是为了解决这个。

一组相关变量的集合。

2）数组的特点：

是引用数据类型；数组长度不可变

3）数组的创建：

I.动态初始化（指定长度）：

数据类型[] 对象数组名称 = new 数据类型 [长度];

int[] arrayA = new int [5];

II.静态初始化（指定内容）：

标准格式：
数据类型[] 对象数组名称 = new 数据类型 []{ …, … , …}
省略格式：
数据类型[] 对象数组名称 = { …, … , …}

int [] arrayB= new int[] {11,22,33};
int [] arrayC= {44,55,66};

III.使用建议：

如果不确定数组当中的具体内容，用动态初始化；确定了具体内容，则最好使用静态。

4）获取数组元素：

格式：数组名称[索引值]
索引值从0开始，一直到"数组长度-1"为止。

动态初始化数组并循环输出：

public class Test {
	public static void main(String[] args) {
		int data [] = new int[3];
		data[0] = 10;
		data[1] = 20;
		data[2] = 30;
		for(int x=0;x<data.length;x++){
			System.out.println(data[x]);
		}
	}
}

5）数组的内存图：

根据地址[0x666]找到数组。

引用传递：同一块堆内存空间，能被不同的栈访问。

6）数组的索引越界：

索引超过了数组的长度。
ArrayIndexOutOfBoundsException异常。

int[] array = {10,20};
System.out.println(array[2]);

7）数组长度的不可变性：

xx.length即可获得数组的长度。
只用你new了，数组的长度就永远不可变。（变了的只是新数组，地址值发生改变）

8）数字作为方法参数：

任何数据类型都能作为方法参数或者返回值类型，数组也不例外。
当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。

public class Demo {
    public static void main(String[] args) {
        int array[] = {10,20,30,40,50};
        printArray(array);
    }
    public static void printArray(int array[]){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

9）数组作为方法的返回值类型：

当有多个返回值时，就可以使用数组。

public class Demo {
    public static void main(String[] args) {
        int result [] = calculate(10,20,30);
        System.out.println("总和"+result[0]);
        System.out.println("平均数"+result[1]);
    }
    public static int[] calculate(int a,int b, int c){
        int sum=a+b+c;      //总和
        int avg= (a+b+c)/3; //平均数
        /*int array[] = new int[2]
          array[0]=sum;
          array[1]=avg
          */
        int array [] ={sum,avg};
        return array;
    }
}

10）冒泡排序

（利用java.util.Arrays.sort() 也可以完成排序）

public class Test10 {
	public static void main(String args[]){
		int data [] = new int [] {
			9,7,6,8,4,5,1,3,2,	
		};
		sort(data);
		print(data);
	}
	public static void sort(int temp[]){
		int t;
		for(int x=0;x<temp.length;x++){
			for(int y =0;y<temp.length-1;y++){
				if(temp[y]>temp[y+1]){
					t = temp[y];
					temp[y] = temp[y+1];
					temp[y+1] = t;
				}
			}
		}
	}
	public static void print(int temp2[]){
		for(int x=0;x<temp2.length;x++){
			System.out.print(temp2[x]);
		}
		System.out.println();
	}
}

11）数组反转

public class Test10 {
	public static void main(String args[]){
		int data [] = new int [] {
			1,2,3,4,5,6,7,8	
		};
		reserve(data);
		print(data);
	}
	public static void reserve(int temp[]){
			int len = temp.length /2;
			int head = 0;
			int tail = temp.length - 1;
			for(int x=0;x<len;x++){
				int a ;
				a = temp[head];
				temp[head] = temp [tail];
				temp[tail] = a;
				head ++;
				tail --;
			}
	}
	
	public static void print(int temp2[]){
		for(int i =0;i<temp2.length;i++){
			System.out.println(temp2[i]);
		}
	}
}

12）对象数组：

数组是引用类型，而类也是引用类型，对象数组就表示一个引用类型里面嵌套其他的引用类型。

对象数组的初始化和数组的一样，上面的数组是属于基本数据类型的数组。
对象数组的初始化：

类名称[] 对象数组名称 = new 类名称[长度]
类名称[] 对象数组名称 = new 类名称 []{ ..., ... , ...}