java 数组
- Ⅰ、数组常见算法：
- Ⅱ、Arrays类的使用：
- Ⅲ、数组常见异常：
- Ⅳ、小结：
Ⅰ、数组常见算法：
1、二维数组的案例1：求和
其一、代码为：
java
package com.atguigu.exer;
public class ArrayExer1 {
public static void main(String[] args) {
int[][] arr = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
int sum = 0;//记录总和
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
sum += arr[i][j];
}
}
System.out.println("总和为：" + sum);//总和为：54
}
}其二、截图为：
2、二维数组的案例2：杨辉三角
其一、描述：
java
* 使用二维数组打印一个 10 行杨辉三角。
【提示】
1. 第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。
即： yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
其二、代码为：
java
package com.atguigu.exer;
public class YangHuiTest {
public static void main(String[] args) {
//1.声明并初始化二维数组
int[][] yangHui = new int[10][];
//2.给数组的元素赋值
for(int i = 0;i < yangHui.length;i++){
yangHui[i] = new int[i + 1];
//2.1 给首末元素赋值
yangHui[i][0] = yangHui[i][i] = 1;
//2.2 给每行的非首末元素赋值
//if(i > 1){
//能去掉的原因：当 i 为 0/1 时，yangHui[0].length - 1 值为 0，因此该内层循环也进不去;
for(int j = 1;j < yangHui[i].length - 1;j++){
yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
}
//}
}
//3.遍历二维数组
for(int i = 0;i < yangHui.length;i++){
for(int j = 0;j < yangHui[i].length;j++){
System.out.print(yangHui[i][j] + " ");
}
System.out.println();
}
}其三、截图为：
3、二维数组的案例3：算法考察(求数值型数组中元素的最大值、最小值、平均数、总和等)
其一、描述：
java
* 算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等
*
*
* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
* 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
* 要求：所有随机数都是两位数。
*
*
* [10,99] Math.random() * (b - a + 1) + a
* 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
其二、代码为：
java
package com.atguigu.java;
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
}
//遍历(即：输出随机值数组)
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//求数组元素的最大值
//此时设置 int maxValue = 0 是不合适的，因为可能随机生成的值是负数，此时最大的值就是初始值0，因此正确的操作为：int maxValue = arr[0];
int maxValue = arr[0];
for(int i = 1;i < arr.length;i++){
if(maxValue < arr[i]){
maxValue = arr[i];
}
}
System.out.println("最大值为：" + maxValue);
//求数组元素的最小值
int minValue = arr[0];
for(int i = 1;i < arr.length;i++){
if(minValue > arr[i]){
minValue = arr[i];
}
}
System.out.println("最小值为：" + minValue);
//求数组元素的总和
//因为要求总和，因此此时可以设置 sum 的值为 0，int sum = 0;
int sum = 0;
for(int i = 0;i < arr.length;i++){
sum += arr[i];
}
System.out.println("总和为：" + sum);
//求数组元素的平均数
int avgValue = sum / arr.length;
System.out.println("平均数为：" + avgValue);
}
}其三、截图为：
4、二维数组的案例4：数组间的赋值
其一、描述：
java
* 使用简单数组
(1)创建一个名为ArrayExer2的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
*
*
* 思考：array1和array2是什么关系？ 答：array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。
* 拓展：修改题目，实现array2对array1数组的复制(即：想要新的数组，新的堆空间)
其二、代码为：
java
package com.atguigu.exer;
public class ArrayExer2 {
public static void main(String[] args) { //alt + /
int[] array1,array2;
array1 = new int[]{2,3,5,7,11,13,17,19};
//显示array1的内容
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + "\t");//2,3,5,7,11,13,17,19;
}
//赋值array2变量等于array1
//不能称作数组的复制(因为在堆空间中的数组依旧只是一个，只是将指向 array1 数组的地址赋值给了 array2 而已)
//而只是相当于创建一个快捷方式;
array2 = array1;
//修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
for(int i = 0;i < array2.length;i++){
if(i % 2 == 0){
array2[i] = i;
}
}
System.out.println();
//打印出array1
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + "\t");//0,3,2,7,4,13,6,19;
}
// int[]x,y[];
// x=y;
// x=y 不成立的原因(因为按道理说，x 表示的也是地址值，而 y 表示的也是地址值，因此将 y 值赋值给 x 值应该是成立的)：
// 答：虽然 x 与 y 都是表示地址值，但其中除了存储地址值以外，其还保存了变量的类型(如：二维的 [[,一维的[)，因为其二维和一维的类型都不能满足，因此也不可以赋值;
// 声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是：
// a ) x[0] = y; no
// b) y[0] = x; yes
// c) y[0][0] = x; no
// d) x[0][0] = y; no
// e) y[0][0] = x[0]; yes
// f) x = y; no
//
// 提示：
// 一维数组：int[] x 或者int x[]
// 二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
}
}其三、截图为：
其四、内存解析：
5、二维数组的案例5：数组间的复制
其一、描述：
java
* 使用简单数组
* 拓展：修改题目，实现array2对array1数组的复制(即：想要新的数组，新的堆空间)
其二、代码为：
java
package com.atguigu.exer;
public class ArrayExer3 {
public static void main(String[] args) { //alt + /
int[] array1,array2;
array1 = new int[]{2,3,5,7,11,13,17,19};
//显示array1的内容
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + "\t");//2,3,5,7,11,13,17,19;
}
//数组的复制(栈中的地址及堆中的数组空间都是新建的，而不是只把数组地址赋值过去):
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
//修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
for(int i = 0;i < array2.length;i++){
if(i % 2 == 0){
array2[i] = i;
}
}
System.out.println();
//打印出array1
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + "\t");//2,3,5,7,11,13,17,19;
}
}
}其三、截图为：
其四、内存解析：
6、二维数组的案例6：数组的复制、反转、查找(线性查找、二分法查找)
其一、描述：
java
* 算法的考查：数组的复制、反转、查找(线性查找、二分法查找)其二、代码为：
java
package com.atguigu.java;
public class ArrayTest2 {
public static void main(String[] args) {
String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
//数组的复制(区别于数组变量的赋值：arr1 = arr)
String[] arr1 = new String[arr.length];
for(int i = 0;i < arr1.length;i++){
arr1[i] = arr[i];
}
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();//JJ DD MM BB GG AA
//数组的反转操作
//方法一：一个变量i;
// for(int i = 0;i < arr.length / 2;i++){
// String temp = arr[i];
// arr[i] = arr[arr.length - i -1];
// arr[arr.length - i -1] = temp;
// }
//方法二：两个变量 i 与 j;
for(int i = 0,j = arr.length - 1;i < j;i++,j--){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//查找(或搜索)
//线性查找(即：从前往后一个一个查找)
String dest = "BB";
// dest = "CC";
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
//此时的 equals 方法比的是：内容是否相同(即：dest.equals(arr[i]), dest 与 arr[i] 的内容是否相同);
if(dest.equals(arr[i])){
System.out.println("找到了指定的元素，位置为：" + i);
isFlag = false;
break;
}
}
if(isFlag){
System.out.println("很遗憾，没有找到的啦！");
}
//二分法查找：(熟悉)
//前提：所要查找的数组必须有序。
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
dest1 = 35;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end)/2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定的元素，位置为：" + middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}else{//arr2[middle] < dest1
head = middle + 1;
}
}
if(isFlag1){
System.out.println("很遗憾，没有找到的啦！");
}
}
}其三、截图为：
7、二维数组的案例7：冒泡排序
其一、描述：
java
数组的冒泡排序的实现其二、代码为：
java
package com.atguigu.java;
public class BubbleSortTest {
public static void main(String[] args) {
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//冒泡排序
for(int i = 0;i < arr.length - 1;i++){
for(int j = 0;j < arr.length - 1 - i;j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
}
}其三、截图为：
8、二维数组的案例8：快速排序(了解)
其一、描述：
java
* 快速排序
*
* 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
* 则分别对这两部分继续进行排序，直到整个序列有序。
* @author shkstart
其二、代码为：
java
package com.atguigu.java;
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//递归调用
subSort(data, high + 1, end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
}
}其三、截图为：
Ⅱ、Arrays类的使用：
1、Arrays类：操作数组的工具类
其一、描述：
java
* java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
import java.util.Arrays;其二、代码为：
java
package com.atguigu.java;
import java.util.Arrays;
public class ArraysTest {
public static void main(String[] args) {
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);//false
//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]
//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10]
//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4]
//5.int binarySearch(int[] a,int key):二分查找;
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);//一般来说只要返回的 index 值为负数，就说明二分查找没找到;
if(index >= 0){
System.out.println(index);//8
}else{
System.out.println("未找到");
}
}
}其三、截图为：
Ⅲ、数组常见异常：
1、数组常见异常：角标越界异常 和 空指针异常
其一、描述：
java
* 数组中的常见异常：
*
* 1. 数组角标越界的异常：ArrayIndexOutOfBoundsException
*
* 2. 空指针异常：NullPointerException其二、代码为：
java
package com.atguigu.java;
public class ArrayExceptionTest {
public static void main(String[] args) {
//1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion(即：数组角标不在指定的范围内，就称为数组角标越界的异常)
int[] arr = new int[]{1,2,3,4,5};
// for(int i = 0;i <= arr.length;i++){
// System.out.println(arr[i]);//ArrayIndexOutOfBoundsExcetion，原因：i <= arr.length 出错，角标 5 越界;
// }
// System.out.println(arr[-2]);//ArrayIndexOutOfBoundsExcetion，原因：角标 -2 越界;
// System.out.println("hello");//前面出现异常，程序运行就终止，因此此时的 'hello' 是不能打印出来的;
//2. 空指针异常：NullPointerException
//情况一：
// int[] arr1 = new int[]{1,2,3};
// arr1 = null;
// System.out.println(arr1[0]);//NullPointerException, 原因：arr1 数组值为 null, 因此输出 arr1[0] 值就报错: 空指针异常;
//因为：arr1 = null; 操作就将 arr1 的地址值换成了 null, 此时的地址指针就没有了，因此想要找到 arr1[0] 就报空指针异常;
//情况二：
// int[][] arr2 = new int[4][];
// System.out.println(arr2[0]);//null
// System.out.println(arr2[0][0]);//NullPointerException, 原因：arr2[0] 值为 null, 因此输出 arr2[0][0] 值就报错: 空指针异常;
//因为：arr2[0] 为 null; 此时的 arr2[0] 地址指针就没有了，因此想要找到 arr2[0][0] 就报空指针异常;
//情况三：(严格上讲不算是我们讲的数组的情况)
String[] arr3 = new String[]{"AA","BB","CC"};
System.out.println(arr3[0].toString());//AA(即：将 arr3 数组的第一个元素输出)
arr3[0] = null;
System.out.println(arr3[0].toString());
//NullPointerException, 原因：arr3[0].toString() 中调用 toString() 方法的 arr3[0] 是一个对象，而该对象是 null 而不是地址指针,
//因此想要调用 toString() 方法, 就报空指针异常;
}
}其三、截图为：
Ⅳ、小结：
其一、哪里有不对或不合适的地方，还请大佬们多多指点和交流！
其二、若有转发或引用本文章内容，请注明本博客地址(直接点击下面 url 跳转) https://blog.csdn.net/weixin_43405300,创作不易，且行且珍惜！