学习Java的笔记（第三天）—— 数组

1.数组

• 名词解释：堆中一块连续的内存空间（变量就是其中一块空间）
• 计算机的微观世界：(JVM微观世界的三大区(栈区，堆区，方法区)
  **当一个test程序执行时，首先生成一个test进程，javaw.exe再将程序调入JVM虚拟机中,也就是JVM为程序分配内存空间。
  1.JVM将程序的所有方法调入方法区。
  2.先将main方法进栈，再将其他方法进栈，（由于栈是后进先出）。
  3.所以栈输出时，先将其他方法输出执行，最后输出main方法，执行main方法结束。
  栈：后进先出
  数据类型：除了四类八种数据类型外，其他的数据类型，在栈中只占一个字节
  变量地址映射表：（数据|地址）、永远指向栈,数组是通过栈找到堆的位置

1.1 数组规则

1.数组的数据存放在堆中
2.堆里面的数据自动初始化
3.变量地址映射表和堆的关系
**数据类型的初始化：
boolean：false
char ： ’ ’ (空)
byte short int long： 0
float double： 0.0

public class Test{
	public  static void main(String[] args){
	
		//定义一个数组
		int[ ] array = new int [12];      //该数组的空间大小为：4*12 = 48字节，并且是连续的空间
	 //1.数组的**数据存放在堆中**
	 //2.堆里面的**数据自动初始化**，就是自动在12块（每块4字节）的空间中存放一个数据（初始化数据）
	 //3.变量地址映射表和堆的关系, array变量存储在变量地址映射表中（存的是栈的地址），通过映射找到其在栈的位置，通过栈的数据（也就是堆的地址）再找到堆的位置


		//定义一个变量---**局部变量一定要初始化**
		int a = 3;
		System.out.println(a);

	  	//遍历数组
	  	for(int i=0; i<12; i++)
	  	{
	  		System.out.println(array[i]);
	  	}      //结果：0 0 0 0 0 0 0 0 0 0 0 0

	}
}

• 使用的场合： 数组的遍历、极值（最大最小值）、 插入、 查找、倒置、 求和、 排序（从大到小，从小到大）

定义数组，并使用

public class Array{
	public static void main(String[] args){
		//声明一个数组，一定要给一个长度（定长），不能改变
		
		//第一种方式：
		int b[]  = new int[4];
		for(int i=0; i<=3; i++){
			b[i] = i;
		}
		
		//第二种方式：
		int b1[] = {1,2,3,4};
		//拆分  阅读
		int b2[ ] = new int[4];
		b2[0] = 1;
		b2[1] = 2;
		b2[2] = 3;
		b2[3] = 4;

		//拿出b的数据，使用a.length
		for(int i=0; i<=b.length-1 ; i++)
		{
			System.out.println(b[i]);
		}
	}
}

判断数组的极值

public class Array{
	public static void main(String[] args){
		//随机数
		Random r = new Random();
		//int num = r.nextInt(100);    //0-100之间的随机数
		//构建一个长度为20的数组
		int [] array = new int [20];
		//存放20个随机数（范围0-100）
		for(int i=0; i<array.length; i++)
		{
			array[i] = r.nextInt(100);     //为数组中20个数传入一个1-100的数字
		}
		//最大值
		int max = array[0];
		for(int i=0; i<array.length; i++)
		{
			if( max<array[i] )
			{
				max = array[i];
			}
		}
		System.out.println(max);
		System.out.println("-------------------");
			//最小值
		int min = array[0];
		for(int i=0; i<array.length; i++)
		{
			if( min>array[i] )
			{
				min = array[i];
			}
		}
		System.out.println(min);
	}
}
	

数组的查找：二分(折半)查找（前提：一个有序的数组）

//二分查找

/**
 * 二分查找(折半查找)
 * 意义：不断缩小改变数组的区间
 * @author 李英超
 *
 */
public class Erfen {
	public static void main(String[] args) {
		//声明数组array
		int[] array = {2,4,6,8,11,14,25,44};
		 //输入要查找的数字
		 Scanner scanner = new Scanner(System.in);
		 System.out.println("请输入要查找的数字:(0-9)");
		 int x = scanner.nextInt();
		 int score = 0 ;
		  
		 //定义起始位置start 和 结束位置end
		 int start = 0; 
		 int end = array.length - 1;
		 int mid = 0;
		// System.out.println(x);
		 //改变区间范围,判定循环的条件是 start > end
		 while(end >=start) {
			 mid = (start + end) / 2; 
			 if(x==array[mid]) {
				 score = mid;
					break;
			 }else if(x < array[mid]) {
				 end = mid - 1;
			 }else {
				 start = mid + 1;
			 }
		 }
		 System.out.println(score);
 
	}
}

数组的排序：冒泡

public class Array{
	public static void main(String[] args){
	Random random = new Random();
	int [] array = new int [100];
	for(int i=0; i<array.length; i++)
	{
		array[i] = random.nextInt(100)；
	}
		//冒泡排序：小的上浮，大的下沉
		//从小到大
		for(int i=0; i<array.length-1; i++)
		{
			for(int j=0; j<array.length-i-1; j++)
			{
				if( array[j]>array[j+1])
				{
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
	System.out.println("-------------------");
	for(int i=0; i<array.length; i++)
	{
		System.out.println(array[i]);
	}
	}
}

数组的排序函数:Arrays.Sort

public class ArraySort{
	public static void main(String[] args){
	//产生随机数
	Random random = new Random();
	int [] array = new int [100];
	
	for(int i=0; i<array.length; i++)
	{
		array[i] = random.nextInt(20)；
	}
	Arrays.sort(array);   //调用ArraySort函数
    for(int i=0; i<array.length; i++)
     {
        System.out.println(array[i] + " ");
     }
     
	}
}