【Java】基础编程篇（3.数组）

于 2021-08-13 22:35:04 发布
阅读量226 收藏
点赞数 1
分类专栏： # JavaSE学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58058653/article/details/119567508
版权

前言

尚硅谷 - Java课程 - 笔记（用于自己复习）
终于把数组看完了，总结一下，继续冲~

一、数组概述

1.数组的理解：

数组(Array)，是多个相同类型数据一定顺序排列的集合，使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.数组相关的概念：

  • 数组名
  • 元素
  • 角标、下标、索引
  • 数组的长度：元素的个数

3.数组的特点：

  • 数组属于引用数据类型的变量。
  • 数组的元素，既可以是基本数据类型，也可以是引用数据类型
  • 创建数组对象会在内存中开辟一整块连续的空间
  • 数组的长度一旦确定，就不能修改。

4. 数组的分类：

① 按照维数：一维数组、二维数组、。。。
② 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

5. 数据结构：

1.数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
2.数据的存储结构：

  • 线性表（一对一）：顺序表（比如：数组）、链表、栈、队列
  • 树形结构（一对多）：二叉树
  • 图形结构(多对多)

6. 算法：

  • 排序算法
  • 搜索算法

二、一维数组

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[] arr4 = {1,2,3,4,5};//类型推断
错误的方式：
 int[] arr1 = new int[];
 int[5] arr2 = new int[5];
 int[] arr3 = new int[3]{1,2,3};

2.一维数组元素的引用

  • 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
  • 数组元素的引用方式：数组名[数组元素下标]
  • 通过角标的方式调用。
//数组的角标（或索引从0开始的，到数组的长度-1结束。
		names[0] = "王铭";
		names[1] = "王赫";
		names[2] = "张学良";
		names[3] = "孙居龙";
		names[4] = "王宏志";//charAt(0)

3.数组的属性：length

System.out.println(names.length); //5
System.out.println(ids.length);

说明：

数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。

4.一维数组的遍历

for(int i = 0;i < names.length;i++){
	System.out.println(names[i]);
}

5.一维数组元素的默认初始化值

在这里插入图片描述

  • 数组元素是整型：0
  • 数组元素是浮点型：0.0
  • 数组元素是char型：0或’\u0000’，而非’0’
  • 数组元素是boolean型：false
  • 数组元素是引用数据类型：null

6.一维数组的内存结构

在这里插入图片描述

二、二维数组

1.如何理解二维数组？

  • 数组属于引用数据类型
  • 数组的元素也可以是引用数据类型
  • 一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。

2.二维数组的声明与初始化

正确的方式：
int[] arr = new int[]{1,2,3};//一维数组
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//也是正确的写法：
int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断
错误的方式：
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}};

3.如何调用二维数组元素:

System.out.println(arr1[0][1]); //2
System.out.println(arr2[1][1]); //null
arr3[1] = new String[4];
System.out.println(arr3[1][0]);
System.out.println(arr3[0]);

4.二维数组的属性：

System.out.println(arr4.length);//3
System.out.println(arr4[0].length);//3
System.out.println(arr4[1].length);//4

5.遍历二维数组元素

for(int i = 0;i < arr4.length;i++){ 
			for(int j = 0;j < arr4[i].length;j++){
				System.out.print(arr4[i][j] + "  ");
			}
			System.out.println();
	}

6.二维数组元素的默认初始化值

规定：二维数组分为外层数组的元素，内层数组的元素

int[][] arr = new int[4][3];

  • 外层元素：arr[0],arr[1]等
  • 内层元素：arr[0][0],arr[1][2]等

数组元素的默认初始化值
针对于初始化方式一：比如：int[][] arr = new int[4][3];

  • 外层元素的初始化值为：地址值
  • 内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如：int[][] arr = new int[4][];

  • 外层元素的初始化值为：null
  • 内层元素的初始化值为：不能调用，否则报错。

7.二维数组的内存结构

在这里插入图片描述

三、数组的常见算法

1.数组的创建与元素赋值：

杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复。

1.1 杨辉三角

使用二维数组打印一个 10 行杨辉三角

  1. 第一行有 1 个元素, 第 n 行有 n 个元素
  2. 每一行的第一个元素和最后一个元素都是 1
  3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。
    即：yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
代码如下：
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++){
			//yangHui[0] = new int[1]; //第一行有 1 个元素, 第 n 行有 n 个元素
			//yangHui[1] = new int[2];
			yangHui[i] = new int[i+1];
			
			//2.1给首末元素赋值
			yangHui[i][0] = yangHui[i][i] = 1;
			
			//2.2给每行的非首末元素赋值 从i=2开始
			if(i>1){ //可以去掉
				//内层循环,从第二列开始j=1,因为是非首末元素,j小于当前行的列数-1，
				for(int j=1;j<yangHui[i].length - 1;j++){ 
					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] + " ");
			}
			System.out.println();//换行
		}
		
	}
}
1.2 创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同

思路：
要求：所有随机数都是两位数。[10,99]公式：(int) (Math.random() * (99-10+1) + 10)

提示：[0,1) * 90 -> [0,90) + 10 -> [10,100) ->[10,99] (int)(Math.random() * 90 + 10)
[1，30] : (int) (Math.random() * 30) + 1

代码如下：
class ArrayExer {
	public static void main(String[] args) {
		//方式一：
//		int[] arr = new int[6];
//		for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31)
//			arr[i] = (int) (Math.random() * 30) + 1;
//
//			boolean flag = false;
//			while (true) {
//				for (int j = 0; j < i; j++) {
//					if (arr[i] == arr[j]) {
//						flag = true;
//						break;
//					}
//				}
//				if (flag) {
//					arr[i] = (int) (Math.random() * 30) + 1;
//					flag = false;
//					continue;
//				}
//				break;
//			}
//		}
//
//		for (int i = 0; i < arr.length; i++) { //遍历
//			System.out.println(arr[i]);
//		}

		//方式二：
		int[] arr = new int[6];
		for (int i = 0; i < arr.length; i++) {  // [0,1) [0,30) [1,31)
			arr[i] = (int) (Math.random() * 30) + 1;
			
				for (int j = 0; j < i; j++) {
					if (arr[i] == arr[j]) {
						i--;
						break;
					}
				}
			}

		for (int i = 0; i < arr.length; i++) {//遍历
			System.out.println(arr[i]);
		}
	}
}
1.3 回形数（二维数组）

从键盘输入一个整数（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

//方式一：
class RectangleTest {
	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();
		}
	}
}

//方式二：
class RectangleTest1 {
	public static void main(String[] args) {
		int n = 7;
		int[][] arr = new int[n][n];

		int count = 0; // 要显示的数据
		int maxX = n - 1; // x轴的最大下标
		int maxY = n - 1; // Y轴的最大下标
		int minX = 0; // x轴的最小下标
		int minY = 0; // Y轴的最小下标
		while (minX <= maxX) {
			for (int x = minX; x <= maxX; x++) {
				arr[minY][x] = ++count;
			}
			minY++;
			for (int y = minY; y <= maxY; y++) {
				arr[y][maxX] = ++count;
			}
			maxX--;
			for (int x = maxX; x >= minX; x--) {
				arr[maxY][x] = ++count;
			}
			maxY--;
			for (int y = maxY; y >= minY; y--) {
				arr[y][minX] = ++count;
			}
			minX++;
		}

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				String space = (arr[i][j] + "").length() == 1 ? "0" : "";
				System.out.print(space + arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}

2.针对于数值型的数组

算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等

  • 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
  • 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
  • 要求：所有随机数都是两位数。[10,99]公式：(int) (Math.random() * (99-10+1) + 10)

提示：

 [0,1) * 90 -> [0,90) + 10 -> [10,100) ->[10,99]
 (int)(Math.random() * 90 + 10)
实现代码如下：
package com.atguigu.java;
public class ArrayTest1 {
	public static void main(String[] args) {
		//数组调出来
		int[] arr = new int [10];
		for(int i=0;i<arr.length;i++){
			arr[i]= (int) (Math.random() * (99-10+1) + 10);	
		}
		
		//遍历
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		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 avgValue = sum / arr.length;
		System.out.println("平均数为：" + avgValue);
	}
}

3.数组的赋值与复制

int[] array1,array2;
array1 = new int[]{1,2,3,4};
3.1赋值：
array2 = array1;

如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。
在这里插入图片描述

3.2 复制：
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}

如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。
在这里插入图片描述

4.数组元素的反转

//方法一：
		for(int i = 0;i < arr.length / 2;i++){
			String temp = arr[i];
			arr[i] = arr[arr.length - i -1];
			arr[arr.length - i -1] = temp;
		}
		
//方法二：
		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}

5.数组中指定元素的查找：

5.1 线性查找：

实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
适用性：具有普遍适用性。

5.2 二分法查找：

实现思路：每次比较中间值，折半的方式检索。
适用性：（前提：数组必须有序）

6.数组的排序算法

排序：假设含有n个记录的序列为{R1，R2，...,Rn},其相应的关键字序列为{K1，K2，...,Kn}。将这些记录重新排序为{Ri1,Ri2,...,Rin},使得相应的关键字值满足条件Ki1<=Ki2<=...<=Kin,这样的一种操作称为排序。
通常来说，排序的目的是快速查找。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

理解：

1）衡量排序算法的优劣：

  • 时间复杂度：分析关键字的比较次数和记录的移动次数
  • 空间复杂度：分析排序算法中需要多少辅助内存
  • 稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

2）排序的分类：内部排序 与 外部排序（需要借助于磁盘）

  • 内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排
    序操作都在内存中完成。
  • 外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排
    序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最
    常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

3）不同排序算法的时间复杂度
在这里插入图片描述
4）手写冒泡排序

        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};		
		//冒泡排序
		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;
				}			
			}		
		}

5）手写快速排序

package com.atguigu.java;
/*
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 */
public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

五、Arrays工具类的使用

1.理解

① 定义在java.util包下。
② Arrays:提供了很多操作数组的方法。
③java.util.Arrays类的sort()方法提供了数组元素排序功能
④java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

2.使用

//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.数组角标越界异常：ArrayIndexOutOfBoundsException

访问到了数组中的不存在的脚标时发生。

		int[] arr = new int[]{1,2,3,4,5};
		
		for(int i = 0;i <= arr.length;i++){
			System.out.println(arr[i]);
		}
		
		System.out.println(arr[-2]);
		
		System.out.println("hello");

2.空指针异常：NullPointerException

arr引用没有指向实体，却在操作实体中的元素时

情况一：
		int[] arr1 = new int[]{1,2,3};
		arr1 = null;
		System.out.println(arr1[0]);
		
情况二：
		int[][] arr2 = new int[4][]; //外层元素的初始化值为null
		System.out.println(arr2[0][0]);

情况三：
		String[] arr3 = new String[]{"AA","BB","CC"};
		arr3[0] = null;
		System.out.println(arr3[0].toString());

小知识：一旦程序出现异常，未处理时，就终止执行。

王六六同学
关注
专栏目录
java编程基础—数组练习.docx
02-27
在Java编程中，数组是一种非常基础且重要的数据结构，它允许我们存储同类型的多个数据项。上述文件中的几个数组练习涵盖了数组定义、初始化、遍历、复制和排序等基本操作。 1. **数组定义和创建**： 在Java中，...
JAVA输出一个3行4列数组_输入一个3行4列的数组,先以3行4列的格式输出该数组
weixin_33087827的博客
02-27 8193
C语言程序设计 定义一个二维数组a[3][4],要求输入12个数每一行从小到大排列,每一列从小到大排列搞那么复杂干嘛,就是一位数组排序,让后放到二位数组里面,一位数组排序网上一大堆,搜下吧再问：亲，我就只要答案，不是方法。即能解决这个问题的程序代码。加油呀！再答：#incluevoidbubble_s矩阵乘法计算编写一个函数实现矩阵A(2行3列)与矩阵B相乘(3行2列),乘积放在C数组中,在主函数...
vue element 实现分页功能
s1ngle的博客
09-30 2520
最近在学分页功能，这里总结下前端如何实现分页 用的是element框架和el-pagination组件 效果图: template代码： <el-pagination :page-size="pageSize" // 设置每页显示多少条 @current-change="currentChangeHandle" // 当前页数改变时调用函数 :current-page="currentPage" // 当前第几页 layout="total
Java基础07--数组
Yu__peng的博客
04-11 353
Java基础07--喝自己之前偷懒的洗脚水（七）数组数组的概述一维数组二维数组的使用数组的常见算法Arrays工具类的使用数组的常见异常 数组 数组的概述 1. 数组的理解： 数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。 2.数组的常见概念： 数组名 元素 角标、下标、索引 数组的长度：元素的个数 3.数组的特点： 1）有序排列 2）数组属于引用类型数据变量，数组的元素，既可以是基本数据类型，也可以是引用数组类型 3）创建数组对象
Java数组专项练习（四）
weixin_44077638的博客
02-28 560
1、稀疏矩阵一般采用三元组顺序表方法压缩存储 。 ( ) 正确答案: A 你的答案: A (正确) 正确 错误 分析： 稀疏矩阵有两种压缩存储方式，一个是三元组，一个是十字链表，两者各有适用环境。 2、下面哪项是数组优于链表的特点？ 正确答案: D 你的答案: D (正确) 方便删除 方便插入 长度可变 存储空间小 分析： 数组优于链表的: 1....
java编程基础—数组练习.pdf
02-27
在Java编程中，数组是一种非常基础且重要的数据结构，它允许我们存储同类型的多个数据项。数组的概念在上述的几个课后题目中被反复强调，包括数组的定义、创建、初始化、复制、排序以及多维数组的操作。接下来，我们...
Java SE编程入门教程 java数组（共33页）.pptx
12-04
了解这些基础知识对于掌握Java SE编程至关重要，因为数组是许多高级概念的基础，如集合框架、泛型、多线程等。随着学习的深入，你会接触到更多关于数组的操作，包括对数组进行复制、合并，以及使用高级数据结构如...
java趣味编程100实例.docx
06-28
总之，《Java趣味编程100实例》中的这个双色球随机生成器不仅提供了一个有趣的编程实践案例，还展示了如何运用Java的基础知识解决实际问题。通过学习此类实例，开发者不仅可以巩固自己的编程技能，还能激发更多的...
JAVA实验报告-数组.docx
06-28
### JAVA实验报告知识点总结 ...综上所述，通过这三个实验，学生能够深入了解Java语言中的字符处理、数组操作以及基本数据类型的转换等核心概念，为后续更复杂的数据结构和算法学习打下坚实的基础。
java 3行4列二维数组_输入一个3行4列矩阵到二维数组中,并打印出来
热门推荐
weixin_33364018的博客
03-02 1万+
输入一个M行M列的二维数组,计算四周元素之和设置数组S(M,M),M>1,ssum=s(1,1)+s(M,M)+s(1,M)+s(M,1)ifM>2fori=2toM-1ssum=ssum+s(1,i)+s(i,1)+s(M,i)+s(i,M)VB 输入一个3行4列的二维数组,分别求出每一行、每一列元素之和 要求你可以将行列算出的值用一个数组接收,这里是采用变量接收的方式.Option...
C语言数组基础知识及常见编程题
gongwa_233的博客
08-06 1063
一维数组的创建和初始化 数组的创建 数组是一组相同类型元素的集合。 数组的创建方式： type_t arr_name [const_n]; //type_t 是指数组的元素类型 //const_n 是一个常量表达式，用来指定数组的大小 数组的初始化方式： 数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。 例如： int arr1[10] = {1,2,3}; int arr2[] = {1,2,3,4}; int arr3[5] = {1，2，3，4，5}
Java基础全面解析——Java语言基础
大闲人柴毛毛
07-12 1809
高级编程语言的组成：关键字、标识符、注释、常量与变量、语句、函数、数组，下面一一介绍各个组成元素。 a)  关键字 i.  定义：关键字是一些英文单词，但在java中有特殊含义，自定义的变量不能和关键字重名。 ii.注：关键字一般都小写。 b)  标识符 i.  定义：标识符就是自定义的变量名 ii.规则：26个字母大小写、0-9、_、$组成 iii.注1：不能以数字
4. 数组int[] intArr = new int[]{5,9,3,7,2,6}，写出一个函数可根据传参（参数为需要获取的数组类型：1：正序排序数组；2：倒序排序数组；）来进行排序，返回值为int
comeonzeze的博客
10-28 2793
4. 数组int[] intArr = new int[]{5,9,3,7,2,6}，写出一个函数可根据传参（参数为需要获取的数组类型：1：正序排序数组；2：倒序排序数组；）来进行排序，返回值为int数组，请注意代码规范与质量。  [分值：20] 您的回答：(空)  （简答题需要人工评分）   package com.interview; public class Test4 { ...
java 数组类型定义_java定义数组的三种类型总结
weixin_35363322的博客
02-21 1296
三种定义数组的格式如下：int[] arr1=new int[10];int[] arr2={1,2,3,6};int[] arr3=new int[]{1,2,3,4,5,6,7,22};注意：数组的length是一个属性，而字符串的length()是一个方法了！！！虽然都是求的他们各自的长度package 第四天;public class 数组 {public void showArray(i...
javascript ES5中 foreach()遍历方法
weixin_44638167的博客
09-28 5945
forcach() array.forEach(function(currentValue, index, arr)) currentValue：数组当前项的值 index：数组当前项的索引 (可选) arr：数组对象本身 filter() 方法创建一个新的数组， 新数组中的元素是通过检查指定数组中符合条件的所有元素,主要用于筛选数组 注意它直接返回一个新数组 代码: <script> var arr=[50,86,12,10,0,38]; var newa
Java数组之常见算法
m0_56084296的博客
04-22 295
1.数组的创建与元素赋值： 杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复。 2.针对于数值型的数组： 最大值、最小值、总和、平均数等 3.数组的赋值与复制 int[] array1,array2; array1 = new int[]{1,2,3,4}; 3.1 赋值： array2 = array1; 如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。 3.2 复制： array2 = ne
毕业设计论文SpringBoot乐享田园系统.docx
10-17
毕业设计论文
3.实验三 顺序栈和队列.doc
最新发布
10-17
3.实验三 顺序栈和队列.doc
Java SE编程基础教程：数组与核心概念解析
"该资源是一系列关于Java SE编程入门的教程集合，涵盖了多个主题，包括但不限于数组、集合、IO、GUI编程、反射、泛型、线程、异常处理、正则表达式等。这些教程旨在帮助初学者系统地学习Java编程基础知识，包括面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值