Array 数组
1.数组的概述
- 数组是相同类型的有序集合
- 每一个数据称作一个数组元素,并且可以通过一个下标来访问他们。
2.数组声明创建
2.1声明数组
数组必须先声明数组变量,才能被程序中使用。
int[] array ; //声明一个 int的数组集合 (首选)
或
int array[] ; //声明一个 int的数组集合 (不推荐)
2.2创建数组
Java是使用new操作符来创建数组的。
int[] array ; // 声明int类型的数据类型集合数组变量
array = new int[2]; //用new操作符创建数组
或
//动态初始化
int[] array2 = new int[2]; //声明int类型的数组变量,同时创建长度为2数组.
array2[0] = 1; //将数组索引0的元素值设置为1
array2[1] = 2; //将数组索引1的元素值设置为2
或
//静态初始化
int[] array3 = {1,2,3,4,5,6}; //声明int类型的数组,并声明其中的值
-
方式一是方式二的简写,是等价的
-
动态初始化与静态初始化一个是声明长度,一个是指定其中的值
-
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也会被按照实例变量被隐式初始化.
2.3数组的边界
数组的合法区间: [0, length-1] ,如果数组越界会报错
java.lang.ArrayIndexOutOfBoundsException
2.4数组的四个基本特点
- 其长度是确定的,一旦被创建,大小是不可以被改变的.
- 其元素必须是相同类型,不允许出现混合类型.
- 数组中的元素可以是任何数据类型,包括基本类型和引用类型
- 数组本身就是对象,java中的 数组和数组中的元素都在堆中.
3.数组的使用
3.1案例一
数组的基本使用
package com.zhao.array;
public class Array02 {
public static void main(String[] args) {
// 定义一个10个数组
double[] array = new double[10];
array[0] = 3.1;
array[1] = 2.5;
array[2] = 4.8;
array[3] = 100;
array[4] = 6.7;
array[5] = 3.7;
array[6] = 3.99;
array[7] = 2.87;
array[8] = 1.1;
array[9] = 3.444;
// 计算所有元素总和
double sum = 0.0;
for (int i = 0 ; i < array.length; i++){ //array.length 指的是该数组的长度
sum += array[i];
}
System.out.println("所有元素的总和为:" + sum);
//计算整个数组的元素的平均值
double average;
average = sum / (array.length+1);
System.out.println("整个数组的元素的平均值为:" + average);
//查找最大的元素值
double max = array[0];
for (int i = 0; i <array.length ; i++) {
}
}
}
运行结果:
所有元素的总和为:132.204
整个数组的元素的平均值为:12.018545454545455
3.2案例二
数组可以作为对象当方法传参入参
public class Array04 {
public static int[] array = {1,2,3,4,5,6,7,8,9};
public static void main(String[] args) {
print(reverseArray(array)); //打印反转后的array数组
print(maxArray(array)); //打印数组中的最大值
print(minArray(array)); //打印数组中的最小值
print(productArray(array)); //打印数组中所有元素的乘积
}
/**
* 打印数组元素
* @param arrays
*/
public static void print(int[] arrays){
for (int i = 0; i <arrays.length ; i++) {
System.out.print(arrays[i]);
}
System.out.println("");
}
/**
* 打印数字元素
* @param a
*/
public static void print(int a){
System.out.println(a);
}
/**
* 反转数组
* 声明一个新数组来接收原先数组
* @param arrays
*/
public static int[] reverseArray(int[] arrays){
int[] array2 = new int[arrays.length];
for (int i=0, j= arrays.length-1 ; i <arrays.length ; i++,j--) {
array2[j] = arrays[i];
}
return array2;
}
/**
* 求函数中最大值
* @param arrays
* @return
*/
public static int maxArray(int[] arrays){
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
// max = max与arrays的元素两者中的较大值
max = max >= arrays[i] ? max : arrays[i] ;
}
return max;
}
/**
* 求元素中的最小值
* @param arrays
* @return
*/
public static int minArray(int[] arrays){
int min = arrays[0];
for (int i = 1; i < arrays.length; i++) {
// min = min与arrays的元素两者中的较小值
min = min <= arrays[i] ? min : arrays[i];
}
return min;
}
/**
* 求所有元素的乘积
* @param arrays
* @return
*/
public static int productArray(int[] arrays){
int product = arrays[0];
for (int i = 1; i < arrays.length; i++) {
product *= arrays[i];
}
return product;
}
}
结果:
987654321
9
1
362880
4.多维数组
多维数组可以看成一个数组的数组,其中每一个元素都可以是个数组
4.1二维数组
4.1.1二维数组的声明和创建
int[][] arrays = new int[2][3]; //声明并创建一个二维数组,长度为2,且子数组长度为3 (动态初始化)
int[][] arrays2 = new int[2][]; //声明并创建一个二维数组,长度为2 (动态初始化)
arrays2[0] = new int[3]; //索引为0的子数组长度为3
arrays2[1] = new int[2]; //索引为1的子数组长度为2
int[][] arrays3 = {{1,2},{3,4,5}};声明并创建一个二维数组,并元素初始化 (静态初始化)
4.1.2二维数组的使用
arrays[0][1] = 1; //将1赋值给二维数组第0号索引中,索引1号的元素.
4.1.3遍历二维数组
public class Array06 {
public static void main(String[] args) {
int[][] arrays3 = {{1,3},{66,4,5},{7},{356,67,99}}; //声明并创建一个二维数组,并元素初始化
for (int i = 0; i < arrays3.length; i++) { //遍历arrays3数组
for (int j = 0; j < arrays3[i].length; j++) { //遍历arrays3[i]的数组
System.out.print(arrays3[i][j]); //打印输出每个元素
}
System.out.println(""); //每个子数组中间断开
}
}
}
结果:
13
6645
7
3566799
5.Arrays类
5.1概述
java.util.Arrays 此类包含用来操作数组的各种方法,比如排序和搜索等。其所有方法均为静态方法,调用起来非常简单。
5.2常用类
Arrays.toString(array); // 将数组转化成字符串形式
Arrays.sort(array); // 将数组进行升序
char[] arrays = string.toCharArray(); // 将字符串转化成字符数组
5.2.1案例一
public static void main(String[] args) {
int[] array = {1,9,55,45,37,4445,66,9945,331,12};
// 打印数组哈希值
System.out.println(array); //[I@4554617c
// 将数组转化成字符串形式
System.out.println(Arrays.toString(array)); //[1, 9, 55, 45, 37, 4445, 66, 9945, 331, 12]
// 将数组进行升序
Arrays.sort(array);
System.out.println( array); //[I@4554617c
System.out.println(Arrays.toString(array)); //[1, 9, 12, 37, 45, 55, 66, 331, 4445, 9945]
}
5.2.2案例二
import java.util.Arrays;
public class Array09 {
public static void main(String[] args) {
String string = "sajskashdsjvagdcmzkkfldsa";
// 将字符串转化成字符数组
char[] arrays = string.toCharArray();
// 对字符数组进行升序排序
Arrays.sort(arrays);
for (int i = arrays.length-1; i >= 0 ; i--) {
System.out.print(arrays[i]+ " "); //z v s s s s s m l k k k j j h g f d d d c a a a a
}
}
}
5.3冒泡排序
import java.util.Arrays;
public class Array07 {
/**
* 定义创建数组
*/
public static int[] array = {1,99,48,66,7,3,4,26,78,6,2};
/**
* 冒泡排序
* @param array
* @return
*/
public static int[] BubbleSort (int[] array){
int a ; // 中间值
for (int j = 0; j < array.length-1; j++) {
for (int i = 0; i < array.length-1; i++) {
if (array[i] <= array[i+1]){
}else {
a = array[i];
array[i] = array[i+1];
array[i+1] = a;
}
}
}
return array;
}
public static void main(String[] args) {
//toString类方法是用来输出数组的
System.out.println(Arrays.toString(BubbleSort(array)));
}
}
6.稀疏数组
6.1概述
什么叫稀疏数组呢?
如果一个数组(包括多维数组)中的大部分元素为0,或者为同一个值的数组时,可以使用稀疏数组来保存该数组,节约空间。
一般来说,稀疏数组的处理方法是:
1.记录数组一共有几行几列,有多少个不同的数值。
2.把具有不同值的元素的行列及记录在一个小规模的数组中,从而缩小程序的规模。
如图所示,一般来说,第一行存取几行几列以及几个数值。
6.2实例
public class Array10 {
public static void main(String[] args) {
// 生成一个11*11的棋盘, 白色 :1 黑色:2 ,其他都为0
int [][] array = new int[11][11];
array[2][3] = 1;
array[3][4] = 2;
// 生成棋盘
for (int a = 0; a < array.length; a++) {
for (int b = 0; b < array[a].length; b++) {
System.out.print(array[a][b] + "\t");
}
System.out.println();
}
System.out.println("------------------");
// 计算稀疏数组需要保存的非0值的个数
int sum = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j] != 0 ){
sum++;
}
}
}
// 创建稀疏数组
int[][] array2 = new int[sum + 1][3];
// 稀疏数组的首行为 11 11 个数
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
int sum2 = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j] != 0 ){
sum2++;
array2[sum2][0] = i+1;
array2[sum2][1] = j+1;
array2[sum2][2] =array[i][j];
}
}
}
System.out.println("稀疏数组的有效个数为:" + sum);
// 遍历稀疏数组
System.out.println("稀疏数组为:");
for (int i = 0; i < array2.length; i++) {
for (int j = 0; j < array2[i].length; j++) {
System.out.print(array2[i][j] + "\t" );
}
System.out.println();
}
System.out.println("------------------");
//还原稀疏数组
System.out.println("还原稀疏数组");
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for (int a = 1; a < array2.length; a++) {
array3[array2[a][0]-1][array2[a][1]-1] = array2[a][2];
}
for (int aa = 0; aa < array3.length; aa++) {
for (int bb = 0; bb < array3[aa].length; bb++) {
System.out.print(array3[aa][bb] + "\t");
}
System.out.println("");
}
}
}
结果:
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 2 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
------------------
稀疏数组的有效个数为:2
稀疏数组为:
11 11 2
3 4 1
4 5 2
------------------
还原稀疏数组
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 2 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0