1. 数组

1.1 数组的特点

  • Java中的数组，既能存储原始数据类型，又能存储对象类型。

  • 数组元素的个数称为数组的长度。数组长度一旦确定，就不能改变。

  • 数组元素的下标是从0开始的，即第一个元素的下标是0。

  • Java不支持多维数组，但是可以创建数组的数组。

  • Java中将数组作为对象处理。数组对象含有成员变量length，用来表示数组的长度。

1.2 一维数组

在Java里创建并使用一维数组，需要以下步骤:

  1. 声明一个数组变量来存放该数组。
  2. 创建一个新的数组对象并将其赋值给上一步所创建的数组变量。
  3. 在该数组中存储数据。
  4. 访问或修改此数组中存储的数据（元素）。

1.2.1 声明一维数组

语法:

// 方式1
数组类型[] 数组名字;

// 方式2
数组类型 数组名字[];

这两种数组变量声明的方式在作用上是相同的，但通常建议采用第一种方式

实例

int[]  weeks; //声明一个整型数组
boolean[]  flag; //声明一个布尔类型的数组
float[]  score;  //声明一个浮点类型的数组

1.2.2 创建一维数组

声明了数组变量之后，下一步就需要创建一个数组对象，并将其赋给所声明的数组变量。而创建数组对象，实际上就是在内存中分配相应大小的存储空间给数组。有两种方式可以用来创建数组对象。

  • 使用new运算符

在Java中，数组是引用对象，所以可以使用new运算符来直接创建一个数组对象，如以下代码所示:

//创建一个整型数组对象，数组大小为7
int[] weeks = new int[7] ;
//创建一个字符串数组，数组大小为10
String[] studentNames = new String[10];

使用new运算符来创建数组对象时，必须指定这个数组的大小。创建数组对象时，仅仅是在内存中为数组变量分配指定大小的空间，并没有实际存储数据，这时数组的所有元素会被自动地赋予初值

- 数字数组，初值是0。
- 布尔数组，初值是false。
- 字符数组，初值是‘\0’。
- 对象数组，初值是null。
  • 直接初始化数组元素

也可以通过把数组元素值直接放在大括号中的办法来同时完成创建和初始化数组，这时将在内存中分配与元素数量相适应的空间大小，并赋予指定的元素值，如以下代码所示。

//创建一个整型数组对象，数组大小为7，并同时赋初值
int[]  weeks = {1,2,3,4,5,6,7};
//创建一个String数组对象，并初始化
String[] studentNames = {"张小明","黄芳","赵秀丽"};

使用这种方法创建数组对象时，大括号里的元素类型必须与指定的数据类型一致，并且数组的大小与大括号中包含的元素个数相同。

1.3 多维数组

数组元素除了可以是原始数据类型、对象类型之外，还可以是数组，即数组的元素是数组。所以虽然Java不支持多维数组，但是可以通过声明数组的数组来实现同样的功能。元素数组还可以包含数组，依此类推，最后创建出达到需要的任意维数。

1.3.1 声明二维数组

语法:

数组类型[][] 数组名字;

数组类型 数组名字[][];

实例

int[][]  year;
boolean[][] flag;
float[][]  score;

1.3.2 创建二维数组

声明了数组变量之后，下一步就需要创建一个数组对象，并将其赋给所声明的数组变量。而创建数组对象实际上就是在内存中分配相应大小的存储空间给数组。有两种方式可以用来创建二维数组对象。

  • 使用new运算符
//创建了一个二维数组对象，用来保存一年中的52个星期及每个星期的7天

int[][]  year = new int[52][7] ;
  • 直接初始化数组元素
//在这里，定义了一个二维数组arrays2，它有3行5列。
int[][] arrays2={{11,12,13,14,15},{21,22,23,24,25},{31,32,33,34,35}}；

//数组中每一行的长度也可以不同：
int[][] arrays2 = {{11,12 },{21,22,23,24,25},{31, 34,35}}；
boolean flags = {{true,false},{true,true,false,false},{false,false,true}};

1.4 数组操作

1.4.1 遍历数组

遍历一维数组

String[] studentNames = {"张三","李四","王伟","刘想"};
//第一种遍历数组
for (int i = 0; i < studentNames.length; i++){
    System.out.println("第一种遍历打印>>>>> " + studentNames[i]);
}

/** 输出:
第一种遍历打印>>>>> 张三
第一种遍历打印>>>>> 李四
第一种遍历打印>>>>> 王伟
第一种遍历打印>>>>> 刘想
**/

//第二种遍历数组
for (String item:studentNames) {
    System.out.println("第二种遍历打印 --->" + item);
}
/** 输出:
第二种遍历打印 --->张三
第二种遍历打印 --->李四
第二种遍历打印 --->王伟
第二种遍历打印 --->刘想
**/

遍历二维数组

String[][] args = {{"张三","李四","王伟","刘想"},{"100","200","300","300"}};
//第一种遍历数组
for (int i = 0; i < args.length; i++){
  for (int j = 0; j < args[i].length; j++){
      System.out.println("第一种遍历: "+i+"-"+j+" >"+ args[i][j]);
  }
}
/** 输出:
第一种遍历: 0-0 >张三
第一种遍历: 0-1 >李四
第一种遍历: 0-2 >王伟
第一种遍历: 0-3 >刘想
第一种遍历: 1-0 >900
第一种遍历: 1-1 >200
第一种遍历: 1-2 >300
第一种遍历: 1-3 >300
**/

//第二种遍历数组
for (String[] item:args) {
    for (String value: item){
        System.out.println("第二种遍历打印 --->" + value);
    }
}
/** 输出:
第二种遍历打印 --->张三
第二种遍历打印 --->李四
第二种遍历打印 --->王伟
第二种遍历打印 --->刘想
第二种遍历打印 --->900
第二种遍历打印 --->200
第二种遍历打印 --->300
第二种遍历打印 --->300
**/

1.4.2 数组填充(fill)

语法

// 把数组所有元素初始化为:value
Arrays.fill(数据类型[] 数组变量名, value)

// 把数组从索引startIndex(包括)开始到endIndex(不包括)内的所有元素初始化为:value
Arrays.fill(数据类型[] 数组变量名, startIndex,endIndex,value)

实例

public static void testFill(){
    // 填充数据 Arrays.fill(数据类型[] 数组变量名, value)
    int[] number = new int[5];
    Arrays.fill(number,10);
    System.out.println(Arrays.toString(number)); // 输出: [10, 10, 10, 10, 10]
    int[] number2 = new int[5];
    Arrays.fill(number2,0,3,6);
    System.out.println(Arrays.toString(number2)); // 输出: [6, 6, 6, 0, 0]
}

1.4.3 数组排序(sort)

int[] arr = {23,90,72,37,662,12};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("排序后:"+ Arrays.toString(arr));
//输出: 排序后:[12, 23, 37, 72, 90, 662]

1.4.4 数组复制(copyOf、copyOfRange)

int[] number = {23, 90, 72, 37, 662, 12, 239, 234};
int[] number1 = Arrays.copyOf(number, 5);
System.out.println(Arrays.toString(number1)); //输出:[23, 90, 72, 37, 662]
int[] number2 = Arrays.copyOfRange(number,3,6);
System.out.println(Arrays.toString(number2)); //输出:[37, 662, 12]