数组
第1章 数组
3.1数组的概述
1.数组的理解
- 数组(Array),是多个相同类型数据按一定顺序排列的集合,并使用同一个名字命名,并通过编号的方式对这些数据进行统一管理.
2.数组常见的概念
-
数组名
-
下表(或索引)
-
元素
-
数组的长度
3.数组的特点
- 数组本身是引用数据类型,而数组中的元素可以使任何数据类型,包括基本数据类型和引用数据类型
- 创建数组对象会在内存中开辟一块连续的空间,而数组名引用的是这块连续空间的首地址
- 数组的长度一旦确定,就不能修改
- 我们可以直接通过下表(或索引)的方式吊应指定位置的元素,速度很快
4数组的分类
- 按照维度:一维数组,二维数组,三维数组...
- 按照元素的数据类型分:基本数据类型元素的数组,引用数据类型元素的数组(即对象数组)
3.2一维数组的使用
1.一维数组的声明和初始化
int num;//整数类型声明
num = 10;//初始化
int id = 1001;//声明+初始化
int[] ids;//声明
//1.1静态初始化:数组的初始化和数组元素的初始化同时进行
ids = new int[]{1001,1002,1003,1004}
//1.2动态初始化:数组的初始化和数组元素的初始化分开进行
String[] names = new String[5];
//错误的写法:
//int[] arr1= new int[];
//int[5] arr1= new int[5];
//int[] arr1= new int[3]{1,2,3};
//也是正确的写法(不建议使用)
String names[] = new String[5];
int[] arr4 = {1,2,3,4,5};//类型推断,省略new int[]
//总结:数组一旦初始化完成,其长度就确定了.
2.如何调用数组的指定位置的元素
//通过角标的方式调用
//数组的角标(或索引)从0开始,倒数租的长度-1结束
names[0] = "王";
names[1] = "王";
names[2] = "张";
names[3] = "孙";
names[4] = "王";//charAt(0)
//names[5] = "周";
3. 如何获取数组的长度
//属性:length
System.out.println(names.length)//5
System.out.println(ids.length)
4. 如何遍历数组的长度
/*
System.out.println(names[0]);
System.out.println(names[1]);
System.out.println(names[2]);
System.out.println(names[3]);
System.out.println(names[4]);
*/
//循环遍历数组
for(int i = 0; i < names.length;i++){
System.out.println(names[i]);
}
5. 数组元素的默认初始化值
- 数组元素是整型:0
- 数组元素是浮点型:0.0
- 数组元素是字符型:\u0000
- 数组元素是布尔型:false
- 数组元素是对象(引用数据类型):null
int[] arr = new int[4];
for(itn i = 0;i < arr.length;i++){
System.out.println(arr[i]);//0
}
System.out.println("*********");
short[] arr1 = new short[4];
for(itn i = 0;i < arr1.length;i++){
System.out.println(arr1[i]);//0
}
System.out.println("*********");
float[] arr2 = new float[4];
for(itn i = 0;i < arr2.length;i++){
System.out.println(ar2r[i]);//0
}
System.out.println("*********");
char[] arr3 = new char[4];
for(itn i = 0;i < arr3.length;i++){
System.out.println(arr3[i]);//0
}
System.out.println("*********");
6. 数组的内存解析
3.3多维数组的使用
1.理解
对于二维数组的理解,我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在.骑士,从数组底层的运行机制来看,其实没有多维数组.
2.二维数组的使用
1.二维数组的声明和初始化
int[] arr = new int[]{1,2,3};//一维数组的静态初始化
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
Stringp[][] arr2 = new String[3][2];
//动态初始化2
Stringp[][] arr3 = new String[3][];
//错误的情况
//String[][] arr4 = new String[][4];
//String[4][3] arr5 = new String[][];
//int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
//也是正确的写法(不建议使用)
String[] arr4[] = new String[3][2];
String arr5[][] = new String[3][2];
int[][] arr6 = {{1,2,3},{4,5},{6,7,8}};//;类型推断
2.如何调用数组的指定位置的元素
System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//null
arr3[1] = new String[4];
System.out.println(arr3[0][1]);//null
3.如何获取数组的长度
System.out.println(arr6.length);//3
System.out.println(arr6[0].length);//3
System.out.println(arr6[1].length);//2
4.如何遍历数组
for(int i = 0;i < arr6.length;i++){
for(int j = ; j <arr6[i].length;j++){
System.out.println(arr6[i][j] + " ");
}
}
5.数组元素的默认初始化值
规定:二维数组分为外层数组的元素,内层数组的元素
//针对初始化方式一:比如:int[][] arr = new int[4][3];
// 外层元素的初始化值为:地址值
// 内层元素的初始化值为:与一维数组初始化情况相同
//针对初始化方式二:比如:int[][] arr = new int[4][];
// 外层元素的初始化值为:null
// 内层元素的初始化值为:不能调用,否则报错
itn[][] arr = new int[4][3];
System.out.println(arr[0]);//[I@15db9742,表示一维整型地址
System.out.println(arr[0][0]);//0
//System.out.println(arr);//[[I@6d06d69c,表示二维整型地址
System.out.println("*********");
float[][] arr1 = new float[4][3];
System.out.println(arr1[0]);//[F@6d06d69c,表示一维float型地址,将上一句注释掉,发现分配的内存地址一样
System.out.println(arr1[0][0]);//0.0
System.out.println("*********");
String[][] arr2 = new String[4][2];
System.out.println(arr2[1]);//[Ljava.lang.String;@7852e922,表示一维String型地址
System.out.println(arr2[1][1]);//null,空地址
System.out.println("*********");
double[][] arr3 = new double[4][];
System.out.println(arr3[1]);//null,空地址
System.out.println(arr3[1][0]);//报错,NullPointerException,空指针异常
6.二维数组的内存解析
3.4数组中涉及的常见算法
1.数组元素的复制(杨辉三角,回形数等)
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++) {
//2.1 给二维数组的内围数组初始化
yanghui[i] = new int[i + 1];
//2.2 给首尾元素赋值
yanghui[i][0] = yanghui[i][i] = 1;
for(int j = 1; j < yanghui[i].length - 1; j++) {
//2.3 给非首尾元素赋值
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] + "\t");
}
System.out.println();
}
}
}
package com.atguigu.exer;
/*
*拓展
*创建一个长度为6的int型数组,要求数组元素的值都在1-30之间,且是随机赋值.
*同时,要求元素的值各不相同.
*/
public class ArrayExr {
public static void main(String[] args) {
//1 声明并初始化数组
int[] arr = new int[6];
//2 给数组元素赋值
for(int i = 0;i < arr.length;i++){
//2.1 随机生成[1,30)的数并赋值
arr[i] = (int) (Math.random() * 29 + 1);
//2.2循环比较生成的数是否已存在
for(int j = 0;j < i;j++){
//若存在
if(arr[i] == arr[j]){
i--;//数组下标(索引)回退,减一
break;//跳出循环
}
}
}
//3 遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i] + "\t");
}
}
}
package com.atguigu.exer;
import java.util.Scanner;
/*
* 此题了解！！！
*
* 回形数格式方阵的实现
* 从键盘输入一个整数（1~20）
* 则以该数字为矩阵的大小，把 1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2
* 4 3
* 输入数字 3，则程序输出：1 2 3
* 8 9 4
* 7 6 5
* 输入数字 4， 则程序输出：
* 1 2 3 4
* 12 13 14 5
* 11 16 15 6
* 10 9 8 7
*/
public class Huixing {
/**
* @param args
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个数字:");
int len = scanner.nextInt();
int[][] arr = new int[len][len];
int s = len * len;
/*
* k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
*/
int k = 1;
int i = 0, j = 0;
for (int m = 1; m <= s; m++) {
if (k == 1) {
if (j < len && arr[i][j] == 0) {
arr[i][j++] = m;
} else {
k = 2;
i++;
j--;
m--;
}
} else if (k == 2) {
if (i < len && arr[i][j] == 0) {
arr[i++][j] = m;
} else {
k = 3;
i--;
j--;
m--;
}
} else if (k == 3) {
if (j >= 0 && arr[i][j] == 0) {
arr[i][j--] = m;
} else {
k = 4;
i--;
j++;
m--;
}
} else if (k == 4) {
if (i >= 0 && arr[i][j] == 0) {
arr[i--][j] = m;
} else {
k = 1;
i++;
j++;
m--;
}
}
}
// 遍历
for (int m = 0; m < arr.length; m++) {
for (int n = 0; n < arr[m].length; n++) {
System.out.print(arr[m][n] + "\t");
}
System.out.println();
}
}
}
2.求数值型数组中元素的最大值,最小值,平均数,总和等
package com.atguigu.exer;
import java.util.Arrays;
public class ArraysTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = (int) (Math.random()*90 + 10);
}
System.out.println(Arrays.toString(arr));
System.out.println("*******************");
//求数组元素最大值
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);
//求数组元素的总和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println("元素总和:" + sum);
//求数组元素的平均值
int average = sum / arr.length;
System.out.println("元素平均值:" + average);
}
}
3.数组的复制,反转,查找(线性查找,二分法查找)
package com.atguigu.exer;
import java.util.Arrays;
/*
*数组的复制
*/
public class ArraysTest2 {
public static void main(String[] args) {
int[] arr1 = new int[]{2,3,5,7,11,13,17,19};
int[] arr2;
//打印arr1的元素
System.out.println(Arrays.toString(arr1));
//复制
arr2 = arr1;//不是真正的复制
// //复制
// arr2 = new int[arr1.length];//是真正的复制
// for(int i =0;i < arr2.length;i++){
// arr2[i] = arr1[i];
// }
//修改arr2的值
for(int i = 0;i < arr2.length;i++){
if(arr2[i] % 2 == 0){
arr2[i] = i;
}
}
//打印arr1的元素
System.out.println(Arrays.toString(arr1));
}
}
package com.atguigu.exer;
import java.util.Arrays;
import javax.xml.transform.Templates;
/*
* 数组的反转
*/
public class ArraysTest3 {
public static void main(String[] args) {
String[] arr = new String[]{"AA","BB","CC","DD","EE"};
System.out.println(Arrays.toString(arr));
//反转
//方法一
// for(int i = 0; i < arr.length / 2;i++){
// String temp = arr[i];
// arr[i] = arr[arr.length - 1 - i];
// arr[arr.length - 1 - i] = temp;
// }
//方法二
for(int i = 0,j = arr.length - 1;i < j;i++,j--){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
System.out.println(Arrays.toString(arr));
}
}
package com.atguigu.exer;
import java.util.Arrays;
import javax.print.attribute.standard.Destination;
/**
* 数组的线性查找
* @author Administrator
*
*/
public class ArraysTest {
public static void main(String[] args) {
int[] arr = new int[100];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random()*90 + 10);
}
System.out.println(Arrays.toString(arr));
int dest = 20;
boolean flag = false;
for (int i = 0; i < arr.length; i++) {
if(arr[i] == dest){
System.out.println("找到指定元素,索引为" + i);
flag = true;
}
}
if(!flag){
System.out.println("很遗憾,没有找到指定元素");
}
}
}
package com.atguigu.exer;
import java.awt.HeadlessException;
import javax.print.attribute.standard.Destination;
/**
* 数组的二分查找法
* @author Administrator
*
*/
public class BinarSearchMethod {
public static void main(String[] args) {
int[] arr = new int[]{-42,-12,-4,0,12,45,56,77};
int dest = 13;
int head = 0;
int end = arr.length - 1;
while(head <= end){
int mid = (head + end) / 2;
if(arr[mid] == dest){
System.out.println("找到指定元素,位置为:" + mid);
break;
}else if(arr[mid] > dest){
end = mid - 1;
}else{
head = mid + 1;
}
}
if(head > end){
System.out.println("很遗憾,没有找到指定元素");
}
}
}
4.数组元素的排序算法
3.5Arrays工具类的使用
| 序号 | 方法名 | 描述 |
|---|---|---|
| 1 | boolean equals(int[] a,int[] b) | 判断两个数组是否相等 |
| 2 | String to String(int[] a) | 输出数组信息 |
| 3 | void fill(int[] a,int[] val) | 将指定值填充到数组之中 |
| 4 | void sort(int[] a) | 对数组进行排序 |
| 5 | int binary Search(int[] a,int key) | 对排序后的数组进行二分法检索指定的值 |
package com.atguigu.exer;
import java.util.Arrays;
public class ArrayTest {
public static void main(String[] args) {
//1.boolean equals(int[] a,int[] b)
int[] arr1 = new int[]{1,2,3};
int[] arr2 = new int[]{1,3,2};
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[]{4,23,56,346,444,555};
int index = Arrays.binarySearch(arr3,23);
System.out.println(index);//1
}
}
3.6数组中常见的异常
1.数组角标越界的异常:ArrayIndexOutOfBoundsException
int[] a = new int[]{1,2,3};
//越界访问例子
//a[-1];
//a[a.length];
2.空指针异常:NullPointerException
int[][] b = new int[4][];
//空指针异常例子
//b[0][0];
浙公网安备 33010602011771号