- 1 一维数组
- 1.1 数组语法
- 1.2 数组动态赋值
- 1.3 数组异常
- 1.3.1 下标越界
- 1.3.2 空指针异常
- 1.4 一维数组练习
- 1.5 数组排序算法
- 1.5.1 冒泡排序与 Arrays.sort(array)
- 1.5.2 直接选择排序
- 2 二维数组
- 2.1 二维数组语法
- 2.2 二维数组练习
- 3 Arrays工具类
Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，…，number99。
声明数组变量的方式有如下两种，第一种为首选：
- 类型[] 数组名;
- 类型 数组名[]。
Java语言使用 new *** 作符来创建数组，有如下两种初始化方式：
- 静态初始化：
类型[] 数组名 = new 类型[]{值1，值2，…}; - 动态初始化：
类型[] 数组名=new 类型[长度 n];
数组名[下标 0]=值0;
数组名[下标 1]=值1;
…
数组名[下标 n-1]=值n-1;
数组 *** 作：
- 获取数组中的元素：可以通过下标；
- 给数组赋值：可以通过下标；
- 获取数组长度：数组名.length。
- 动态数组初始化有默认值：整型 0，浮点 0.0，布尔 false，字符 ‘u0000’，引用 null。
数组动态初始化默认值展示：
public class ArrayOperation01 {
public static void main(String[] args) {
// 基本类型
// 整型默认值 0 char short int long
byte[] b1=new byte[5]; //有5个0
b1[0]=13;
//输出第一个元素
System.out.println(b1[0]);
// 小数 默认值 0.0 float double
float[] f1 = new float[3]; //有3个0.0
System.out.println(f1[0]);
//char 默认值 'u0000' 空格
char[] c1 = new char[5]; //空格
System.out.println("第二个元素:["+c1[1]+"]"); //输出第二个元素
//boolean 默认值 false
boolean[] bools = new boolean[3];
System.out.println(bools[0]);
//引用类型 默认值 null;
String[] names =new String[5]; //null
names[2]="张三";
System.out.println(names[2]);
}
}
1.2 数组动态赋值
通过键盘数据给数组动态赋值：
import java.util.Arrays;
import java.util.Scanner;
public class ArrayDynamic {
public static void main(String[] args) {
// 导入键盘输入类
Scanner input = new Scanner(System.in);
// 动态初始化一维数组 num，长度为 3
int[] num = new int[3];
// for 循环往动态数组中赋值
for(int i = 0; i < num.length; i++) {
// 打印赋值开始提示
System.out.println("请输入第"+(i+1)+"个整数:");
// 键盘开始输入赋值
num[i]=input.nextInt();
}
// 输出数组信息，导入包 Arrays 工具类.
System.out.println(Arrays.toString(num));
// 或者 for 循环遍历输出数组信息
for(int j = 0;j<3;j++) {
System.out.print(num[j]+"t");
}
System.out.println("n===================");
// 直接输出数组名得到的是数组地址
System.out.println(num);
// 直接输出变量名得到的是变量值
int a = 100;
System.out.println(a);
}
}
运行结果如下所示;
请输入第1个整数: 10 请输入第2个整数: 11 请输入第3个整数: 12 [10, 11, 12] 10 11 12 =================== [I@7ea987ac 1001.3 数组异常 1.3.1 下标越界
创建一个数组，长度为4，正确下标是0 ~ 3：
int[] score = new int[]{80,79,65,90};
// 打印下标4 报错，异常 java.lang.ArrayIndexOutOfBoundsException
System.out.println(score[4]);
1.3.2 空指针异常
// 初始化一个一维数组
int[] score = new int[]{80,79,65,90};
// 将数组赋值为 null
score = null;
// 打印数组长度，异常 java.lang.NullPointerException
System.out.println(score.length);
或者
// 创建一个引用类型的一维数组，默认值都为 null String[] names = new String[3]; // 将数组赋值为 null names=null; // 打印数组信息，异常 java.lang.NullPointerException System.out.println(names.toString());1.4 一维数组练习
- 数组中最大元素，最小元素，和，平均值：
public class ArrayOperation02 {
public static void main(String[] args) {
//声明一个静态整型数组
int[] num = new int[]{89,34,7,66,90};
//假设数组最后一个值是最大值
int max = num[num.length-1];
//假设数组最后一个值是最小值
int min = num[num.length-1];
//求和
int sum = 0;
for (int i = 0; i < num.length; i++){
// 如果现在的最大值 < 当前数组下标的值
if(max < num[i]) {
// 当前数组下标的值为现在的最大值，赋值给 max
max = num[i];
}
// 如果现在的最小值 > 当前数组下标的值
if(min > num[i]) {
// 当前数组下标的值为现在的最小值，赋值给 min
min = num[i];
}
// 求和，累加当前数组下标的值
sum += num[i];
}
System.out.println("最大值:" + max);
System.out.println("最小值:" + min);
System.out.println("数组中元素的和:" + sum);
System.out.println("元素的平均值:" + (sum * 1.0 / num.length));
}
}
程序运行结果如下所示：
最大值:90 最小值:7 数组中元素的和:286 元素的平均值:57.2
- 数组复制，反转：
浅拷贝(数组地址赋值，其中一个数组对象改变会影响另一个数组对象)：
import java.util.Arrays;
public class ArrayCopy01 {
public static void main(String[] args) {
// 声明一个数组
int[] num = {1,2};
// 打印当前数组地址
System.out.println(num);
// 浅拷贝
int[] newnum = num;
// 导入包 Arrays 工具类，打印浅拷贝的数组内容
System.out.println(Arrays.toString(newnum));
// 简单 for 循环打印数组内容
// for(int i=0;i
深拷贝（改变其中一个数组对象中的数据，不会影响另一个数组对象的数据）：
- 1、按下标赋值；
- 2、系统函数：System.arraycopy(a, 0, b, 0, a.length);
- 3、工具类函数：Arrays.copyOf(a, a.length);
- 4、数组自带函数：a.clone();
import java.util.Arrays;
public class ArrayCopy02 {
public static void main(String[] args) {
//1、按下标赋值
// int[] a = {1,2};
// int[] b = new int[a.length];
// for(int i=0;i
// b[i]=a[i];
// }
// b[1]=8;
// System.out.println(Arrays.toString(a));
// System.out.println(Arrays.toString(b));
//2、深拷贝
// int[] a = {1,2};
// int[] b = new int[a.length]; //0
// System.arraycopy(a, 0, b, 0, a.length);
// b[1]=8;
// System.out.println(Arrays.toString(a));
// System.out.println(Arrays.toString(b));
//3、深拷贝
// int[] a = {1,2};
// int[] b = Arrays.copyOf(a, a.length);
// b[1]=8;
// System.out.println(Arrays.toString(a));
// System.out.println(Arrays.toString(b));
//4、深拷贝
int[] a = {1,2};
int[] b = a.clone();
b[1] = 8;
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
}
}
反转：
import java.util.Arrays;
public class ArrayReversal {
public static void main(String[] args) {
int[] num = {12,56,3,78,45};
System.out.println("反转前:" + Arrays.toString(num));
// 1、逆序输出（没有改变数组中的元素）
System.out.print("逆序输出:");
for(int i = num.length-1;i>=0;i--) {
System.out.print(num[i] + "t");
}
// 2、改变数组中数据顺序实现反转
for(int i = 0; i < num.length / 2; i++) {
int temp = num[i];
num[i] = num[num.length-1-i];
num[num.length-1-i] = temp;
}
System.out.println("n反转后:" + Arrays.toString(num));
}
}
- 键盘接收学员的成绩（数组长度为学员人数），获取数组中的最高分，并且根据计算规则输出相应成绩的等级：
如：int[] score = new int[长度];
成绩 >= 最高分-10 A级
成绩 >= 最高分-20 B级
成绩 >= 最高分-30 C级
否则是D级
最后输出例子：成绩 65 分，等级 C 级
import java.util.Scanner;
public class ArrayOperation03 {
public static void main(String[] args) {
// 键盘输入类
Scanner inputScore = new Scanner(System.in);
// 初始化一维数组存储每个学员的分数,假设有5个学员
int[] score = new int[5];
// 记录最高分
int maxScore = score[0];
// 键盘依次录入每个学员成绩
for (int i = 0; i < score.length; i++) {
System.out.println("请输入第 " + (i + 1) + " 个学员的成绩:");
// 开始接收键盘输入，并赋值给数组
score[i] = inputScore.nextInt();
// 判断当前输入的分数是否是当前最高的分数
if (maxScore < score[i]){
// 当前输入的分数是最高的，替换
maxScore = score[i];
}
}
// 输出每个分数的等级
for (int i = 0; i < score.length; i++) {
if(score[i] >= maxScore - 10) {
System.out.println("成绩 "+score[i]+" 分,等级 A 级");
}else if(score[i] >= maxScore-20) {
System.out.println("成绩 "+score[i]+" 分,等级 B 级");
}else if(score[i] >= maxScore-30) {
System.out.println("成绩 "+score[i]+" 分,等级 C 级");
}else {
System.out.println("成绩 "+score[i]+" 分,等级 D 级");
}
}
}
}
运行结果如下所示：
请输入第 1 个学员的成绩:
65
请输入第 2 个学员的成绩:
99
请输入第 3 个学员的成绩:
45
请输入第 4 个学员的成绩:
87
请输入第 5 个学员的成绩:
76
成绩 65 分,等级 D 级
成绩 99 分,等级 A 级
成绩 45 分,等级 D 级
成绩 87 分,等级 B 级
成绩 76 分,等级 C 级
1.5 数组排序算法
1.5.1 冒泡排序与 Arrays.sort(array)
排序（数组元素从小到大或从大到小）：
- Arrays.sort(数组变量名);，从小到大排列；
- 冒泡排序：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
规则：两两比较，小在前，从小到大；
口决：外层循环 N-1 次，内层循环 N-1-i 次。
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
// 静态初始化一个整型数组 numArrSort，用于工具类 Arrays 排序
int[] numArrSort = {12,4,78,56,32};
System.out.println("Arrays 工具类排序前:" + Arrays.toString(numArrSort));
// 复制数组下来用于冒泡排序
int[] numBubSort = numArrSort.clone();
// 修改冒泡排序数组中两个值
numBubSort[0] = 63;
numBubSort[1] = 42;
System.out.println("冒泡排序前:" + Arrays.toString(numBubSort));
// 1、Arrays.sort()
// 使用 Arrays 工具类排序算法函数 sort：从小到大排序
Arrays.sort(numArrSort);
// 打印排序后的数组内容
System.out.println("Arrays 工具类从小到大排序:" + Arrays.toString(numArrSort));
// 2、冒泡排序
//规则 ：两两比较，小在前，从小到大排序
for(int i = 0; i < numBubSort.length-1; i++) {
for(int j = 0; j < numBubSort.length-1-i; j++) {
if(numBubSort[j] > numBubSort[j+1]) {
int temp = numBubSort[j];
numBubSort[j]=numBubSort[j+1];
numBubSort[j+1]=temp;
}
}
}
System.out.println("冒泡排序从小到大排序:" + Arrays.toString(numBubSort));
}
}
程序运行结果如下所示：
Arrays 工具类排序前:[12, 4, 78, 56, 32]
冒泡排序前:[63, 42, 78, 56, 32]
Arrays 工具类从小到大排序:[4, 12, 32, 56, 78]
冒泡排序从小到大排序:[32, 42, 56, 63, 78]
1.5.2 直接选择排序
直接选择排序(Straight Select Sorting) 也是一种简单的排序方法。
它的基本思想是：
- 第一次从array[0] ~ array[n-1]中选取最小值，与 array[0] 交换;
- 第二次从 array[1] ~ array[n-1] 中选取最小值，与 array[1] 交换，…；
- 第 i 次从 array[i-1] ~ array[n-1] 中选取最小值，与 array[i-1] 交换，…；
- 第 n-1 次从 array[n-2] ~ array[n-1] 中选取最小值，与 array[n-2] 交换；
- 总共通过 n-1 次，得到一个按排序码从小到大排列的有序序列。
import java.util.Arrays;
public class StraightSelSort {
public static void main(String[] args) {
// 1、静态初始化一个数组
int[] num = {12,4,78,56,32};
// 选择轮数
for(int i = 0; i < num.length - 1; i++){
// t 记录最小值坐标
int t = i;
for (int j = i + 1; j < num.length; j++){
if (num[t] > num[j]){
// 有比 t 下标的值更小，替换当前最小值下标
t = j;
}
}
if (t != i){
// 当前轮数 i 下标不是最小值下标 t，替换掉数组数据最小值
int temp = num[i];
num[i] = num[t];
num[t] = temp;
}
}
System.out.println(Arrays.toString(num));
}
}
运行结果如下所示：
[4, 12, 32, 56, 78]
2 二维数组
2.1 二维数组语法
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
语法首选第一种：
- 类型[][] 数组名;
- 类型 数组名[][] ;
- 类型[] 数组名[];
初始化方式：
- 静态初始化：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
也可以是：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：int[][] arr = {{1,3,5},{4,5},{6}};。 - 动态初始化 1：
数据类型[][] 变量名 = new 数据类型[m][n];
m 表示这个二维数组有多少个一维数组；
n 表示每一个一维数组的元素个数；
举例：定义了一个二维数组 array:
int[][] array =new int[3][2];
这个二维数组有 3 个一维数组，名称是 array[0],array[1],array[2];
每个一维数组有 2 个元素，可以通过 array[m][n]来获取，比如第一个一维数组的两个元素:array[0][0]，array[0][1]。 - 动态初始化 2：
数据类型[][] 变量名=new 数据类型[m][];
m 表示这个二维数组有多少个一维数组，
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：定义了一个二维数组 array:
int[][] array=new int[3][];
给第一个一维数组给定长度为2；
array[0] = new int[2];
给第二个一维数组给定长度为3；
array[1]= new int[3];
给第三个一维数组给定长度为1；
array[2]=new int[1];
二维数组的长度：数组变量名.length;
二维数组中一维数组的长度：数组变量名[m].length;
2.2 二维数组练习
1、遍历一个行列确定的二维数组，静态初始化：
public class TwoDimensionalArray01 {
public static void main(String[] args) {
int[][] num = new int[][]{{1,2},{3,4,5},{6,7,8,9}};
System.out.println("二维数组的长度:" + num.length);
System.out.println("二维数组中第三个一维数组的长度:" + num[2].length);
// 遍历二维数组
for(int i=0; i < num.length; i++) {
for(int j = 0; j < num[i].length; j++) {
System.out.print(num[i][j]+"t");
}
System.out.println();
}
}
}
运行结果：
二维数组的长度:3
二维数组中第三个一维数组的长度:4
1 2
3 4 5
6 7 8 9
2、公司年销售额求和，某公司按照季度和月份统计的数据如下：
第一季度：22，66，44
第二季度：77，33，88
第三季度：11，66，99
第四季度：25，45，65
public class TwoDimensionalArray02 {
public static void main(String[] args) {
int[][] num ={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum = 0;
// 遍历二维数组
for(int i=0; i < num.length; i++) {
for(int j = 0; j < num[i].length; j++) {
sum += num[i][j];
}
}
System.out.println("公司年销售额:" + sum);
}
}
运行结果如下：
公司年销售额:641
3、杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
......
杨辉三角规则：
第 1 行有 1 个元素，第 N 行有 N 个元素，每一行中第一个元素和最后一个元素是 1，从第三行开始除第一个元素和最后一个元素，每个元素是前一行前两项之和：
num[i][j] = num[i-1][j] + num[i-1][j-1];
打印一个 10 行的杨辉三角：
public class YangHuiTriangle {
public static void main(String[] args) {
// 定义一个二维数组存储 10 行的杨辉三角
int[][] yh = new int[10][];
// 初始化杨辉三角每一行的元素个数，一维数组的长度
for (int i = 0; i < yh.length; i++){
yh[i] = new int[i + 1];
}
// 杨辉三角每一行元素赋值
for (int i = 0; i < yh.length; i++) {
for (int j = 0; j < yh[i].length; j++) {
// 第一行第二行都为 1
if (i == 0 || i == 1){
yh[i][j] = 1;
} else {
// 从第三行开始，第一个元素和最后一个元素都为 1
if (j == 0 || j == yh[i].length - 1){
yh[i][0] = 1;
yh[i][yh[i].length - 1] = 1;
} else {
// 中间的元素等于上一行的相同列与前一列的两数之和
yh[i][j] = yh[i - 1][j] + yh[i - 1][j - 1];
}
}
}
}
// 打印杨辉三角
//遍历
for(int i=0; i < yh.length; i++) {
for(int j=0; j < yh[i].length; j++) {
System.out.print(yh[i][j] + "t");
}
System.out.println();
}
}
}
运行结果：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
3 Arrays工具类
java.util.Arrays 类能方便地 *** 作数组，它提供的所有方法都是静态的。
具有以下功能：
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法,按升序。
- 比较数组：通过 equals 方法比较数组中元素值是否相等。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法 *** 作。
具体说明请查看下表：
序号 方法 说明 1public static int binarySearch(Object[] a, Object key)用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。 2public static boolean equals(long[] a, long[] a2)如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 3public static void fill(int[] a, int val)将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 4public static void sort(Object[] a)对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）