所谓数组,是有序的元素序列。
若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中,为了处理方便,把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。
数组是用于储存多个相同类型数据的集合。
Java中的数组
案例引入
如何存储100名学生的成绩?
办法:使用变量存储,重复声明100个double类型变量即可
缺点:麻烦,重复操作过多
如何让100名学生成绩全部+1?
办法:100个变量重复相同操作,直至全部完毕
缺点:无法进行统一的操作
1.数组的概念
- 概念:数组是一组连续的存储空间,存储多个相同数据类型的值
- 特点:类型相同;长度固定。
2.数组的创建
public class *{
public static void main(String[] args) {
int[] a; //声明int数组类型变量,定义变量名为a
a= new int[5]; //分配长度为5的连续空间
}
}
3.数组的使用
- 数组中的每个数据格被称为“数组元素”;
- 对每个元素进行赋值或取值的操作被称为“元素的访问”;
- 访问元素时,需要使用"下标"(从0开始,依次+1,自动生成);
- 访问数组的语法:数组名[下标]; //例如 存:a[0]=10; 取:a[0];
4.数组的声明与赋值
public class shuzu1{
public static void main(String[] args) {
//创建数组
int[] a= new int[5];
//依次给数组内元素赋值
a[0]= 5;
a[1]= 4;
a[2]= 3;
a[3]= 4;
a[4]= 5;
//依次取值
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
System.out.println(a[4]);
}
}
5.数组的下标
- 有效下标范围:0 ~ 数组长度-1
- 访问无效下标,会导致数组下标越界
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:
6.数组的遍历
- 概念:从头到尾,逐一对每个元素进行访问。
public class shuzu1{
public static void main(String[] args) {
//遍历数组
int[] a= new int[5];
a[0]= 5;
a[1]= 4;
a[2]= 3;
a[3]= 4;
a[4]= 5;
for (int i = 0;i<a.length;i++){ //数组名.length动态获取数组的长度
System.out.println(a[i]); //使用循环变量"i"充当下标,逐一访问数组中的每个元素
}
}
}
7.数组的默认值
public class shuzu1{
public static void main(String[] args) {
int[] a= new int[5];
for (int i = 0;i<a.length;i++){
System.out.println(a[i]); //在没有为数组元素赋值的情况下,依旧可以正确访问
}
}
}
数组类型 | 默认值 |
---|---|
整数 int | 0 |
小数 float | 0.0 |
布尔 boolean | false |
字符型 char | \u0000 (空格) |
字符串 string | null |
其他 | null |
8.数组创建语法
8.1先声明,再分配空间
数据类型[] 数组名;
数组名 = new 数据类型[长度];
8.2声明并分配空间
数据类型[] 数组名 = new 数据类型[长度];
8.3声明并赋值(繁)
数据类型[] 数组名 = new 数据类型[]{value1,ualue2,...}; //显式初始化
8.4声明并赋值(简)
数据类型[] 数组名 = {value1,ualue2,...}; //显式初始化,不可换行
//正确语法1
int[] a = {3,5,7,8,4}; //ok
//正确语法2
int[] a;
a = new int[]{3,5,7,8,4}; //ok
//错误语法1
int[] a = new int[5]{3,5,7,8,4}; //error
//错误语法2
int[] a;
a = {3,5,7,8,4}; //error
9.可变长参数
- 概念:可接收多个同类型实参,个数不限,使用方式与数组相同
- 语法:
数据类型... 形参名 //必须定义在形参列表的最后,且只能有一个
//案例
public class shuzu1 {
public static void main(String[] args) {
printArray(111,222,333,444,555); //可为可变长参数赋予0~n个实际参数
}
public static void printAreay(int... oneArray){ //定义int型可变长参数
for(int i = 0;i< oneArray.length;i++){
System.out.println(oneArray [i]);
}
}
}
10.数组的操作
10.1 数组的扩容
- 创建数组时,必须显示指定长度,并再创建之后不可更改长度;
- 扩容的思路: 创建大于原数组长度的新数组; 将原数组中的元素依次复制到新数组中;
10.2复制的方法
- 循环将原数组中的所有元素逐一赋值给新数组;
public class TestCopyArray{
public static void main(String[] args){
int[] oldArray = new int[]{1,2,3,4,5}; //数组创建后,长度不可变
//1.创建比原数组大的新数组
int[] newArray = new int[oldArray.length * 2];
//2.复制原数组中的所有元素到新数组
for(int i = 0;i < oldArray.length;i++){
newArray[i] = oldArray[i];
}
//打印原数组
for(int i = 0;i < oldArray.length;i++){
System.out.print(oldArray[i] +" ");
}
System.out.println();
//遍历新数组
for(int i = 0;i < newArray.length;i++){
System.out.print(newArray[i] +" ");
}
}
}
- System.arraycopy(原数组 , 原数组起始 , 新数组 , 新数组起始 , 长度);
public class TestCopyArray2{
public static void main(String[] args){
int[] oldArray = new int[]{1,2,3,4,5}; //数组创建后,长度不可变
//1.创建比原数组大的新数组
int[] newArray = new int[oldArray.length * 2];
//2.复制原数组中的所有元素到新数组
//System.arraycopy(原数组 , 原数组起始 , 新数组 , 新数组起始 , 长度);
System.arraycopy(oldArray,0,newArray,0, oldArray.length);
//打印原数组
for(int i = 0;i < oldArray.length;i++){
System.out.print(oldArray[i] +" ");
}
System.out.println();
//遍历新数组
for(int i = 0;i < newArray.length;i++){
System.out.print(newArray[i] +" ");
}
}
}
- java.util.Array.copyOf(原数组 , 新长度); //返回带有原值的新数组
public class TestCopyArray3{
public static void main(String[] args){
int[] oldArray = new int[]{1,2,3,4,5}; //数组创建后,长度不可变
//1.创建比原数组大的新数组
int[] newArray = new int[oldArray.length * 2];
//2.复制原数组中的所有元素到新数组
//新数组名 = java.util.Arrays.copyOf(原数组,新长度);
newArray = java.util.Arrays.copyOf(oldArray , oldArray.length * 2);
//打印原数组
for(int i = 0;i < oldArray.length;i++){
System.out.print(oldArray[i] +" ");
}
System.out.println();
//遍历新数组
for(int i = 0;i < newArray.length;i++){
System.out.print(newArray[i] +" ");
}
}
}
11.数组的排序
11.1 冒泡排序
- 相邻的两个数组比较大小,互换位置
- 记忆:外层循环:nums.length-1 内层循环:nums.length-i-1
public class TestBubble{
public static void main(String[] args){
int[] nums = {1,5,9,8,6};
printArray(nums);
//冒泡排序:相邻的两个数值比较大小,互换位置
//轮次:数组长度 - 1
//单论次数:逐级递减(数组长度-1的基础上再做逐级递减)
for(int i = 0;i < nums.length - 1;i++){//外层循环:控制比较轮次(nums.length-1),比较4次
for(int j = 0;j < nums.length - i - 1;j++){//内层循环:控制单轮次数(nums.length-i-1),比较4、3、2、1次
if(nums[j] > nums[j+1]){
int temp = nums[j];
nums [j] = nums[j+1];
nums [j+1] = temp;
}
}
}
printArray(nums);
}
public static void printArray(int[] nums){
for(int i = 0;i < nums.length;i++){
System.out.print(nums[i] +"\t");
}
System.out.println();
}
}
11.2 选择排序
- 固定值与其它值依次比较大小,互换位置
- 记忆:外层length-1 同时外层i作为固定值,内层的j=i+1作为其它值的起始
public class TestSelect{
public static void main(String[] args){
int[] nums = {5,7,9,1,6};
printArray(nums);
//选择排序:固定值与其它值比较大小,互换位置
for(int i = 0; i < nums.length - 1;i++){
for(int j = i + 1 ; j < nums.length;j++){
if(nums[i] > nums[j]){
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
}
printArray(nums);
}
public static void printArray(int[] nums){
for(int i = 0;i < nums.length;i++){
System.out.print(nums[i] +"\t");
}
System.out.println();
}
}
11.3 JDK排序
java.util.Arrays.sort(数组名); //JDK提供(升序)
public class TestJDKSort{
public static void main(String[] args){
int[] nums = {4,3,5,2,1};
java.util.Arrays.sort(nums);
printArray(nums);
//手动颠倒元素,达到倒序的情况
for(int i = 0;i < nums.length / 2;i++){
int temp = nums[i];
nums[i] = nums[nums.length - 1 - i];
nums[nums.length - 1 - i] = temp;
}
printArray(nums);
}
public static void printArray(int[] nums){
for(int i = 0;i < nums.length;i++){
System.out.print(nums[i] +"\t");
}
System.out.println();
}
}
12.二维数组
12.1概念
一维数组中的一维数组;数组中的元素,还是数组。
12.2赋值
public class shuzu1 {
public static void main(String[] args) {
int[][] array = new int[3][5];
array[0][0]=10;
array[0][3]=20;
array[1][1]=30;
array[1][2]=40;
array[2][4]=50;
/*
使用双下标访问二维数组中的元素,
第一个下标代表:行号(高维下标),
第二个下标代表:列号(低维下标)。
高维数组中的每一个元素,保存了低维数组的地址
*/
}
}
12.3二维数组的访问:
public class shuzu1 {
public static void main(String[] args) {
int[][] array= new int[3][5];
array[0][0]=10;
array[0][3]=20;
array[1][1]=30;
array[1][2]=40;
array[2][4]=50;
for (int i = 0;i<a.length;i++){
for (int j = 0;j<array[i].length;j++){ //访问低维长度:array[0].length,首个低维数组的长度
System.out.println(array[i][j]); //访问低维数组元素:array[0][0],首个低维数组的首个元素
}
System.out.println(a[i]);
}
}
}
12.4二维数组创建语法:
12.4.1先声明,再分配空间
数据类型[][] 数组名;
数组名 = new 数据类型[高维长度][低维长度];
12.4.2声明并分配空间
数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];
12.4.3声明并赋值(繁)
数据类型[][] 数组名 = new 数据类型[高维长度][]; //不规则数组, 自行new低维数组
12.4.4声明并赋值(简)
数据类型[] 数组名 = {{v1,v2,v3},{v4,v5},{v6,v7,v8,v9}}; //显式初始化
案例:打印杨辉三角
public class yhsj{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int[][] a = new int[n][];
for(int i = 0 ; i < n; i++){
a[i] = new int[i+2];
a[i][0] = 1;
a[i][i+1]=1;
for(int j = 1 ; j <= i ; j++){
a[i][j] = a[i-1][j-1]+a[i-1][j];
}
//遍历打印
for(int j = 0 ; j < i+2; j++){
System.out.print(a[i][j]+"\t");
}
System.out.println();
}
}
}
总结
- 数组的概念:
一组连续的存储空间,存储多个相同数据类型的值; - 数组的声明与赋值:
数据类型[] 数组名 = new 数据类型[长度];
数组名[下标] = 值; - 数组的遍历:
从头至尾,逐一对数组的每个元素进行访问; - 数组的排序:
冒泡排序、选择排序、JDK快速排序; - 数组的应用:
数组复制、数组扩容、数组参数、数组返回值、二维数组;
好啦,今天的分享就到这里啦,后续有新内容随时更新,有什么不懂的地方记得来私信小编喏~