数组

couyisi4740

于 2010-01-29 16:36:01 发布

阅读量103

点赞数

Java编程那些事儿44—数组基础语法

6.2 数组基本语法
         了解了数组的概念以后，下面来看一下数组的语法格式。数组的语法格式主要有四种：数组声明、数组初始化、引用数组元素和获得数组长度。
6.2.1 数组声明
         和变量类似，数组在使用以前也必须声明，数组的声明语法格式为：
              数据类型数组名称[]
     或：
              数据类型[] 数组名称
         例如：
                   int m[];
                   char c[];
                   double d[];
         这里的数据类型可以是Java语言的任意数据类型，也就是说既可以是基本数据类型也可以是复合数据类型。在声明数组时使用一对中括号，该对中括号既可以放在数据类型的后面，也可以放在数组名称的后面。数组名称是一个标识符，可以根据需要设置其名称，在程序中使用该名称代表该数组。
         这两种声明的语法格式在实际使用时完全等价，可以根据习惯进行使用。
         数组声明以后在内存中不占用空间，没有地址，由于数组是复合数据类型，所以声明完成以后其默认值是null。
         数组声明以后不能直接使用，必须对其初始化以后才可以进行使用。
6.2.2 数组初始化
         数组初始化就是对数组进行赋值。数组的初始化语法分为两种：静态初始化和动态初始化。静态初始化适用于已知数组所有元素的值，一次初始化所有元素，动态初始化只申请空间，每个元素的值是数组声明时数据类型对应的初始值。
6.2.2.1 静态初始化
         静态初始化，也称数组的整体赋值，是一次为数组中所有元素依次进行赋值的语法，通过可以语法可以指定数组中每个元素的值，同时也指定了数组的长度。
         语法格式为：
                   数据类型[] 数组名称 = {值1,值2,……,值n};
         例如：
                   int[] m = {1,2,3,4};
                   char c[] = {‘a’,’f’,’d’};
         静态初始化必须和数组的声明位于同一行，换句话说，只能在声明数组的同时进行静态初始化。数组中的所有元素书写一对大括号的内部，系统按照值的书写顺序依次为数组运算进行赋值，例如数组m，则将1赋值给m数组的第一个元素，2赋值给m数组的第二个元素，依次类推，数组的总长度等于静态初始化时数值的个数。在实际书写时，需要注意，值的类型必须和数组声明时的类型匹配，或者可以自动进行转换。
         在实际程序中，静态初始化一般书写一组已知的无规律数值，这样书写起来比较简单，格式比较统一。
6.2.2.2 动态初始化
         动态初始化，也就是只为数组指定长度，并且在内存中申请空间。动态初始化可以不必和数组的声明放在一起，也可以重新初始化一个初始化的数组。
         动态初始化的语法格式：
                   数据类型[] 数组名称 = new 数据类型[长度];
         例如：
                   int[] m = new int[10];
                   char[] c;
                   n = new char[3];
         动态初始化使用new关键字进行初始化，new关键字后续的数据类型要求和数组声明时的数据类型一样，中括号内部是需要初始化的数组长度，该长度值可以是数字也可以是整型变量，如果是整型变量则不能为long型。在实际使用时，也可以先声明再进行动态初始化。
         动态初始化指定了数组的长度，在内存中申请了对应长度的空间，而每个元素的值取数组数据类型对应的默认值。默认值的规定如下：
a、 boolean类型的默认值是false。
b、其它7种基本数据类型是0。说明：char的默认值是编码为0的字符，而不是字符0。
c、复合数据类型的初始值是null。
动态初始化只专注于为数组申请对应长度的空间，具体存储的元素的值可以根据需要依次进行指定。
6.2.3 引用数组元素
         数组是一组数的集合，在实际使用时还需要引用数组中的每个元素。则引用数组中元素的语法格式为：
                   数组名称[下标]
         其中下标指数组中每个元素的索引值，Java语法规定数组中的第一个元素索引值是0，第二个是1，依次类推。在程序书写时，下标位置既可以书写常数也可以书写变量。而整个引用元素的表达式可以看作是一个变量，该变量的类型和数组的类型一致。
         示例代码如下：
                   int[] m = {3,2,4,6};
                   m[1] = 4;
                   m[2] = m[3] + m[0];
         在代码中，可以使用变量作为下标，示例代码如下：
                   char[] ch = new char[10];
                   int i = 2;
                   ch[i] = ‘a’;
         使用变量作为数组的下标，极大的增强了数组元素使用的灵活性，也是灵活使用数组必须深刻理解的内容。
         因为数组的下标都从0开始，所以有效的数组下标区间是0到数组的长度减1，其它的下标都是非法的。在代码中出现非法的下标不会出现语法错误，但是会导致运行时出现异常。
6.2.4 获得数组长度
         为了方便的操作数组，Java语法中提供了获得数组长度的语法格式。对于一个已经初始化完成的数组，获得该数组长度的语法格式为：
                   数组名称.length
         示例代码如下：
                   int[] n = {1,2,3,4,6};
                   int len = n.length;
         则在该代码中n.length代表数组n的长度，由数组的初始化可以看出数组n的长度是5，则变量len的值将是5。使用该语法，可以只需要知道数组的名称就可以获得数组的长度，便于灵活操作数组。
         综合前面下标的语法和长度的语法，则输出数组n中所有元素的代码为：
                   for(int i = 0;i < len;i++){
                            System.out.println(n[i]);
                   }
         这种使用数组的方式称作数组的遍历，遍历数组是使用数组的基础，也是很多和数组相关逻辑实现的基础。
         关于数组的语法就介绍这么，下面通过一些示例来演示数组的实际使用。

6.3 数组使用示例
         本部分通过一系列的示例，熟悉数组的基本语法，并演示一些使用数组可以解决的基本问题。在实际使用数组时，数组的长度以及数组中每个元素存储的数据，都根据逻辑需要进行设计。
6.3.1 循环初始化数组元素
         要求：初始化一个长度为100的int数组，数组中的元素依次为1-100。
         这是一个基本的使用，主要是熟悉数组的语法，在实际编写时，需要发现数组下标和数组元素值之间的规律即可。
         第一种思路：循环数组的下标0-99，则和下标对应的元素的值比数组下标多1。
         则实现代码如下：
                   int[] m = new int[100];
                   for(int i = 0;i < m.length;i++){
                            m[i] = i + 1;
                   }
         代码说明：声明并初始化一个长度是100的数组，使用循环循环数组的下标，下标的区间是 [0,m.length-1]，其中m.length表示数组的长度。在实际赋值时，把数组的下标做成变量，则当i的值为0时，则m[i]就是m[0]，依次类推，按照题目的要求，则数值的规律是i+1，这样循环结束以后，数组m中的值就依次是1-100了。
         第二种思路：循环数组的值1-100，则下标比数组的值下1。
         则实现的代码如下：
                   int[] m = new int[100];
                   for(int i = 1;i <= 100;i++){
                            m[i – 1] = i;
                   }
         该代码中循环变量i的值从1循环到100，则数组的下标是i – 1，这样也可以实现题目要求的功能。
6.3.2输出数列
         要求：输出1 1 2 3 5 8 13……这样的数列，输出该数列的前20个数字。
         该题是一个基本的数字逻辑，在实际解决该问题时，首先要发现该数字的规律，然后按照该规律来设计数组即可。
         实现思路：数字的规律是除了数列里的前两个数字以外，其它的数字都满足该数字等于前两个数字的和，由于题目要求输出前20个数字，所以需要一个长度为20的数组，第一个和第二个数字直接赋值，后续的数字通过前两个数字元素得到。
         则实现的代码如下：
                   int[] num = new int[20];
                   num[0] = 1;
                   num[1] = 1;
                   //循环初始化
for(int i = 2;i < num.length;i++){
                            num[i] = num[i – 1] + num[i – 2];
                   }
                   //循环输出
for(int i = 0;i < num.length;i++){
                            System.out.print(num[i]);
                            System.out.print(‘ ‘);
                   }
                   System.out.println(); //换行
         在该代码中，初始化一个长度为20的数组，首先将数组中的前两个元素赋值成1，然后循环对后续的元素的赋值，如果当前元素的下标是i，则它前一个元素的下标是i-1，再前面一个元素的下标是i-2，只需要将这2个元素的值相加，然后赋值给当前元素即可。后面使用一个循环，输出数组中所有的元素，元素和元素之间有一个间隔的空格，在输出所有的元素以后换行。
6.3.3 歌手打分
         要求：在歌唱比赛中，共有10位评委进行打分，在计算歌手得分时，去掉一个最高分，去掉一个最低分，然后剩余的8位评委的分数进行平均，就是该选手的最终得分。如果已知每个评委的评分，求该选手的得分。
         该题实际上涉及到求数组的最大值、最小值，以及求数组中所有元素的和，也是数组方便统计的用途体现。
         实现思路：求出数组元素的最大值、最小值以及和，然后使用和减去最大值和最小值，然后除以8获得得分。
         则实现的代码如下：
                   int[] score = {90,78,90,96,67,86,78,92,79,85}; //评委打分
                   int sum = 0;        //存储和
                   int max =score[0]; //存储最大值
                   int min = score[0]; //存储最小值
                   //求和
                   for(int i = 0;i < score.length;i++){
                            sum += score[i];
                   }
                   //获得最大值
                   for(int i = 1;i < score.length;i++){
                            //比较
                            if(max < score[i]){                                      max = score[i];
                            }
                   }
                   //获得最小值
                   for(int i = 1;i < score.length;i++){
                            //比较
                            if(min > score[i]){                                      min = score[i];
                            }
                   }
                   //计算平均分
                   double avg = (sum – max – min)/8.0;
                   System.out.println(avg);
         在该代码中，实现数组求和的思路和以前的一样，就是每次加一个元素，然后用得到的结果再和后续的元素依次相加。求最大值的思路是首先假设第一个元素最大，把score[0]赋值给max，然后使用max的值和后续依次比较，如果后续的元素比max 大，则把该值赋值给max，然后再和后续的元素比较，求最小值的思路和最大值的思路一样。然后计算平均分就完成了题目的要求。
         该代码虽然结构比较清晰，但是效率不高，为了追求效率，可以把以上三个循环合并起来，代码如下：
                   for(int i = 0;i < score.length;i++){
                            sum += score[i]; //求和
                            //获得最大值
                            if(max < score[i]){                                      max = score[i];
                            }
                            //获得最小值
                            if(min > score[i]){                                      min = score[i];
                            }
                   }
         这样虽然在结构上稍微复杂了一些，但是效率得到了改善。在实际编写程序时，一般会在功能书写完成以后，对代码进行优化，提高程序的执行效率。