Java中的内存分配,数组；冒泡排序；二维数组

Java中的内存分配

1. 栈内存:方法加载进栈(里面存储局部变量)

2. 堆内存:new出来的东西 new 类名() ; (成员变量)

3. 方法区:存储一些字节码文件对象(xxx.class),static相关的,字符串常量池等等…

4. (Java代码经历三个阶段:Source(源码),C LASS阶段(反射完成的), RUNTIME阶段(运行阶段)
   反射中讲关于java经历的三个阶段)

5. 本地方法区:和系统相关

6. 寄存器:和cpu有关系

数组的静态初始化:

指定的元素的内容,系统默认长度!
静态的初始化的格式:

1. 标准格式:

数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3,,,,} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3,,,,} ;

2. 简写方式:(推荐)

数据类型[] 数组名称 = {元素1,元素2,元素3,,,,}  ;
数据类型 数组名称[] = {元素1,元素2,元素3,,,,}  ;

int[] arr = new int[]{1,2,3} ;
int[] arr = {1,2,3} ;

数组中会遇见的一些异常:

异常:Throwable 类
异常分为两大类:

	Error:程序出现了严重的问题;
	Exception:
			RuntimeException:运行时期异常 
				java.lang.ArrayIndexOutOfBoundsException属于运行时期异常的一种
				java.lang.NullPointerException属于运行时期异常的一种
					
			编译时期异常(只要不是RuntimeException的异常都属于编译时期)
	

	java.lang.ArrayIndexOutOfBoundsException:属于运行时期异常的一种
					数组角标越界异常
							出现的原因:访问了数组中不存在的角标值
							解决方案:更改角标在范围内即可!
							
							
	java.lang.NullPointerException:空指针异常(引用类型中经常会出现的异常!)
	出现的原因:
			代码结构不严谨(某个对象已经为null,还有使用这个对象调用方法或者访问元素...)
	解决方案:
			只要 给对该对象进行非空判断
			如果该对象不为空,才能使用这个对象完成一些操作!

面试题:
数组中有没有length属性,字符串中有没有length属性,集合中有没有length属性

1. 数组中:存在length属性
2. 字符串没有length属性------->String类中:length()
3. 集合中没有length属性------->集合中:size()

数组的元素查表法:
通过数组名称[角标值]确定内容

数组的基本查找法:
(数组的元素内容可以无序)

• 从数组中的开始索引一直查询到末尾,查询出元素第一次在数组中的索引值
• 数组的高级查找:二分搜索法(折半查找): 前提条件:数组的元素必须有序!

冒泡排序的思想:

两两比较,将较大的值往后放,第一次比较完毕,最大值出现在 最大索引处,依次这样比较...
	规律:
			两两比较,将较大的值往后放
			总共比较的次数:数组长度-1次

class ArrayDemo{
	public static void main(String[] args){
		
		//定义一个数组,静态初始化
		int[] arr = {24,60,87,57,13} ;
		
		//调用数组遍历的功能
		System.out.println("排序之前:") ;
		printArray(arr) ;
		for(int x = 0 ; x < 4 ; x ++ ){//循环次数
			for(int y = 0 ;y < arr.length-1-x; y++){ //元素比较
				//判断:
				if(arr[y] > arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		
		System.out.println("排序之后:") ;
		printArray(arr) ;
		
		System.out.println("-------------------------------") ;
		
		//问题:上面的4次,数出来的,它应该 比较的次数:数组长度-1次
		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]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		System.out.println("排序之后:") ;
		printArray(arr) ;
		
		System.out.println("-------------------------------") ;
		//将排序的代码---->使用功能定义
		//调用冒泡排序的方法
		bubbleSort(arr) ;
		//遍历
		printArray(arr) ;
		
		
	}
	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]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
	}
	
	//遍历的功能
	public static void printArray(int[] arr){
		System.out.print("[");
		for(int x = 0 ; x < arr.length ; x ++){
			//判断
			if(x== arr.length-1){
				System.out.println(arr[x]+"]") ;
			}else{
				System.out.print(arr[x]+", ") ;
			}
		}
	}
}

二维数组:

1. 定义:其实就是一个元素为一维数组的数组
   定义格式:
   数据类型[] 数组名称[] ;
   数据类型[][] 数组名称 ;

2. 动态初始化:

   格式1:
   	数据类型[][] 数组名称 = new 数据类型[m][n] ;
   举例:
   	 int[][] arr = new int[3][2] ;
   =号左边:
   	int:当前数组存储的是int类型的元素
   	[][]:定义的是一个二维数组
   	arr :数组对象名称
   =号右边:
   	new :在堆内存中创建该数组的对象(产生堆内存空间地址)
   	int:当前数组存储的是int类型的元素
   	[3]:当前定义的这个二维数组中有3个一维数组
   	[2]:每一个一维数组中有2个长度
   

3. 二维数组的格式2:

   指定了一维数组的个数,一维数组的长度需要动态给定
   数据类型[][] 数组名称 = new 数据类型[m][] ;

   举例:
   int[][] arr = new int[3][] ;

   二维数组的格式3:
   就是静态初始化
   数据类型[][] 数组名称 =
   new 数据类型[][]{{元素1,元素2,元素3…},{元素1,元素2,元素3,…},{,}};
   简写格式:
   数据类型 [][] 数组名称 = {{元素1,元素2,元素3…},{元素1,元素2,元素3,…},{,}};

   举例
   	int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}} ;
   	
   	-->简写格式
   	int[][] arr = {{1,2,3},{4,5,6},{7,8,9}} ;