小黑子—Java从入门到入土过程：第四章
Java零基础入门4.0
- Java系列第四章
-
- 1. 顺序结构
- 2. if语句
- 3. switch 语句
-
- 3.1 default的位置和省略
- 3.2 case 穿透
- 3.3 switch 新特性 （jdk12开始）
- 4. for 循环
- 5. while 循环
- 6.do...while 循环
- 7. 无限循环
- 8. 跳转控制语句
- 9. 练习
-
- 9.1 逢七过
- 9.2 平方根
- 9.3 求质数
- 10. 随机数
- 11. 数组
-
- 11.1 数组的地址
- 11.2 数组索引
- 11.3 数组的遍历
- 11.4 数组的动态初始化
- 12. 数组练习
-
- 12.1 求最值
- 12.2 遍历数组求和
- 12.3 交换数据
- 12.4 打乱数据
- 13. 数组的内存图
Java系列第四章
1. 顺序结构
2. if语句
3. switch 语句
3.1 default的位置和省略
- 1.位置 : defaule不一定是写在最下面的，我们可以写在任意位置。只不过习惯会写在最下面
- 2.省略: defaule可以省略，语法不会有问题，但是不建议省略。
3.2 case 穿透
就是语句体中没有写break导致的。
执行流程:
- 首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配。
- 如果匹配上了，就会执行对应的语句体，如果此时发现了break，那么结束整个switch语句。
- 如果没有发现break，那么程序会继续执行下一个case的语句体，一直遇到break或者右大括号为止。
- 如果多个case的语句体重复了，那么我们考虑利用case穿透去简化代码。
3.3 switch 新特性 （jdk12开始）
支持箭头表达式返回
import org.junit.Test;
enum Gender {
MALE, FEMALE, UNKNOWN;
}
public class TestX {
private Gender gender = Gender.MALE;
@Test
public void show() {
switch (gender) {
case MALE:
System.out.println("男");
break;
case FEMALE:
System.out.println("女");
break;
default:
throw new IllegalStateException(gender.toString());
break;
}
}
}
Java 新特性 的 switch 表达式使用箭头表达时，不需要在每一个 case 后都加上 break。
@Test
public void show() {
switch (gender) {
case MALE -> System.out.println("男");
case FEMALE -> System.out.println("女");
default -> throw new IllegalStateException(gender.toString());
}
4. for 循环
package com.itheima.demo1;
import java.util.Scanner;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//分析:
//1.键盘录入两个数字
Scanner sc = new Scanner(System.in);
System.out.print("请录入一个数字表示范围的开始：");
int start = sc.nextInt();
System.out.println("请录入一个数字表示范围的结束：");
int end = sc.nextInt();
// 统计变量
//简单逻辑，统计符合要求的数字个数
int count = 0;
//2.利时循环获取这个范围中的每一个数字
for (int i = start; i <= end; i++) {
//3.对每一个数字进行判断，统计有多少个满足要求的数字
if (i % 3 == 0 && i % 5 == 0) {
count++;
}
}
System.out.println(count);
}
}
5. while 循环
for 和 while 的对比
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//分析:
//1.定义数字
int x = 123321;
//定义一个临时变量用于记录×原来的值，用于最后进行比较
int temp = x;
//记录倒过来之后的结果
int num = 0;
//2.利用循环开始
while (x != 0) {
//从右往左获取每一位数字
int ge = x % 10;
//修改下x记录的值
x= x/10;
//把当前获取到的数字拼接到最右边
num = num * 10 + ge;
}
System.out.println(num);
System.out.println(x);
System.out.println(num == temp);
}
}
6.do…while 循环
7. 无限循环
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
// for 格式的无限循环
for(;;){
System.out.println("wdnmd");
}
}
}
可以按红色的方块暂停
8. 跳转控制语句
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
if(i==3){
continue;
}
System.out.println("wdnmd"+i+"fk");
}
}
}
2.
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
if(i==3){
break;
}
System.out.println("wdnmd"+i+"fk");
}
}
}
9. 练习
9.1 逢七过
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
for (int i = 1; i <=100; i++) {
if(i%10==7||i/10%10==7||i%7==0){
System.out.println("过");
continue;
}
System.out.println(i);
}
}
}
9.2 平方根
package com.itheima.demo1;
import java.util.Scanner;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int number = sc.nextInt();
for (int i = 1; i < number; i++) {
if (i * i == number) {
System.out.println(i + "就是" + number + "的平方根");
break;
} else if (i * i > number) {
System.out.println((i - 1) + "就是" + number + "平方根的整数部分");
break;
}
}
}
}
9.3 求质数
- 标记法
package com.itheima.demo1;
import java.util.Scanner;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int number = sc.nextInt();
//定义一个变量，表示标记
// 标记着number是否为一个质数
// true:是一个质数
//false :不是一个质数
boolean flag = true;
for (int i = 2; i < number; i++) {
// i 表示依次表示这个范围之内的每一个数字
//看number是否能被i整除就可以了
if(number%i ==0){
flag = false;
break;
}
}
//只有当这个循环结束了，表示这个范围之内所有的数字都判断完毕了
// 此时才能断定number是一个质数
if(flag){
System.out.println(number+"是一个质数");
}else{
System.out.println(number+"不是一个质数");
}
}
}
- 平方根法
10. 随机数
package com.itheima.demo1;
import java.util.Random;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//先获取一个随机数。
// 范围:2~10
//2.创建对象
Random r = new Random();
//3.生成随机数//判断技巧:
//在小括号中，书写的是生成随机数的范围//这个范围一定是从e开始的。
//到这个数-1结束
//口诀:包头不包尾，包左不包右
for(int i = 0;i<100;i++){
int number = r.nextInt(10)+5;//0+5~9+5 //5~14
System.out.println(number);
}
}
}
练习：
package com.itheima.demo1;
import java.util.Random;
import java.util.Scanner;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//需求:程序自动生成一个1-100之间的随机数字，使用程序实现猜出这个数宇是多少?
// 扩展小需求:加一个保底机制,3次猜不中，直接提示猜中了。
//注意点:
//1.生成随机数的代码int number = r.nextInt(100) +1;
// 不能写在循环的里面的，否则每一次都会产生一个新的随机数
//2.抽奖机制
//用点券去抽水晶
// 保底360次
//计数器
//用来统计当前已经猜了多少次。
int count = 0;
//分析
// 1．生成一个1-100之间的随机数字
Random r = new Random();
int number = r.nextInt(100) + 1;
System.out.println(number);
// 2. 猜这个数字是多少
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入你要猜的数字：");
int gussNumber = sc.nextInt();
//3 .判断两个数字给出不同的提示
// 猜的数字大了，提示大了
//猜的数字小了，提示小了
//猜的数字一样，提示猜中了
count++;
if(count == 3){
System.out.println("猜中了");
break;
}
if(gussNumber>number){
System.out.println("大了");
}else if(gussNumber<number){
System.out.println("小了");
}else{
System.out.println("猜中了");
break;
}
}
}
}
11. 数组
11.1 数组的地址
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
double[] arr6={1.93,1.75,1.73,181};
System.out.println(arr6);// [D@4554617c 地址值
// 扩展：
//解释一下地址值的格式含义[D@4554617c
//[﹔表示当前是一个数组
//D:表示当前数组里面的元素都是double类型的
//@:表示一个间隔符号。(固定格式）
// 4554617c:才是数组真正的地址值,(十六进制)
// 平时我们习惯性的会把这个整体叫做数组的地址值。
}
}
11.2 数组索引
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//利用索引对数组中的元素进行访问1/1.获取数组里面的元素
//格式:
//数组名[索引]
int[]arr = {1,2,3,4,5};
//获取数组中的第一个元素//其实就是e索引上对应的元素l / int number = arr[e];
// system.out.println( number);//1
//获取数组中1索引上对应的数据,并直接打印出来/ / system.out.println(arr[1]);//2
//2.把数据存储到数组当中
//格式:数组名[索引]=具体数据/变量;
//细节:一旦覆盖之后，原来的数据就不存在了。
arr[0] = 100;
System.out.println(arr[0]);//100
}
}
11.3 数组的遍历
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//利用循环改进代码//开始条件: 0
//结束条件:数组的长度-1(最大索引)
//在Java当中，关于数组的一个长度属性,length
// 调用方式:数组名.length
//扩展:
//自动的快速生成数组的遍历方式/ lidea提供的
//数组名.fori
int[] arr = {1,2,3,4,5};
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
练习：
1.
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//分析:
//1.定义一个数组存储1,2,3,4,5,6,7,8,9,10
int [] arr={1,2,3,4,5,6,7,8,9,10};
int count =0;
for (int i = 0; i < arr.length; i++) {
//i表示数组里面的每一个索引
// arr[i]表示数组里面的每一个元素
//3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次。
if(arr[i]%3==0){
count++;
}
}
System.out.println("数组中能被3整除的数字有"+count+"个");
}
}
2.
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//分析:
//1.定义一个数组存储1,2,3,4,5,6,7,8,9,10
int [] arr={1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < arr.length; i++) {
//i表示数组里面的每一个索引
// arr[i]表示数组里面的每一个元素
//3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次。
if(arr[i]%2==0){
// 偶数变二分之一
arr[i]=arr[i]/2;
}
else{
arr[i]=arr[i]*2;
}
}
// 遍历数组
// 一个循环尽量只做一件事情
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
11.4 数组的动态初始化
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//格式:
//数据类型[门]数组名= new数据类型[数组的长度];
//在创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始化值
String[] arr = new String[50];
//添加学生
arr[0] = "zhangsan";
arr[1] = "lisi";
System.out.println(arr[0]);//zhangsan
System.out.println(arr[1]);//lisi
System.out.println(arr[2]);//打印出来的是默认初始化值null
//数组默认初始化值的规律
//整数类型:默认初始化值0
// 小数类型:默认初始化值0.0
//字符类型:默认初始化值"/u0000" ->空格
//布尔类型:默认初始化值 false
//引用数据类型:默认初始化值null
int[] arr2=new int[3];
System.out.println(arr2[0]);//0
System.out.println(arr2[1]);//0
System.out.println(arr2[2]);//0
}
}
数组常见问题
当访问了数组中不存在的索引，就会引发索引越界异常。
12. 数组练习
12.1 求最值
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//扩展问题:
//1.根据求最大值的思路，自己改写一下求最小智
//2.为什么max要记录为arr[0],默认值不能为0吗?
// 不能写0
// max的初始化值一定要是数组中的值。
// 3.循环中开始条件一定是0吗?
//循环的开始条件如果为0，那么第一次循环的时候是自己跟自己比了一下，对结果没有任何影响，但是效率偏低
// 为了提高效率,减少一次循环的次数，循环开始条件可以写1.
//1. 定义数组用来储存5个值
int []arr={33,5,22,44,55};
//2. 定义一个变量用来储存最大值
//临时认为0索引的数据是最大的
int max=arr[0];
//3. 循环获取素组的每一个元素
//拿每一个元素跟max进行比较
for (int i = 0; i < arr.length; i++) {
//i 索引 arr[i]元素
if(arr[i]>max){
max=arr[i];
}
}
// 4. 当循环结束之后，max记录的就是数组中的最大值
System.out.println(max);
}
}
12.2 遍历数组求和
package com.itheima.demo1;
import java.util.Random;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
// 分析：
//1.定义数组
//动态初始化
int[] arr = new int[10];
//2.把随机数存入到数组当中
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
// 每循环一次，就会生成一个新的随机数
int number = r.nextInt(100) + 1;
// 相当于new Random().nextInt(100) 通过netInt方法的值输到随机数中
//从0~99随机，要到100就在后面+1
// 把生成的随机数添加到数组当中
// 数组名[索引]=数据；
arr[i] = number;
}
//1.求出所有数据的和
int sum=0;
for (int i = 0; i < arr.length; i++) {
sum=sum+arr[i];
}
System.out.println("所有数据的和："+sum);
//2.求出所有数据的平均数
int avg = sum/arr.length;
System.out.println("所有数据的平均数："+avg);
//3.统计有多少个数据比平均值小
int count=0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]<avg){
count++;
}
}
// 当循环结束之后，就表示我已经找到了所有的比平均值小的数据
System.out.println("在数据中，一共有："+count+"个数据比平均数小");
// 遍历数组，验证答案
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]+" ");
}
}
}
12.3 交换数据
- 定义交换
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
int a=10;
int b=20;
//把变量b的值，赋值给了变量a，那么变量a原来的值被覆盖了
int temp =a;
// 把变量b的值，赋值给了a，那么变量a原来记录的值就被覆盖了
a=b;
// 就是把变量a原来的值，赋值给了变量b
b=temp;
System.out.println(a);//20
System.out.println(b);//10
}
}
- 遍历数组法
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
// 1.定义一个数组
int[] arr ={1,2,3,4,5};
//2.将数组中0索引和最大索引引出的值进行交换
`在这里插入代码片` int temp = arr[0];
arr[0] = arr[4];
arr[4]=temp;
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
package com.itheima.demo1;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//1.定义数组存储数据
int[] arr={1,2,3,4,5};
//2.利用循环去交换数据
for(int i=0,j=arr.length-1;i<j;i++,j--){
//交换变量i和变量j指向的元素
int temp = arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
// 当循环结束之后，那么数组中的数据就实现了头尾交换
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
12.4 打乱数据
package com.itheima.demo1;
import java.util.Random;
public class ArithmeticoperatorDemo1 {
public static void main(String[] args) {
//难点：
//如何获取数组中的随机索引
//1. 定义数组存储1~5
int[] arr={1,2,3,4,5};
// 2. 循环遍历数组，从0索引开始打乱数据的顺序
Random r =new Random();
for(int i=0;i<arr.length;i++){
// 生成一个随机索引
int randomIndex = r.nextInt(arr.length);
//拿着随机索引指向的元素 跟 i 指向的元素进行交换
int temp =arr[i];
arr[i]=arr[randomIndex];
arr[randomIndex]=temp;
}
// 当循环结束之后，那么数组中所有的数据已经打乱顺序了
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"");
}
}
}
13. 数组的内存图
