数组的定义
- 数组是相同类型数据的有序集合
- 数组描述相同类型的若干个数据,按照一定先后次序排列组合而成
- 每一个数据称作一个数组元素,每个数组元素可以通过下标来访问它们,下标由0开始计算
数组的声明和创建
-
首先表明数组的变量,才能在程序中使用数组声明变量的语法为
int[] nums; //首选方法 int nums[];//效果相同,但不是首选方法
-
java语言用new操作符来创建数组,语法如下
int[] nums=new int[]
-
数组的元素是通过索引来访问的,数组索引从0开始
-
获取数组的长度用:数组名.length
package com.YouHaoXin.array;
public class ArrayDemo01 {
public static void main(String[] args) {
int[] nums;//1.声明一个数组
nums=new int[10];//2.创建一个数组
//int[] nums=new int[10];声明与创建也可以写在一起
nums[0]=1;//3.给数组赋值
nums[1]=10;
nums[2]=100;
nums[3]=1000;
nums[4]=10000;
nums[5]=2;
nums[6]=20;
nums[7]=200;
nums[8]=2000;
nums[9]=20000;
System.out.println(nums[1]);//10
//计算整个数组的和
int sun=0;
for (int i = 0; i < nums.length; i++) {
//nums.length 是表示数组的长度
sun=sun+nums[i];//计算整个数组的和
}System.out.println("总和为:"+sun);//输出 总和为:33333
System.out.println("=============================");
char[] nums1=new char[10];
nums1[0]='A';
nums1[1]='B';
nums1[2]='C';
nums1[3]='D';
nums1[4]='E';
nums1[5]='F';
nums1[6]='G';
nums1[7]='H';
nums1[8]='I';
nums1[9]='J';
System.out.println(nums1[9]);//J
}
}
内存分析
- 声明数组是,声明的类型存在于栈中
- 创建数组是,声明的类型会在堆中开辟一个空间,存放数组
- 给数组元素赋值
数组的三种初始化
-
静态初始化
//语法为:int[] a={1,2,3}; //静态初始化:创建+赋值 int[] arrayNums={1,2,3,4,5,6}; for (int i = 0; i < 6; i++) { System.out.print(arrayNums[i]+"\t"); } System.out.println();
-
动态初始化
/*语法为:int[] a=new int[2]; a[0]=1; a[1]=2; */
-
默认初始化
- 数组为引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式隐式初始化
//动态初始化:包含默认初始化,若不给数组赋值,就会输出默认值
int[] arrayNums1=new int[5];
arrayNums1[0]=10;
arrayNums1[1]=100;
arrayNums1[2]=1000;
arrayNums1[3]=10000;
arrayNums1[4]=100000;
for (int i = 0; i < 5; i++) {
System.out.print(arrayNums1[i]+"\t");//10 100 1000 10000 100000
}
数组的四个基本特点
- 其长度是确定的,数组一旦创建,他的大小就是不可改变的
- 其元素必须是相同的类型,不允许出现混合类型。
- 数组的元素可以是任何类型,包括基本类型和引用类型
- 数组的变量属于引用类型,也可看成对象,数组对象本身就是存放在堆中的。
数组的结果
- 下标的合法区间为:[0.length-1],如果越界就会报错。
- ArrayIndexOutOfBoundsException:表示数组下标越界异常
数组结构的注意点
- 数组是相同数据类型(可以是任意类型)的有序集合
- 数组也是对象,数组的元素相当于对象的成员
- 数组的长度是确定的,不可变的,如果越界,就会报错
数组的使用
-
普通For循环
package com.YouHaoXin.array; public class ArrayDemo03 { public static void main(String[] args) { //普通For循环的使用 int[] arrays={10,20,30,40,50,60}; //打印所有的数组元素 for (int i = 0; i <arrays.length; i++) { System.out.print(arrays[i]+"\t"); } System.out.println(); //计算所有元素的总和 int sun=0; for (int i = 0; i <arrays.length; i++) { sun=sun+arrays[i]; } System.out.println("sun="+sun); //查找数组中的最大元素 int result=arrays[0]; for (int i = 1; i < arrays.length; i++) { if (result<arrays[i]){ result=arrays[i]; } } System.out.println("max="+result); } }
-
增强For循环的使用
int[] arrays = {10, 20, 30, 40, 50, 60}; //增强for循环的使用 for (int array : arrays) { System.out.print(array+"\t");//10 20 30 40 50 60 }
-
数组做方法入参
public static void main(String[] args) { int[] arrays = {10, 20, 30, 40, 50, 60}; printArray(arrays);//10 20 30 40 50 60 System.out.println(); System.out.println("sun="+sunArray(arrays));//sun=210 } //数组作为方法入参 //打印数组的所有元素 public static void printArray(int[] arrays){ for (int i = 0; i <arrays.length ; i++) { System.out.print(arrays[i]+"\t"); } } //计算所有元素的总和 public static int sunArray(int[] arrays){ int sun=0; for (int i = 0; i <arrays.length; i++) { sun=sun+arrays[i]; }return sun; }
-
数组做返回值
public static void main(String[] args) { int[] arrays = {10, 20, 30, 40, 50, 60}; int[] i = reverse(arrays); printArray(i);//60 50 40 30 20 10 } //数组作为返回值 //反转数组元素 public static int[] reverse(int[] arrays){ int[] result=new int[arrays.length]; for (int i = 0,j=arrays.length-1; i <arrays.length ; i++,j--) { result[j]=arrays[i]; }return result; }
二维数组
-
二维数组可以看成一个一维数组中嵌套了另外一个一维数组
package com.YouHaoXin.array; public class ArrayDemo05 { public static void main(String[] args) { //二维数组 /* 以下表示的为一个4行2列的数组 1,2 arrays[0][0],arrays[0][1] 3,4 arrays[1][0],arrays[1][1] 5,6 arrays[2][0],arrays[2][1] 7,8 arrays[3][0],arrays[3][1] */ int[][] arrays={{1,2},{3,4,},{5,6},{7,8}}; System.out.println(arrays[2][1]);//6 for (int i = 0; i <arrays.length ; i++) { for (int j = 0; j <arrays[i].length ; j++) { System.out.print(arrays[i][j]+"\t");//12 34 56 78 } } } }
package com.YouHaoXin.sort;
import java.util.Scanner;
public class SortDemo01 {
public static void main(String[] args) {
//二维数组使用示例1:计算二维数组中总和
int[][] arrays = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};
int sun = 0;
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
sun = sun + arrays[i][j];
}
}
System.out.println("sun=" + sun + "万元");
System.out.println("==========================");
/*二维数组使用示例2:打印一个杨辉三角形
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
*/
Scanner scanner = new Scanner(System.in);
System.out.println("请输入行数");
int count = scanner.nextInt();
int[][] arrays1 = new int[count][count];
for (int i = 0; i <arrays1.length ; i++) {
arrays1[i][0] = 1;
arrays1[i][i] = 1;
}
for (int i = 2; i < arrays1.length; i++) {
for (int j = 1; j <= i; j++) {
arrays1[i][j] = arrays1[i - 1][j - 1] + arrays1[i - 1][j];
}
}
for (int i = 0; i < arrays1.length; i++) {
for (int j = 0; j <= i; j++) {
System.out.print(arrays1[i][j]+"\t");
}
System.out.println();
}
数组工具类:Arrays类
-
由于数组对象本身并没有什么方法供我们使用,从而可以对数据对象进行一些基本操作,在API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本操作,我们从JDK帮助文档中也可以找到这个类
-
Arrays类中的方法都是Static修饰的静态方法,我们可以直接使用类名调用
package com.YouHaoXin.array; import java.util.Arrays; public class ArrayDemo06 { public static void main(String[] args) { //Arrays类的一些方法 int[] a={5,7455,45,458,54,81,35,157}; int[] b={5, 2, 2, 2, 2, 157, 458, 7455}; //打印所有元素:Arrays,toString System.out.println(Arrays.toString(a));//[5, 7455, 45, 458, 54, 81, 35, 157] array(a);//[5, 7455, 45, 458, 54, 81, 35, 157] System.out.println(); //对数组进行排序:Arrays.sort Arrays.sort(a);//升序排序 System.out.println(Arrays.toString(a));//[5, 35, 45, 54, 81, 157, 458, 7455] //对排序好的数组进行进行二分查找法操作:Arrays.binarySearch System.out.println( Arrays.binarySearch(a,1,6,55));//-5 //对数组的数字进行填充:Arrays.fill Arrays.fill(a,1,5,2); System.out.println(Arrays.toString(a));//[5, 2, 2, 2, 2, 157, 458, 7455] //比较两个数组是否相等:Arrays.equals System.out.println(Arrays.equals(a,b));//true } public static void array (int[] a){ for (int i = 0; i < a.length; i++) { if (i==0){ System.out.print("["); } if (i==a.length-1){ System.out.print(a[i]+"]"); }else{ System.out.print(a[i]+", "); } } } }
二分查找法
1.二分查找法是,通过最大索引值、最小索引值及中间索引值三方与输入值进行比较,来进行查找。
2.使用二分查找法,数组必须是排序的数组且不能有相同的数字。
package com.YouHaoXin.sort;
import java.util.Arrays;
public class SortDome03 {
public static void main(String[] args) {
//二分查找法
int[] arrays={1,20,54,5,51,81,26,95};
Arrays.sort(arrays);//使用二分查找法前,需将数组进行排序,只有排序好的数组才能使用二分查找法
System.out.println(Arrays.toString(arrays));//[1, 5, 20, 26, 51, 54, 81, 95]
int search = search(arrays,26);
System.out.println(search);//7
}
public static int search (int[] arrays,int count){
int max=arrays.length-1;//定义一个最大索引
int min=0;//定义一个最小索引
for (int i = (max+min)/2; i <arrays.length && min<=max; i=(max+min)/2) {
if (count == arrays[i]){
return i;//当输入值为中间值是,直接返回值
} else if(count<arrays[(max+min)/2]){
max=(max+min)/2-1;//若输入值小于中间的索引值,则移动最大值
}else if(count>arrays[(max+min)/2]){
min=(max+min)/2+1;//若输入值大于中间的索引值,则移动最小值
}
//通过循环系统,循环比较,得出结果
}
return -1;//若输入值不为数组中的值,则直接返回-1;
}
}
稀疏数组
- 当一个数组中大部分为0,或者为同一值的数组是,可以用稀疏数组来保存该数据
- 稀疏数组的处理方式
- 记录数组一共有几行及列,有多少个不同值
- 把具有不同值的元素的行、列及值记录在一个小规模的数组中,从而压缩程序的规模
package com.YouHaoXin.array;
import java.util.Arrays;
public class ArrayDemo08 {
public static void main(String[] args) {
//示例1
int[][] arrays1=new int[11][11];
arrays1[1][2]=1;
arrays1[2][3]=2;
System.out.println("输出原始的数组");
/*
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
*/
//打印原始数组
for (int[] a:arrays1) {
for (int b: a
) {
System.out.print(b+"\t");
}
System.out.println();
}
System.out.println("=======================");
//用稀疏数组表示
//1.提取数组中的有效数字
int sun=0;
for (int i = 0; i <arrays1.length ; i++) {
for (int j = 0; j <arrays1[i].length ; j++) {
if (arrays1[i][j]!=0){
sun++;
}
}
}
System.out.println("有效值个数为:"+sun);
//2.创建一个稀疏数组
int[][] arrays2=new int[sun+1][3];
arrays2[0][0]=arrays1.length;//代表:行
arrays2[0][1]=arrays1[0].length;//代表:列
arrays2[0][2]=sun;//代表:值
//3.把有效值赋予稀疏数组
int count=0;
for (int i = 0; i <arrays1.length ; i++) {
for (int j = 0; j <arrays1[i].length ; j++) {
if (arrays1[i][j]!=0){
count++;
arrays2[count][0]=i;
arrays2[count][1]=j;
arrays2[count][2]=arrays1[i][j];
}
}
}
//4.打印稀疏数组
for (int i = 0; i <arrays2.length ; i++) {
for (int j = 0; j <arrays2[i].length; j++) {
System.out.print(arrays2[i][j]+"\t");
if (j==arrays2[i].length-1){
System.out.println();
/*
11 11 2
1 2 1
2 3 2
*/
}
}
}
System.out.println("==========================");
//还原稀疏数组
int[][] arrays3=new int[arrays2[0][0]][arrays2[0][1]];
for (int i = 1; i < arrays2.length; i++) {
arrays3[arrays2[i][0]][arrays2[i][1]]=arrays2[i][2];
}
System.out.println("输出还原的数组");
for (int[] a:arrays3) {
for (int b: a
) {
System.out.print(b+"\t");
}
System.out.println();
}
}
}
package com.YouHaoXin.array;
public class ArrayDemo09 {
public static void main(String[] args) {
//示例2
int[][] arrays1=new int[6][7];
arrays1[0][3]=22;
arrays1[0][6]=15;
arrays1[1][1]=11;
arrays1[1][5]=17;
arrays1[2][3]=-6;
arrays1[3][6]=39;
arrays1[4][0]=91;
arrays1[5][2]=28;
for (int[] a:arrays1
) {
for (int b:a
) {
System.out.print(b+"\t");
}
System.out.println();
/*
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 0 39
91 0 0 0 0 0 0
0 0 28 0 0 0 0
*/
}
//创建一个稀疏数组
int sun=0;
for (int i = 0; i <arrays1.length ; i++) {
for (int j = 0; j <arrays1[i].length; j++) {
if (arrays1[i][j]!=0){
sun++;
}
}
}
//定义稀疏数组的长度
System.out.println("sun="+sun);
int[][] arrays2=new int[sun+1][3];
arrays2[0][0]=arrays1.length;
arrays2[0][1]=arrays1[0].length;
arrays2[0][2]=sun;
int count=0;
for (int i = 0; i < arrays1.length; i++) {
for (int j = 0; j <arrays1[i].length ; j++) {
if (arrays1[i][j]!=0){
count++;
arrays2[count][0]=i;
arrays2[count][1]=j;
arrays2[count][2]=arrays1[i][j];
}
}
}
//打印稀疏数组
for (int[] a:arrays2
) {
for (int b:a
) {
System.out.print(b+"\t");
}
System.out.println();
/*
6 7 8
0 3 22
0 6 15
1 1 11
1 5 17
2 3 -6
3 6 39
4 0 91
5 2 28
*/
}
//还原稀疏数组
int[][] arrays3=new int[arrays2[0][1]][arrays2[0][1]];
for (int i = 1; i <arrays2.length ; i++) {
for (int j = 0; j <arrays2[i].length ; j++) {
arrays3[arrays2[i][0]][arrays2[i][1]]=arrays2[i][2];
}
}
for (int[] a:arrays3
) {
for (int b:a
) {
System.out.print(b+"\t");
}
System.out.println();
}
}
}