JAVA之数组

update：2022-3-10

数组

数组是一种常见的数据结构，用于存储多个数据；
数组是指一组相同类型的数据的集合，数组中的每个数据称为元素，数组本身是一种引用数据类型。

数组的特点

数组的特点：
1.数组中的元素按线性方式排列，可以通过编号来访问数组中的每个元素;
2.一旦初始化完成，数组在内存中所占的空间就固定下来，即数组的长度不可改变;
3.数组既可以存基本数据类型的数据，也可以存引用类型的数据，只要类型相同即可。

创建数组大致包括如下步骤

（1）声明一个数组类型的引用变量，简称为数组变量。
（2）用new语句构造数组的实例。new语句为数组分配内存，并且为数组中的每个元素赋予默认值。
（3）初始化，即为数组的每个元素设置合适的初始值。

数组变量的声明

int[] scores;  //scores数组存放int类型的数据
String[] names;  //names数组存放String类型的数据

以下数组变量的声明方式也是合法的：（一般用上面一种）

int scores[];
String names[];

数组的初始化

静态初始化

数组声明时初始化

arrayName = new type[] {element1, element2， ...};
type[] arrayName = {element1, element2， ...}; //声明时初始化

动态初始化

int[] scores=new int[100];  //创建一个int数组，存放100个int数据

new语句执行以下步骤。
（1）在堆区中为数组分配内存空间，以上代码创建了一个包含100个元素的int数组。每个元素都是int类型，占4个字节，因此整个数组在内存中占用400个字节。
（2）为数组中的每个元素赋予其数据类型的默认值。以上int数组中的每个元素都是int类型，因此它们的默认值都为0。
（3）返回数组的引用。

访问数组中的元素

数组中的每个元素都有一个索引，或者称为下标。arrayName[index]，index即索引，是一个从0开始的整数；数组中的第一个元素的索引为0 arrayName[0]，第二个为1 arrayName[1]，依次类推，最后一个元素是arrayName[arrayName.length-1].

访问数组的长度

所有Java数组都有一个length属性（不是方法），表示数组的长度，它的声明形式为：
public final length;

length属性被public和final修饰，因此在程序中可以读取数组的length属性，但不能修改这一属性：

遍历数组

for循环

for循环（老方法）

for(int i=0; i<array.length; i++) {
System.out.println(array[i]) ;
}

foreach循环

for (type variableName : array | collection) {
System. out . println (variableName) ;
}

foreach循环

int[] arr = {1,2,3,4,5,6};
        for(int var:arr){
            System.out.println(var);
        }

Arrays工具类

其中对数组进行操作的一些常用方法：

eg：

    int[] arr1 = {13,42,23,4,55,6};
    //打印
    System.out.println(Arrays.toString(arr1));
    //比较
    int[] arr2 = {22,44,36,67,2,9};
    System.out.println(Arrays.equals(arr1,arr2));//比较的是里面每个对应的位置值是否相等
    System.out.println(arr1 == arr2);   //比较的是内存中的位置
    //排序
    Arrays.sort(arr1);
    System.out.println(Arrays.toString(arr1));
    //复制
    int[] arr3 = Arrays.copyOf(arr1,10);
    System.out.println(Arrays.toString(arr3));

输出结果：

多维数组

如果宾馆有三层楼，并且每一层都有4个房间，那么可以按如下方式创建rooms数组：

String[][] rooms=new String[3][4];

rooms[0][0]=“Tom”；//宾馆第一层的第一个房间的客人为Tom

若是宾馆房间是以下布局呢：

可以用两维不规则数组来存储各个房间的客人信息:

String[][] rooms=new String[3][];  
rooms[0]=new String[]{"Tom","Mike","Jack",null};  //第一层楼的客人
rooms[1]=new String[]{"Mary",null,"Linda"};  //第二层楼的客人
rooms[2]=new String[]{null,"Jane",null,null,"Rose"};  //第三层楼的客人

以上代码等价于：

String[][] rooms={
                    {"Tom","Mike","Jack",null},
                    {"Mary",null,"Linda"},
                    {null,"Jane",null,null,"Rose"}
              };

以下程序打印各个房间的客人信息：

for(int i=0;i<rooms.length;i++)
  for(int j=0;j<rooms[i].length;j++){
    int roomNumber=(i+1)*100+j;  //计算房间编号
    System.out.println(roomNumber+"房间:"+rooms[i][j]);
  }

以上程序的打印结果为：
100房间:Tom
101房间:Mike
102房间:Jack
103房间:null
200房间:Mary
201房间:null
202房间:Linda

把数组座位方法参数

为数组排序：冒泡排序

为以下数组中的元素排序。
int[] array={4,7,5,3,9,0};

第1趟排序：4 5 3 7 0 9
第2趟排序：4 3 5 0 7 9
第3趟排序：3 4 0 5 7 9
第4趟排序：3 0 4 5 7 9
第5趟排序：0 3 4 5 7 9

把最大的往后面拍，需要拍5次

 public class ArraySorter{
  /** 冒泡排序 */
  public static void bubbleSort(int[] array){
    for(int i=0;i<array.length-1;i++){  //外层循环
      for(int j=0;j<array.length-i-1;j++){  //内层循环
        if(array[j]>array[j+1]){
          int temp=array[j];
          array[j]=array[j+1];
          array[j+1]=temp;
        }
      }
      print(i+1,array);
    }
  }
  public static void print(int time,int[] array){
    System.out.print("第"+time+"趟排序：");
    for(int i:array)
      System.out.print(i+"  ");
 
    System.out.println();  //换行
  }
 
  public static void main(String args[]){
    int[] array={4,7,5,3,9,0};
    bubbleSort(array);
  }

思考题

2．以下代码能否编译通过，假如能编译通过，运行时出现什么情况？
public class MyAr{
public static void main(String argv[]){
int[] i = new int[5];
System.out.println(i[5]);
}
}
[答案] 运行时抛出ArrayIndexOutOfBoundsException。

3．如何获得数组myarray的长度？
a) myarray.length()
b) myarray.length
c) myarray.size
d) myarray.size()
[答案] b

4．以下哪些是合法的数组声明和初始化？
a) int x[] = {1,2,3};
b) int []x[] = {{1,2,3},{1,2,3}};
c) int x[3] = {1,2,3};
d) int []x = {0,0,0};
e) char c[] = {‘a’, ‘b’};
f) int x[]=new int[]{1,2,3};
g) int x[]=new int[3]{1,2,3};
[答案] a,b,d,e,f