chap06-数组

最新推荐文章于 2024-10-17 19:11:48 发布

村头张大炮

最新推荐文章于 2024-10-17 19:11:48 发布

阅读量121

点赞数 3

分类专栏： Corejava 文章标签： java

本文链接：https://blog.csdn.net/Z_0394/article/details/117997826

版权

Corejava 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

chap06-数组

一.相关概念
二、语法
三.数组遍历
四.数组的内存结构
五.数组的扩容
七.数组排序
八.二维数组

一.相关概念

数组:内存中一段连续的存储空间,可以存储多个同类型的变量

特点:类型相同,长度固定

概念:

长度:定义数组时进行声明,数组的长度,代表内存中开辟空间的数量,以及后期存值的数量 数组名.length
元素:数组中每个数据格中的存值称为元素
访问:对元素的存值和取值称为元素的访问
下标:数组有下标,下标从0开始,依次+1
存值:数组名[下标]=值 取值:数组名[下标]

在这里插入图片描述

二、语法

数组的声明并分配空间

数据类型[] 数组名=new 数据类型[长度];

先声明后分配空间

//声明数组
数据类型[] 数组名;//数据类型 []数组名; 数据类型 数组名[];
//分配空间
数组名=new 数据类型[长度];

声明数组并赋值

数据类型[] 数组名=new 数据类型[]{值1,值2,值3,...};

声明数组并赋值

数据类型[] 数组名={值1,值2,值3,...};//不能换行

三.数组遍历

for(int i=0;i<数组名.length;i++){
//通过数组名[i]访问数组的元素
}

访问下标超出数组下标范围:java.lang.ArrayIndexOutOfBoundsException(数组下标越界异常)

数组有默认值:
整数:0 浮点数:0.0 char:’\u0000’ 空格布尔:false 引用:null
打印数组名结果为数组的地址

四.数组的内存结构

基本类型存值直接是字面值,数组存值,数组名存的实际内容为数组在堆内存中的地址
基本类型相互赋值,赋值内容为字面值;数组进行相互赋值,赋值内容为地址

五.数组的扩容

数组复制:创建新数组,把老数组的数据放到新数组的对应下标处

数组扩容

 思想:"大搬家",新创建一个更大的数组,把数组的原有值赋值到新数组,老数组的数组名指向新数组
 方法一:创建新数组,把老数组的数据放到新数组的对应下标处,新数组长度>老数组长度
 方法二:System.arraycopy(老数组,老数组复制的起始下标,新数组,新数组赋值的起始下标,复制长度);
 方法三:java.util.Arrays.copyOf(老数组,新长度);//返回一个新数组

七.数组排序

冒泡排序:相邻的两个数据进行比较,按要求换位置

  比如数组 int a[] ={ 8，2，9，7，1 };
  第一次循环：
  			下标0的值(8)和下标1的值(2)比较，8>2,则交换位置，此时数组为{2,8,9,7,1}，
  			下标1的值(8)和下标2的值(9)比较，8<9,则不交换位置，此时数组为{2,8,9,7,1}，
  			下标2的值(9)和下标3的值(7)比较，9>7,则交换位置，此时数组为{2,8,7,9,1}，
  			下标3的值(9)和下标4的值(1)比较，9>1,则交换位置，此时数组为{2,8,7,1,9}，
  第二次循环：
  			下标0的值(2)和下标1的值(8)比较，2<8,则不交换位置，此时数组为{2,8,7,1,9}，
  			下标1的值(8)和下标2的值(7)比较，8>7,则交换位置，此时数组为{2,7,8,1,9}，
  			下标2的值(8)和下标3的值(1)比较，8>1,则交换位置，此时数组为{2,7,1,8,9}，
  第三次循环：
  			下标0的值(2)和下标1的值(7)比较，2<7,则不交换位置，此时数组为{2,7,1,8,9}，
  			下标1的值(7)和下标2的值(1)比较，7>1,则交换位置，此时数组为{2,1,7,8,9}，
  第四次循环：
  			下标0的值(2)和下标1的值(1)比较，2>1,则交换位置，此时数组为{1,2,7,8,9}，
  实例代码：
  	for (int i = 0; i < a.length - 1; i++) {
  	for (int j = 0; j < a.length - i - 1; j++) {
  		//数据交换
  		if(a[j] > a[j + 1]) {
  			int temp = a[j];
  			a[j] = a[j + 1];
  			a[j + 1] = temp;
  		}
  	}
  }

选择排序:使用固定下标与其他值对比,按照要求更换位置

  比如数组 int a[] ={ 8，2，9，7，1 };		
  第一次循环：
  			下标0的值(8)和下标1的值(2)比较，8>2,则交换位置，此时数组为{2,8,9,7,1}，
  			下标0的值(2)和下标2的值(9)比较，2<9,则不交换位置，此时数组为{2,8,9,7,1}，
  			下标0的值(2)和下标3的值(7)比较，2<7,则不交换位置，此时数组为{2,8,9,7,1}，
  			下标0的值(2)和下标4的值(1)比较，2>1,则交换位置，此时数组为{1,8,9,7,2}，
  第二次循环：
  			下标1的值(8)和下标2的值(9)比较，8<9,则不交换位置，此时数组为{1,8,9,7,2}，
  			下标1的值(8)和下标3的值(7)比较，8>7,则交换位置，此时数组为{1,7,9,8,2}，
  			下标1的值(7)和下标4的值(2)比较，7>2,则交换位置，此时数组为{1,2,9,8,7}，
  第三次循环：
  			下标2的值(9)和下标3的值(8)比较，9>8,则交换位置，此时数组为{1,2,8,9,7}，
  			下标2的值(8)和下标4的值(7)比较，8>7,则交换位置，此时数组为{1,2,7,9,8}，
  第四次循环：
  			下标3的值(9)和下标4的值(8)比较，9>8,则交换位置，此时数组为{1,2,7,8,9}，
  实例代码：
  	 for (int i = 0; i < a.length-1; i++) {
      for (int j = i+1; j < a.length; j++) {
          //交换数据
          if(a[i]>a[j]){
              int temp = a[i];
              a[i]=a[j];
              a[j]=temp;
          }
      }
  }

JDK排序:java.util.Arrays.sort(数组名);//升序排序

  int a[] ={ 8，2，9，7，1 };	
  java.util.Arrays.sort(a);
          for (int i : a) {
              System.out.println(i);
          }

八.二维数组

概念:数组的元素还是数组

 高维数组中存放低维数组,通过数组名[高维下标][低维下标]访问元素

语法:

 //声明数组并分配空间:数据类型[][] 数组名=new 数据类型[高维长度][低维长度];
 int[][] a=new int[5][3];
 //先声明数组再分配空间:(声明不规则数组)
 //数据类型[][] 数组名=new 数据类型[高维长度][];低维数组后续自行赋值
 int[][] a=new int[5][];
 //声明数组并赋值:数据类型[][] 数组名={{值1,值2,...},{值1,值2,...},{值1,值2,...},...};
 int[][] a={{1,2,3},{4,5,6},{7},{8,9},......};

内存结构:

数组名中存储高维数组的地址,高维的元素为低维数组的地址

遍历

 //遍历
 System.out.println(a.length);//代表高维长度
 //外层遍历高维数组--通过a[i]获取低维数组
 for(int i=0;i<a.length;i++){
 		//System.out.println(a[i]);a[i]代表数组
 		//内层循环遍历低维数组
 		for(int j=0;j<a[i].length;j++){
 			System.out.print(a[i][j]+" ");
 		}
 		System.out.println();
 }

看完如果对你有帮助，感谢点赞支持！
在这里插入图片描述