数组讲义

数组

概述：数组是一种容器。容器就是存处数据的，数组可以同时存储多个数据的容器

比如：班级有100个学生，100个名字，定义变量的方式，需要定义出100个变量，储存名字更好的解决方法：100个名字全部存储在一个容器中，方便管理这些数据

凡是数据多了，存储在数组容器中。

java数组：只能存储同一个数据类型的数据。

数组的定义

数据类型

数据类型[] 数组的名字= new 数据类型[整数值];
数据类型[] 数组的名字= { 元素1，元素2，元素3}；
数据类型[] 数组的名字= new 数据类型[]{ 元素1，元素2，元素3}；

• []表示数组，
• 数组的名字，理解为就是一个变量的名字，
• new创建数组容器的关键字
• 数据类型，定义1的数组容器存储的数据类型，int这个数组只能存储整数
• 整数值，表示的是数组的长度，就是容量，

JVM内存的划分

1. 方法运行，进入到这个内存区域------>方法栈、线程栈（Method stack）
2. 存储数组、存储对象 new Scanner（）-------->堆 （heap）
3. 操作系统，JVM用到操作系统的功能，使用这个内存区域 ---------------->本地方法栈（Native stack）
4. 存储我们运行时的class文件 -------->元数据区（Meta Data）

运行过程

jvm调用方法main执行程序入口点

main方法：进入到方法栈找内存区域运行

执行1一行代码，创建数组（堆内存）

jvm：在堆内存空间 ，开辟一个小的区域，存储数组

数组在堆中存储（堆中的任何数据，必须有值） 默认的值

JVM 数组中的地址，传递到main方法中的变量，arr（定义的数组变量）

arr变量，保存的是堆内存中的，数组的地址（不是具体数据）

数组是引用数据类型

输出完毕arr数组地址，main方法结束了，栈内存的空间，立刻释放main方法就出去。变量arr也不存在了数组在内存中，也没有变量保存地址数组在内存中变成了垃圾，等待JVM去内存中回收。

• 栈内存和堆内存的区别

  1. 栈内存使用完就释放。效率高

  2. 堆内存等待jvm垃圾回收，效率低

  3. 栈内存中的变量必须赋值,否则不能用

  4. 堆内存的数据,必须有默认值

  5. 栈内存,方法运行的时候计算

  6. 堆内存,负责存储对象和数据

     数组的访问

     操作数组中的数据，存储到数组中的任何数据，都称为数组的元素（Element）

     数组元素的访问，依靠数组的索引（index）（下标）

     • 数组的索引

       每个数组都有自己的索引

       索引是从0开始的

       索引是数组的特性，天生就有，本质上就是数组中每个元素的编号

       • 数组访问的语法

       [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AKbyxI9h-1595496486475)(C:\Users\lj\Pictures\批注 2020-07-08 172520.png)]

存储String类型的数组，默认值是null；

数组的长度

Java中的数组是定长的，数组的长度也就是他能存储元素的个数，一旦创建完毕，不可改变。

定长也是数组一个弊端

对于数组：jvm赋予数组一个属性（属性：属于这个事物的特征）

属性的名字length，表示数组的长度（int 类型）

使用方法：数组名.length

数组的定义

• 定义格式

  数据类型[] 数组的名字= new 数据类型[]{ 元素1，元素2，元素3}；
  

  定义格式：

  数据类型[] 数组的名字= { 元素1，元素2，元素3}；
  

  定义格式:

  数据类型[] 数组名字=new 数据类型[数据个数];
  

  数组操作的2个异常

  • 数组的索引超过范围（索引越界）

  程序中访问了不存在索引(只有五个确搞得大于五个)

  空指针异常

  数组的内存问题

  两个数组在内存中的表现

  每个数组都会在内存中开辟空间存储数据 ,但是两个数组之间没有任何联系

  多变量指向同一个内存空间

  public static void main(String[] args) {
  	//定义数组
    int[] arr1 = new int[] {1,2,3,4,5};
  //  int[] arr2 = new int[] {6,7,8,9,0};
    System.out.println(arr1);
    //将数组arr1的内存地址,复制到另一个变量
    int [] arr2= arr1;
    System.out.println(arr2);
  		  System.out.println(arr1[0]);
  		  arr2[0]=100;
  		  System.out.println(arr1[0]);
  }
  

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wzpS16fJ-1595496486479)(C:\Users\15272\Desktop\笔记\笔记照片\多变量指向同一个内存空间.png)]

数组的常见操作

数组的遍历

所谓的数组遍历,就是将数组中的每一个元素分别取出的过程

循环遍历取出元素,循环次数由数组长度length决定

	public static void main(String[] args) {
	int [] arr1 = {2,4,6,8,10};
	for (int i = 0; i < arr1.length; i++) {
		System.out.println(arr1[i]);
	    }
	}

数组最值获取

取出数组中的最大值或者最小值

	int [] arr1 = {2,4,6,8,10};
	//定义存储最大值的变量,初值为arr1[0]
	int max=arr1[0];
	for (int i = 0; i < arr1.length; i++) {
		//比较连续小标的值,把大赋值给max
		if (arr1[i]>=max) {
			max=arr1[i];
		} 
	}
	System.out.println("最大值是:"+max);
	

数组拼接为字符串

任意数组:int[] arr={1,2,3,4,5,6,7,8,9};遍历数组,去除元素,拼接为一个字符串,输出格式为[1,2,3,4,5,6,7,8,9]

/ * @author 15272
 * 输出【1，2，3，4，5，6，7】
 *
 */
public class ShuZu03 {

	public static void main(String[] args) {
		//创建数组
		int [] arr= {1,2,3,4,5,6,7};
		String s="[";
		for (int i = 0; i < arr.length; i++) {
			if (i<arr.length-1) {
				s=s+arr[i]+",";
			}else {
				s=s+arr[i]+"]";
			}
		}System.out.println(s);
	}
	//也可以吧数组转化为字符串
	System.out.println(Arrays.toStoring(arr));

数组元素查找

一直数组：在数组中查找一个元素是否存在

存在：返回索引，不存在：返回复数

public class ShuZu04 {

	public static void main(String[] args) {
	//定义一个数组
		int[]arr= {1,2,3,4,5,6,7,8,9,0};
		//数组转化为字符串
		String string=Arrays.toString(arr);
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入你要查找的数");
		int age=scanner.nextInt();
		
		int a=-1;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i]==age) {
				
				a=i;
			break;
			}
		}
		System.out.println(a);
			

	}

数组翻转

所谓数组翻转,就是数组中元素位置发生了转变,不是倒序遍历

原数组:[1,2,3,4]
翻转后:[4,3,2,1]

		int[] arr= {1,2,3,4,5,6,7,8,9};
		int min=0;
		int max=arr.length-1;
		/*
		 * for (int i = 0; i < arr.length; i++) { if (arr.length%2==0) { while
		 * (i<arr.length-1) { temp=arr[i]; arr[i]=arr[arr.length-1];
		 * arr[arr.length-1]=arr[i];
		 * 
		 * } } if (arr.length%2!=0) { while (i<=arr.length) {
		 * 
		 * temp=arr[i]; arr[i]=arr[arr.length-1]; arr[arr.length-1]=arr[i];
		 * 
		 * } } }
		 */
		for (; min<=max; ) {
			int temp=arr[max];
			arr[max]=arr[min];
			arr[min]=temp;
			min++;
			max--;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

二维数组

• 一维数组:一个数组,存储的是需要的数据

• 二维数组:一个数组,存储的元素,是另一个数组的地址,理解为数组中的数组定义方式

  • 定义方式1

    数据类型[][] array = new数据类型[3][2]
    格式解析:定义一个二维数组
    [3]:二维数组存放三个一维数组;[2]一维数组的长度
    
    	public static void main(String[] args) {
    		//定义一个二维数组
    	int [] [] arr= new int[3][2];
    	System.out.println(arr);
    
    	}
    
    
    

  • 二位数组中,存储的是一维数组的地址

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F87aQoZL-1595496486481)(C:\Users\15272\AppData\Roaming\Typora\typora-user-images\1594274408177.png)]

  • 定义方式2

    数据类型[][]arr=new 数据类型[][]{{},{},{}   };
    
    

    /**
     * @author 15272
     *int[][] {  {},{},{}    };二位数组中有三个一维数组
     */
    public class ErWeiShuZu01 {
    
    	public static void main(String[] args) {
    		//定义一个二维数组,给二维数组赋值
    	int [] [] arr= new int[][] {  {1,2},{1,2,3,},{1,2,3,4,5}    };
    	System.out.println(arr);
    	
    	
    
    	}
        
    
    

• 定义方式三

数据类型[][]arr={  {},{}, {} };
	int[] [] arr= {{1,2},{1,2,3},{1,2,3,4,4}};

遍历

二位数组遍历 ;利用嵌套循环双for,外循环

 * 利用嵌套for遍历二维数组
 */
public class ErWeiShuZu01 {

	public static void main(String[] args) {
		//定义一个二维数组,给二维数组赋值
	int [] [] arr= new int[][] {  {1,2},{1,2,3,},{1,2,3,4,5}    };
	//外循环遍历二维数组,取出里面三个一维数组
	for (int i = 0; i < arr.length; i++) {
		//System.out.println(arr[i]);
		for (int j = 0; j < arr[i].length; j++) {
			System.out.print(arr[i][j]);
		}
		System.out.println();
	}

	}