JAVA学习第二周(笔记总结)内含三种循环结构以及基础数组知识,适合初学者学习

JAVA学习第二周(笔记总结)(包含循环结构和数组以及jvm内存图、随机数等基本知识)

如有侵权,联系作者立马删!!

循环结构

为什么需要循环？

因为有一些问题需要进行多次重复，为了简化编程结构出现的一种程序结构；比如:输出1,2,3,4,5你可以直接输出，但是输出1,2,3…n-1,n,n+1就要用到循环结构了。

循环的定义:

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构,它根据循环体中的条件判断继续执行某个功能还是退出循环,根据判断条件，循环结构又可细分以下两种形式:***先判断后执行的循环结构(while/for)***和先执行后判断的循环结构(do-while)。

while循环

public class Demo001{
    public static void main(String[] args){
        //while循环的语法格式
        int i = 0;  //声明并初始化循环变量
        while(循环条件){
            //循环体 (注:要循环运行的代码)
        }
        
    }
}

while循环的执行顺序一般如下:

1. 声明并初始化循环变量
2. 判断循环条件是否满足,满足执行循环体,否则退出循环
3. 若条件满足执行完一遍循环后,继续判断条件是否成立

do-while循环

该循环语句和while循环类似，二者最大的区别是do-while循环无论条件是否成立,至少都会执行一次

public class Demo002{
    public static void main(String[] args){
        //do-while循环语法
        do{
            //循环体
        }while(循环条件); //切记:while后面的分号(;)一定不能少
    }
}

执行顺序如下：

1. 声明并初始化循环变量
2. 执行一遍循环操作
3. 判断循环条件，如果循环条件满足，则循环继续执行，否则退出循环

---

while和do-while的异同

相同点: 都属于循环结构，功能一致

不同点: 语法不同、执行次序不同

‍♂ 在一开始循环条件就不满足的情况下，while循环结构一次都不会执行，do-while循环结构不管什么情况都至少执行一次

for循环

for循环在实际开发中使用最频繁,一般推荐在确定循环次数时使用

public class Demo003{
    public static void main(String[] args){
        //for循环语法
        for(初始部分; 条件判断; 迭代部分){
            //循环体
        }
        //初始部分:设置循环变量赋初值 例如:int i = 1;
        //循环体:重复执行的代码
        //迭代部分:通常用来修改循环变量的值,也是循环语句中最重要的一点,没有它,很有可能构成死循环
        //条件判断(循环条件):判断是否继续循环的条件 例如: i <= 100
    }
}

for循环注意点:

1. 括号内三个表达式必须使用分号(;)隔开
2. 括号内的三个表达式可以省略不写,但是分号(;)必须在
3. 缺少的表达式应该在其他部分添加,否则可能造成死循环

---

⭕️ for循环执行顺序（重点）

1. 执行初始部分(int i = 1)
2. 进入循环条件判断( i <= 100)
3. 根据循环条件判断结果
   • 如果为true，则执行循环体
   • 如果为false，则退出循环，步骤4、5均不执行
4. 执行迭代部分，改变循环变量值(i++)
5. 依次重复步骤2~步骤4，直到条件不满足退出for循环结构

//举例：通过for循环依次遍历1,2,3,4...100
public class Demo004{
    public static void main(String[] args){
        for(int i = 1; i <= 100; i++){
            System.out.println("输出i值" + i);
        }
         /*
            	初始化变量i=1,判断i是否小于等于100,成立(true)则输出 “输出i值1”
            然后i++,继续判断条件 2 <= 100 ,成立则继续输出...,直到i值为101,条件
            101 <= 100 不成立,循环结束..
         */
    }
}

三种循环结构的总结

• 编写循环结构代码是需注意：循环变量的初值，循环操作中对循环变量值的改变
• 掌握循环条件三者间的关系，确保循环次数正确，不要出现*“死循环”*
• while/for循环的特点是***先判断,后执行***; do-while循环的特点是***先执行,再判断***

---

聊完三种循环语句，再来说一下初学者面对循环最容易犯的错误: ”死循环“

造成死循环的原因一般都是循环变量设置不当、循环条件根本无法满足、循环次数没有叠加、或者由循环体导致的原因等等…

如何解决死循环

1. 代码规范，条件正确
2. 用break跳出循环
3. 设置循环到某个数，跳出循环

---

break和continue

• break
  1. break用于switch语句中,终止switch语句
  2. break用于循环时,跳出循环(若有循环嵌套,break在哪个循环内部就结束哪个循环)
  3. break用于其他地方毫无意义
  • continue
    1. continue在循环中,跳出本次循环,继续执行下一次循环
    2. continue在其他地方毫无意义

若存在循环嵌套,break和continue还可以结束或跳过外层循环

public class Demo005{
	public static void main(String[] args){
		label:for(int i=0;i<10;i++){
				for(int j=0;j<8;j++){
                    System.out.print(j);
                    if(j%2!=0){
                        break label; // 结束外层循环，即label所指代码处
                    }
				}
		}
	}
}
/*
	以上程序的执行结果为：0 1
*/

循环的嵌套（以for循环举例）

主要有两种类型的for循环嵌套

1. 内外循环独立运行
2. 内部循环依赖于外部循环

//内外循环独立运行举例
public class Demo006{
    public static void main(String[] args){
        for(int i = 0; i < 5; i++){
            for(int j = 0; j < 5; j++){ //外层循环一次,内侧循环五次，总共循环25次，内外互不影响
                System.out.print("*"); //输出星号(*)
            }
            System.out.println(); //换行标记
        }
    }
}
/*
	以上程序的执行结果为:
           *****
           *****
           *****
           *****
           *****
*/

//内部循环依赖于外部循环
public class Demo006{
    public static void main(String[] args){
        for(int i = 0; i < 5; i++){
            for(int j = 0; j <= i; j++){ //内部循环的条件随外部循环的i值而变化,每一次的条件都在变
                System.out.print("*"); //输出星号(*)
            }
            System.out.println(); //换行标记
        }
    }
}
/*
	以上程序的执行结果为:
           *
           **
           ***
           ****
           *****
*/

当然以上只是1个循环嵌套的举例，循环嵌套可以嵌套多个,其原理和以上基本一致,主要在于掌握它是如何运行的，了解内外层循环直接的直接或间接的关系

---

数组

数组的定义

简单来说，数组就是一个长度规定的容器,该容器内可以装类型一致的变量或值，指的就是一组相关变量的集合。 例如:现在想要定义100个整型变量，如果按照传统思路:int i1,i2,i3…i100，一共写100个变量。

动态初始化

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

public class Demo007{
    public static void main(String[] args){
        int[] arrays = new int[5]; //表示定义了一个int类型的数组,其内包含5个int类型的元素
    }
}

静初始化

数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，元素3};

数据类型[] 数组名称 = {元素1，元素2，元素3};

静态初始化的同时就已经将数组长度固定了,比如上面的数组长度即为3

public class Demo007{
    public static void main(String[] args){
        //定义int类型数组,并初始化其值
       	//方式1:
        int[] arrays = new int[]{1,2,3,4,5}; 
        //方式2:
        int[] arrays1 = {1,2,3,4,5}; 
    }
}

当数组开辟空间之后，那么可以采用“数组名称[下标|索引]”的形式访问，但是数组的下标都是*从0开始，即：如果是长度的为3的数组，下标的范围：0 ~ 2 (0、1、2一共是3个元素), 如果访问的时候超过了数组的允许下标长度，就会出现数组下标越界异常（ArrayIndexOutOfBoundsException）

public class Demo008{
    public static void main(String[] args){
      int[] arrays = new int[3];//定义长度为3的int类型数组
        System.out.println(arrays[3]);
    }
}

运行结果如下：

数组在内存中的存储形式:

JVM内存简概

方法区	方法区内存一般用来放一些字节码文件(.class文件)和常量池、静态变量等
堆内存	堆内存中存放实例变量和new出来的实例对象(实例变量:没有static修饰的变量)
栈内存	栈内存中存放局部变量,即方法内部定义的变量，方法的运行在栈中运行
本地方法栈	本地方法栈英文全称 Native Method Stack 是存放本地方法的地方。
寄存器	指cpu内部的一部分,主要用来算术运算,其运算速度在内存和cache缓存之上

---

s = s + 1 和 s += 1 的区别：

如果s的数据类型小于int类型，如short s = 10，则s = s + 1会发生编译异常(InputMismatchException)，而s += 1则不会出现任何问题，因为s += 1有隐式强制类型转换，会自动提升将类型转换为等号左边的属性类型。

==和equals比较有什么区别?

==：如果比较的对象是基本数据类型，则比较的是数值是否一致;如果比较的是引用数据类型，则比较的是对象的内存地址是否一致。

equals()：equals()默认用来比较对象的地址是否一致,一般是用在引用数据类型之间的比较，不能用于比较基本数据类型,如果对象和自身进行比较，则equals()方法与==的作用是一样的。

---

随机数的生成方式

1. Math.random()的方法生成，返回一个0-1之间的double值(不包括1本身)
2. 通过Random类来产生I一个随机数,这个是专业的Random工具类，功能强大（java.util包下）

import java.util.Random; //导入util包下的Random类
public class Demo009{
    public static void main(String[] args){
        //实例化Random对象
        Random random = new Random();
        random.nextInt(10); //生成一个0-10之间的随机数(不包含10本身)
    }
}

生成任意范围内的随机数（重点）

// randNumber 将被赋值为一个 MIN 和 MAX 范围内的随机数
int randNumber =rand.nextInt(MAX - MIN + 1) + MIN;

作者:胡亦
时间:2021年11月22日19:37:04
文章如有错误或不足，欢迎各位大佬指教!!~