java数组复习和内存分配

Java基础知识复习

1.循环

1.1、 for循环

for(int i =1;i<=10;i++){
			System.out.println("Hello world"+i);
		}

• 补充：i++与++i的区别

package com.daytwo;

public class Tarray {

	public static void main(String[] args) {
		//i++与++i的区别
		int k=1;
		int c=1;
		int k1=k++;
		int c1=++c;
		System.out.println(k1); //1
		System.out.println(c1);	//2
		 /* i++ 先赋值在运算,例如 a=i++,先赋值a=i,后运算i=i+1,所以结果是a==1
		 	++i 先运算在赋值,例如 a=++i,先运算i=i+1,后赋值a=i,所以结果是a==2*/
	}

}

1.2 while循环

• do ..while 最少执行一次
• while和for循环最少执行0次（条件不满足）

package com.daytwo;
public class Tarray {
	public static void main(String[] args) {
		//WHILE循环
		//标准格式
		//扩展格式
		int i=0;
		while(i<10){
			System.out.println("Hello world"+i);
			i++;
		}
		//do while
		/*格式
		 * do{
		 * 	循环体
		 * }while（条件）
		 * */
		int kk=1;
		do{
			System.out.println("Hello world"+kk);
			kk++;
		}while(kk<=10);
	}
}

• 注意：for循环的变量在小括号中定义，属于局部变量，而while和do while循环写在外面，循环结束之后可以继续使用；

• 建议：凡是次数一定的就选择for循环，次数不一定的选择while或者do while循环

1.3、终止语句

• break

package com.daytwo;

public class demo1 {

	public static void main(String[] args) {
		/*关键字break，continue*/
		for (int i=1;i<=10;i++){
			if(i==4){
				break;//结束整个循环
			}else{
				System.out.println("Hello WORLD"+i);
			}
		}
	}
}

• continue

package com.daytwo;

public class demo1 {

	public static void main(String[] args) {
		/*关键字break，continue*/
		for(int i=1;i<=10;i++){
			if(i==4){
				continue;//跳出本次循环
			}else{
				System.out.println("Hello WORLD"+i);
			}

		}
	}

}

补充：永远停不下来的循环叫做死循环；

2、数组

• 数组是一种引用类型的数据
• 数组中的数据必须类型同一
• 数组的长度在程序运行期间不能改变

2.1数组创建

• 动态初始化

//语法
int[] array1=new int[300];
double[] array1 =new double[400]
String [] array2=new String[300]

• 静态初始化

package com.daytwo;

public class DemoArray {

	public static void main(String[] args) {
		//数组
		//数组是一种引用类型的数据
		// 数组中的数据必须类型同一
		// 数组的长度在程序运行期间不能改变
		//动态初始化
		int[] array1=new int[300];
		//静态
		//省略格式
		int [] arry2 ={15,25,35};
		//另一种静态声名方法
		//标准格式
//		int[] array2=new int[]{5,15,25};
		String str =arry2.toString();
		System.out.println(str);//[I@15db9742直接对象打印出地址；
	}
}

• 如果不确定数组的元素使用动态初始化，确定使用静态初始化；

• 直接打印数组名称得到的是数组对应内存地址的哈希值

注意：

• 动态声名空数组是数组中的内容规则如下
  • int 默认为0
  • double（浮点型）默认为0.0
  • 字符型 默认为 '\u0000' uniquecode编码的0
  • 如果是引用类型则为null
  • 静态初始化时也有默认值的过程但是会直接被大括号中的值覆盖掉

2.2 数组的赋值

		array1[0]=1;array1[1]=10;
		System.out.println(array1[1]);

2.3 数组内存的变化

• 单数组和两个数组不发生交互

package com.daytwo;

public class Demo {
	public static void main(String[] args){
		/*两个数组内存变化，不产生关联*/
		int[] array1= new int[3];
		array1[1]=10;
		array1[2]=20;
		System.out.println(array1);
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		System.out.println("======================");
		int[] array2 =new int[3];
		array2[1]=100;
		array2[2]=200;
		System.out.println(array2);
		System.out.println(array2[0]);
		System.out.println(array2[1]);
		System.out.println(array2[2]);

	}
}

/***********输出结果*************/
/*
[I@15db9742
0
10
20
======================
[I@6d06d69c
0
100
200
*/

• 产生交互赋值

  package com.daytwo;
  
  public class Demo2 {
  
  	public static void main(String[] args) {
  		int[] array1= new int[3];
  		array1[1]=10;
  		array1[2]=20;
  		System.out.println(array1);
  		System.out.println(array1[0]);
  		System.out.println(array1[1]);
  		System.out.println(array1[2]);
  		System.out.println("======================");
  		int[] array2 =array1;
  		System.out.println(array2);
  		System.out.println(array2[0]);
  		System.out.println(array2[1]);
  		System.out.println(array2[2]);
  		System.out.println("======================");
  		array2[1]=100;
  		array2[2]=200;
  		System.out.println(array2);
  		System.out.println(array2[0]);
  		System.out.println(array2[1]);
  		System.out.println(array2[2]);
  	}
  }
  /*
  输出结果
  [I@15db9742
  0
  10
  20
  ======================
  [I@15db9742
  0
  10
  20
  ======================
  [I@15db9742
  0
  100
  200
  */
  

2.4 数组空指针异常

• 所有的引用类型数据都可以赋值为一个null，但代表什么都没有；

package com.daytwo;

public class ArrayEx {

	public static void main(String[] args) {
		//数组常见异常

		//1、数组越界
//		int[] arr ={1,2,3};
//		System.out.println(arr[0]);
		//此处超出越界
//		System.out.println(arr[3]);
		//ArrayIndexOutOfBoundsException

		//空指针异常
//		所有的引用类型数据都可以赋值为一个null，但代表什么都没有；
		int[] arry=null;
		System.out.println(arry[0]);//NullPointerException

		/*
		 * 数组必须进行new初始化才能使用其中的元素
		 * 如果只是赋值了一个null，没有进行new创建那么将会发生空指针异常NullPointerException
		 * */
	}
}

2.5 数组的遍历

• 常规遍历

  //数组的遍历
  		int[] arrt={1,2,34,4,56,8,7};
  		for(int i=0;i<arrt.length;i++){
  			System.out.println(arrt[i]);
  		}
  

• foreach遍历

遍历数组就是获取数组的每个元素。通常遍历数组都是使用for循环来实现的，但是for循环不够简洁，下面我们简要介绍一下使用foreach语句来实现遍历数组的方法。java5之后，Java提供了一种更简洁的循环：foreach循环，这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时，无须获得数组和集合长度，无须根据索（下标）引来访问数组元素，foreach循环自动遍历数组和集合的每一个元素。

// foreach 语法
for(type element: array)
{
	System.out.println(element);
}

foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。foreach 语句用于循环访问集合以获取所需信息，但不应用于更改集合内容以避免产生不可预知的副作用。

因此不要对foreach的循环变量赋值。

例如：

package com.daytwo;

public class Demo3 {

	public static void main(String[] args) {
		//数组的遍历
		int[] arrt={1,2,34,4,56,8,7};
		for(int i=0;i<arrt.length;i++){
			System.out.println(arrt[i]);
		}
		System.out.println("=======================");
		for(int a:arrt){
			//一般不要对a进行赋值；
//			a=0;
			System.out.println(a);
		}
	}

}

2.6 数组参数

• 数组可以作为方法的参数

• 当调用方法的时候，方法向小括号进行传参，传递进去的其实是数组的地址值。

  package com.daytwo;
  
  public class Demo6 {
  
  	/*
  	 * 数组可以作为方法的参数
  	 * 当调用方法的时候，方法向小括号进行传参，传递进去的其实是数组的地址值。
  	 * */
  	public static void main(String[] args) {
  		// TODO Auto-generated method stub
  		int[] arry={1,2,3};
  		teAray(arry);//实参是arry的地址值；
  	}
  
  	public static void teAray(int[] arry){
  		System.out.println("接收的参数是"+arry);//地址值
  		for(int a:arry){
  			System.out.println(a);
  		}
  	}
  }
  
  

  2.7 数组返回值

  package com.daytwo;
  
  public class Demo6 {
  
  	/*
  	 * 数组可以作为方法的参数
  	 * 当调用方法的时候，方法向小括号进行传参，传递进去的其实是数组的地址值。
  	 * */
  	public static void main(String[] args) {
  		// TODO Auto-generated method stub
  		int[] arry={1,2,3};
  		teAray(arry);//实参是arry的地址值；
  		System.out.print(arry[0]);
  		int[] res=col(2,3,4);
  		System.out.println("返回值是"+res);//返回值是数组是数组地址
  		System.out.println(res[0]);
  		System.out.println(res[1]);
  	}
  
  	public static void teAray(int[] arry){
  		arry[0]=100;//方法内部修改数组的值会直接修改，不像局部变量一样有作用域，因为数组存放在堆内存中
  		System.out.println("接收的参数是"+arry);//地址值
  		for(int a:arry){
  			System.out.println(a);
  		}
  	}
  
  	/*数组作为方法返回值，返回的也是数组的地址值*/
  	public static int[] col(int i,int b,int c){
  		int sum=i+b+c;
  		int avg=(i+b+c)/3;
  		int[] arr={sum,avg};
  		//一个函数或者方法只能有一个返回值
  		System.out.println("方法内部数组的地址是"+arr);
  		return arr;
  	}
  }
  
  

3、内存

3.1内存分配

• 1、栈（Stack）存放的都是方法中的局部变量，方法的运行一定要在栈当中运行。
  • 局部变量：方法的参数，或者是方法{}内部的变量
  • 作用域：一旦超出作用域，立刻从栈内存中消失
• 2、堆（Heap）:凡是new 出来的东西都在堆内存中
  • 堆内存里面的东西只有一个地址值：16进制
  • 堆内存里卖弄的数据，都有默认值。规则与数组类似；
    • 补充：布尔型默认是false
• 3、方法区（method Area）:存储class相关信息，包含方法信息
• 4、本地方法栈（Native Method Stack）：与操作系统相关
• 5、寄存器（pc Register）与CPU相关