Java学习笔记2024/2/1
1. 循环高级
1.1 无限循环
package com.angus.loopAdvanced.infiniteLoop_1;
public class note {
public static void main(String[] args) {
//无限循环:循环一直停不下来
//for循环
//while循环 ->最常用,因为不知道循环的范围或者次数
//do...while循环
// for (;;){
// System.out.println("学习");
// }
// while (true){
// System.out.println("学习");
// }
// do {
// System.out.println("学习");
// } while (true);
//无限循环的下面不能再写其他的代码了,因为执行不到
System.out.println("^^");
}
}
1.2 跳转控制语句
package com.angus.loopAdvanced.jumpControlStatement_2;
public class demo1 {
public static void main(String[] args) {
//1.跳过某次循环
for (int i = 1; i <= 5; i++) {
if (i == 3) {
//跳过这次循环,继续下次循环
continue;
}
System.out.println(i);
}
System.out.println("^^");
}
}
package com.angus.loopAdvanced.jumpControlStatement_2;
public class demo2 {
public static void main(String[] args) {
//2.结束整个循环
for (int i = 1; i <= 5; i++) {
System.out.println(i);
if (i == 3) {
//结束整个循环
break;
}
}
System.out.println("^^");
}
}
package com.angus.loopAdvanced.jumpControlStatement_2;
public class test1 {
public static void main(String[] args) {
/*朋友聚会的时候可能会玩一个游戏：逢7过
游戏规则：从任意一个数字开始报数，当你要报的数字是包含7或者是7的倍数时都要说过：过
需求：使用程序在控制台打印出1-100之间的满足逢七必过规则的数据*/
//随笔
//自己做的分析太混乱了,先模仿教学视频java老师的,之后再形成自己的
//分析:
//个位7 十位7 7倍数
//1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过 18 19 20 过...
//69 过 过 ... 80
//1.得到1-100之间的每一个数
//开始: 1
//结束: 100
for (int i = 1; i <= 100; i++) {
//2.判断每一个数字,如果符合规范,就打印过,如果不符合就打印真实的数字
if (i/1%10 == 7 || i/10%10 == 7 || i%7 == 0) {
System.out.println("过");
continue;
}
System.out.println(i);
}
System.out.println("^^");
}
}
package com.angus.loopAdvanced.jumpControlStatement_2;
import java.util.Scanner;
public class test2 {
public static void main(String[] args) {
/*需求：键盘录入一个大于等于2的整数 x ，
计算并返回 x 的 平方根 。
结果只保留整数部分 ，小数部分将被舍去 。*/
//分析:
//平方根 16的平方根4
// 4的平方根2
//10
//1 * 1 = 1 < 10
//2 * 2 = 4 < 10
//3 * 3 = 9 < 10
//4 * 4 = 16 > 10
//推断: 10的平方根是在3~4之间
//20
//1 * 1 = 1 < 20
//2 * 2 = 4 < 20
//3 * 3 = 9 < 20
//4 * 4 = 16 < 20
//5 * 5 = 25 > 20
//推断: 10的平方根是在4~5之间
//在代码当中
//从1开始循环,拿着数字的平方跟原来的数字进行比较
//如果小于的,那么继续往后判断
//如果相等,那么当前数字就是平方根
//如果大于的,那么前一个数字就是平方根的整数部分
//1.键盘录入一个整数
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = scanner.nextInt();
//2.从1开始循环判断
//开始: 1 结束: number
for (int i = 1; i <= number; i++) {
//用i * i 再跟number进行比较
//怎么比,用关系运算符
if (i*i==number){
System.out.println(i + "就是" + number + "的平方根");
//随笔
//案例代码可以自己照着写也可以复制粘贴,建议有些自己写[大框架],有些复制粘贴[小细节],
//老师的思路分析复制粘贴就行了,
//不然太费时间了而且思维也会在跟着打字的同时被禁锢,
//要的是变通的思维不是盲目的思维
//老师的分析下面可以自己再解析分析
//这也是锻炼自己的思维
//一旦找到了，循环就可以停止了，后面的数字就不需要再找了，提高代码的运行效率。
break;
} else if (i * i > number) {
System.out.println((i - 1) + "就是" + number + "平方根的整数部分");
break;
}
}
System.out.println("^^");
}
}
package com.angus.loopAdvanced.jumpControlStatement_2;
import java.util.Scanner;
public class test3 {
public static void main(String[] args) {
//随笔
//思维要具有结构化,流程化
//如果听一下就打一下,思维很容易混乱
//所以之前的我才会建议先听完一整个知识点再去整理笔记
//不只是整理笔记,还有重新理一下思路,再写一次代码加分析
//但是随笔可以随时整理
//需求：键盘录入一个正整数 x ，判断该整数是否为一个质数。
//质数：
//如果一个整数只能被1和本身整除，那么这个数就是质数。否则这个数叫做合数
//所以想要找到质数我们只要将它本身和1排除在外,
//再看看在它和1之间有没有能够将它整除的数,
//有就不是质数,没有就是质数
//7 = 1 * 7 质数
//8 = 1 * 8 2 * 4 合数
//分析：
//1.键盘录入一个正整数
//number
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个正整数");
int number = sc.nextInt();//9
//定义一个变量，表示标记
//标记着number是否为一个质数
//true： 是一个质数
//false : 不是一个质数
//表示最初就认为number是一个质数
boolean flag = true;
//2.判断
//写一个循环，从2开始判断，一直判断到number-1为止
//看这个范围之内，有没有数字可以被number整除
for (int i = 2; i < number; i++) {
//i 依次表示这个范围之内的每一个数字
//看number是否能被i整除就可以了
if(number % i == 0){// 9 % 2 = 1
flag = false;
//System.out.println(number + "不是一个质数");
break;
}/* else {
System.out.println(number + "是一个质数");
}
}*/
//只有当这个循环结束了，表示这个范围之内所有的数字都判断完毕了
//此时才能断定number是一个质数
}
if(flag){
System.out.println(number + "是一个质数");
}else{
System.out.println(number + "不是一个质数");
}
System.out.println("^^");
}
}
package com.angus.loopAdvanced.jumpControlStatement_2;
public class test3_3 {
public static void main(String[] args) {
//test3的优化
//随笔
//计算器快捷键: win+R输calc
// 100000
// 2 ~ 99999
//循环的次数：将近10万次
//推荐一个简化的思路
//81
//1 * 81
//3 * 27
//9 * 9
//以81的平方根9，为中心
//而且假设 a * b = 81
//那么a和b中，其中有一个必定是小于等于9的。
//另一个是大于等于9的。
//我们要找的就是那个小于等于9的
//假设，都是大于9 --- 9.1 * 9.1 > 81
//假设，都是小于9 --- 8.9 * 8.9 < 81
//其中一个数字一定是小于等于平方根
//另外一个数字一定是大于等于平方根
int number = 81;
//如果这个范围之内，所有的数字都不能被number整除
//那么number就一定是一个质数。
/*
for (int i = 2; i <= number的平方根; i++) {
}
*/
System.out.println("^^");
}
}
package com.angus.loopAdvanced.jumpControlStatement_2;
//1.导包
import java.util.Random;
public class test4 {
public static void main(String[] args) {
//先获取一个随机数。
//范围：0~10
//2.创建对象
Random random = new Random();
//3.生成随机数
//判断技巧：
//在小括号中，书写的是生成随机数的范围
//这个范围一定是从0开始的。
//到这个数-1结束
//口诀：包头不包尾，包左不包右
for (int i = 0; i < 5; i++) {
int number = random.nextInt(10);// 0 ~ 9
System.out.println(number);
}
System.out.println("^^");
}
}
package com.angus.loopAdvanced.jumpControlStatement_2;
import java.util.Random;
public class test5 {
public static void main(String[] args) {
//需求：
//随机数范围：1~100
//创建对象
Random r = new Random();
//生成随机数
int number = r.nextInt(100) + 1;//1 ~ 100
System.out.println(number);
//解析:
//1.100-1=99
//2.99+1=100
//3.r.nextInt(100)
//4.r.nextInt(100) + 1
//秘诀
//用来生成任意数到任意数之间的随机数 7 ~15
//1.让这个范围头尾都减去一个值，让这个范围从0开始 -7 0~8
//2.尾巴+1 8 + 1 = 9
//3.最终的结果，再加上第一步减去的值。
/* Random r = new Random();
int number = r.nextInt(9) + 7;// 7 ~ 15
// 0 ~ 8 + 7
System.out.println(number);*/
//解析:
//1.15-7=8
//2.8+1=9
//3.r.nextInt(9)
//4.r.nextInt(9) + 7
//总结:
//1.要求的范围->大范围值-小范围值=值1
//2.值1+1=值2
//3.值2的随机数表达式
//4.值2的随机数表达式+小范围值
System.out.println("^^");
}
}
package com.angus.loopAdvanced.jumpControlStatement_2;
//导包Random,导包Scanner
import java.util.Random;
import java.util.Scanner;
public class test6 {
public static void main(String[] args) {
//需求：程序自动生成一个1-100之间的随机数字，
//使用程序实现猜出这个数字是多少？
//分析:
//1.生成一个1-100之间的随机数字
//2.猜这个数字是多少
//3.如果猜一次猜不中,就需要不断猜,直到猜中为止
//4.先写里面再写外面,
//意思就是先写判断再写循环
//意思就是判断一次后再不断重复判断
//判断一次的情况就是先写里面的意思
//不断判断就是再写外面的意思
//1.生成一个1-100之间的随机数字
//创建Random对象
Random r = new Random();
//生成随机数 需要写在死循环的外面,不然就会一直生成新的随机数
int number = r.nextInt(100) + 1;
// //2.猜这个数字是多少
// Scanner sc = new Scanner(System.in);
// System.out.println("请输入你要猜的数字");
// //键盘录入
// int guessNumber = sc.nextInt(); //需要放在死循环的里面,这样才不会一直重复打印,原因就是死循环一旦执行到一条语句就会无限执行下去
//不知道循环次数或范围用while
while (true){ //死循环,无限循环
//2.猜这个数字是多少
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要猜的数字");
//键盘录入 需要放在死循环的里面,这样才不会一直重复打印,原因就是死循环一旦执行到一条语句就会无限执行下去
int guessNumber = scanner.nextInt();
if (guessNumber > number) {
System.out.println("大了");
} else if (guessNumber < number) {
System.out.println("小了");
} else {
System.out.println("猜中了");
break; //猜中了就break跳出死循环
}
}
//随笔
//反思
//代码还是得自己独立写一遍,理解理解代码原理
//还是自己分析吧,这样更乱了,而且还把自己绕晕了
//最重要的是自己独立分析才能巩固学的知识点
//之前的方案pass pass pass
//那和抄袭没什么区别了都我发现
//还是得自己再重新独立写一遍才能真正掌握
//不过就是有点慢服了...
//我就当是磨刀不误砍柴工了
//那两句话得提醒一下自己了
//1.学我者生，似我者寄
//2.你看懂了，不去写，其实你还是不懂。
//重新简单总结一下自己的学习方法: 就是老师写完一个练习就跟着他写这个练习,写完后再继续后面的优化改进什么的
System.out.println("^^");
}
}package com.angus.loopAdvanced.jumpControlStatement_2;
import java.util.Random;
import java.util.Scanner;
public class test6_6 {
public static void main(String[] args) {
//加一个保底活动
Random r = new Random();
int number = r.nextInt(100) + 1;
int count = 0;
while (true){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要猜的数字");
int guessNumber = scanner.nextInt();
count++;
if (count == 3){
System.out.println("保底了");
break;
}
if (guessNumber > number) {
System.out.println("大了");
} else if (guessNumber < number) {
System.out.println("小了");
} else {
System.out.println("猜中了");
break;
}
}
System.out.println("^^");
}
}2. 数组
2.1 数组介绍
package com.angus.array.introductionToArray_1;
public class note {
public static void main(String[] args) {
//什么是数组呢?
//数组指的是一种容器,可以用来存储同种数据类型的多个值
//但也不用限定死,还要考虑隐式转换
//例如:int类型的数组容器(boolean错 byte对 short对 int对 double错)
// double类型的数组容器(byte对 int对 long对 double对)
//建议:容器的类型和存储的类型保持一致
System.out.println("^^");
}
}
2.2 数组的定义与静态初始化
package com.angus.array.definitionAndDynamicInitializationOfArray_2;
public class note {
public static void main(String[] args) {
//知识点一
//数组的定义
//以前定义变量时: int a = 0; -> int a 叫做定义, = 0 叫做赋值
//定义数组就比定义变量多了个[]
//定义数组有两种格式,常用第一种
//格式一: 数据类型 [] 数组名
//例子: int [] array
//格式二: 数据类型 数组名 []
//例子: int array []
//数组定义之后只有一个名字,容器还没出现
//知识点二
//数组的初始化
//初始化:就是在内存中,为数组容器开辟空间,并将数据存入容器中的过程
//数组初始化的两种方式
//静态初始化
//动态初始化
//数组的静态初始化
//简化格式: 数据类型[] 数组名 = {元素1,元素2,元素3...};
//例子: int[] array1 = {1, 2, 3};
// double[] array2 = {1.1, 1.2 ,1.3};
System.out.println("^^");
}
}
package com.angus.array.definitionAndDynamicInitializationOfArray_2;
public class demo1 {
public static void main(String[] args) {
//需求1：定义数组存储5个学生的年龄
int[] arr1 = {11,12,13,14,15};
//需求2：定义数组存储3个学生的姓名
String[] arr2 = {"aadad","阿达","大大"};
//需求3：定义数组存储4个学生的身高 1.93
double[] arr3 = {1.5,1.6,1.7,1.8}; // [D@b4c966a 数组的地址值->表示数组在内存中的位置 有4个数->表示数组的长度
System.out.println(arr3);
//扩展：
//解释一下地址值的格式含义 [D@b4c966a
//[ ：表示当前是一个数组
//D：表示当前数组里面的元素都是double类型的
//@：表示一个间隔符号。（固定格式）
//b4c966a：才是数组真正的地址值，（十六进制）
//平时我们习惯性的会把这个整体叫做数组的地址值。
System.out.println("^^");
}
}
2.3 数组元素访问
package com.angus.array.arrayElementAccess_3;
public class note {
public static void main(String[] args) {
//数组元素访问
//格式: 数组名[索引];
//索引:也叫做下标,角标
//索引的特点:从0开始,逐个+1增长,连续不断
System.out.println("^^");
}
}
package com.angus.array.arrayElementAccess_3;
public class demo1 {
public static void main(String[] args) {
//题目
//利用索引对数组中的元素进行访问
//获取数组里面的元素
//格式： 数组名[索引]
//获取数组中的元素
//可以直接获取
//也可以间接使用变量获取
//获取数组中的第一个元素
int[] arr = {1,2,3,4,5};
//1.直接获取
System.out.println(arr[0]);
//2.间接获取
int a = arr[0];
System.out.println(a);
System.out.println("^^");
}
}
package com.angus.array.arrayElementAccess_3;
public class demo2 {
public static void main(String[] args) {
//题目
//把数据存储到数组当中
//格式： 数组名[索引] = 具体数据/变量；
//细节：一旦覆盖之后，原来的数据就不存在了。
int[] arr = {1,2,3,4,5};
arr[0] = 1000; //把1000赋值给arr的0索引
int a = arr[0];
System.out.println(a);
System.out.println("^^");
}
}
未完待续...