Java基础（四）数组的创建和使用

àì夳堔傛蜴生んèń 2022-07-12 02:18 200阅读 0赞

# Java基础（四） 数组的创建和使用 #

*  数组的创建：基本数据类型数组/类类型数组
 *  访问数组的元素和长度
 *  创建一个数组的数组

数组是一组数据的集合，数组内的每个数据叫做元素，数组也是Java对象。数组中的元素可以是任意的数据类型（基本数据类型和引用数据类型），但是同一个数组内只能存放一种数据类型的数据。创建数组的流程大致包括入下几个步骤：

*  基本步骤：声明数组变量 -> 创建数组实例 -> 初始化数组
 *  声明一个数组的引用变量，简称为数组变量；
 *  用new语句构造数组实例，new语句为数组在JVM内存内分配空间，并且为数组内的每个元素设置默认值；
 *  初始化，为数组内的每个元素设置合适的初始值。
 *  之前接触的main方法内的参数，就是一个数组类型的形参数

public static void main(String[] args){}

## 1.数组的声明 ##

数组的声明：

*  数组内只能同时存放一种数据类型的数组；
    
    a.可以是基本数据类型，也可以是引用数据类型；  
    b.数组内的那个数据都是元素。
 *  数组是一个对象，成员是数组内的成员元素和数组的长度等数组的属性；
 *  声明数组变量，并不是创建了一个数组对象，而是创建了一个指针一样的数据引用。使用new创建数组实例，分配内存空间，才是创建了一个数组对象；
 *  声明数组的形式：  
    `int arrary[]＝new int［］或者 int []array 基本数据类型数组，数组内存放的是基本的数据类型`  
    `String arrary[]＝new String［］或者 String []array 类类型数组，数组内存放的是String类类型的对象`
 *  注意：数组声明的时候，不能够设置长度。所以`int x[1]; 和 int[2] x;`都是非法的。
 *  为什么初始化声明这样设置？因为，前面声明的变量并不是数组实例，而是实例的一个引用地址。关于数组的长度及其元素的个数是由后方的数组实例决定的。

## 2.初始化 ##

初始化：创建变量后，首次对变量进行赋值的过程。

### 2.1 创建数组对象 ###

数组对象和其他的Java对象一样，都是使用new语句进行创建；  
`int []isArray＝new int[2];`

`new int[2]`语句执行的过程主要包括3个步骤：

1.在堆区为数组分配内存空间，`new int[2]`表示在堆区创建一个包含2个元素的数组；  
2.为数组内的每个元素赋予其数据类型的默认值，具体默认值如下：

*  整数类型byte/short/int/long 0
 *  浮点数类型float 0.0f
 *  浮点数类型double 0.0d
 *  字符串类型String null
 *  char类型 ‘\\u0000’(unicode编码)
 *  boolean布尔类型 true

3.返回数组对象的引用

#### 2.1.1 示例1 ####

使用new语句创建数组对象的时候，需要指定数组的长度，即数组内元素的个数。这个数字可以是常数，也可以是变量值表示的数字。  
例如：

int isArray[]=new int[2];
    //也可以是变量
    int size＝2；
    int isArray[]=new int[size];

#### 2.1.2 示例2 ####

数组的长度可以为0，也就是数组内部一个元素都没有。例如：  
`int []isArray=new int [0]`

对于Java类的程序入口方法main(String args\[\]),如果运行时这个类没有输入参数，那么main()方法的参数args并不是null, 而是一个长度为0的数组。例如：

public class Sample {
         public static void main(String[] args) {
           System.out.println(args.length);           //打印0
          }
        }

数组创建后，数组的长度是固定的，无法改变。但是数组可以改变所引用的数组对象。例如：

int []x=new int[3];
    int []y=x;
    y=new int[4];

### 2.2 初始化数组对象 ###

数组内的每个元素都有一个索引，即下标。数组内部的第一个元素下标为0，第二个下标为1，一次类推。通过索引可以访问数组内的指定元素，或者更改元素的值。

*  声明、创建、初始化分开

//声明
    int []isArray=new int[2];
    //初始化
    isArray[0]=0;
    isArray[1]=2;

*  声明、创建的同时初始化数组

//声明+初始化
    int []isArray={
       1,2,3};
    int []isArray=new int[] {
       1,2,3};
    Student isArray[]=new Student {
       new Student(a,b,c),new Student()};
    Student isArray[]={
       new Student(a,b,c),new Student()};

注意下方类型是非法的：

int []x=new int[5]{
       1,2,3,4,5}; //编译出错，创建数组对象的同时并初始化的时候就不能指定数组长度了；
    
    int[] x;
    x = {
       5,4,3,2,1};  //{5,4,3,2,1}必须在声明数组变量的语句中使用，不能单独使用

### 2.3 多维数组 ###

Java 支持多维数组，我们经常使用的二维数组，就是其中之一。例如：

假定某个宾馆有三层楼，第一层有4个房间，第二层有3个房间，第三层有5个房间。某一天客户人住宿情况如
    下图所示:
    
    第三层:           |    |Tom |Jerry|    |Rose|
    第二层：          |Mary|    |Kevin|
    第一层：          |Mike|Jane|Duke |    |
    
    可以用两维数组来存储各个房间的客人信息。
    
    String [][]roomArray＝{
                                {
       "Mike","Jane","Duke",null},
                                {
       "Marry",null,"Kevin"},
                                {
       null,"Tom","Jerry",null,"Rose} } 也可以这样赋值 String [][]roomArray＝new String[3][]; roomArray[0]=new String[]{"Mike","Jane","Duke",null}; roomArray[1]=new String[]{"Marry",null,"Kevin"}; roomArray[2]=new String[]{null,"Tom","Jerry",null,"Rose};

多维数组的本质还是数组，也就是数组的数组，数组的元素内容还是数组。  
多维数组仍需要补充!!!

### 2.4 数组的边界 ###

*  一个数组的下标从0开始，数组通过数组对象的下标对于数组进行访问。
    
    数组第一个元素的下标为0，第二个元素的下标为1，依次类推。如果一个数组长度为5，那么其元素下标为0-4。如果通过下标5进行访问，超过了数组的边界，在运行时会抛出`ArrayIndexOutOfBoundsException`异常。
 *  通过调用数组的length方法，可以获得一个数组的元素个数（数组的长度）。若一个数组有2个元素，其中的length值应当为2，而其下标访问的范围应当为0-1。  
    所有Java数组都有一个length属性，表示数组的长度. 该属性只能读取，但是不能修改。猜测源码内部应当是设定其为private变量，在数组对象初始化的时候进行单次的赋值。
 *  以下修改数组的length属性，这是非法的。

int[] x = new int[4];
              x.length = 10;            //编译出错，length属性不能被修改。

*  注意事项：

注：a. 数组变量必须在指向一个数组对象之后，才能访问其元素。
    
    public class Sample {
       private int[] x;
       public static void main(String[] args) {
           Sample s = new Sample();
           System.out.println(s.x);         //打印null
           System.out.println(s.x[0]);      //运行时抛出NullPointerException
           System.out.println(s.x.length);  //运行时抛出NullPointerException
        }
     }
    
        b. 当数组的元素为引用类型时，数组中存放的是对象的引用，而不是对象本身；

### 2.5 数组的拷贝 ###

数组的长度一旦确定，我们可以通过复制数组的内容来改变数组的长度。在System类中提供一个辅助的arraycopy方法提供复制数组内容的功能。

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
    参数1: 需要被复制的数组
    参数2: 需要从哪个位置进行复制
    参数3: 需要把数据复制到的 那个数组
    参数4: 被复制到的那个数组 从哪个位置进行写入
    参数5: 需要复制的数组内容的长度

## 3.数组练习 ##

课堂练习：1) 求一组值的平均值：  
    
                     public class ArrayAvgTest {
                          public double avg(int[] n) {
                               double result = 0.0;
                               for(int i=0;i<n.length;i++) {
                                      result += n[i];
                               }
                               result /= n.length;
    
                               return result;
                          }
    
                          public static void main(String[] args) {
                               ArrayAvgTest a = new ArrayAvgTest();
                               int[] a = {
       100,60,80,90,75,38};
                               System.out.println("Avg score: " + a.avg(a));
                          }
                     }          
    
                 2)  求一组值的最大值：  
    
                     public class ArrayMaxTest {
                          public int max(int[] n) {
                               int result = n[0];
                               for(int i=1;i<n.length;i++) {
                                      if(result<n[i])
                                            result = n[i];
                               }
    
                               return result;
                          }
    
                          public static void main(String[] args) {
                               ArrayMaxTest a = new ArrayMaxTest();
                               int[] n = {
       100,60,80,90,75,38};
                               System.out.println("Max score: " + a.max(n));
                          }
                     } 
    
                  3) 数组内容排序
    
                     冒泡排序：值较小的数逐渐向数组的顶部(即朝第一个元素)冒上来，就像水中的气泡上升一样，同时，值较大的数据逐渐
                               向数组的底部(即朝最后一个元素)沉下去。这种算法用嵌套的循环对整个数组进行数次遍历，每次遍历都要比
                               较数组中相邻的一对元素，如果这对元素以升序(或者值相等)的顺序排列，那么保持它们的位置不变；如果这
                               对元素以降序的顺序排列，那么交换它们的值。
    
                     数组原内容：100,60,80,90,75,38
    
             第一次循环： 60  80  90  75  38  100 
             第二次循环： 60  80  75  38  90  100 
             第三次循环： 60  75  38  80  90  100 
             第四次循环： 60  38  75  80  90  100 
             第五次循环： 38  60  75  80  90  100
    
            public class ArraySortTest {
    
                public void sort(int[] n) {
                    for(int i=0;i<n.length-1;i++) {
                        for(int j=0;j<n.length-i-1;j++) {
                            if(n[j]>n[j+1]) {
                                int temp = n[j];
                                n[j] = n[j+1];
                                n[j+1] = temp;
                            }
                        }
                        print(n);
                    }
                }
    
                public void print(int[] n) {
                    for(int i=0;i<n.length;i++)
                        System.out.print(n[i] + "\t");
                    System.out.println();
                }
    
                public static void main(String[] args) {
                    ArraySortTest s = new ArraySortTest();
                    int[] n = {
       100,60,80,90,75,38};
                    s.sort(n);
                    s.print(n);
                }
            }                 
    
                  4) java.util.Arrays辅助类的使用。sort(int[] n)以及binarySearch(int[] n,int key)
                     方法的使用。
    
                     注意： a. 这二个方法均为static方法，可直接通过类名使用；
                           b. binarySearch方法必须保证数组中的元素已经按照升序排列，这样才能得到正确的结果；
    
            import java.util.Arrays;
    
            public class ArraySortTest2 {
    
                public void print(int[] n) {
                    for(int i=0;i<n.length;i++)
                        System.out.print(n[i] + "\t");
    
                    System.out.println();
                }
    
                public static void main(String[] args) {
                    ArraySortTest2 s = new ArraySortTest2();
                    int[] n = {
       100,60,80,90,75,38};
                    Arrays.sort(n);
                    System.out.println(Arrays.binarySearch(n, 80));
                    s.print(n);
                    System.out.println(Arrays.binarySearch(n, 80));     
                }
            }
    
    
                  5)从众多手机号码中抽取一个获奖手机号码
    
            public class ArrayRandomTest {
                public String getTel(String[] n) {
                    int index = (int)(Math.random()*n.length);
                    return n[index];
                }
    
                public static void main(String[] args) {
                    ArrayRandomTest a = new ArrayRandomTest();
                    String[] n = { "1318259016", "13564560540","13858687810","13999999999"};
                    System.out.println(a.getTel(n));
                }
            }
    
                  6)产生四位长度的验证码, 验证码内容为大小写字母或数字组成；
    
            public class ArrayValidateCodeTest {
    
                private char[] c;
    
                public ArrayValidateCodeTest() {
                    String s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
                    c = s.toCharArray();
                }
    
                public String getValidateCode() {
                    int i1 = (int)(Math.random()*c.length);
                    int i2 = (int)(Math.random()*c.length);
                    int i3 = (int)(Math.random()*c.length);
                    int i4 = (int)(Math.random()*c.length);
    
                    return ""+c[i1]+c[i2]+c[i3]+c[i4];
                }
    
                public static void main(String[] args) {
                    ArrayValidateCodeTest a = new ArrayValidateCodeTest();
                    System.out.println(a.getValidateCode());
                }
            }

## 4.其他内容 ##

### 4.1 可变参数 ###

所谓可变参数，就是参数的个数不确定，但是参数的类型还是固定的。

没有可变参数之前，我们通常这样写：

public void test(int[] a){
    
        }
        main:
            int[] i = {
       1,2,3,4};
            a.test(i);

有了可变参数，我们可以这样写：

public void function2(int ... a)
    调用：function(1,2);function(1,2,3,4)
    
    可变参数写法
    public void test2(int... a){}
    main函数调用:
            int[] i = {
       1,2,3,4};
            test2(i);
            test2();
            test2(1,2,3,4);
            test2(1,2,3,4,5,6,7);

可变参数前面可以加其他参数

public static void test3(String msg,int... a){}
        main:
            int[] i = {
       1,2,3,4};
            String msg = "helo";
            test3(msg,i);
            test3(msg);
            test3(msg,1,2,3,4);
            test3(msg,1,2,3,4,5,6,7);

但是可变参数不能其他变量前面，也就是可变参数后方不能再加参数。当然，也不能同时有两个可变参数了。例如：

可变参数后面不能加任何参数 这样是编译不通过的
    public static void test4(int... a,String msg){}

### 4.2 格式化输出 ###

在JDK1.5及其以上，Java给出了和C类似的`printf()`函数，用来处理Java的格式化输出。

*  %f,输出浮点数；
 *  %9.2f,输出浮点数 总长度为9位，浮点数字位2位；
 *  %+9.2f,＋表示带正负号输出；
 *  %-9.2f，－表示左对齐，默认是右对齐；
 *  %d,表示输出十进制数字；
 *  %o,表示输出八进制数字；
 *  %x,表示输出十六进制数字；
 *  %\#x,表示输出带ox的十六进制数字；
 *  %s,表示输出字符串。

例如：

System.out.printf是JDK1.5之后加入的新的方法，可以给我们格式化输出内容
    
        常见用法例子:
            // 定义一些变量，用来格式化输出。  
            double d = 345.678; 
            String s = "你好！"; 
            int i = 1234; 
            // "%"表示进行格式化输出，"%"之后的内容为格式的定义。 
            // "f"表示格式化输出浮点数。 
            System.out.printf("%f", d); //345.678000
            System.out.println(); 
            // "9.2"中的9表示输出的长度，2表示小数点后的位数。 注意输出数字前面的空格 
            System.out.printf("%9.2f", d);// 345.68
            System.out.println(); 
            // "+"表示输出的数带正负号。  
            System.out.printf("%+9.2f", d);// +345.68
            System.out.println(); 
            // "-"表示输出的数左对齐（默认为右对齐）。  
            System.out.printf("%-9.4f", d);//345.6780
            System.out.println(); 
            // "+-"表示输出的数带正负号且左对齐。  
            System.out.printf("%+-9.3f", d);//+345.678
            System.out.println(); 
            // "d"表示输出十进制整数。
            System.out.printf("%d", i);//1234
            System.out.println(); 
            // "o"表示输出八进制整数。 
            System.out.printf("%o", i);//2322
            System.out.println(); 
            // "x"表示输出十六进制整数。  
            System.out.printf("%x", i);//4d2
            System.out.println(); 
            // "#x"表示输出带有十六进制标志的整数。  
            System.out.printf("%#x", i);//0x4d2
            System.out.println(); 
            // "s"表示输出字符串。
            System.out.printf("%s", s);//你好！ 
            System.out.println(); 
            System.out.printf("输出一个浮点数：%f，一个整数：%d，一个字符串：%s", d, i, s);
        //输出一个浮点数：345.678000，一个整数：1234，一个字符串：你好！