一、JAVA 数组
- 数组的定义
1. 数组是存储同一种数据类型的多个元素的集合。也可以看成是一个容器。
2. 数组中只能存储相同类型的若干个数据，根据先后存储的顺序排列组合而成。
3. 数组中，每一个数据都称作数组元素，每一个数组元素都有自己的下标，可以通过这个下标来访问这些数组元素。
4. 数组既可以存储基本数据类型，也可以存储引用数据类型。
注：想要使用数组，必须要声明和创建数组变量。
- 声明创建数组变量的格式：
数据类型[] 数组变量名 = new 数据类型[定义数组长度]；
注：在[]中定义数组长度这一步叫数组元素初始化，数组必须先初始化，然后才可以进行使用。
代码示例：int[] nums = new int[10];
//解释：定义了一个int类型的数组，这个数组中可以存放10个int类型的值。
数组初始化方式有两种：
1.动态初始化：格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
2.静态初始化：格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
代码示例：int[] arr = new int[]{1,2,3};
//解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
//现在我们经常用下面这简化写法
int[] arr = {1,2,3};
- 数组遍历
数组的遍历就是依次输出数组中的每一个元素。
数组提供了一个属性length，用于获取数组的长度。
格式：数组名.length
Demo代码示例：
public class ArrayDemo01 {
public static void main(String[] args) {
//声明创建数组
int[] nums = new int[10];
//给数组的下标赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
int sum = 0;
//length方法：获取数组的长度
for (int i = 0; i < nums.length; i++) {
//数组每一个下标代表的数字相加之和
sum = sum + nums[i];
}
System.out.println(sum);
}
}
代码运行结果是55。
二、初识JAVA的内存
我们在使用数组之前，需要先声明这个数组，这个时候，Java虚拟机会将声明的数组放入栈中，现在的数组中什么都没有，只是一个空的数组。我们要使用的话就需要创建数组对象，并将数组初始化。在我们完成创建和初始化操作之后，Java虚拟机会将我们创建好的数组对象放入堆中，并根据初始化的数组长度在堆中开辟出相同数量的空间。
- 下标越界异常
创建数组时，Java虚拟机会根据初始化定义的数组长度，来在堆中开辟出相同数量的空间与之对应。
如果我们在编写代码时，所使用的下标是超出数组整体长度的，就会报一个下标越界的错误。
错误提示：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
意思是数组下标越界
三、数组的使用
- 数组当作参数使用
找出数组中的最大值和最小值
public class ArrayTest2 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {34,98,10,25,67};
//调用方法
int max = getMax(arr);
System.out.println("max:"+max);
//请获取数组中的最小值
int min = getMin(arr);
System.out.println("min:"+min);
}
/*
需求：获取数组中的最大值
两个明确：
返回值类型：int
参数列表：int[] arr
*/
public static int getMax(int[] arr) {
//从数组中任意的找一个元素作为参照物
int max = arr[0];
//然后遍历其他的元素
for(int x=1; x<arr.length; x++) {
//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
if(arr[x] > max) {
max = arr[x];
}
}
//最后参照物里面保存的就是最大值。
return max;
}
public static int getMin(int[] arr) {
//从数组中任意的找一个元素作为参照物
int min = arr[0];
//然后遍历其他的元素
for(int x=1; x<arr.length; x++) {
//依次获取和参照物进行比较，如果小就留下来，如果大，就离开。
if(arr[x] < min) {
min = arr[x];
}
}
//最后参照物里面保存的就是最小值。
return min;
}
}
- 当作方法返回值使用
public class ArrayDemo01 {
public static void main(String[] args) {
//声明创建数组
int[] nums = {12,96,8,445,4,44,94};
int[] reverse = reverse(nums);
printArray(reverse);
}
//将数组中的元素反转过来
public static int[] reverse(int[] nums){
int[] result = new int[nums.length];
for (int i = 0, j = result.length-1; i < nums.length; i++,j--) {
result[j] = nums[i];
}
return result;
}
//打印数组元素方法
public static void printArray(int[] nums){
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]+"");
}
}
}
运行结果：
四、二维数组
概述：一个数组元素为一维数组的数组，由多个一维数组组成。
- 有三种格式
格式1、数据类型[][] 变量名 = new 数据类型[m][n]；
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
格式2：数据类型[][] 变量名 = new 数据类型[m][];
格式3：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
- 举例
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取,
表示获取第m+1个一维数组的第n+1个元素
遍历二维数组:
遍历数组就是获取数组中的每一个元素，通常遍历数组都是使用for循环来实现。使用双层for循环，通过数组length属性可以获得数组的长度
- 案例一
public class Gushi {
public static void main(String[] args) {
/* ******横向输出******
床 前 明 月 光
疑 是 地 上 霜
******纵向输出******
床 疑
前 是
明 地
月 上
光 霜*/
// TODO Auto-generated method stub
String[][] ss=new String[][]{{"床","前","明","月","光"},{"疑","是","地","上","霜"}};
System.out.println("******横向输出******");
for(int i=0;i<ss.length;i++) {
for(int j=0;j<ss[i].length;j++) {
System.out.print(ss[i][j]+"\t");
}System.out.println();
}
System.out.println("******纵向输出******");
for(int row=0;row<ss[0].length;row++) {
for(int col=0;col<ss.length;col++) {
System.out.print(ss[col][row]+"\t");
}System.out.println();
}
}
}
- 案例二
//将原有积分进行备份，然后赠送每位会员500积分，编写程序输出积分情况
/*请输入5位会员的积分
第1位会员积分:1859
第2位会员积分:235
第3位会员积分:468
第4位会员积分:452
第5位会员积分:23
1859
序号 历史积分 新年积分
1 1859 2359
2 235 735
3 468 968
4 452 952
5 23 523*/
public class Jifen {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
System.out.println("请输入5位会员的积分");
int[][] fen=new int[2][5];
for(int i=0;i<fen[0].length;i++) {
System.out.print("第"+(i+1)+"位会员积分:");
fen[0][i]=sc.nextInt();
fen[1][i]=fen[0][i]+500;
}
System.out.println(fen[0][0]);
//遍历数组
System.out.println("序号\t历史积分\t新年积分");
for(int row=0;row<fen[0].length;row++) {
System.out.print(row+1);
for(int col=0;col<fen.length;col++) {
System.out.print("\t"+fen[col][row]);
}System.out.println();
}
sc.close();
}
}
关于二维数组我们平时用的地方不是很多，但是数组我们还是会经常用到的，所以要熟练掌握。
五、冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处.同理，即可得到排好序的数组。
//数组排序之冒泡排序
public class ArrayDemo {
public static void main(String[] args) {
// 定义一个数组
int[] arr = { 24, 69, 80, 57, 13 };
System.out.println("排序前：");
printArray(arr);
bubbleSort(arr);
System.out.println("排序后：");
printArray(arr);
// 遍历功能
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}
//冒泡排序代码
public static void bubbleSort(int[] arr){
for (int x = 0; x < arr.length-1; x++) {
for (int y = 0; y < arr.length-1-x; y++) {
if (arr[y] > arr[y + 1]) {
int temp = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = temp;
}
}
}
}
}
程序运行结果
冒泡排序原理：
在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。
在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数）将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。
六、Arrays类类概述及其常用方法
针对数组进行操作的工具类。为数组提供了排序，查找等功能。
- 成员方法
public static String toString(int[] a)：把数组转成字符串<br>
public static void sort(int[] a)：对数组进行排序
代码示例：
public class ArraysDemo {
public static void main(String[] args) {
// 定义一个数组
int[] arr = { 24, 69, 80, 57, 13 };
// public static String toString(int[] a) 把数组转成字符串
System.out.println("排序前：" + Arrays.toString(arr));
// public static void sort(int[] a) 对数组进行排序
Arrays.sort(arr);//底层是快速排序，了解就可以了
System.out.println("排序后：" + Arrays.toString(arr));
}
}
运行结果
349
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
