Java数组

一、定义：数组是相同类型的数据按顺序组成的一种引用数据类型

二、数据类型包括：

1. 基本数据类型

2. 引用数据类型

   • 类
   • 接口
   • 数组

三、学习内容

1. 一维数组

   （1）声明

   • 语法格式：

     • 数据类型[] 数组名; eg: int[] myIntArray;

     • 数据类型 数组名[]; eg: int myIntArray[];

     • 例子

       • char[] ch;
       • String[] strArray;

   • 对比变量声明的语法格式：

     • 数据类型 变量名;

   （2）创建

   • 语法格式一：先声明后创建

     • 数据类型[] 数组名;

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

     • eg: int[] arr;

       arr = new int[10];//创建一个长度为10的整型数组。

   • 语法格式二：声明的同时创建数组

     • 数据类型[] 数组名 = new 数据类型[数组长度];
     • eg: int[] arr = new int[10];
   • 注意：数组长度必须指定。

   ---

   • 数组在内存中的存储
     • 数组会被分配连续的内存空间

   （3）初始化

   • 定义：声明数组的同时给数组赋值，叫做数组的初始化。eg: int[] arr = {1,2,3,4,5,6,7,8,9,10};

   （4）元素的引用

   • 语法格式：数组名[下标];
     • 注意：下标从0开始。
     • eg: int[] arr = {1,2,3,4,5,6,7,8,9,10}; 该数组中数组元素1对应 arr[0], 2对应 arr[1]，以此类推。

   （5）长度

   • 定义：初始化时所给数组元素的个数。如 int[] arr = {1,2,3,4,5,6,7,8,9,10}; 该数组的长度是10 .
   • 属性 length 表示数组的长度，如 arr.length

   （6）数组的应用

   public class ArrayDemo {
       public static void main(String[] args) {
           //声明一个整型数组
           int[] intArray;
           //声明一个字符串类型的数组
           String strArray[];
           //创建数组
           intArray = new int[5];
           strArray = new String[10];
           //声明数组的同时进行创建
           float[] floatArray = new float[4];
           //初始化数组
           char[] ch = {'a','b','c','d'};
           System.out.println("ch数组的长度为："+ch.length);
           System.out.println("intArray数组的第2个元素为："+intArray[1]);
           System.out.println("strArray数组的第5个元素为："+strArray[4]);
           System.out.println("floatArray数组的最后一个元素为："+floatArray[floatArray.length-1]);
           //循环为整型数组赋值
           for (int i = 0; i < 5; i++) {
               intArray[i] = i+1;
           }
           System.out.println("整型数组 intArray 的元素为：");
           //循环输出整型数组中的元素
           for (int i = 0; i < 5; i++) {
               System.out.print(intArray[i] + "  ");
           }
       }
   }
   

   运行结果如下：

   ch数组的长度为：4

   intArray数组的第2个元素为：0

   strArray数组的第5个元素为：null

   floatArray数组的最后一个元素为：0.0

   整型数组 intArray 的元素为： 1 2 3 4 5

   Ps:

   • 对象数组创建后元素默认值是 null；
   • 整型数组创建后的元素默认值是0；
   • 浮点型数组创建后的元素默认值是0.0 。

   ---

   例1: 求整型数组的累加和

   import java.util.Scanner;
   
   public class ArrayDemo1 {
       public static void main(String[] args) {
           //求整型数组的累加和
           //定义整型数组
           int[] a = new int[5];
           Scanner scanner = new Scanner(System.in);
           //从键盘接收数据，为数组元素赋值
           for (int i = 0; i < a.length; i++) {
               System.out.println("请输入第"+(i+1)+"个元素:");
               a[i] = scanner.nextInt();
           }
           System.out.println("数组元素的内容为：");
           for (int i = 0; i < a.length; i++) {
               System.out.print(a[i]+"  ");
           }
           //求数组元素的累加和
           int sum = 0 ;
           for (int i = 0; i < a.length; i++) {
               sum = sum + a[i];
           }
           System.out.println();
           System.out.println("数组元素的累加和为："+sum);
       }
   }
   

   运行结果如下：

   请输入第1个元素: 1

   请输入第2个元素: 2

   请输入第3个元素: 3

   请输入第4个元素: 4

   请输入第5个元素: 5

   数组元素的内容为： 1 2 3 4 5

   数组元素的累加和为：15

   例2: 求数组元素的最大值

   public class ArrayDemo2 {
       public static void main(String[] args) {
           //求数组元素的最大值
           int[] a = {34,23,78,99,31};
           int max = a[0];
           for (int i = 1; i < a.length; i++) {
               if (a[i] > max) {
                   max = a[i];
               }
           }
           System.out.println("数组的最大值是"+max);
       }
   }
   

   运行结果如下：

   数组的最大值是99

   ---

   增强型for循环

   • 又叫 foreach 循环
   • 应用：

   int[] a = {34,23,78,99,31};
   for (int i: a) {
      System.out.println(i);
   }
   

   运行结果为：

   34

   23

   78

   99

   31

   ---

   案例:

   • 如何对变量a,b 的值进行交换？

   int a = 3,b = 5;
   int temp;
   temp = a;
   a = b;
   b = temp;
   

   • 冒泡排序
     • 对一组整数按照由小到大的顺序进行排序。
     • 一组整数，如：{34,53,12,32,56,17}

   public class ArraySortDemo {
           public static void main(String[] args) {
               int[] arr = {34,53,12,32,56,17};
             
               //外层循环控制排序的次数
               for (int i = 0; i < arr.length - 1; i++) {
                   //内层循环找到每趟排序的最大值
                   for(int j = 0;j< arr.length - i - 1;j++) {
                       if (arr[j] > arr[j+1]) {
                           int temp = arr[j];
                           arr[j] = arr[j+1];
                           arr[j+1] = temp;
                       }
                   }
               }
               for (int n: arr) {
                   System.out.print(n + "   ");
               }
           }
       }
   

   运行结果如下：

   12 17 32 34 53 56

   小结：

   • 数组是引用数据类型；
   • 创建数组时，会开辟连续的内存空间；
   • 数组长度使用 length 属性获取；
   • 数组元素的下标从0开始。
   • 注意数组下标越界问题（错误信息如下：Exception in thread "方法名" java.lang.ArrayIndexOutOfBoundsException: 越界值 at 包名.类名.方法名（文件名：行号），此处 文件名: 行号 可点击，点击后可直接跳转到代码异常的地方）