java-数组

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量129 收藏
点赞数
分类专栏： java 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51313154/article/details/125046181
版权

数组1

1.数组的概念

数组的概念：在内存中开辟一块连续的空间，存储数据类型相同的数据，长度是固定的

2. 数组的创建

先声明、再分配空间：

数据类型[] 数组名;

数组名 = new 数据类型[长度];

声明并分配空间：

数据类型[] 数组名 = new 数据类型[长度];

声明并赋值（繁）：

数据类型[] 数组名 = new 数据类型[]{value1,value2,value3,…};

声明并赋值（简）：
数据类型[] 数组名 = {value1,value2,value3,…};

package com.qfedu.test1;
/**
 * 	数组的概念：在内存中开辟一块连续的空间，存储数据类型相同的数据，长度是固定的
 * 	数组的4种定义方式
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		// 方式1 先声明 再开辟空间
		int [] arr1;
		arr1 = new int[6];
		
		
		// 方式2 连声明 带开辟空间
		byte [] arr2 = new byte[10];
		
		short arr3 [] = new short[5];
		
		
		// 方式3 声明并且赋值 繁琐
		// 这种方式 不能在中括号中书写长度 因为具体长度根据数据的个数来决定
		double  [] arr4 = new double[] {11.5,22.2,33.6,20,60,55};
		
		
		// 方式4 声明并且赋值 简单
		String [] arr5 = {"a","b","hello","中国","666"};
		
		
		
		
		
		
		
		
	}
}

3. 数组的访问

数组中的每个数据格被称为“数组元素”。

对每个元素进行赋值或取值的操作被称为“元素的访问”。

访问元素时，需要使用“下标”（从0开始，依次+1）。

访问的语法：数组名[下标]; //例如 存：a[0]=10; 取：a[0]

4. 数组的下标

下标：数组中的下标从0开始，往后依次+1

package com.qfedu.test2;
/**
 * 	数组的访问
 * 	下标：数组中的下标从0开始，往后依次+1
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] arr1 = new int[5];
		// 赋值
		arr1[0] = 11;
		arr1[1] = 22;
		arr1[2] = 23;
		arr1[3] = 43;
		arr1[4] = 56;
		// arr1[5] = 77; 访问超出范围的下标 报错 ArrayIndexOutOfBoundsException：数值 
		// arr1[10] = 222;
		
		
		// 取值
		System.out.println(arr1[0]);
		System.out.println(arr1[1]);
		System.out.println(arr1[2]);
		System.out.println(arr1[3]);
		System.out.println(arr1[4]);
		// System.out.println(arr1[6]); 数组下标越界异常
		
		
	}
}

5. 数组的遍历

遍历：逐一对数组中的元素进行访问

package com.qfedu.test2;
/**
 * 	数组的遍历1
 * 	遍历：逐一对数组中的元素进行访问
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int [] nums = new int[4];
		nums[0] = 11;
		nums[1] = 22;
		nums[2] = 33;
		nums[3] = 44;
		
		for(int i = 0;i < 4;i++) {
			System.out.println(nums[i]);
		}
		
		
		
	}
}

使用循环对数组中的元素赋值 并且取值

package com.qfedu.test2;

import java.util.Scanner;

/**
 * 	数组的遍历2
 * 	使用循环对数组中的元素赋值 并且取值
 * @author WHD
 *
 */
public class Test3 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int [] nums = new int[5];
		
		for(int i = 0;i < 5;i++) {
			System.out.println("请输入第"+ (i + 1) +"个元素的值 ");
			int num = input.nextInt();
			nums[i] = num;
		}
		
		System.out.println("------------------赋值完毕------------------");
		
		System.out.println("取值");
		for (int i = 0; i < 5; i++) {
			System.out.println(nums[i]);
		}
		
		
	}
}

6. length属性

length属性表示数组的长度，是一个int类型的数值，使用数组名.length使用

package com.qfedu.test2;
/**
 * 	数组的遍历 和 length属性
 * 	length属性表示数组的长度，是一个int类型的数值，使用数组名.length使用
 * @author WHD
 *
 */
public class Test4 {
	public static void main(String[] args) {
		int [] nums = {1,2,3,4,5,6,56,456,12,4545,47,12,4545,212,12,454,21,5242,12,124,4545,212,12,454,21,5242,12,124,4545,212,12,454,21,5242,12,124};
		
		System.out.println("nums数组的长度为：" + nums.length);
		
		
		for(int i = 0;i < nums.length;i++) {
			System.out.print(nums[i] + "\t");
		}
		System.out.println();
	}
}

7. 数组的默认值

数组的默认值

整数：0

小数：0.0

布尔：false

字符：\u0000

其他：null

package com.qfedu.test3;
/**
 * 	数组的默认值
 * 	整数：0
 * 	小数：0.0
 * 	布尔：false
 * 	字符：\u0000
 * 	其他：null
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		byte [] arr1 = new byte[3];
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(arr1[i] + "\t");
		}
		System.out.println();
		
		short [] arr2 = new short[4];
		for (int i = 0; i < arr2.length; i++) {
			System.out.print(arr2[i] + "\t");
		}
		System.out.println();
		
		int [] arr3 = new int[5];
		for (int i = 0; i < arr3.length; i++) {
			System.out.print(arr3[i] + "\t");
		}
		System.out.println();
		
		
		long [] arr4 = new long[6];
		for (int i = 0; i < arr4.length; i++) {
			System.out.print(arr4[i] + "\t");
		}
		System.out.println();
		System.out.println("----------------------------------");
		
		float [] arr5 = new float[2];
		for (int i = 0; i < arr5.length; i++) {
			System.out.print(arr5[i] + "\t");
		}
		System.out.println();
		
		double [] arr6 = new double[10];
		for (int i = 0; i < arr6.length; i++) {
			System.out.print(arr6[i] + "\t");
		}
		System.out.println();
		System.out.println("----------------------------------");
		
		boolean [] arr7 = new boolean[3];
		for (int i = 0; i < arr7.length; i++) {
			System.out.print(arr7[i] + "\t");
		}
		System.out.println();
		System.out.println("----------------------------------");
		
		char [] arr8 = new char[5];
		for (int i = 0; i < arr8.length; i++) {
			System.out.print(arr8[i] + "---" + "\t" );
		}
		System.out.println();
		System.out.println("----------------------------------");
		
		String [] arr9 = new String[3];
		for (int i = 0; i < arr9.length; i++) {
			System.out.print(arr9[i] + "\t");
		}
		System.out.println();		
	}
}

8. 数组的扩容

思路：创建一个更大的数组，将原数组中元素依次存放到新数组中，然后将新数组的地址赋值给原来的数组，实现扩容

package com.qfedu.test4;
/**
 * 	数组的扩容
 * 	思路：创建一个更大的数组，将原数组中元素依次存放到新数组中
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		// 原数组
		int [] oldArr = {11,22,33,44,55};
		
		// 新数组
		int [] newArr = new int[oldArr.length * 2];
		
		// 将原数组中的元素依次复制到新数组中
		for(int i = 0;i < oldArr.length;i++) {
			newArr[i] = oldArr[i];
		}
		
		// 遍历新数组
		for(int i = 0;i < newArr.length;i++) {
			System.out.print(newArr[i] + "\t");
		}
		
		System.out.println();
		
		// 将两个数组的地址进行打印
		System.out.println(oldArr);// 15db9742
		System.out.println(newArr);// 6d06d69c
		
		// 将新数组的地址赋值给原数组
		oldArr = newArr;
		
		System.out.println("赋值地址以后，两个数组地址相同");
		System.out.println(oldArr);
		System.out.println(newArr);
		
		System.out.println("遍历原来的老数组");
		
		for (int i = 0; i < oldArr.length; i++) {
			System.out.print(oldArr[i] + "\t");
		}
		System.out.println();
		
	}
}

9. 值传递和引用传递的区别

基本数据类型传参，传递的是值本身(值的拷贝、值的副本)，在方法中对参数的改变，不会影响原来的实参

引用数据类型传参，传递的是地址，在方法中对参数的改变，会影响原来的实参

String类型属于特殊的引用数据类型，作为参数传递不会改变原来的值

package com.qfedu.test5;
/**
 * 	面试题：值传递和引用传递的区别？
 * 		基本数据类型传参，传递的是值本身(值的拷贝、值的副本)，在方法中对参数的改变，不会影响原来的实参
 * 		引用数据类型传参，传递的是地址，在方法中对参数的改变，会影响原来的实参
 * 		String类型属于特殊的引用数据类型，作为参数传递不会改变原来的值
 * @author WHD
 *
 */
public class Test1 {
	public static void m1(int a) {
		a+= 10;
		System.out.println("m1方法中a的取值 为：" + a);
	}
	
	public static void m2(int [] nums2) {
		System.out.println("m2方法中nums2的地址是：" + nums2);
		for (int i = 0; i < nums2.length; i++) {
			System.out.print(nums2[i] + "\t");
		}
		System.out.println();
		
		
		
		for(int i = 0;i < nums2.length;i++) {
			nums2[i]++;
		}
	}
	
	
	public static void main(String[] args) {
		int b = 10;
		m1(b);
		System.out.println("main方法中b的取值为：" + b);
		System.out.println("-------------------------------------");
		
		int [] nums1 = {1,2,3,4,5};
		System.out.println("main方法nums1的地址是：" + nums1);
		m2(nums1);
		for (int i = 0; i < nums1.length; i++) {
			System.out.print(nums1[i] + "\t");
		}
		System.out.println();
	}
}

10. 课堂练习

统计int类型数组中所有元素的总和。

统计int类型数组中所有元素的平均值。

求一个数组中的最大值，或者最小值。

package com.qfedu.test6;

import java.util.Scanner;

/**
 * 	统计int类型数组中所有元素的总和。统计int类型数组中所有元素的平均值。
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		
		System.out.println("请输入一个数组的长度");
		
		int length = input.nextInt();
		
		int [] nums = new int[length];
		
		int sum = 0;
		
		for (int i = 0; i < nums.length; i++) {
			System.out.println("请输入第"+ (i + 1) +"个元素的值");
			nums[i] = input.nextInt();
			
			sum += nums[i];
		}
		
		System.out.println("总和是：" +  sum + "平均值为：" + sum / nums.length);
		
		
		
		
		
		
	}
}



package com.qfedu.test6;
/**
 * 	求一个数组中的最大值，或者最小值。
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int [] nums = {45,78,5689,6564,87,45456,22};
		
		int min = nums[0]; // 假设一个最大值 
		
		for(int i = 1;i < nums.length;i++) {
			if(min > nums[i]) {
				min = nums[i];
			}
		}
		
		System.out.println("最小值为：" + min);
		
	}
}

数组2

1. 复制数组的方式

循环将原数组中所有元素逐一赋值给新数组。

System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);

java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。

package com.qfedu.test1;
/**
 * 	复制数组方式1：使用for循环将原数组中所有元素逐一赋值给新数组。
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] oldArray = {1,2,3,4,5};
		
		int [] newArray = new int[8];
		
		for(int i = 0;i < oldArray.length;i++) {
			newArray[i] = oldArray[i];
		}
		
		for (int i = 0; i < newArray.length; i++) {
			System.out.print(newArray[i] + "\t");
		}
		System.out.println();
		
		
	}
}


package com.qfedu.test1;
/**
 * 	复制数组方式2：System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
 * @author WHD
 *
 */
public class Test2 {
	public static void main(String[] args) {
		int [] oldArray = {1,2,3,4,5,6,7,8};
		
		int [] newArray = new int[oldArray.length * 2];
		
		System.arraycopy(oldArray, 3, newArray, 2, 2);
		
		
		for (int i = 0; i < newArray.length; i++) {
			System.out.print(newArray[i] + "\t");
		}
		System.out.println();
		
		
	}
}


package com.qfedu.test1;

import java.util.Arrays;

/**
 * 	复制数组方式3：java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。
 * @author WHD
 *
 */
public class Test3 {
	public static void main(String[] args) {
		int [] oldArray = {1,2,3,4,5};
		
		int [] newArray = Arrays.copyOf(oldArray, 10);
		
		for (int i = 0; i < newArray.length; i++) {
			System.out.print(newArray[i] + "\t");
		}
	}
}

2. 数组类型的参数

数组类型的参数，与之前参数使用方式一致

需求：在main方法中提示用户输入5门成绩，使用数组保存，编写方法将成绩打印

package com.qfedu.test2;

import java.util.Scanner;

/**
 * 	数组类型的参数，与之前参数使用方式一致
 * 	需求：在main方法中提示用户输入5门成绩，使用数组保存，编写方法将成绩打印
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		
		int [] scores = new int[5];
		
		for (int i = 0; i < scores.length; i++) {
			System.out.println("请输入第"+ (i + 1) +"门成绩");
			scores[i] = input.nextInt();
		}
		
		printScore(scores);
		
	}
	
	public static void printScore(int [] scores) {
		for (int i = 0; i < scores.length; i++) {
			System.out.println("第"+ (i + 1) +"门成绩为：" + scores[i]);
		}
	}

}

3. 数组类型的返回值

数组类型的返回值，与之前返回值使用方式一致

需求：编写方法提示用户输入5门成绩，使用数组保存并且返回

Arrays.toString(数组名)：表示将数组中的元素转换为字符串的格式 前后都加上中括号

package com.qfedu.test2;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 	数组类型的返回值，与之前返回值使用方式一致
 * 	需求：编写方法提示用户输入5门成绩，使用数组保存并且返回
 * 
 * 	Arrays.toString(数组名)：表示将数组中的元素转换为字符串的格式 前后都加上中括号
 * @author WHD
 *
 */
public class Test2 {
	public static double[] inputScore() {
		Scanner input = new Scanner(System.in);
		double [] scores = new double[5];
		for (int i = 0; i < scores.length; i++) {
			System.out.println("请输入第"+ (i + 1) +"门成绩");
			scores[i] = input.nextDouble();
		}
		return scores;
	}
	
	public static void main(String[] args) {
		double scores[] = inputScore();
		
		System.out.println(Arrays.toString(scores));
	}

}

4.可变长参数

概念：可接收多个同类型实参，个数不限，使用方式与数组相同。

语法：数据类型… 形参名

要求：必须定义在形参列表的最后，且只能有一个。

可变长参数：表示调用者可以传入0个或者多个同类型的参数

package com.qfedu.test2;
/**
 * 	概念：可接收多个同类型实参，个数不限，使用方式与数组相同。
 *	语法：数据类型... 形参名 
 *	要求：必须定义在形参列表的最后，且只能有一个。
 *
 *	可变长参数：表示调用者可以传入0个或者多个同类型的参数
 * @author WHD
 *
 */
public class Test3 {
	public static void printNum(int a,int... nums) {
		for(int i = 0;i < nums.length;i++) {
			System.out.print(nums[i] + "\t");
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		printNum(1,2,3,4,5,6);
	}

}

5. 冒泡排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mEE2eslz-1653892599682)(.\img\冒泡排序.gif)]

冒泡排序：相邻的两个数值比较大小，互换位置。

规律：

1.比较的轮数，永远是长度-1 6个数比较5轮 7个数比较6轮，外层循环控制比较的轮数

2.每一轮比较的次数，最多的一次是长度-1 ，后续每次递减1，内层循环控制每一轮比较的次数

外层循环 n- 1

内层循环 n -1 -i

package com.qfedu.test3;

import java.util.Arrays;

/**
 * 	冒泡排序：相邻的两个数值比较大小，互换位置。
 * 
 * 	规律：
 * 	1.比较的轮数，永远是长度-1  6个数比较5轮  7个数比较6轮，外层循环控制比较的轮数
 * 	2.每一轮比较的次数，最多的一次是长度-1 ，后续每次递减1，内层循环控制每一轮比较的次数
 * 
 * 	外层循环 n- 1 
 * 	内层循环 n -1 -i
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
//		int a = 10;
//		int b = 20;
//		int temp = a;
//		a = b;
//		b = temp;
//		
//		System.out.println(a);
//		System.out.println(b);
		
		
		int [] nums = {110,23,556,98845,774,520,321,41,5};
		for(int i = 0;i < nums.length -1;i++) {
			for(int j = 0 ;j < nums.length -1 - i ;j++) {
				if(nums[j] < nums[j + 1]) {
					int temp = nums[j];
					nums[j] = nums[j + 1];
					nums[j + 1] = temp;
 				}
			}
			System.out.println("第"+(i + 1)+"轮比较以后的顺序：" + Arrays.toString(nums));
		}
		
		System.out.println(Arrays.toString(nums));

	}
}

6. 选择排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LvyLOcqh-1653892599684)(.\img\选择排序.gif)]

选择排序：固定位置的元素依次与其他元素比较，比较一轮以后，交换一次位置

回顾我们刚才学过的冒泡排序，发现元素的位置需要频繁的移动，效率比较第，而选择排序

是每一轮最多交换一次位置，从而提高效率

举例：赵四 188 大拿 175 刘能 150

分析：

外层循环属于比较的数A，从第一个元素到倒数第二个元素，属于比较的数A

内层循环属于比较的数B，从第二个元素到末尾，属于比较的数B

在整个比较过程中，需要交换比较的数，所以我们定义index 与i相同 后续比较过程中 改变index的值

package com.qfedu.test4;

import java.util.Arrays;

/**
 * 	选择排序：固定位置的元素依次与其他元素比较，比较一轮以后，交换一次位置
 * 
 * 	回顾我们刚才学过的冒泡排序，发现元素的位置需要频繁的移动，效率比较第，而选择排序
 * 	是每一轮最多交换一次位置，从而提高效率
 * 	举例：赵四 188  大拿 175  刘能 150
 * 
 * 	分析：
 * 	外层循环属于比较的数A，从第一个元素到倒数第二个元素，属于比较的数A
 * 	内层循环属于比较的数B，从第二个元素到末尾，属于比较的数B
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] nums = {-1,110,23,556,98845,774,520,321,41,5};
		for(int i = 0;i < nums.length-1;i++) {
			int index = i;
			for(int j = i + 1;j < nums.length;j++) {
				if(nums[index] > nums[j]) {
					index = j;
				}
			}
			// 这里应该交换元素了 因为一轮比较完毕
			if(i != index) {
				int temp =nums[i];
				nums[i] = nums[index];
				nums[index] = temp;
			}
			
			System.out.println("第"+(i + 1)+"轮比较完以后的顺序：" + Arrays.toString(nums));
			
		}
		
		System.out.println(Arrays.toString(nums));

	}

}

7. JDK排序

JDK排序：java.util.Arrays.sort(数组名); //JDK提供（升序）

package com.qfedu.test5;

import java.util.Arrays;

/**
 * 	JDK排序：java.util.Arrays.sort(数组名); //JDK提供（升序）
 * @author WHD
 *
 */
public class Test1 {
	public static void main(String[] args) {
		int [] nums = {-1,110,23,556,98845,774,520,321,41,5};
		Arrays.sort(nums);
		System.out.println(Arrays.toString(nums));
		
		for(int i = nums.length -1;i >= 0;i--) {
			System.out.print(nums[i] + "\t");
		}
		
		
		
	}
}

8. 二维数组

二维数组：数组中的元素还是数组

创建二维数组，高维度必须指定，低维度可以单独分开指定

二维数组赋值和遍历

package com.qfedu.test5;
/**
 * 	二维数组赋值和遍历
 * @author WHD
 *
 */
public class Test3 {
	public static void main(String[] args) {
		int [][] nums = new int[3][3];
		
		nums[0][0] = 11;
		nums[0][1] = 13;
		nums[0][2] = 14;
		
		nums[1][0] = 15;
		nums[1][1] = 16;
		nums[1][2] = 17;
		
		nums[2][0] = 33;
		nums[2][1] = 44;
		nums[2][2] = 55;
		
		for(int i = 0;i < nums.length;i++) {
			for(int j = 0;j < nums[i].length;j++) {
				System.out.println(nums[i][j]);
			}
			System.out.println();
		}
		
		
		
	}
}

先声明、再分配空间：
数据类型[][] 数组名;
数组名 = new 数据类型[高维长度][低维长度];
声明并分配空间：
数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];
声明并赋值（繁）：
数据类型[][] 数组名 = new 数据类型[高维长度][]; //不规则数组，自行new低维数组
声明并赋值（简）：
数据类型[] 数组名 = { {v1,v2,v3},{v4,v5},{v6,v7,v8,v9} }; //显示初始化

sky-lb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中有关二维数组的笔记
qq_59281438的博客
04-02 664
/** java中的二维数组： 1.二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组 2、三维数组是一个特殊的二维数组。实际开发中使用最多的是一维数组和二维数组。 3.二维数组的静态初始化： */ public class ArrayTest02 { public static void main(String [] args){ int[][] a={ {1,2,3}, {4,5,6},
定义一个int类型的数组，统计数组元素出现的次数
09-05
定义一个方法传入一个 int 类型数组，输出这个数组中每一个数字及其出现的个数 例如 传入数组[1,2,2,2,3,3,4,4,4,4] 打印结果： 数字 1 出现了 1 次 数字 2 出现了 3 次…
计算给定数组 arr 中所有元素的总和
蜗牛的博客
06-18 4566
输入描述: 数组中的元素均为 Number 类型 输入例子: sum([ 1, 2, 3, 4 ]) 输出例子: 10 JS代码程序： （一） function sum(arr) { var suml = 0; for(var i = 0; i<arr.length; i++){ suml+=arr[i]; }
Java int数据类型数组求最大值、最小值、元素总和
MarkandLcg的博客
04-27 3853
Java int数据类型数组求最大值、最小值、元素总和 1.方法一： public class Main { public static void main(String[] args) { int[] num = {1, 9, 2, 6, 5}; //定义一个int数组 int max = Integer.MIN_VALUE; //最大值赋值为最小数(防止数组内的数比max初始值小) int min = Integer.MAX_VALU
五种方法计算给定数组中所有元素的总和
ruanhongbiao的专栏
05-10 1万+
1.不考虑算法复杂度，用递归做： function sum(arr) { var len = arr.length; if(len == 0){ return 0; }else if (len == 1){ return arr[0]; }else { return arr[0] + sum(arr.slice...
Educoder题目：Java入门 - 数组进阶答案解析.md
11-01
Educoder题目：Java入门 - 数组进阶答案解析
Java - 数组面试题 - 个人整理
08-20
数组 - 需要参加面试的人
Java-数组实验.pdf
10-03
【Java 数组基础与文件操作】\n\nJava 数组是一种数据结构，它允许程序员存储固定数量的相同类型的数据。数组在 Java 中是基础且重要的概念，它提供了一种高效的方式来组织和处理数据。本实验旨在帮助你深入理解数组...
JAVA-数组进制转换
10-08
.java文件，对java基础的数组部分的进制类型转换部分的说明。
Java计算数组中元素的总和
热门推荐
allway2的博客
04-30 4万+
数组元素的总和是指数组中所有元素（或数字）的总和。数组元素可以是整数（int）或十进制数字（float或double）。 方法1：使用for循环 这是一种传统且最常用的方法，其中使用for循环来迭代数组。 在每次迭代中，将当前数组元素添加到一个保存数组元素总和的变量中。 在循环开始之前，此变量被初始化为0。例如， ​ public class ArraySumCalculator { public static void main(String[] args) { int[] array .
如何定义一个int类型的数组，并求出数组中所有元素的和
LQ-Pro
03-01 1558
package kuangshen.array; //数组 public class Demo01 { public static void main(String[] args) { //如何定义一个数组 int[] nums;//声明一个数组 nums = new int[10];//给数组开辟一个空间 //也可以写为 //int[] nums=new int[10]; //赋值
Java基础知识2--数组
qq_45593083的博客
01-12 243
数组 数组也是一种数据类型,它本身是一种引用类型,例如:int是一个基本类型,但int[]（这是定义数组的一种方式）就是一种引用类型。 数组定义 语法： int [] arrayName;//建议使用这一种可读性比较好 int arrayName []; 数组的初始化 静态初始化 arrayName = new type[] {element1,element2,…}; 显示指定的数组元素的类型必须与new关键字后的type类型相同 eg： //定义一个int数组类型的变量，变量名为intArr
Java计算int数组中所有元素的和（简便方法）
qq_51560486的博客
06-26 1450
Java计算int数组中所有元素的和
给定一个数组，有n个元素的int型数组，求取数组中所有元素之和（要求代码量越少越好）
dong223的博客
04-19 1740
题目 给定一个数组，有n个元素的int型数组，求取数组中所有元素之和（ 要求:代码量越少越好） 解答 用递归实现 #include<stdio.h> int sum(int *a,int n); int main(void) { int arr[10] ={1,2,3,4,5,6,7,8,9,10}; //55 int value = sum(arr,10); ...
java中的值传递和String的特殊性（不可变性）
吕小医的博客
06-20 373
/** * @author Lvzixin * @date 2021/6/20 11:05 */ public class StringExer { String str = new String("good"); char [] ch = {'t','e','s','t'}; int a = 1; public void change(String str, char ch [],int a ) { str = "test ok";
计算给定数组 arr 中所有元素的总和（JS实现）
唐宋元明清
04-17 1万+
不考虑算法复杂度，用递归做：12345678910function sum(arr) {    var len = arr.length;    if(len == 0){        return 0;    } else if (len == 1){        return arr[0];    } else {        return arr[0] + sum(arr.slice(...
为什么String作为形参不会改变本身的值？
ZJH
08-22 1314
为什么 数组和String 同为引用数据类型，String的地址传递不会改变原本的值？ 查看API文档可知String类型的构造器有一个final修饰符，final修饰符导致了String一旦定义就是最终形态，任何试图改变String值的操作都只能重新开辟地址。 不同于数组Array，数组的构造器没有final修饰符，所以形参的改变会影响到实参本身 String和数组 在方法中值传递机制的区别 public class StringTest { public stat..
java 统计数组中各元素出现的次数
MIYAOW
10-26 2万+
package javatest;   import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set;   public class NumOfEle {       public static void mai...
配置Java开发环境
最新发布
Broken_x的博客
07-10 1438
Java开发环境配置
Java基础--数组练习2
07-25
Java基础--数组练习2 在Java中，数组是一种用来存储一组相同数据类型的数据的容器。它的特点包括数组是一个引用数据类型，数组内部可以存储基本类型或引用类型...愿大家在学习Java数组练习过程中取得更进一步的进步！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值