java数组复习和内存分配

Java基础知识复习

1.循环

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

for循环

  • 补充：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);
			}
			
		}
	}

}

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

2、数组

  • 数组是一种引用类型的数据
  • 数组中的数据必须类型同一
  • 数组的长度在程序运行期间不能改变
2.1数组创建
  • 动态初始化
//语法
int[] array1=new int[300];
double[] array1 =new double[400]
String [] array2=new String[300]

image-20211017210625637

  • 静态初始化
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直接对象打印出地址；
	}
}

image-20211017212725450

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

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

注意：

  • 动态声名空数组是数组中的内容规则如下
    • 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
*/

image-20211017220939741

image-20211017221805009

  • 产生交互赋值

    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
*/

  • image-20211017223747267

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;
	}
}

image-20211018191254727

3、内存

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

image-20211017215017591

posted @ 2021-10-18 19:27  紫青宝剑  阅读(47)  评论(0)  编辑  收藏  举报