JAVASE基础知识（七）数组---增强for循环

最新推荐文章于 2024-05-15 16:39:25 发布
最新推荐文章于 2024-05-15 16:39:25 发布
阅读量311 收藏
点赞数 1
文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44804206/article/details/105155821
版权

温故知新

  1. 标号：
  • break 标号：可以直接结束，标号所对应的循环
  • continue 标号：可以直接跳转到标号所对应的循环的迭代 for 或while
  1. 方法：
  • 好处：代码复用，功能模块
  • 定义方法语法：
    【各种修饰符 】返回类型（java 支持的任意类型+void ）方法名（参数列表）{方法体}
    3.return：
    方法一旦返回（结束 ）在方法中定义的局部变量在栈中分配内存，都将自动回收。

4.cpu:寄存器，其次是栈，最后是堆

5.方法的重载：overload:在同样一个类内部，方法名字相同，参数列表不同，与返回类型无关

//定义方法，对应指定概率事件，求本次事件是否发生的方法

/*实现一场战斗
亚瑟 VS 后裔
每个英雄 赋值 初始血量 1000，
每个英雄 伤害随机
亚瑟 damage[30,50)暴击率30% 暴击 伤害1.8
后裔 damage[20,40) 暴击率50% 暴击伤害2
然后普通攻击和暴击要求不同的输出内容，输出本次伤害，和对方剩余的血量
一人一刀互相伤害
使用循环模拟两人的一场战斗
最终输出结果，谁胜利，剩余血量**/ 
public class Test1 {
	//主函数
	public static void main(String[] args){
		damage();
	}
	//定义方法对应指定的概率的事件，求本次事件是否发生的方法
	public static boolean isHappened(double precent){
		return Math.random()<precent;
	} 
	//获取0,1随机数
	 public static int suiJi(int a,int b){
		return (int)(Math.random()*(b-a));
	}
	 //随机产生伤害方法
	 public static double getDamage(double min,double max){
		 return Math.random()*(max-min)+min;
	 }
	 
	 //王者荣耀峡谷之战
	public static void damage(){
		//默认初始生命值
		final double HP=1000;
        //亚瑟的相关属性
        final double YASE_DAM_MIN=30;
        final double YASE_DAM_MAX=50;
        final double YASE_CRITICAL_PERCENT=0.3;
        final double YASE_CRITICAL_DAM=1.5;
        //后裔的相关属性
        final double HOUYI_DAM_MIN=20;
        final double HOUYI_DAM_MAX=40;
        final double HOUYI_CRITICAL_PERCENT=0.5;
        final double HOUYI_CRITICAL_DAM=2;
        //随机数
        final int SUIJIMAX=3;
        final int SUIJIMIN=1;
        //初始化两个人物的血量
        double yaseHP=HP,houyiHp=HP;
        System.out.println("=====两人相遇战斗开始=====");
        while(yaseHP > 0 && houyiHp > 0){
            if(suiJi(SUIJIMIN, SUIJIMAX)==1){
            	System.out.println("亚瑟先手");
            	//亚瑟造成随机伤害
            	double yase =getDamage(YASE_DAM_MIN, YASE_DAM_MAX);
            	//是否产生暴击
            	boolean isCritical=false;
            	if(isHappened(YASE_CRITICAL_PERCENT)){
            		isCritical=true;
            	}
            	if(isCritical){
            		yase*=YASE_CRITICAL_DAM;
            		System.out.println("亚瑟挥舞一刀造成暴击伤害"+yase);
            	}else{
            		System.out.println("亚瑟挥舞一刀造成伤害"+yase);
            	}
            		houyiHp=houyiHp-yase<0?0:houyiHp-yase;
            		System.out.println("后裔剩余血量"+houyiHp);
            }else{
            	System.out.println("后裔先手");
            	//后裔造成随机伤害
            	double houyi =getDamage(HOUYI_DAM_MIN, HOUYI_DAM_MAX);
            	//是否产生暴击
            	boolean isCritical=false;
            	if(isHappened(HOUYI_CRITICAL_PERCENT)){
            		isCritical=true;
            	}
            	if(isCritical){
            		houyi*=HOUYI_CRITICAL_DAM;
            		System.out.println("后裔射出一箭造成暴击伤害"+houyi);
            	}else{
            		System.out.println("后裔射出一箭造成造成伤害"+houyi);
            	}
            		yaseHP=yaseHP-houyi<0?0:yaseHP-houyi;
            		System.out.println("亚瑟剩余血量"+yaseHP);
            }
    	}
        if(houyiHp==0){
        	System.out.println("后裔战死");
        }else if(yaseHP==0){
        	System.out.println("亚瑟战死");
        } 
	}   
}

数组

练习

public class Test1 {
	//主函数
	public static void main(String[] args){
		getScoreArray();
	}
	//利用数组查看随机十个学生的成绩
	public static void getScoreArray(){
		final int count=10;
		final int MAX=101;
		final int MIN=60;
		int sum=0;
		//定义一个数组，这个数组要保存十个学生的分数。
		//数组是一种数据类型。
		//使用new关键字 向jvm申请内存空间
		int[] scores =new int[count];
		//数组中的每一个数，数组的元素element
		//数组元素本质上就是一个变量，和变量的使用方式是一样
		//如何访问每个元素，通过数组变量名[元素序号]
		//元素的序号从0开始，到元素的数量-1，序号连续
		for (int i = 0; i < count; i++) {
			//将随机分数逐个赋值给每个元素变量
			//int score=(int)getDamage(MIN, MAX);
			scores[i]=(int)getDamage(MIN, MAX);
			System.out.println("score【"+i+"】:"+scores[i]);
			sum+=scores[i];
		}
		System.out.println("总分"+sum);
		for (int i = 0; i < count; i++) {
			System.out.println("score:"+scores[i]);
		}
	}
	//得到十个随机的学生的分数【60-101】，然后求学生的分数的总分数和平均值
	public static int getSum(){
		final int count=10;
		final int MAX=101;
		final int MIN=60;
		int sum=0;
		for (int i = 0; i < count; i++) {
			int score=(int)getDamage(MIN, MAX);
			System.out.println("score:"+score);
			sum+=score;
		}
		return sum;
	}
	//定义方法对应指定的概率的事件，求本次事件是否发生的方法
	public static boolean isHappened(double precent){
		return Math.random()<precent;
	} 
	//获取0,1随机数
	 public static int suiJi(int a,int b){
		return (int)(Math.random()*(b-a));
	}
	 //随机产生伤害方法
	 public static double getDamage(double min,double max){
		 return Math.random()*(max-min)+min;
	 }
}

数组详解

数组是一个对象。是一个具有同种数据类型变量集合
定义数组：
语法：

元素类型[] 数组变量名=new 元素类型[元素个数]。
int [] scores =new int [10];

元素类型：java 支持的任意类型。
【】：代表这是数组
new :😗*java的关键字。用来向jvm申请空间的

数组内存分配图

在这里插入图片描述

数组的特点和属性

  1. 数组中只能存储一种类型的数据。
  2. 数组中保存的每个变量称为数组元素element .
  3. 数组的元素在堆内存中被分配空间而且元素的空间是连续分配的
  4. 数组的每个元素都有一个序号称为数组下标，数组的索引，数组的角标。数组元素的下标从0开始连续递增
  5. 数组有一个属性一个长度属性，一个int 类型的长度的属性。使用【数组名.leagth】得到数组的长度，元素的个数
  6. 数组的元素的下标的取值范围【0~length-1】
  7. 数组中的元素的使用和普通的变量的使用方式一致，数组名【下标】
  8. 数组元素一旦在堆中被分配了内存中被分配了空间，那么都会有默认值
  9. 数组变量名又可以称为数组引用，保存都是数组元素在堆内存中的首地址，数组变量指向堆内存中实际数组数据

数组初始化

如何初始化数组：
两种方式：

  • 动态初始化：
int [] scores=new int[10];//元素被jvm进行默认初始化
  • 静态初始化
int [] scores=new int[]{1,2,3,4,5};
int [] scores={1,2,3,4,5};

练习查找元素

package com.zhangjie.main;

import java.util.Random;
import java.util.Scanner;


public class Test1 {
	//主函数
	public static void main(String[] args){
		int [] arr=getRandomArrays(10, 0, 21);
		printArrays(arr);
	}
	//定义一个方法根据给定的长度，动态初始化一个int 类型元素数组，然后对元素随机赋值根据给定的区间，并返回该数组
	public static int[] getRandomArrays(int length,int min,int max){
		//动态初始化一个int 类型
		int[] arr =new int[length];
		//对数组进行赋值
		for (int i = 0; i < arr.length; i++) {
			arr[i]=(int)getRandom(min, max);
			
	}
		return arr;
	}
	//打印数组元素
		public static void printArrays(int[] arrays){
			System.out.print("[");
			for (int i = 0; i < arrays.length; i++) {
				System.out.print(arrays[i]+",");
			}
			System.out.print("]");
			
		}
	//定义一个boolean 类型数组，动态初始化，长度随机【5-10】并打印输出数组长度。然后对数组元素随机赋值Random提供nextBoolean方法
	//遍历输出数组的元素的内容。
	public static void testArraysBoolean(){
		final int MIN=5;
		final int MAX=10;
		int length =(int)getRandom(MIN, MAX);
		System.out.println("length="+length);
		boolean[] bools=new boolean[length];
		Random rand=new Random();
		for (int i = 0; i < bools.length; i++) {
			bools[i]=rand.nextBoolean();
		}
		for (int i = 0; i < bools.length; i++) {
			System.out.println(bools[i]);
		}
	}
//	写一个方法；功能要求：定义一个byte 类型的数组，长度自定义输入，静态初始化，元素的数值要求随机【10-100】
	public static void testByte(){
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输出数组长度：");
		int length=scanner.nextInt();
		byte [] bytes=new byte[length];
		
		for (int i = 0; i < bytes.length; i++) {
			bytes[i]=(byte)getRandom(0, 100);
			System.out.println(bytes[i]);
		}
	}
	//利用数组查看随机十个学生的成绩
	public static void getScoreArray(){
		final int count=10;
		final int MAX=101;
		final int MIN=60;
		int sum=0;
		//定义一个数组，这个数组要保存十个学生的分数。
		//数组是一种数据类型。
		//使用new关键字 向jvm申请内存空间
		int[] scores =new int[count];
		//数组中的每一个数，数组的元素element
		//数组元素本质上就是一个变量，和变量的使用方式是一样
		//如何访问每个元素，通过数组变量名[元素序号]
		//元素的序号从0开始，到元素的数量-1，序号连续
		for (int i = 0; i < count; i++) {
			//将随机分数逐个赋值给每个元素变量
			//int score=(int)getDamage(MIN, MAX);
			scores[i]=(int)getRandom(MIN, MAX);
			System.out.println("score【"+i+"】:"+scores[i]);
			sum+=scores[i];
		}
		System.out.println("总分"+sum);
		for (int i = 0; i < count; i++) {
			System.out.println("score:"+scores[i]);
		}
		
	}
	//得到十个随机的学生的分数【60-101】，然后求学生的分数的总分数和平均值
	public static int getSum(){
		final int count=10;
		final int MAX=101;
		final int MIN=60;
		int sum=0;
		for (int i = 0; i < count; i++) {
			int score=(int)getRandom(MIN, MAX);
			System.out.println("score:"+score);
			sum+=score;
		}
		return sum;
	}
	//定义方法对应指定的概率的事件，求本次事件是否发生的方法
	public static boolean isHappened(double precent){
		return Math.random()<precent;
	} 
	//获取0,1随机数
	 public static int suiJi(int a,int b){
		return (int)(Math.random()*(b-a));
	}
	 //随机产生伤害方法
	 public static double getRandom(double min,double max){
		 return Math.random()*(max-min)+min;
	 }
}

数组练习：最大值

public class Test1 {
	//主函数
	public static void main(String[] args){
		int [] arr=getRandomArrays(10, 0, 21);
		printArrays(arr);
		int max=maxArray(arr);
		System.out.println("最大值"+max);
		}
	//自定义方法实现任意 int 类型的元素的数组，求出该数组的最大值
	public static int maxArray(int[] array){
		int max =array[0];
		//将元素的最大值赋值给max
		for (int i = 1; i < array.length; i++) {
			if(array[i]>max){
				max=array[i];
			}
		}
		return max;
	}
}

数组作为参数元素交换
方法操作的是形参，形参是对实际参数的拷贝，无法改变实际参数的值。

package com.zhangjie.main;

public class Test1 {
	//主函数
	public static void main(String[] args){
		int [] arr=getRandomArrays(2, 0, 21);
		printArrays(arr);
		changeValue(arr);
		printArrays(arr);
		
		}
	public static void changeValue(int[] arr){
		int temp =arr[0];
		arr[0]=arr[1];
		arr[1]=temp;
	}
	//定义一个方法根据给定的长度，动态初始化一个int 类型元素数组，然后对元素随机赋值根据给定的区间，并返回该数组
	public static int[] getRandomArrays(int length,int min,int max){
		//动态初始化一个int 类型
		int[] arr =new int[length];
		//对数组进行赋值
		for (int i = 0; i < arr.length; i++) {
			arr[i]=(int)getRandom(min, max);
	}
		return arr;
	}
	//打印数组元素
		public static void printArrays(int[] arrays){
			System.out.print("[");
			for (int i = 0; i < arrays.length-1; i++) {
				System.out.print(arrays[i]+",");
			}
			
			System.out.print(arrays[arrays.length-1]+"]\n");
		}
	 //随机数方法
	 public static double getRandom(double min,double max){
		 return Math.random()*(max-min)+min;
	 }
}

删除数组元素：效率不高
删除元素（指定下标）：直接在原数组上删除，后续的元素需要整体前移。（最后的元素不需要处理）。最后返回数组的有效数据的个数。

//删除元素（指定下标）：直接在原数组上删除，后续的元素需要整体前移。（最后的元素不需要处理）。最后返回数组的有效数据的个数
public static int removeElementByIndex(int [] srcArray,int removeIndex){
		//原数组，堆内存里面没有空间
		if(srcArray==null){
			return -1;
		}
		int len=srcArray.length;
		//元素长度为0
		if(len==0){
			return 0;
		}
		//removeIndex 不在 区间内之内
		if(removeIndex<0 || removeIndex>len-1){
			return -2;
		}
		//逐个移位
		for (int i = removeIndex+1; i < len; i++) {
			//将当前i的位置上的值赋值给它前面的一个元素的值i-1
			srcArray[i-1]=srcArray[i];
		}
		return len-1;
	}

数组中插入元素

//插入一个元素：后续元素整体后移，挤掉最后一个元素
	public static void insertElementByIndex(int[] srcArray,int insertIndex,int value){
		
		for (int i =srcArray.length-2; i >=insertIndex ; i--) {
			srcArray[i+1]=srcArray[i];
		}
	}

增强for循环
jdk1.5版本之后才有的。
作用：用来遍历容器。可以用来遍历数组只能用来遍历元素
使用增强的for 循环访问的数组的数据，都是原数组元素的copy
语法：

int []arr=new int[10];
for(int value :arr){
}
arr 是被遍历的数组
value 是循环每迭代一次，从arr中顺序的取出的元素的值
for(int i=0;i<arr.length;i++){
arr[i];
}

总结：
增强的for 循环，只能遍历元素

java张小生
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javase基础自学笔记-java开端-概述
05-07
了解这些基础知识后，你可以编写、编译和运行简单的Java程序，例如经典的"Hello, World!"。 学习Java SE，你需要掌握以下核心概念： 1. **基本数据类型**：包括整型（byte, short, int, long）、浮点型（float, ...
杂记一——数组集合的遍历（增强for循环的使用）
abingR的博客
03-07 1510
1，增强for循环的使用 增强型for循环使用起来比较方便，代码也比较简单，如果只是操作集合中元素的而不使用索引的话，建议用此方法。 对于普通for循环，如果需要使用索引进行其它操作的话，建议用这个。 详细来说： 1，区别： 增强for循环必须有被遍历的目标（如集合或数组）。 普通for循环遍历数组的时候需要索引。 增强for循环不能获取下标，所以遍历数组时最好使用普通for循环。 ...
数组增强for循环遍历
m0_52318340的博客
07-01 2488
二维数组增强for循环遍历： 对于二维数组的增强for循环遍历，说白了就是，二维数组的遍历就是一个一维数组在对其一维数组下的每一个数组进行循环遍历。 遍历结果：
Java | 增强for底层工作机制
最新发布
很高兴你能看到这里
05-15 984
在Java中，增强for循环是一种语法糖。本文简单探究一下它的底层工作机制。
增强for循环和一般for循环的对比使用
做笔记\记录遇到的程序bug
09-26 1265
增强for循环(也称for each循环) 是迭代器遍历方法的一个“简化版”，是JDK1.5以后出来的一个高级for循环专门用来遍历数组和集合。其内部原理是一个Iteration迭代器，在遍历数组/集合的过程中，不能对集合中的元素进行增删操作。
增强for循环的使用（数组和集合遍历尤为简单）
m0_52646273的博客
05-11 1579
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。 格式： for(元素的数据类型 变量 : Collection集合or数组){ //写操作代码 } 它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。 package day02collection; import java.util.A
2020老杜最新Java零基础进阶视频教程-数组课件
12-10
【Java数组基础知识】 Java数组是Java编程中基本的数据结构之一，它是存储一组具有相同类型的数据的集合。在Java中，数组被当作一种引用类型，这意味着数组本身是在堆内存中分配的，而数组的元素可以是基本类型（如...
张龙老师JAVASE视频源源码11-完.rar
04-07
在Java基础部分，学习者可能会接触到变量、数据类型、运算符、控制结构（如if语句、for循环、while循环）、方法定义与调用、数组等核心概念。 2. **面向对象编程**：作为Java的核心特性，面向对象编程（OOP）是Java...
100个JavaSE 经典例子（1-10）
08-04
以上十个实例覆盖了JavaSE的基础知识点，通过这些实例的学习，开发者可以逐步建立起对Java编程的全面理解。在实践中，不断尝试和调试这些示例，将有助于巩固理论知识，并提升编程技能。对于初学者来说，这是一个很好...
JavaSE--思维导图解析
07-26
JavaSE 是 Java Standard Edition 的缩写，指的是 ...以上是 JavaSE 的思维导图解析，涵盖了 Java 语言的基础知识、语言特性、数据类型、变量、常量、类型转换、运算符、逻辑控制、方法、递归、数组等方面的知识点。
java for循环与增强for循环
11-28
增强型的for循环 和普通for循环一样 增强型的for循环 优点主要体现在集合中，随便举个例子 比如对 set 的遍历 一般是迭代遍历
Java自学-数组 增强型for循环
我的博客
03-19 1188
Java 中如何使用增强for循环 增强型for循环在遍历一个数组的时候会更加快捷 步骤 1 : 增强型for循环 注：增强型for循环只能用来取值，却不能用来修改数组里的值 public class HelloWorld { public static void main(String[] args) { int values [] = new int[]{18,62,6...
遍历数组和集合可以用增强for语句来实现
hackjava的专栏
08-21 3365
数组和集合可以用for增强来遍历：                 int[] arr = { 1, 2, 3, 4, 5 };                 // 旧式方式               for (int i = 0; i
数组系列教材 （四）- Java 中如何使用增强for循环
weixin_50279139的博客
09-21 229
数组系列教材 （四）- Java 中如何使用增强for循环 增强型for循环在遍历一个数组的时候会更加快捷 步骤1:增强型for循环步骤2:练习-最大值步骤3:答案-最大值 步骤1:增强型for循环 注：增强型for循环只能用来取值，却不能用来修改数组里的值 publicclassHelloWorld { publicstaticvoidmain(String[] args) { intvalues [] =newint[]{1...
【数组】数组的使用 for Each循环 增强for循环
xiaodogeeg的博客
12-02 103
package com.zhen.array; //数组的使用 for Each循环 增强for循环 public class ArrayDemo04 { public static void main(String[] args) { int [] a = {1,2,3,4,5,6}; // 数组的类型 数组的每一个元素 数组的名称 //没有下标，适合打印数组元素，不适合去操作里面的数组元素 // for (int i.
Java基础教程——数组与增强型for循环
RedstoneCuberoot的博客
03-05 831
为什么要使用数组？ 经过学习，我们可以通过编写程序来解决一些较复杂的问题了但是当需要处理的数据过多时，仅仅依靠普通的变量是不够的，即使简单的问题也可能需要复杂的程序来解决、处理。 举例：有五十只小狗，将他们的名字储存到计算机中，用程序如何解决呢？ 首先我们要定义五十个变量： String name1,name2,name3,…,name50 = new String(“”); 如果这样写的话就代表省略号部分的所有变量都要表示出来，这导致程序十分繁琐。有的人说：这不简简单单，复制（c）粘贴（v）就可
增强for循环遍历数组集合
GZL的博客
10-21 2920
for(元素类型 局部变量名,数组集合地址)
java数组——数组的遍历（普通for循环，增强for循环）
热门推荐
weixin_45397671的博客
07-14 1万+
普通for循环 数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。 例： publicclassTest{ publicstaticvoidmain(String[]args){ int[]a=newint[4]; //初始化数组元素的值 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值