练习题：
1.求数组中所有元素的和.
//求数组中所有元素的和.
public class ArrayEcer1 {
public static void main(String[] args) {
int[][] arr1 = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
int num =0;
for(int i = 0;i < arr1.length;i++) {
for(int j = 0; j < arr1[i].length;j++) {
num += arr1[i][j];
}
}
System.out.println(num);
}
}
2.：int[ ] x,y[ ]; 在给x,y变量赋值以后，以下选项允许通过编译的是：
提示： 一维数组：int[ ] x 或者int x[ ]
二维数组：int[ ][ ] y 或者 int[ ] y[ ] 或者 int y[ ][ ]
int[ ] x,y[ ] ;意思就是x是一维数组，而y为二维数组.
a ) x[0] = y; no y是二维数组不能给一位数组赋值
b) y[0] = x; yes 一维数组给二维数组赋值是可以的
c) y[0][0] = x; no x表示一维数组，而y[0][0]表示一个int型的数
d) x[0][0] = y; no x[0][0]写法都错了 他是一维数组
e) y[0][0] = x[0]; yes 两者都代表int型的数，可以赋值.
f) x = y; no 二维不能给一维赋值.
3.杨辉三角的打印
public class MultidimensionalArrayPractise {
public static void main(String[] args) {
// 声明并初始化二维数组
int[][] YhTriangle = new int[10][];
// 2.给数组的元素赋值
for (int i = 0; i < YhTriangle.length; i++) {
YhTriangle[i] = new int[i + 1];
//2.1给首末元素赋值
YhTriangle[i][0] = YhTriangle[i][i] = 1;
//2.2给每行的非首末元素赋值
if(i>1) {
for(int j = 1;j <YhTriangle[i].length - 1;j++) {
YhTriangle[i][j] = YhTriangle[i-1][j-1] + YhTriangle[i-1][j];
}
}
}
// 遍历二维数组
for (int i = 0; i < YhTriangle.length; i++) {
for (int j = 0; j < YhTriangle[i].length; j++) {
System.out.print(YhTriangle[i][j] + " ");
}
System.out.println();
}
}
}
数组中涉及的常见算法
1. 数组元素的赋值(杨辉三角、回形数等)
2. 求数值型数组中元素的最大值、最小值、平均数、总和等
3. 数组的复制、反转、查找(线性查找、二分法查找)
4. 数组元素的排序算法
求随机数公式
定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。
package com.acoffee.exer;
/*定义一个int型的一维数组，包含10个元素，
* 分别赋一些随机整数，然后求出所有元素的最大值，
* 最小值，和值，平均值，并输出出来。
* 要求：所有随机数都是两位数。
*/
public class AvarageNum {
public static void main(String[] args) {
//声明并初始化一个一维数组
int[] a = new int[10];
//给一位数组赋值
for(int i=0; i <10; i++) {
a[i] = (int)(Math.random()*(99-10+1)+10);
}
//遍历数组
for(int i = 0;i < a.length; i++) {
System.out.print(a[i]+"\t");
}
System.out.println();
//求数组的最大值
int maxnum = a[0];
for(int i = 0; i < a.length; i++) {
if (maxnum < a[i]) {
maxnum = a[i];
}
}
System.out.println("最大值："+maxnum);
//求数组的最小值
int minnum = a[0];
for(int i = 0; i < a.length; i++) {
if (minnum > a[i]) {
minnum = a[i];
}
}
System.out.println("最小值："+minnum);
//求数组的总和
int sum = 0;
for(int i = 0; i < a.length; i++) {
sum += a[i];
}
System.out.println("总和："+sum);
//求数组的平均值
int avaragenum = sum/a.length;
System.out.println("平均数："+avaragenum);
}
}
使用简单数组
(1)创建一个名为ArrayTest的类，在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是什么关系？ 拓展：修改题目，实现array2对array1数组的复制
/*
* 使用简单数组
(1)创建一个名为ArrayTest的类，
在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是什么关系？
拓展：修改题目，实现array2对array1数组的复制*/
package com.acoffee.exer;
public class CopyArray {
public static void main(String[] args) {
//声明并初始化arr1
int[] arr1 = new int[]{2,3,5,7,11,13,17,19};
//遍历arr1的内容
System.out.print("arr1:\t");
for(int i = 0; i < arr1.length; i++){
System.out.print(arr1[i]+"\t");
}
int[] arr2 =new int[8];
//arr2 = arr1; 这个不是赋值这个是将arr1的地址赋给arr2.
//下面写真正的赋值
System.out.print("\narr2:\t");
for(int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
System.out.print(arr2[i]+"\t");
}
System.out.println("");
System.out.print("更改之后的arr2:\t");
for(int i = 0; i < arr2.length; i++) {
if(i % 2 == 0) {
arr2[i] = i;
System.out.print(arr2[i]+"\t");
}
else {
System.out.print(arr2[i]+"\t");
}
}
}
}
复制
不规则二维数组的复制：
@Test
public void test4(){
int[][] arr1 = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
int[][] arr2 = new int[arr1.length][];
arr2[0] = new int[3];
arr2[1] = new int[2];
arr2[2] = new int[4];
for (int i = 0; i < arr1.length; i++) {
for (int j = 0;j < arr1[i].length; j++){
arr2[i][j] = arr1[i][j];
}
}
System.out.println(arr1);
System.out.println(arr2);
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[i].length;j++){
System.out.print(arr2[i][j]+"\t");
}
}
}
反转：
一个数组反转个另外一个数组
自身反转：
一个数组反转个另外一个数组
自身反转：
查找
public class Seek {
public static void main(String[] args) {
String[] arr =new String[] {"AA","BB","CC","DD","EE","GG"};
//查找
//线性查找
String dest = "BB";
dest = "CC";
boolean isFlag = true;
for(int i = 0;i < arr.length; i++) {
if(dest.equals(arr[i])) {
System.out.println("找到了，位置是："+ i);
isFlag = false;
break;
}
}
if(isFlag) {
System.out.println("很遗憾，没有找到指定元素.");
}
//二分法查找(所查找的必须有序)
int[] Array = new int[] {-100,-22,-11,-2,-1,0,1,2,3,444,566};
int dest1 = -2;
int head = 0;
int end = Array.length - 1;
boolean Flag = true;
while(end > head) {
int mid = (head + end)/2;
if(dest1 == Array[mid]){
System.out.println("找到了指定的元素，位置是："+mid);
Flag = false;
break;
}else if(dest1 > Array[mid]){
head = mid + 1;
}else{
end = mid - 1;
}
}
if(Flag) {
System.out.println("很遗憾没有找到");
}
}
}
数组中涉及到的常见算法：排序算法
排序：假设含有n个记录的序列为{R1，R2，…,Rn},其相应的关键字序列为 {K1，K2，…,Kn}。将这些记录重新排序为{Ri1,Ri2,…,Rin},使得相应的关键 字值满足条Ki1<=Ki2<=…<=Kin,这样的一种操作称为排序。 通常来说，排序的目的是快速查找。
衡量排序算法的优劣：
1.时间复杂度：分析关键字的比较次数和记录的移动次数
2.空间复杂度：分析排序算法中需要多少辅助内存
3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保 持不变，则称这种排序算法是稳定的。
冒泡排序：
package com.acoffee.exer;
public class Bubble {
public static void main(String[] args) {
int[] arr = new int[] {11,-11,-22,-88,32,59,965,25,224};
//冒泡排序
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 + 1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
for(int i = 0;i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
}
}
快速排序：
Arrays工具类的使用
import java.util.Arrays;
/*
* 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);
//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//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);
if(index >= 0){
System.out.println(index);
}else{
System.out.println("未找到");
}
}
}
数组中的常见异常
/*
* 1.数组角标越界的异常：
* ArrayIdexOutOfBoundsExcetion
*
* 2.空指针异常：
*NullPointerException
*
* */
public class ArrayException {
public static void main(String[] args) {
//1.数组角标越界的异常：ArrayIdexOutOfBoundsExcetion
int[] arr =new int[] {1,2,3,4,5};
// for(int i = 0; i <= arr.length;i++) {//不能等于等于就取到5了.
// System.out.println(arr[i]); //所以就越界了.
// }
//System.out.println(arr[-2]);出现异常就不会往下执行了.
//2.空指针异常：NullPointerException
//情况一:
//int[] arr1 = new int[] {1,2,3};
//arr1 = null;
//System.out.println(arr1[0]);
//情况二：
int[][] arr2 = new int[5][];//空指针
System.out.println(arr2[0][0]);
int[][] arr3 = new int[0][];//越界
System.out.println(arr2[0][0]);
//情况三:
String[] arr4 = new String[] {"AA","BB","CC"};
arr4[0] = null;
System.out.println(arr4[0].toString());//空指针
}
}
每日一练：
1.使用冒泡排序，实现如下的数组从小到大排序。
int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
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;
}
}
}
快排时间复杂度：O(nlogn)
冒泡时间复杂度：O(n^2)
堆排序、归并排序
2.如何反转上面的数组。请代码实现
略
3. 复制上述数组，得到一个新的数组
vs 赋值操作
array2 = array1;
int[] arr1 = new int[arr.length];
for(;;)...
4. 使用线性查找，从上述数组中查找22是否存在。存在，返回所在位置的索引。不存在，输出提示信息。
int dest = 22;
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
if(dest == arr[i]){
sysout(i);
isFlag = false;
break;
}
}
if(isFlag){
sysout("未找到");
}
或
int dest = 22;
for(int i = 0;i < arr.length;i++){
if(dest == arr[i]){
sysout(i);
break;
}
}
if(i == arr.length){
sysout("未找到");
}
5. 数组中常见的异常有哪些？请举例说明
ArrayIndexOutOfBoundsException:数组角标越界异常：
合理范围：[0,arr.length -1]
越界：arr[-1],arr[arr.length]
NullPointerException:空指针异常
int[] arr = null;
arr[0];
368
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
