Java学习_day06_（02_数组及其应用）

最新推荐文章于 2022-11-06 08:23:45 发布
最新推荐文章于 2022-11-06 08:23:45 发布
阅读量223 收藏 1
点赞数 1
分类专栏： 日常学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45873813/article/details/116606263
版权

一.数组

引用数据类型: 数组,类,接口!

举例:
有80个员工,给80个员工发工资,需要定义80个变量,很麻烦!
传统方式使用变量去定义,代码非常臃肿,Java提供了"容器"给我们使用----“数组”

数组的概念: 就是用来存储同一种数据类型的容器!(类型必须一致,否则数组定义的时候 编译通过不了)

数组的定义格式: (数组目前:都存储基本类型)
方式1) 数据类型[] 数组名称 ; (推荐)
举例:
int[] arr ; 定义了一个int类型的数组arr变量

方式2) 数据类型 数组名称[] ;
举例
int arr[] ; 定义了一个int类型的arr数组变量;

数组的初始化:
动态初始化
静态初始化

动态初始化:我们定义了数组的长度,数组的元素由系统默认初始化!

数据类型[] 数组名称 = new 数据类型[数组长度] ;
int[] arr = new int[3] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;
int arr[] = new int[3]

在数组中如何获取数组的元素?
数组名称[索引值]:索引值:0开始
最大索引值:数组长度-1

class ArrayDemo{
	public static void main(String[] args){
		
		//数据类型[] 数组名称 = new 数据类型[数组长度] ;
		//创建一个int类型的数组,长度为4
		int[] arr = new int[4] ;//arr[0],arr[1],arr[2],arr[3]
		
		int[] arr2 = new int[3] ;
		System.out.println(arr2) ;
		
		System.out.println(arr) ; //[I@6d06d69c  地址值
		//[:数组
		//@:地址值标记
		//6d06d69c:一堆十六进制数据
		
		/*
			解释说明一下格式:
			=号左边
			int:里面存储的都是int类型
			[]:一维数组
			arr:数组名称(符号标识符的规则)
			=号右边
			new :创建对象
			int:int类型的元素
			[]:一维数组
			4:数组的长度
		
		*/
		System.out.println("----------------------------") ;
		//在数组中如何获取数组的元素?
		//数组名称[索引值]:索引值:0开始
		System.out.println(arr[0]) ;
		System.out.println(arr[1]) ;
		System.out.println(arr[2]) ;
		System.out.println(arr[3]) ;
	}
}

内存示意：
在这里插入图片描述

数组的特点：
(1) 数组长度是固定的！
(2) 储存的类型必须是同一种类型
(3) 数组中储存的元素可以是引用类型，也可以储存基本数据类型

二.Java中的内存分配

Java中的内存分配：对象一旦创建完毕，地址值十固定的，除非重新在栈内存中开辟新的空间.

(1) 栈内存：方法进栈，储存的局部变量（在方法定义中以及方法声明上）.
(2) 堆内存：new出来的东西都存在堆内存中（创建对象）.
(3) 方法区：字节码文件class域，static静态域，常量池（constantpool）.
(4) 本地方法区：以及寄存器，跟系统/cpu相关.

栈内存存储的都是局部变量，生命周期随着方法调用完毕而消失.

堆内存：储存的new出来的东西，创建对象，对象创建完毕之后，不会立即消失，需要等待垃圾回收器（GC）回收

class类先在方法区创建class域，生成main方法，然后main方法在栈内存中划出来空间内存，int[] arr 变量（局部）会存进栈内存里，new的东西存进堆内存中，根据数组长度划出元素，并生成一个地址，int[] arr 再指向这个地址，对象一旦创建完毕，内存地址十固定的（除非重新在栈内存中开辟新的空间）.

三.多个数组赋值

创建多个数组对象:
创建两个数组对象,分别输出数组名称以及他们的元素
重新给这两个数组中的元素进行赋值

定义第三个数组,将第一个数组名称赋值给它,再次重新给元素赋值

多个栈指向一个堆内存，arr3这个数组指向arr这个数组的地址，重新赋值就相当于改变了arr的元素

class ArrayDemo2{
	public static void main(String[] args){
		
		//创建第一个数组
		int[] arr = new int[2] ;
		int[] arr2 = new int[3] ;
		System.out.println(arr) ;
		System.out.println(arr2) ;
		System.out.println(arr[0]) ;	//0
		System.out.println(arr[1]) ;	//0
		System.out.println(arr2[0]) ;	//0
		System.out.println(arr2[1]) ;	//0
		System.out.println(arr2[2]) ;	//0
		System.out.println("-----------------") ;
		arr[0] = 10 ;
		arr[1] = 5 ;
		arr2[1] = 20 ;
		arr2[2] = 30 ;
		System.out.println(arr) ;
		System.out.println(arr2) ;
		System.out.println(arr[0]) ;	
		System.out.println(arr[1]) ;	
		System.out.println(arr2[0]) ;	
		System.out.println(arr2[1]) ;	
		System.out.println(arr2[2]) ;	
		//定义第三个数组,将第一个数组名称赋值给它
		System.out.println("-----------------") ;
		int[] arr3 = arr ;
		arr3[0] = 100 ;
		arr3[1] = 200 ;
		System.out.println(arr[0]) ;	
		System.out.println(arr[1]) ;	
		System.out.println(arr2[0]) ;	
		System.out.println(arr2[1]) ;	
		System.out.println(arr2[2]) ;		
	}
}

内存示意：
在这里插入图片描述

四.数组的静态初始化

数组的静态初始化: 给定了数组的元素的内容,由系统指定数组的长度

格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3…} ;(推荐)
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3…} ;

简写方式:
数据类型[] 数组名称 = {元素1,元素2,元素3…} ;
int[] arr = {1,2,3,4,5,6} ;

注意: 不能动静初始化(要么动态初始化,要么静态初始化!)
int[] arr = new int[3]{1,2,3} ; 错误的

class ArrayDemo3{
	public static void main(String[] args){
		//创建一个数组,静态初始化
		int[] arr = {11,22,33,44,55} ;
		
		System.out.println(arr) ; //地址值
		System.out.println(arr[2]) ;
		System.out.println(arr[3]) ;
	}
}

内存示意：
在这里插入图片描述

五.数组的常见问题

在数组注意问题:
1)数组角标越界异常:ArrayIndexOutOfBoundsException

出现的原因:访问了数组中不存在的索引值,索引值是非法!(大于或者等于数组长度,索引值为负)
解决方案:及时检查错误,然后更新代码!

数组是引用类型,引用类型的默认值是null(空对象),
空指针异常:NullPointerException

出现的原因:
1)在数组中的,数组对象已经为null,还要访问里面的元素
2)在后期可能会使用某些类的功能的时候,但是这个类的对象已经为null了

解决方案:(在idea中,使用断点来调试程序!debug)
在某段代码中,如果出现空指针,在使用该对象的时候,进行非空判断!

class ArrayTest{
	public static void main(String[] args){
	
		//创建一个数组,静态初始化
		int[] arr = {1,2,3} ;
		
		System.out.println(arr[0]) ;
		System.out.println(arr[1]) ;
		System.out.println(arr[2]) ;
		//System.out.println(arr[4]) ; //编译不会报错,jvm 检查java语法:数组名称[索引值]访问数组的元素
	
		System.out.println("--------------") ;
		arr = null ;
		//对arr进行非空判断
		if(arr!=null){
			System.out.println(arr[0]) ;
		}else{
			System.out.println("数组对象已经为null了...") ;
		}
		
		//System.out.println(arr[0]) ; //java.lang.NullPointerException
		
		//arr=null ;  将堆内存 中没有值了(空值了),还要访问空对象中的元素!
	}
}

内存示意：
在这里插入图片描述

六：数组的应用

数组的应用:
1)遍历数组就是将数组的元素一一获取并输出

class ArryTest2{
	public static void main(String[] args){
		
//创建一个数组,静态初始化
		int[] arr = {11,22,33,44,55} ;
		//数组名称[索引值]:访问数组的元素
		
		//最原始的做法
		System.out.println(arr[0]) ; 
		System.out.println(arr[1]) ; 
		System.out.println(arr[2]) ; 
		System.out.println(arr[3]) ; 
		System.out.println(arr[4]) ; 
		System.out.println("--------------------------") ; 
		
		//冗余度非常高 
		//arr[] :数组名称[0,1,2,3,4]
		//循环改进
		//x:角标(索引值)
		for(int x = 0 ; x < 5 ; x ++ ){
			System.out.println(arr[x]) ; 
		}
		
		//创建一个数组:
		int[] arr2 = {11,23,4,5,6,8,9,78,45,30,20,22,55,120} ;
		//任何数组有一个属性:length:获取的长度
		System.out.println(arr.length) ;
		System.out.println(arr2.length) ;
		System.out.println("--------------------------") ; 
		//优化:获取数组长度
		for(int x = 0 ; x < arr.length ; x ++ ){
			System.out.println(arr[x]) ; 
		}
		
		System.out.println("--------------------------") ; 
		//学习Java中的方法:调用遍历数组的功能
		printArray(arr) ;
		System.out.println("--------------------------") ; 
		
		//int[] arr = {11,22,33,44,55} ;
		//输出的格式:[元素1, 元素2, 元素3, ...]
		printArray2(arr) ;
		
		
	}
	//最终版的代码
	public static void printArray2(int[] arr){
		//输出一个"["
		System.out.print("{") ;
		//遍历数组,获取元素内容
		for(int x = 0 ; x < arr.length ; x ++){
			//获取到了
			//判断x是否能够取到最大索引值:arr.length-1
			if(x==arr.length-1){
				//获取最大索引值对应最后一个元素
				System.out.println(arr[x]+"}") ;
			}else{
				//不是最后一个元素,中间的元素 
				//元素1, 元素2, ..
				System.out.print(arr[x]+", ") ;
			}
		}
		
	}
	
	/*
		定义一个遍历数组的功能
		两个明确
			1)明确返回值类型:void 代替
			2)明确参数类型以及参数个数
						int[]  一个参数
	*/
	public static void printArray(int[] arr){
		for(int x = 0 ; x < arr.length ; x ++ ){
			System.out.println(arr[x]) ; 
		}
	}
}

在这里插入图片描述

七.数组的最值

数组的最值
需求:给定一个数组,静态初始化,获取数组中的最大值

class ArrayTest3{
	public static void main(String[] args){
		//指定一个数组,静态初始化
		int[] arr = {69,45,87,13,24} ;
		
		//定义一个参照物:
		int max = arr[0] ; //arr[0]它是最大值
	
	
	
		//遍历数组中的后面元素,1开始
		for(int x = 1 ; x < arr.length ; x ++){
			//判断:使用后面的元素依次和这个max进行比较
			//如果后面的元素都大于max
			if(arr[x]> max){
				//改变max的值
				max = arr[x] ;
			}
		}
		
		System.out.println("数组中的最大值是:"+max) ;
		System.out.println("----------------------") ;
		int max2 = getMax(arr) ;
		System.out.println("数组的最大值是:"+max) ;
		System.out.println("----------------------") ;
		int min = getMin(arr) ;
		System.out.println("数组的最小值是:"+min) ;
		
	}
	//定义一个求最小值的方法
	public static int getMin(int[] arr){
		//定一个参照物:它是最小值
		int min = arr[0] ;
		
		for(int x = 1; x < arr.length ; x ++){
			if(arr[x] < min){
				min = arr[x] ;
			}
		}
		return min ;
	}
	
	/*
		定义一个求最大值的方法
		两个明确
			1)明确返回值类型:int
			2)明确参数类型以及参数个数
					int[]  1个参数
	*/
	public static int getMax(int[] arr){
		//定义有一个参照物
		int max = arr[0] ;
		//遍历其他元素
		for(int x = 1 ; x < arr.length ; x ++){
			if(arr[x] > max){
				max = arr[x] ;
			}
		}
		return max ;
	}
}

八.元素逆序

元素逆序
需求:
已知数组,静态初始化,将元素逆序!

举例:将这个数组元素逆序
int[] arr = {14,69,24,78,52} ;

分析:
1)已知数组,静态初始化
2)
需要将arr[0]和arr[arr.length-1] 对应的元素进行互换
arr[1]和arr[arr.length-1-1] 对应的元素进行互换…
…
…
保证数的长度arr.length/2

class ArrayTest4{
	public static void main(String[] args){
		
		//创建数组,并静态初始化
		int[] arr = {14,69,24,78,52} ;
		System.out.println("逆序前:") ;
		printArray(arr) ;
		
		System.out.println("--------------------") ;
		
		System.out.println("逆序后:") ;
		//reverse(arr) ;
		reverse2(arr) ;
		printArray(arr) ;
		
		
	}
	
	//方式2
	public static void reverse2(int[] arr){
	//start,end:索引值
		for(int start = 0 ,end = arr.length-1 ; start < end ;start ++,end -- ){
				//使用中间变量的方式
				int temp = arr[start] ; 
				arr[start] = arr[end] ;
				arr[end] = temp ;
		}
	}
	/*
		方式1:
		定义方法:逆序的方法
		两个明确
			1)明确返回值类型:void
			2)明确参数类型以及参数格式:int[] 数组 1个参数
			
			
			需要将arr[0]和arr[arr.length-1] 对应的元素进行互换
			arr[1]和arr[arr.length-1-1] 对应的元素进行互换...
			...
			...
			保证数的长度arr.length/2
			
	*/
	public static void reverse(int[] arr){
		for(int x = 0 ; x < arr.length/2; x ++){
			//采用中间变量方式互换
			int temp = arr[x] ;
			arr[x] = arr[arr.length-1-x] ;
			arr[arr.length-1-x] = temp ;
		}
	}
	
	//遍历的功能
	public static void printArray(int[] arr){
		System.out.print("[") ;
		for(int x = 0 ; x < arr.length ; x ++){
			if(x==arr.length-1){
				System.out.println(arr[x]+"]") ;
			}else{
				System.out.print(arr[x]+", ") ;
			}
		}
	}
}

九.元素查表法

元素查表法
举例: 字符串数组
String[] strs = {“星期一”,“星期二”,“星期三”,“星期四”,“星期五”,“星期六”,“星期日”} ;

键盘录入一个数据(0-6)

使用 :数组名称[索引值] 确定元素

import java.util.Scanner ;
class ArrayTest5{
	public static void main(String[] args){
		
		//已知字符串数组
		String[] strs = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ; 
	
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入
		System.out.println("请输入一个数据(0-6):") ;
		int num = sc.nextInt() ;
		
		System.out.println("当前是"+strs[num]) ;
	}
}

十.数组中的基本元素查找法

数组中的基本元素查找法:
基本查询：在数组中从头查找到末尾
高级查询: 二分搜索法(数组 折半查找)

已知一个数组,静态初始化
int[] arr = {69,78,34,200,120} ;

需求:查询34这个元素在数组的角标值(默认int)

分析:
1)创建一个数组,静态初始化
2)定义一个功能:查询元素在数组的角标值的功能
两个明确
1)明确返回值类型: int
2)明确参数类型以及参数格式
两个参数:
int[] arr
int target/key

方式1: 以后在判断:无非两种情况:要么成立,要么不成立!

先去遍历数组中的所有元素,一一获取每一个元素
判断:
如果当前要查询的target元素和arr[x]元素一致，找到了,直接x返回;
如果找不到呢? 在Java中:如果元素在数组中没有找到,返回负数:-1

class ArratTest6{
	public static void main(String[] args){
		 //已知一个数组,静态初始化
		int[] arr = {69,78,34,200,120} ;
		
		//查询34这个元素第一次在数组中出现索引值
		//int index = getIndex(arr,34) ;
		int index = getIndex2(arr,120) ;
		System.out.println("index:"+index) ;
		
		//int index2 = getIndex(arr,250) ;
		int index2 = getIndex2(arr,300) ;
		System.out.println("index2:"+index2) ;
	}
	
	
	//方式2:
	//使用一种假设思想
	public static int getIndex2(int[] arr,int key){
		//定义一个变量index
		int index = -1 ; //假设找不到
		//遍历arr数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断
			if(arr[x] == key){
				 index = x ;
				 break ;
			}
		}
		return index ;
	}
	
	//方式1:
	//定义一个功能
	//参数1:在指定的数组中查询
	//参数2:要查找的元素
	public static int getIndex(int[] arr,int target){
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//获取到元素
			//判断:如果当前要查询的target元素和arr[x]元素一致
			if(target == arr[x]){
				return x ; //找到了
			}
			
		}
		//找不到
		return -1 ;	
	}
}

十一.高级算法之冒泡排序

冒泡排序:
思想：两两比较,将较大的值往后方法,第一次比较完毕,最大值出现在最大索引处!
依次这样比较…最后得到一个排好序的数组

最终比较次数:数组长度-1次

class ArrayTest{
	public static void main(String[] args){
		
		//创建一个数组,静态初始化
		int[] arr = {24,69,87,56,13} ;
		
		System.out.println("排序前:") ;
		printArray(arr) ;
		System.out.println("-------------------") ;
		
		/*
		//第一次比较
		//arr.length-1:防止角标越界
		//arr.length-1-0:第一次比较:有0个不比 (为了减少比较的次数)
		for(int x = 0 ;x < arr.length-1-0;x ++){
			//将元素一一获取到了
			//判断:如果前面的元素比后面元素大,互换!
			if(arr[x] > arr[x+1]){
				//中间变量
				int temp = arr[x] ;
				arr[x]  = arr[x+1] ;
				arr[x+1] = temp ;
			}
			
		}
		System.out.println("第一次比较后:") ;
		printArray(arr) ;
		System.out.println("-------------------") ;
		
		//第二次比较
		//arr.length-1:为了角标越界
		//arr.length-1-1:第二次有1个不比,减少比较次数
		for(int x = 0 ; x < arr.length-1 -1; x ++){
			//将元素一一获取到了
			//判断:如果前面的元素比后面元素大,互换!
			if(arr[x] > arr[x+1]){
				//中间变量
				int temp = arr[x] ;
				arr[x]  = arr[x+1] ;
				arr[x+1] = temp ;
			}
		}
		System.out.println("第二次比较后:") ;
		printArray(arr) ;
		System.out.println("-------------------") ;
		
		
		//第三次
		//arr.length-1:为了角标越界
		//arr.length-1-2:第三次有2个不比,减少比较次数
		for(int x = 0 ; x < arr.length-1 -2; x ++){
			//将元素一一获取到了
			//判断:如果前面的元素比后面元素大,互换!
			if(arr[x] > arr[x+1]){
				//中间变量
				int temp = arr[x] ;
				arr[x]  = arr[x+1] ;
				arr[x+1] = temp ;
			}
		}
		System.out.println("第三次比较后:") ;
		printArray(arr) ;
		System.out.println("-------------------") ;
		
		//第四次
		//arr.length-1:为了角标越界
		//arr.length-1-3:第四次有3个不比,减少比较次数
		for(int x = 0 ; x < arr.length-1 -3; x ++){
			//将元素一一获取到了
			//判断:如果前面的元素比后面元素大,互换!
			if(arr[x] > arr[x+1]){
				//中间变量
				int temp = arr[x] ;
				arr[x]  = arr[x+1] ;
				arr[x+1] = temp ;
			}
		}
		System.out.println("第四次比较后:") ;
		printArray(arr) ;
		System.out.println("-------------------") ;
		*/
		
		//上面代码:冗余度非常高,循环改进 循环了四次
		/*
		for(int x = 0 ; x < 4 ; x ++){ //比较4次
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判断
				if(arr[y] > arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		System.out.println("排序后:") ;
		printArray(arr) ;
		*/
		
		//优化:上面4:我们数的,本身比较的次数:数组长度-1次
		/*
		for(int x = 0 ; x < arr.length-1 ; x ++){ //比较4次
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判断
				if(arr[y] > arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		System.out.println("排序后:") ;
		printArray(arr) ;
		*/
		
		//使用功能代码块调用
		//调用冒泡排序的方法
		bubbleSort(arr) ;
		//遍历
		printArray(arr) ;
	}
	
	//定义一个冒泡排序的功能
	//两个明确:明确返回值类型: void
			//明确参数类型以及参数个数:int[]  一个参数
	public static void bubbleSort(int[] arr){
		for(int x = 0 ; x < arr.length-1 ; x ++){ //比较4次
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判断
				if(arr[y] > arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
	}
	
	//遍历的功能
	public static void printArray(int[] arr){
		System.out.print("[") ;
		for(int x = 0 ; x < arr.length ; x ++){
			//判断
			if(x == arr.length-1){
				System.out.println(arr[x]+"]") ;
			}else{
				System.out.print(arr[x]+", ") ;
			}
		}
	}
}

在这里插入图片描述

学习使我快乐~~
关注
专栏目录
Java基础编程题（3）
编程小菜kun
09-24 281
3.改变原有数组元素的值,实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}7.数组转字符串,实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.4.打印数组,实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.
自学Java笔记_day04_第四章 数组
Java码农那些事
08-25 347
4.1 数组的相关概念和名词（了解） 1、数组(array)： ​ 一组具有相同数据类型的数据的按照一定顺序排列的集合。 ​ 把有限的几个相同类型的变量使用一个名称来进行统一管理。 2、数组名： ​ （1）这个数组名，代表的是一组数 ​ （2）这个数组名中存储的整个数组的“首地址” 3、下标(index)： ​ 我们使用编号、索引、下标来区别表示一组数当中某一个。 ​ 范围：[0,数组长度-1] ​ 例如：for(int i = 0; i<arr.length; i++){} 4
java6.0——数组的定义和使用
weixin_63056061的博客
04-18 445
目录 一，数组的基本概念 1.什么是数组 2.数组的创建和初始 (1)动态初始化 （2）静态初始化 【注意】 3.为什么使用数组 4.数组的使用 （1）数组的元素访问 （2）遍历数组 二，数组——引用类型 1.JVM 简述 2.基本类型变量和引用类型变量的区别 三，数组的应用场景 1.保存数据 2.作为函数的参数 （1）参数传基本数据类型 （2）参数传数组类型 (3)作为函数返回值 一，数组的基本概念 1.什么是数组 相同类型元素的一个集合，在内存中是一段
JavaEE
ZhaoZhiXinLiMiao的博客
11-01 325
Day06 一维数组的应用 数组的遍历(将数组中的元素一一输出出来) 1.自定义数组 int[ ] arr = {11,22,33,44,55} ; 2.数组中的属性:length 数组中的最大索引值:arr.length-1 在这里插入代码片 ...
Java当中的数组的定义与简单使用
最新发布
weixin_64308540的博客
11-06 724
Java当中的数组的定义与简单使用
JavaScript求一个数组中重复出现次数最多的元素及其下标位置示例
10-18
主要介绍了JavaScript求一个数组中重复出现次数最多的元素及其下标位置,涉及javascript数组元素遍历、判断、正则过滤、追加等相关操作技巧,需要的朋友可以参考下
Java_day25上课资料.zip
04-01
【Java_day25上课资料.zip】是一个包含Java学习资源的压缩包，可能涵盖了第25天的课程内容。从标题可以推断，这是一份针对Java编程的学习材料，适合已经有一定基础的学习者或者正在系统学习Java的人。由于没有提供...
coreJava_day2
03-17
【标题】"coreJava_day2" 指的是在学习Java编程时的第二天课程，主要集中在Core Java的基础知识上。Core Java是Java编程的核心部分，包括面向对象编程、类库、集合框架、输入输出流、多线程、网络编程等方面。在"day...
传智播客_Java培训_毕向东_Java基础源代码day02
10-22
本资源“传智播客_Java培训_毕向东_Java基础源代码day02”聚焦于Java的基础学习，由知名教育机构传智播客提供，由资深讲师毕向东指导，旨在帮助初学者快速掌握Java编程的核心概念。 源代码是编程中的关键部分，它是...
黑马程序员_毕向东_Java基础_DAY02学习笔记
longlangss的专栏
06-28 1487
------- android培训、java培训、期待与您交流！ ---------- /* 黑马程序员_毕向东_Java基础视频教程—— 0201-标识符.avi 0202-常量.avi 0203-进制的特点.avi 0204-进制转换(十进制和二进制).avi 0205-进制转换(八进制和十六进制).avi 0206-进制转换(负数二进制).avi 0207-变量.a
IDEA debug时，显示完整数组
mktb的博客
05-29 2190
修改以下设置 File -> Setting -> Build, Execution, Deployment -> Debugger -> Data Views -> Java Hide null elements in arrays and collectios 把这个选项关掉 Enable alternatice view for Collections classes 这个选项也可以关掉 更改设置前后对比 更改之前 更改之后 可以清楚的看到HashMap未指定大小时，初
二维数组练习
毕富国的博客
08-02 1156
1、创建一个称作Array2D 的类，在main()方法中声明一个称作twoD的变 量，类型为int二维数组，第一维长度为4。 2、创建一个元素类型为int的数组，该数组应包括4 个元素并被赋值到变量twoD[0]。 3、编写两个嵌套for()循环语句以打印twoD 的全部值，以矩阵的格式输出。 4、编译并运行程序。是不是发现此时出现了运行错误(空指针异常)，这是因为twoD[1]至twoD...
8.java基础---常用类API大题
weixin_44140163的博客
03-08 476
8.java基础—常用类API大题 一、需求说明：模拟登录，给三次机会，并提示还有几次。 操作步骤描述 1.定义两个字符串对象，用于存储已经存在的用户名和密码。 2.键盘录入用户名和密码 3.拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较 如果内容相同，就提示登录成功 如果内容不同，就提示登录失败，并提示还有几次机会 package com.china.homework; /*操作步骤描述 1.定义两个字符串对象，用于存储已经存在的用户名和密码。 2.键盘录入
Java编程基础06——数组
weixin_34195546的博客
08-29 133
1.数组概述和定义格式说明 A:为什么要有数组(容器)： 为了存储同种数据类型的多个值 B:数组概念： 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器；数组既可以存储基本数据类型，也可以存储引用数据类型。 C:数组定义格式：数据类型[] 数组名 = new 数据类型[数组的长度]; public class Demo_A...
从键盘给数组录入数据，并求数组中的最大值
weixin_42820509的博客
06-04 3652
从键盘给数组录入数据，并求数组中的最大值 定义一个int类型数组名为arr的数组，长度为5 int[] arr=new int[5]; 从键盘给arr数组中的元素进行赋值 Scanner sc= new Scanner(System.in); for(int n=0;n<arr.length;n++){ System.out.pritln("请输入第"+n+"个元素"); arr...
java定义int数组_怎样用java定义一个int数组
热门推荐
weixin_42173205的博客
02-12 2万+
展开全部数组：是一组相关变量的集合数组是一组相关数据的集合，一个数组实际上就是32313133353236313431303231363533e4b893e5b19e31333363373731一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组数据的有点不使用数组定义100个整形变量：int i1;int i2;int i3使用数组定义 int i[100];数组定义：int i[10...
javaday05-数组
First 007的博客
12-06 848
05.01_Java语言基础(数组概述和定义格式说明)(了解) A:为什么要有数组(容器) 为了存储同种数据类型的多个值 B:数组概念数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。 数组既可以存储基本数据类型，也可以存储引用数据类型。 C:数组定义格式 数据类型[] 数组名 = new 数据类型[数组的长度]; class Demo1_Array {public static v
数组知识点
zhuimengtianya33的博客
08-25 513
黑马程序员 数组知识点 ------- android培训、java培训、期待与您交流！---------- 1:方法的概念?方法的格式?格式的解释说明 2:方法的调用 A:明确返回值类型的方法调用 B:void类型的方法调用 3:方法的练习： A:求两个数据之和 B:判断两个数据是否相等 C:获取两个数中较大的值 D:打印m
数组--数组的初始化--静态初始化
赤兔胭脂小吕布的博客
11-29 369
静态初始化 初始化时指定每个数组元素的初始值，由系统决定数组长度。 格式： 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…}; 举例： int[] arr = new int[]{1,2,3}; 解释： 定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。 其实这种写法还有一个简化的写法 ： int[] arr = {1,2,3}; ...
Java开发入门：理解JVM内存模型与数组
此外，还详细介绍了数组的定义、初始化及其在Java编程中的应用。" 在Java开发中，数组是一种非常基础且重要的数据结构。数组允许我们存储一组具有相同类型的元素，这对于处理批量数据非常有用。在Day04的学习中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值