Java基础--二维数组&&方法1

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量232 收藏 1
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1476027184/article/details/108053882
版权

二维数组

  • 定义：一维数组中的元素也是数组
  • 声明方式
    数据类型[][] 数组名 = new 数据类型[外层数组长度][内层数组长度];
    数组类型[][] 数组名 = {{1,2,3},{4,5,6},{7,8,9},…};
  • 遍历方式：需要使用双层for，才能获取到元素的具体值
/**
 * 
 * @author Administrator
 *	二维数组
 *		可以理解为一维数组的元素还是一个数组
 *		第一个长度为外层数组的长度，第二个长度为元素数组的长度
 */

public class ArrayDemo {

	public static void main(String[] args) {
		// 定义一个二维数组
		int[][] arr = new int[2][3]; //动态创建
		//System.out.println(arr.length);  //二维数组层次的长度
		int[][] arr1= {{1,2,3},{4,5,6}};//静态创建
		System.out.println(arr1);
		for (int[] is : arr1) {
			System.out.println(is);
		}
		//foreach遍历二维数组 
		for (int[] is : arr1) {
			for (int i : is) {
				System.out.print(i+"  ");
			}
		}
		System.out.println();
		//for遍历二维数组
		for (int i = 0; i < arr1.length; i++) {
			for (int j = 0; j < arr1[i].length; j++) {
				System.out.print(arr1[i][j]+"  ");
			}
		}
	}
}
  • 堆栈图：
    在这里插入图片描述

数组加强练习

import java.util.Arrays;

/**
 * 1.设计一个方法,统计一个字符在字符数组中出现的次数（直接输出）
 * 2.设计一个方法,统计一个字符在字符数组中出现的次数（直接输出）
 * 3.已知这样的整型数组 int[] arr = {1,2,3,4,5,6,7,8,9,11,22}， 计算出其中的奇数和以及偶数和
 * 4.现在有数组 double[] scores = {11,34,76,77,88,99,58,97,56};定义一个方法统计并打印出每一个阶段的学生人数(分段方式:0-60; 60-80;80-100)
 * 5.设计一个方法,翻转传入数组中的元素
 * 	例如有这样的数组 char[] arr = {'源','代','码','教','育'};
 * 	调用完上面的方法之后，arr中的内容是这样的{'育','教','码','代','源'};
 * 6.使用嵌套循环打印下面图形
 * 	1
 * 	1 2
 * 	1 2 3
 * 	1 2 3 4
 * 	1 2 3 4 5
 * 	1 2 3 4 5 6
 * 	1 2 3 4 5 6 7
 * 	1 2 3 4 5 6 7 8
 * 	1 2 3 4 5 6 7 8 9
 * 7.移除数组int[] arr = {1,2,3,4,5,1,9,4,12,67,1};中1这个元素，返回一个新的数组 （不带有1）；即新数组为int[] arr2 ={2,3,4,5,9,4,12,67};
 */
public class ArrayStrongerPractice {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//第一题
		char[] c= {'a','a','s','c','w','f','e','a','g','e','t'};
		System.out.println(statisticsChar(c, 'a'));
		//第二题
		int[] arr = {1,2,3,4,5,6,7,8,9,11,22};
		getSum(arr);
		//第三题
		int[] scores = {11,34,76,77,88,99,58,97,56};
		statisticsEachStepScore(scores);
		//第四题
		char[] arrC = {'源','代','码','教','育'};
		flipArry(arrC);
		System.out.println(Arrays.toString(arrC));
		//第五题
		printGraph(9);
		//第六题
		int[] arr1 = {1,2,3,4,5,1,9,4,12,67,1};
		int[] newArr = remove_1_fromArray(arr1);
		System.out.println(Arrays.toString(newArr));
		test(arr1);
	}
	/**
	 * 1.设计一个方法,统计一个字符在字符数组中出现的次数（直接输出）
	 * @param char[] arrC
	 * @param char c
	 * @return int
	 */
	public static int statisticsChar(char[] arrC,char c) {
		int count=0;
		for (char d : arrC) {
			if(c==d) {
				count++;
			}
		}
		return count;
	}
	/**
	 * 3.已知这样的整型数组 int[] arr = {1,2,3,4,5,6,7,8,9,11,22}， 计算出其中的奇数和以及偶数和
	 * @param arr
	 */
	public static void getSum(int[] arr) {
		int oddSum=0;   //接收奇数的和
		int evenSum=0;     //接收偶数的和
		for (int i : arr) {
			if(i%2==0) {
				evenSum+=i;
			}else {
				oddSum+=i;
			}
		}
		System.out.println("奇数和为："+oddSum);
		System.out.println("偶数和为："+evenSum);
	}
	
	/**
	 * 4.现在有数组 double[] scores = {11,34,76,77,88,99,58,97,56};定义一个方法统计并打印出每一个阶段的学生人数(分段方式:0-60; 60-80;80-100)
	 * @param arr
	 */
	public static void statisticsEachStepScore(int[] arr) {
		int scoreA=0;
		int scoreB=0;
		int scoreC=0;
		//for 循环遍历数组
		for (int i : arr) {
			//使用switch选择判断，i/10得到一个整数，所以只要判断i/10即可选择分数段
			switch (i/10) {
				case 10:
				case 9:
				case 8: scoreA++;break;
				case 7:
				case 6: scoreB++;break;
				default: scoreC++;break;
			}
		}
		//打印各分数段的人数
		System.out.println("0~60分的人数有："+scoreC);
		System.out.println("60~80分的人数有："+scoreB);
		System.out.println("80~100分的人数有："+scoreA);
	}
	/**
	 *	5.设计一个方法,翻转传入数组中的元素
	 *	 	例如有这样的数组 char[] arr = {'源','代','码','教','育'};
	 *	 	调用完上面的方法之后，arr中的内容是这样的{'育','教','码','代','源'};
	 * @param arrC
	 */
	public static void flipArry(char[] arrC) { 
		char t;
		for (int i = 0; i < arrC.length/2; i++) {
			t=arrC[i];
			arrC[i]=arrC[arrC.length-1-i];
			arrC[arrC.length-1-i]=t;
		}
	}
	/**
	 * 6.使用嵌套循环打印下面图形
	 * 	1
	 * 	1 2
	 * 	1 2 3
	 * 	1 2 3 4
	 * 	1 2 3 4 5
	 * 	1 2 3 4 5 6
	 * 	1 2 3 4 5 6 7
	 * 	1 2 3 4 5 6 7 8
	 * 	1 2 3 4 5 6 7 8 9
	 */
	public static void printGraph(int n) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(j+" ");
			}
			System.out.println();
		}
	}
	/**
	 * 	7.移除数组int[] arr = {1,2,3,4,5,1,9,4,12,67,1};中1这个元素，
	 * 	返回一个新的数组 （不带有1）；即新数组为int[] arr2 ={2,3,4,5,9,4,12,67};
	 * @param arr
	 * @return
	 */
	public static int[] remove_1_fromArray(int[] arr) {
		int count=0;
		int n=0;
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]!=1) {
				count++;
			}
		}
		int[] newArr=new int[count];
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]!=1) {
				newArr[n++]=arr[i];
			}
		}
		return newArr;
	}
}

方法

  • 定义：可以完成某个独立功能的代码块，存在于类中，可以重复使用，每次互不影响。
  • 方法的调用：
    1. 在同一个类中：方法名(有参传参);
    2. 不在同一个类中：
      如果没有static修饰：类名.方法名(有参传参)；
      如果没有static修饰：创建对象 对象名.方法名(有参传参)：
/**
 * @author Administrator
 *	方法：可以完成某种独立功能的代码块，存在于类结构中，可以重复使用，每次使用互不影响
 *	main方法介绍：
 *		public：修饰符                               非必须
 *		static：修饰符，jvm优先加载                    非必须
 *		void：空的（返回值类型）                       必须
 *		main：方法名                                 必须
 *		()：用来存放参数的                            必须 
 *		String[] args：参数                         非必须
 *		{}：结构体（程序块）                          必须
 *
 *	自定义方法
 *	方法的调用
 *		1.同一个类中的方法调用，直接：方法名();
 *			静态上下文不能引用非静态上下文
 *		2.不同类中的方法调用
 *			如果方法有static修饰，调用：类名.方法名；
 *			没有static修饰，创建对象，调用：对象名.方法名
 */
public class MethodDemo {

	public static void main(String[] args) {
		MethodDemo m=new MethodDemo();
		m.show();
		System.out.println("哈哈哈哈哈哈哈！");
	}
	
	//自定义一个方法
	void show() {
		System.out.println("这是一个自定义方法！");
	}
	void heihei() {
		System.out.println("嘿嘿嘿嘿");
	}
}

方法的参数

/**
 * @author Administrator
 *	有参数:
 *		调用方传递的参数叫实际参数
 *		被调用方接受的参数叫形式参数
 */
public class MethodDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		getS(5, 6);
	}
	
	static void getS(int a,int b) {
		System.out.println(a*b);
	}

}

方法的返回

  • return 返回值

      方法的返回值类型根据实际返回结果的类型来确定
  在方法的最后一句中加上return返回结果:
  return后面不能重有功能语句，
  如果方法中有判断出现，此时需要考虑判断以外的也需要返回值

/**
 * @author Administrator              
 *	有参数:
 *		调用方传递的参数叫实际参数
 *		被调用方接受的参数叫形式参数
 *	参数传递时如果实参名字和形参名字一致的时候
 *	要看实参是局部变量还是成员变量
 *		如果是成员变量这个时候在调用的方法中修改参数此时修改的是调用方法的参数不是修改的成员变量是修改局部变量
 *		如果是局部变量那么修改就不会有任何影响
 *	方法的返回值:
 *		方法的返回值类型根据实际返回结果的类型来确定
 *		在方法的最后一句中加上return返回结果:
 *		return后面不能重有功能语句，
 *		如果方法中有判断出现，此时需要考虑判断以外的也需要返回值
 */
public class MethodDemo4 {
	static int x=11;
	static int y=22;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * int x=1; int y=2;
		 */
		getS(x, y);
		System.out.println(x);
		System.out.println(y);
		System.out.println(getSum(12, 22));
	}
	
	static void getS(int a,int b) {
		a=12;
		b=32;
		x=22;
		y=43;
	}
	static int getSum(int a,int b) {
		return a+b;
	}
	
	//设计一个方法  判断一个数是否是偶数    返回值为"是"或者"否"
	static String checkEven(int a) {
		if(a%2==0) {
			return "是";
		}
		return "否";
	}
}

练习题

public class Practice {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int max = getMax(14, 20);
		System.out.println(max);
		int min = getMin(20, 15, 14);
		System.out.println(min);
		int[] arr= {4,2,5,6,8,9};
		int product = getProduct(arr);
		System.out.println(product);
	}
	
	//1.定义一个方法getMax，接收两个int参数，返回较大的一个数。
	public static int getMax(int a,int b) {
		// TODO Auto-generated method stub
		return a>b?a:b;
	}
	//2.定义一个方法，接受三个int参数，返回最小的一个数。
	public static int getMin(int a,int b,int c) {
		int min = a>b?b:a;
		return min>c?c:min;
	}
	
	//3.设计一个方法求多个整数积的方法
	//(提示：定义一个方法，方法的参数是 int 数组，参考求多个整数和的示例)
	public static int getProduct(int[] arr) {
		int p=1;
		for (int i = 0; i < arr.length; i++) {
			p*=arr[i];
		}
		return p;
	}
}

/**
 * 
 * @author Administrator
 *	1.定义一个方法getMax,接收两个int参数,返回最大的一个数(低级)
 *	建议使用三目运算
 */
public class Work1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int max = getMax(29, 20);
		System.out.println(max);
	}
	/**
	 * 	获取两个数中的最大值
	 * @param a
	 * @param b
	 * @return int
	 */
	public static int getMax(int a,int b) {
		return a>b?a:b;
	}

}

/**
 * 
 * @author Administrator
 *	定义一个方法,接收三个int参数,返回最小的一个数(低级)
 */
public class Work2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int max=getMaxFromThree(20, 20, 50);
		System.out.println(max);
	}
	/**
	 * 	获取三个数中的最小值
	 * @param a
	 * @param b
	 * @param c
	 * @return
	 */
	public static int getMaxFromThree(int a,int b,int c) {
		a=a<b?a:b;  //先求出a和b的最小值放到a中
		return a<c?a:c;//再求a和c的最大值并返回
	}
}

/**
 * 
 * @author Administrator
 *	3.设计一个求3个int类型积的方法,并返回这个积(低级)
 */
public class Work3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int s=getProduct(20, 30, 40);
		System.out.println(s);
	}
	/**
	 *	求三个数的乘积
	 * @param a
	 * @param b
	 * @param c
	 * @return
	 */
	public static int getProduct(int a,int b,int c) {
		return a*b*c;
	}
}


/**
 * 
 * @author Administrator
 *	4.设计一个方法，传入一个int的数组，返回该数组中最大的值(中级)
 */
public class Work4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[]= {10,50,78,50,12,56,87,35,75,18,57,95,82,102};
		int maxInArr = getMaxInArr(arr);
		System.out.println(maxInArr);
	}
	/**
	 * 	求数组中的最大值
	 * @param arr
	 * @return
	 */
	public  static int getMaxInArr(int[] arr) {
		int max=arr[0];
		for (int i = 0; i < arr.length; i++) {
			if(max<arr[i]) {
				max=arr[i];
			}
		}
		return max;
		
	}

}

/**
 * 5.设计一个方法，查询并返回一个字符在字符数组中第一次出现的位置(高级)
 *	char arr = {'a','b','c','a','g'};
 *	char c = 'a';
 *
 *	四要素：	
 *		返回值类型：int 
 *		方法名：getIndexInArray()
 *		形参列表：char c,char[] arr
 *		方法体：
 *			遍历整个数组，将c 和 arr[i] 如果相等，返回下标i
 *			如果遍历完，没有找到，返回 -1  下标范围：0,n
 */
public class Work5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		char arr[] = {'a','b','c','a','g'};
		char c='f';
		System.out.println(getIndexInArray(c, arr));
	}
	/**
	 * 	获取一个字符在一个字符数组中的第一次出现的位置
	 * @param c
	 * @param arr
	 * @return int
	 */
	public static int getIndexInArray(char c,char[] arr) {
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]==c) {
				return i;
			}
		}
		return -1;
	}
}


/**
 * 
 * @author Administrator
 *	6.设计一个方法,统计返回一个字符在字符数组中出现的次数(高级)
 */
public class Work6 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		char arr[] = {'a','b','c','a','g'};
		char c='a';
		System.out.println(getCountInArray(c, arr));
	}
	/**
	 * 统计返回一个字符在字符数组中出现的次
	 * @param c
	 * @param arr
	 * @return
	 */
	public static int getCountInArray(char c,char[] arr) {
		int count = 0;
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]==c) {
				count++;
			}
		}
		return count;
	}
}

/**
 * 
 * @author Administrator
 * 7.设计一个方法,已知这样的整形数组  int[] arr = {1,2,3,4,5,6,7,8,9,11,12}返回其中的奇数和
 */
public class Work7 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
	}
	public static int getArraySum(int[] arr) {
		int sum=0;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i]%2!=0) {
				sum+=arr[i];
			}
		}
		return sum;
	}

}


/**
 * 
 * @author Administrator
 *	8.现在有数组 double[] scores = {11,34,76,77,88,99,58,97,56};定义一个方法统计并打印出每一个阶段学生人
 *	数(分段方式：0-60;60-80;80-100)(高级)
 */
public class Work8 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		double[] scores = {11,34,76,77,88,99,58,97,56};
		statisticalScore(scores);
	}
	/**
	 * 分数阶段统计
	 * (分段方式：0-60;60-80;80-100)
	 * @param arr
	 */
	public static void statisticalScore(double[] arr) {
		int scoreCountA=0;
		int scoreCountB=0;
		int scoreCountC=0;
		for (double i : arr) {
			if(i<60) {
				scoreCountC++;
			}else if(i<80){
				scoreCountB++;
			}else {
				scoreCountA++;
			}
		}
		System.out.println("0-60分的人数有："+scoreCountC);
		System.out.println("60-80分的人数有："+scoreCountB);
		System.out.println("80-100分的人数有："+scoreCountA);
	}

}

/**
 * 
 * @author Administrator
 *	9.设计一个方法，传入一个int数组，翻转该数组中的元素，并且返回反转后的数组(牛皮做)
 */
public class Work9 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr= {1,2,3,4,5,6};
		arr=flipArray(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+",");
		}
	}
	/**
	 * 翻转数组
	 * @param arr
	 * @return
	 */
	public static int[] flipArray (int[] arr) {
		int t;
		for (int i = 0; i < arr.length/2; i++) {
			t=arr[i];
			arr[i]=arr[arr.length-1-i];
			arr[arr.length-1-i]=t;
		}
		return arr;
	}

}
迎战未来
关注
专栏目录
JAVA 二维数组
x_eminem的博客
03-27 116
package com.method; public class Demo07 { public static void main(String[] args) { int[][] a ={{4,5,6},{9,8,7},{6,3,1},{9,3,6}}; for (int i = 0; i < a.length; i++) { for (int j = 0; j < a[i].length; j++) { .
数组<------->面向对象思想
08-06 144
数组[ ]: 存储相同类型的多个数据 1.变量:存储单个数据 2.数组:存储相同类型的多个数据 数组的特点: 1.数组是引用数据类型 2.数组是个容器,长度一旦确定不可改变 3.数组中存放的多个数据的数据类型要求一致 4.数组中的数据是有序的,(可以通过索引或者下标)索引从开始 操作数组中的数据: 根据下标 数组名[下表|索引] 数组的声明: 数据类型 []...
自定义函数multi（）实现多个数求积
weixin_30480651的博客
04-23 3821
# multiply def multi(a): s=1 for i in a: s*=i return s def inp(): a=input('please input nums(split with comma):') return a if __name__=='__main__': try : ...
定义一个方法求两个整数范围内所有数的累加和
#7的博客
04-21 5108
import java.util.Scanner;/* * 定义一个方法求两个整数范围内所有数的累加和 */public class Demo28 { public static void main(String[] args) { Scanner sc=new Scanner(System.in); System.out.println("请输入两个整数："); int m=sc.next...
6 Java基础语法(二维数组,参数传递与数据加密问题)＆面向对象(面向对象思想,类与对象及使用,对象内存图解)
飛白的学习笔记
04-02 1848
Java基础语法(二维数组,参数传递与数据加密问题)＆面向对象(面向对象思想,类与对象及使用,对象内存图解)
java代码-日常练习21，二维数组及二维数组的遍历
07-15
此外，Java还提供了一些内置方法来处理二维数组，如`Arrays.deepToString()`，它可以将整个二维数组转换为字符串，方便输出或日志记录。需要注意的是，二维数组并非真正的数组，而是一个数组的数组，因此在操作时需...
java String 转成Double二维数组的方法
09-01
因此，我们可以调用`JSON.parseObject()`方法将字符串解析为String类型的二维数组： ```java String[][] arr = JSON.parseObject(str, String[][].class); ``` 3. **转换为Double数组**：最后，我们需要遍历...
JAVA-基础⑦二维数组与排序
weixin_66768178的博客
04-30 1790
1、 冒泡排序（Bubble Sort） 冒泡排序是所有排序算法中最简单的一个排序，也是我个人学习的第一个排序方法，在这里重新进行一个总结。 冒泡排序（Bubble Sort）就如同其名称一样，水中的气泡由于压强的原因所以从下到上其大小也是从小到大，如下图 整个排序过程分为一个大循环和大循环中的很多小循环进行，我们先来讲其中的小循环他做的事情： 每次小循环其实做的事情都很简单，就是单纯的循环所有数据找到其中最大值，将最大值放到当前比较数据的最后一个位置。下面给大家举个例子： 第一步，我们需要一
Java编程一维数组转换成二维数组实例代码
08-28
在Java编程语言中，我们可以使用以下方法将一维数组转换成二维数组： ```java public static double[][] TwoArry(double[] onedouble){ double[][] arr=new double[1][onedouble.length]; for (int i = 0; i ; i+...
java object 二维数组_Java基础系列 - 数组、二维数组、对象数组
weixin_36156209的博客
02-12 843
package com.test2;public class demo2 {public static void main(String[] args) {/*** 一维数组使用*///数组最大的缺陷：长度固定//int data[] = {10, 20, 30}; /*开辟了一个长度为3的数组*///int[] arr3 = new int[]{1, 2, 3, 4, 5, 6, 7, 22};...
作业题--------设计一个类，求和的方法，求乘积的方法
weixin_38166560的博客
06-06 235
作业题（总结）设计一个类：包含$a,$b，求和的方法,求乘积的方法，可以对变量进行初始化，$a,$b必须大于0小于100 1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3...
java二维数组A.length和A[i].length的区别
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
08-11 3万+
public static void main(String[] args) { //// write your code here int[][] A=new int[][]{{1,2},{4,5},{7,8,10,11,12},{}}; System.out.println(A.length);//4,表示数组的行数 System.out.p
java初始化二维数组的三种方式
Code_lr的专栏
11-15 11万+
//第一种方式： int a[][]={{1,2,3},{4,5,6}}; //第二种方式； int[][] ints = new int[4][2]; ints[i][j] =__; //分别赋值 //第三种方式：第二维的长度可以动态申请 int[][] arr3 = new int[5][];//五
七、《方法》的引入和作用以及使用
yqx1714768514的博客
01-23 516
1、方法引入 先来看看，我们之前写的代码： public static void main(String[] args) { // 需求1：求1-10的和 int sum = 0; for (int i = 1; i <= 10; i++) { sum += i; } System.out.println("1~10的和：" + sum); // 需求2：求1-100的和 int sum2 = 0; for (int i = 1; i <= 100; i++) {
JAVA中的二维数组的定义及使用
热门推荐
lhj_sjtu的博客
03-19 17万+
二维数组其实是一位数组的嵌套（每一行看做一个内层的一维数组） 两种初始化形式    格式1: 动态初始化数据类型 数组名 [ ][ ] = new 数据类型[m][n]数据类型 [ ][ ]  数组名 = new 数据类型[m][n]数据类型 [ ]   数组名 [ ] = new 数据类型[m][n]举例：int [ ][ ]  arr=new  int [5][3];  也可以理解为“5行3例...
Java企业面试题3
m0_74972727的博客
09-15 909
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 246
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 531
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 186
faiss版本 faiss-v1.7.4。
Java大数据基础：详解二维数组
"这篇博客主要介绍了Java中的二维数组，它是大数据学习的基础知识。作者通过代码示例解释了二维数组的定义、初始化以及四种遍历方式。" 在Java编程语言中，二维数组是处理多行多列数据的重要工具，特别是在大数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值