Java语言程序设计(基础篇) 第七章 一维数组

第七章 一维数组

7.2 数组的基础知识

　　1.一旦数组被创建，它的大小是固定的。使用一个数组引用变量，通过下标来访问数组中的元素。

　　2.数组是用来存储数据的集合，但是，通常我们会发现把数组看作一个存储具有相同类型的变量集合会更有用。

7.2.1 声明数组变量

　　1.为了在程序中使用数组，必须声明一个引用数组的变量，并指明数组的元素类型

　　　　语法：elementType[] arrayRefVar;(数据类型[] 数组引用变量)

　　2.elementType可以是任意数据类型，但是数组中所有的元素都必须具有相同的数据类型。

7.2.2 创建数组

　　1.不同于基本数据类型变量的声明，声明一个数组变量时并不在内存中给数组分配任何空间。它只是创建一个对数组的引用的存储位置。如果变量不包含对数组的引用，那么这个变量的值为null。除非数组已经被创建，否则不能给它分配任何元素。

　　　　例子：double[] myList=new double[10];

　　2.一个数组变量看起来似乎是存储了一个数组，但实际上它存储的是指向数组的引用。严格来讲，一个数组变量和一个数组是不同的，但多数情况下它们的差别是可以忽略的。

7.2.3 数组大小和默认值

　　当数组分配空间时，必须指定该数组能够存储的元素个数，从而确定数组大小。创建数组之后就不能在修改它的大小。

7.2.4 访问数组元素

　　1.数组元素可以通过下标访问。数组下标是基于0的，也就是说，其范围从0开始到arrayRefVar.length-1结束。

　　2.数组中的每个元素都可以使用下面的语法表示，称为下标变量(indexed variable)

7.2.5 数组初始化语法

　　1.Java有一个简捷的标记，称作数组初始化语法，它使用下面的语法将声明数组、创建数组和初始化数组结合到一个语句中：

　　elementType[] arrayRefVar={value0,value1,value2,...,valuek};

　　(元素类型[] 数组引用变量={值1,值2,...,值k};)

　　2.数组初始化语法中不使用操作符new。使用数组初始化语法时，必须声明、创建和初始化数组都放在一条语句中。将他们分开会产生语法错误。因此，下面的语句是错误的：

　　double[] myList;

　　myList={1.9,2.9,3.4,3.5};

7.2.6 处理数组

　　处理数组元素时，经常会用到for循环，理由有以下两点：

• 数组中所有元素都是同一类型的。可以使用循环以同样的方式反复处理这些元素。
• 由于数组的大小是已知的，所以很自然地就使用for循环。

7.3 编写一个程序，找到大于所有平均值的那些项

　　

 package com.chapter7;
 
 import java.util.Scanner;
 
 public class AnalyzeNumber {
 
     /**
      * 找到大于所有项大于平均值的那些项
      */
 
     public static void main(String[] args) {
 
         Scanner input=new Scanner(System.in);
 
         System.out.println("请输入要存储的个数");
         int n=input.nextInt();
 
         double[] numbers=new double[n];
         double sum=0;
 
         System.out.println("请输入您想存储的数字");
         for(int i=0;i<numbers.length;i++){
             numbers[i]=input.nextDouble();
             sum+=numbers[i];
         }
 
         double avg=sum/n;
         System.out.println("平均值为："+avg);
 
         for (int i = 0; i < n; i++) {
             if(numbers[i]>avg){
                 System.out.println(numbers[i]);
             }
         }
 
     }
 
 }

　　7.5 数组的复制

　　1.在Java中，可以使用复制语句复制基本数据类型的变量，但不能复制数组。将一个数组变量赋值给另一个数组变量，实际上是将一个数组的引用复制给另一个变量，使两个变量都指向相同的内存地址。

　　2.复制数组的三种方法：

• 使用循环语句逐个地复制数组的元素。
• 使用System类中的静态方法arraycopy。
• 使用clone方法复制数组。

  • • •  　　　　 int[] sourceArray={2,3,1,5,10};
                 int[] targetArray=new int[sourceArray.length];
                 for(int i=0;i<sourceArray.length;i++){
                     targetArray[i]=sourceArray[i];
                 }
         
                 System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);
         
                 for (int i : targetArray) {
                     System.out.println(i);
                 }

　　7.6 将数组传递给方法

　  Java使用按值传递(pass-by-value)的方式将实参传递给方法。传递基本数据类型变量的值与传递数组值有很大的不同。

• 对于基本数据类型参数，传递的是实参的值。
• 对于数组类型参数，参数值是数组的引用，给方法传递的这个引用。从语义上来讲，最好的描述就是参数传递的是共享信息(pass-by-sharing)，既方法中的数组和传递的数组是一样的。所以，如果改变方法中的数组，将会看到方法外的数组也变化了。　

　　7.7 从方法中返回数组

 package com.chapter7;
 
 public class Reverse {
 
     public static void main(String[] args) {
 
         int[] list1={1,2,3,4,5};
         int[] list2=reverse(list1);
         for (int i : list2) {
             System.out.println(i);
         }
 
     }
 
     public static int[] reverse(int[] list){
 
         int[] result=new int[list.length];
 
         for(int i=0,j=list.length-1;i<list.length;i++,j--){
             result[j]=list[i];
         }
         return result;
     }
 
 }

　　7.8 示例学习：统计每个字母出现的次数

　　

package com.chapter7;
 
import java.util.Random;
 
import com.chapter6.RandomCharacter;
 
public class CounteLettersInArray {
 
    /**
     *    统计一个字符数组中每个字母出现的次数
     */
 
    public static void main(String[] args) {
 
        char[] chars=createArray();
        displayArray(chars);
        int[] counts=countLetters(chars);
        displayCounts(counts);
    }
 
    public static char[] createArray(){
 
        char[] chars=new char[100];
        for(int i=0;i<chars.length;i++){
            chars[i]=RandomCharacter.getRandomCharacter('a', 'z');
        }
        return chars;
    }
 
    public static void displayArray(char[] chars){
 
        for(int i=0;i<chars.length;i++){
            if((i+1)%20==0){
                System.out.println(chars[i]);
            }else{
                System.out.print(chars[i]+" ");
            }
        }
    }
 
    public static int[] countLetters(char[] chars){
        int[] counts=new int[26];
        for(int i=0;i<counts.length;i++){
            counts[chars[i]-'a']++;
        }
        return counts;
    }
 
    public static void displayCounts(int counts[]){
 
        for(int i=0;i<counts.length;i++){
            if((i+1)%10==0){
                System.out.println((char)(i+'a')+"出现"+counts[i]+"次");
            }else{
                System.out.print((char)(i+'a')+"出现 "+counts[i]+"次");
            }
        }
    }
 
}

7.9 可变长参数列表

　　1.具有同样类型的可变长度的参数可以传递给方法，并将作为数组对待。

　　2.可以把类型相同但个数可变的参数传递给方法，方法中的参数声明如下：

　　　　typeName...parameterName(类型名...参数名)

 package com.chapter7;
 
 public class VarArgsDemo {
 
     public static void main(String[] args) {
         printMax(34,3,3,2,56.5);
         printMax(new double[]{1,2,3});
     }
 
     public static void printMax(double...numbers){
         if(numbers.length==0){
             System.out.println("No argument passed");//没有参数传递
             return;
         }
 
         double result=numbers[0];
 
         for(int i=1;i<numbers.length;i++){
             if(numbers[i]>result){
                 result=numbers[i];
             }
         }
         System.out.println("The max value is"+result);
 
     }
 
 }

　　7.1 数组的查找

　　如果一个数组排好序了，对于寻找数组中的一个元素，二分查找法比线性查找更高效。

　　7.10.1 线性查找法

　　线性查找法将要查找的关键字key与数组中的元素逐个进行比较。这个过程持续在列表中找到与关键字匹配的元素，或者查完列表也没有找到关键字为止。如果匹配成功，线性查找法返回与关键字匹配的元素在数组中的下标。如果没有匹配成功，则返回-1。

　　

 package com.chapter7;
 
 public class LinearSearch {
 
     public static void main(String[] args) {
 
         int[] list={1,4,4,2,5,-3,6,2};
         int i=linearSearch(list, 4);
         System.out.println(i);
         int j=linearSearch(list, -4);
         System.out.println(j);
     }
 
     public static int linearSearch(int[] list,int key){
         for(int i=0;i<list.length;i++){
             if(key==list[i]){
                 return i;
             }
         }
         return -1;
     }
 }

　　7.10.2 二分查找法

　　二分查找法是另一种常见的对数值列表的查找方法。使用二分查找法的前提条件是数组中的元素必须已经排好序。假设数组已按升序排列。二分查找法首先将关键字与数组的中间元素进行比较。考虑下面三种情况：

• 如果关键字小于中间元素，只需要在数组的前一半元素中继续查找关键字。
• 如果关键字和中间元素相等，则匹配成功，查找结束。
• 如果关键字大于中间元素，只需要在数组的后一半元素中继续查找关键字。　　

　　

　　7.11 数组的排序

　　选择排序

　　

package com.chapter7;
 
public class SelectionSort {
 
    public static void main(String[] args) {
        int[] list={9,8,7,6,5,4,3,2,1};
        SelectionSort.selectionSort(list);
    }
 
    public static void selectionSort(int[] list){
        for(int i=0;i<list.length-1;i++){
            for(int j=i+1;j<list.length;j++){
                int temp=list[i];
                list[i]=list[j];
                list[j]=temp;
            }
        }
        for (int i : list) {
            System.out.println(i);
        }
    }
}

　　7.12 Arrays类（java.util.Arrays）

　　1.Arrays类包含一些实用的方法用于常见的数组操作，，比如排序和查找。

　　2.Arrays类包含各种各样的静态方法，用于实现数组的排序和查找、数组的比较和填充数组元素，以及返回数组的字符串表示。这些方法都有对所有基本类型的重载方法。

　　3.可以使用sort或parallelsort方法对整个数组或部分数组进行排序。

　　4.可以采用二分查找法(binarySearch方法)在数组中查找关键字。数组必须提前按升序排列好。如果数组中不存在关键字，方法返回 -（插入点下标+1）。

　　5.可以采用equals方法检测两个数组是否相等。如果他们的内容相同，那么这两个数组相等。

　　6.可以使用fill方法填充整个数组或部分数组。

　　7.可以是同toString方法来返回一个字符串，该字符串中代表了数组中的所有元素。这是一个显示数组中所有元素的快捷和简便的方法。