Java入门基础知识之数组

其他 2020-03-30 10:31:56 阅读次数: 0

所谓数组，是有序的元素序列。
若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便，把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。
数组是用于储存多个相同类型数据的集合。

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快速排序；
  • 数组的应用：
    数组复制、数组扩容、数组参数、数组返回值、二维数组；

好啦，今天的分享就到这里啦，后续有新内容随时更新，有什么不懂的地方记得来私信小编喏~

微笑·不失礼
发布了14 篇原创文章 · 获赞 12 · 访问量 648
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_44664231/article/details/104733433
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022