数组

数组

• 变量的特点：

  1. 一个变量表示一块内存空间，只能存储一个数据
  2. 当需要存储多个数据时，需要重复定义多个变量
  3. 不便于对多个数据统一进行操作
  

• 例：

//使用变量存储100名学生成绩
int score1 = sc.nextInt();
int score2 = sc.nextInt();
int score3 = sc.nextInt();
int score4 = sc.nextInt();
int score5 = sc.nextInt();
//....100个变量
    
//如何计算平均分？
(score1+score2+score3+score4+....score100) / 100
    
//通过程序把所有不及格的学生改为及格,操作过于繁琐
if(score1<60) score1 = 60;
if(score2<60) score2 = 60;
//.......
if(score100<60) score100 = 60;

概念：内存中一段连续的内存空间，可以存储多个相同类型的变量。

一、数组的组成部分与基本操作（重点）

(一) 数组的定义/申明

• 语法：

  数据类型[] 数组名;[推荐]
  数据类型 []数组名;
  数据类型 数组名[];
  

  例：

  //声明定义一个int类型数组
  int[] is;
      
  //声明定义一个double类型数组
  double[] ds;
  

(二) 手动为数组分配空间

• 作用：数组是由多个内存空间构成， 必须根据需求手动分配空间数量，无法自动分配 。

• 语法：

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

  长度是一个整数，表示为数组分配的内存空间数量，一块内存空间可以存储一个数据，所以长度也可以表示数组的容量。

  例：

  //声明定义一个int类型数组
  int[] is;
  //为is数组分配5块内存空间
  is = new int[5];
      
      
  //声明定义一个double类型数组
  double[] ds;
  //为ds数组分配10块内存空间
  ds = new double[10];
  

(三) 下标

• 概念：数组为每块内存空间分配的编号，int类型，从0开始到长度-1结束。
  

(四) 使用下标操作数组

• 将数据保持在数组中

  数组名[下标] = 数据;
  

例：```java
int[] is;
is = new int[5];

is[0] = 100;//将100存储到数组的第1块内存空间中
is[1] = 80;//将80存储到数组的第2块内存空间中
is[2] = 70;//将70存储到数组的第3块内存空间中
is[3] = 60;//将60存储到数组的第4块内存空间中
is[4] = 40;//将40存储到数组的第5块内存空间中```

• 提取、获取数组中的数据

  例：

  数组名[下标];
  

int[] is;
is = new int[5];    
is[0] = 100;
is[1] = 80;    
//略....    

int e1 = is[0];//提取数组中的第1个数据，打印输出
System.out.println( e1 );

int e2 = is[1];//提取数组中的第2个数据，打印输出
System.out.println( e2 );

System.out.println( is[2] );//获取数组中的第3个数据，打印输出
System.out.println( is[3] );//获取数组中的第4个数据，打印输出
System.out.println( is[4] );//获取数组中的第5个数据，打印输出

习惯：存储在数组中的数据，称为数组的元素，获取数据称为获取元素或访问元素，存储数据称为存储元素或添加元素。

注意：使用下标操作数组，务必保证下标的合法，否则会出现数组下标越界异常。

(五) 获取数组的长度

• 数组长度：表示数组的空间数量，数组的容量。

• 语法：数组名.length 得到一个int类型的整数，表示数组的长度

  例：

int[] is;
is = new int[10];
        
double[] ds;
ds = new double[15];
    
//获取is数组长度
int len1 = is.length;
System.out.println( len1 );
System.out.println( is.length );//同上
    
//获取ds数组长度
int len2 = ds.length;
System.out.println( len2 );
System.out.println( ds.length );//同上

(六) 遍历数组

• 遍历：从“头”到“尾”访问获取每个元素
• 例：

int[] is;
is = new int[5];
    
is[0] = 100;
is[1] = 80;
//....略
    
//遍历数组
System.out.println( is[0] );
System.out.println( is[1] );
System.out.println( is[2] );
System.out.println( is[3] );
System.out.println( is[4] );

• 例：使用变量代替下标获取元素，寻找共性

int[] is;
is = new int[5];
    
is[0] = 100;
is[1] = 50;
//...略
    
//访问数组的元素
int i = 0;
System.out.println( is[i] );
i++;

System.out.println( is[i] );
//以此类推，共性相同

• 使用循环遍历[推荐]

  编程套路：

//合法下标范围：0~~is.length-1
for(int i=0; i<数组名.length; i++){
  //使用i变量作为数组下标
   数组名[i];
}
  例：遍历is数组中的每个元素
//合法下标范围：0~~is.length-1
for(int i=0; i<is.length; i++){
  //使用i变量作为数组下标
  System.out.println( is[i] );
}

• 利用遍历统一操作数组元素

  例：计算班级平均分

double[] ds;
ds = new double[5];

ds[0] = 75.5;
ds[1] = 80D;
ds[2] = 95.5;
ds[3] = 82.5;
ds[4] = 100;
    
//遍历数组累加每个元素
double sum = 0D;//计算累加和
    
for(int i=0; i<ds.length; i++){
      
  //double score = ds[i];   提取成绩
  //sum += score;       累加求和
      
  sum += ds[i];//效果同上
      
}
    
//计算平均成绩
System.out.println( sum / ds.length );
 

(七) 创建数组的其他方式

1. 声明并分配空间

   语法：

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

2. 显式初始化

   作用：创建数组同时添加元素，元素个数巨顶数组的长度

   语法：

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

   例：

   int[] is;
   is = new int[]{100, 70, 80, 40};
   

3. 显式初始化（简写形式）

   语法：

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

二、数组的特性(重点)

(一) 数组的默认值

• 数组的每个元素都具备默认值

  例

int[] is = new int[5];
System.out.println( is[0] );//默认值：0
    
double[] ds = new double[5];
System.out.println( ds[0] );//默认值：0.0
    
String[] str = new String[5];
System.out.println( str[0] );//默认值：null

• 默认值对照表

数据类型	默认值
整数类型(byte,short,int,long)	0
浮点类型（float,double）	0.0
布尔类型（boolean）	false
字符类型（char）	'\u0000'
引用类型 （String）	null

(二) 引用类型

• 引用：引用计算机或外部提供的内容，到程序道中

• 特点：

  1. 该类型的变量中存储的不是真正的数据（数值），而是内存空间的地址。
  2. 基本类型直接传递数据，引用类型传递地址。
  

  例：引用类型中存储的内容【门牌与房间的关系】

  int a = 10;//基本类型
  System.out.println( a );//打印结果：10
      
  int[] as = new int[5];//引用类型
  System.out.println( as );//[I@16f65612(*内存空间地址)
  //[ ：表示数组
  //I ：表示int类型
  //@ ：普通的@符号，无其他含义
  //16f65612 ：引用计算机提供的内存地址并转换为16进制
  //说明这是一个int类型数组，存储在哪个区域中
  

  例：应用类型之间的传递规则

  int a = 10;//基本类型
  int b = a; //将a变量中存储的数据复制一份给b变量使用
  b++;     //b变量自加1
  System.out.println( a );//打印结果：10
      
      
      
  int[] as = new int[5];//引用类型
  int[] bs = as;      //将as变量中存储的地址复制一份给bs变量使用
  bs[0] = 100;      //将100添加到bs[0]的位置
  System.out.println( as[0] );//打印结果：100
  

  [课堂案例]

  public static void main(String[]args){
      int a = 10;
      changeVar( a );
      System.out.println( a );
      
      int[] as = new int[10];
    changeArray( as );
      System.out.println( as[0] );
  }
  public static void changeVar( int a ){
      a = 20;
  }
  public static void changeArray( int[] as ){
      as = new int[5];
      as[0] = 10;
  }
  

数组寻址策略

数组引用中存储的是数组首元素的首地址，由于数组空间连续且类型统一，可以很方便的通过下标找到每个元素所处的位置

(三) 数组的不可变型与扩容

• 数组的内存空间为连续内存一旦确定将不可改变，因为后续内存空间可能被其他程序使用

• 数组的扩容：在元素不变的情况下增加数组容量

• 扩容思路：

  1. 创建一个比原来数组更大的新数组
  2. 将原数组中的元素拷贝到新数组中
  3. 替换原数组引用，让引用指向新数组
  

• 扩容方式：

  1. 基础编码实现

  int[] a = {20,10,40};
      
  //1、准备一个更大的数组
  int[] b = new int[a.length*2];
      
  //2、将a数组中的内容复制到b数组中
  for(int i=0; i<a.length; i++){
    b[i] = a[i];
  }
  //3、替换a数组引用
  a = b;
  

  2.利用System.arraycopy扩容

  ​ 作用：复制数组元素

  ​ 使用方法:

  System.arraycopy( 原数组引用 , 拷贝起始下标, 新数组的引用, 粘贴起始下标, 拷贝长度 );
  

  int[] a = {20,10,40};  
  int[] b = new int[a.length*2];
      
  //使用System.arraycopy拷贝数组
  //从 a 数组下标为 0 的位置开始拷贝，从 b 数组下标为 0 的位置开始粘贴
  //按此规则向后拷贝 a.length 个元素
  System.arraycopy(a,0,b,0,a.length);
  
  //替换a数组引用    
  a = b;
  

  3. 利用Arrays.copyOf扩容

     作用：将a数组扩容到指定长度并返回新数组

     使用方法：数据类型[] 新数组名 = java.util.Arrays.copyOf(原数组引用，新数组长度);

     该方法会自动帮你创建新数组，复制原数据，最终将整理号的新数组作为返回值返回给调用者，注意接受返回值。
     int[] a = {20,10,40};
     a = java.util.Arrays.copyOf(a,a.length*2);