小白学习日志-Nebula

2026.4.7

变量：

相当于一个储存临时数据的容器
但是这个容器只能存一个值

public class VariableDemo{
public static void main(String[] args){
    //定义一个整数类型的变量
    //数据类型 变量名 = 数据值;
    int a = 16;
    System.out.println(a);//16
    //定义一个小数类型的变量
    double b = 10.1;
    System.out.println(b);//10.1
  }
}

变量的注意事项：

变量名不能重复
一条语句可以定义多个变量，但是我不习惯用
变量在使用之前必须要赋值

基本数据类型：

整数类型：byte, short, int, long
浮点数类型：float, double
字符串类型：char
布尔类型：boolean

编程的本质

编就是编写
程，程序，是由数据和函数组成的
数据的本质就是处于计算硬盘上的数字0和1
而程序的主要任务就是编写函数来处理计算机上的数据
这么说只要掌握了数据和函数，其他的就是这些理论的实践了
对于现实世界来说，整个宇宙就是一个巨大的程序
小到细胞，原子
大到生物，星球
无一不是遵循着酷似函数处理的机制一样运行着
他们会迭代进化
无机到有机，水生到陆生
都是从原本简单的程序迭代到复杂的程序
作为人
奋斗者每日吾日三省，专注于改善和提高自己的程序，其处理效率日益增长
躺平者每日欢呼享乐，专注于如何让自己安乐于躺平，其程序酷似古董一般
编程
不断编写，不断完善，提高level

感想：虽然学的不多，但是相对于AI给我的安排来说，这个学起来更加的轻松和细致

2026.4.8

键盘录入（Scanner）:

创建对象
接收数据
导报的话我的IDEA会自动导报上去

//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
  public static void main(String[] args){
    //2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
    Scanner sc = new Scanner(System.in);
    //3.接收数据
    //当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
    System.out.println("请输入一个数字");
    int i = sc.nextInt();
    System.out.println(i);
  }
}

算数运算符：

基本介绍：

分类：+ - * / %

运算特点：

整数相除必须为整数
小数直接参与计算的时候可能不准确，这是计算机二进制转换的问题，相当于十进制的三分之一

public class OperatorDemo1 {
    public static void main(String[] args) {
        /*
            算数运算符：+ - * / %

            整数计算、小数计算

        */
        // 1. 整数计算
        // 细节：整数相除结果还是整数，就是商
        //       其他运算跟数学中是一模一样的
        int a = 10;
        int b = 3;

        System.out.println(a + b);// 13
        System.out.println(a - b);// 7
        System.out.println(a * b);// 30
        System.out.println(a / b);// 3
        System.out.println(a % b);// 1

        System.out.println("-------------------------");

        // 2.小数计算
        // 细节：
        //     小数直接参与计算，结果有可能不精确的
        double c = 1.1;
        double d = 1.01;

        System.out.println(c + d);// 13.0
        System.out.println(c - d);// 7.0
        System.out.println(c * d);// 30.0
        System.out.println(c / d);// 3.3333333333333335
        System.out.println(c % d);// 1.0



    }
}

关于对技能大赛的了解和启发

技能大赛，之前叫全国职业技能大赛，现在更名为世界职业技能大赛
正如上述操作无非就是改了名字
但是其对参赛者有着比较高的素养的要求，因此不管是名誉上的亮眼还是对自己技能的一个证明
迫使着有抱负，有追求的高职学生往着技能大赛的方向努力着
但是要想有世界职业技能大赛的参赛资格则必须要拿到重庆市一个等奖
而市级技能大赛是高职院校主办的，但是呢根据政策的规定，他们出的样题80%都是按照国赛的标准来办理的，20%是自由发挥的
说是自由发挥，无疑就是给自己学校的团队走后门罢了
但是这并不意味着我们就不需要对这个赛事上心而敷衍了事
反而是我们必须更加的努力提高自身的素养，并且和团队的队员们提高配合的默契度，是我们能够产出更加牛逼的东西出来，让所有的评委都认可，这是我们需要努力的
关于赛事要求：
比如说实训操作、与团队的配合、细致程度这些都要必须重视和反复的去打磨
不应该在一些小事情上失误

2026.4.9

数值拆分（算法题）：

package com.itheima.operator;

import java.util.Scanner;

public class OperatorDemo2 {
    static void main() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个三位数：");

        int num = sc.nextInt();

        int ge = num % 10;
        int shi = num / 10 % 10;
        int bai = num / 100;
        System.out.println("个位；" + ge);
        System.out.println("十位：" + shi);
        System.out.println("百位；" + bai);



    }
}

时间转换：

package com.itheima.operator;

import java.util.Scanner;

public class OperatorDemo3 {
    static void main() {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入秒数：");

        int num = sc.nextInt();
        // 3611 / 3600 = 1....11
        int hour = num / 3600;
        // 3611 % 3600 / 60 = 0....11
        int min = num % 3600 / 60;
        // 3611 % 3600 % 60 = 0;
        int sec = num % 3600 % 60;

        System.out.println(hour + ":" + min + ":" + sec);
    }
}

隐式转换：

就是小的给大的，可以直接给

如果是byte类型和short类型就先提升为int类型
把取值范围小的提升为大的再进行计算（否则会损失精度）

比如说：

package com.itheima.operator;

public class OperatorDemo4 {
    static void main() {
        short s1 = 100;
        short s2 = 200;

//        byte result = s1 + s2; // 错误，运算结果超出了byte的范围,s1 + s2 的时候已经隐式转化成了int类型了
//        方法一：强制转化，有时候或损失精度，就比如下面这个，打印出的是44，而不是300
        byte s3 = (byte)(s1 + s2);
        System.out.println(s3);// 44

//        方法二；根据隐式转化来
        int s4 = s1 + s2;
        System.out.println(s4); // 300
    }
}

强制转换：

背景：

如果要把取值范围大的数据或者变量复制给取值范围小的变量是不允许直接操作的，但是硬要这样的话那就需要强制转换了

书写格式：

double a = 12.3;

int b = (int) a;

关于服务器本地部署：

关于云服务器的部署我不是很了解，但是看到刘杰一下午的操作，对其有祛魅，并没有想象中的那么复杂，只是我了解的东西不多

如果我了解的足够，知道他们的作用和关联，我想我大概是可以做出来的，而且是游刃有余，行云流水的操作

我有这个信心，因为我相信我的能力，目前只能写这么点，但是以后我会完善非常多

感想：

由下个星期二即将要交的政治作业而启动的一个非常有意义的项目

因为我们想做一个扬名立万的事情，不单单只是做一个简单的只局限于政治作业的项目

而是一个可以让我们燃起斗志，觉得每天都很美好，每天过得都很有意义很充实

这种感觉不是有一个人都有的

2026.4.10

随着项目的推进我们遇到的瓶颈：

一是这个论坛的一个flurm的一个底层的代码有很多BUG，毕竟是轻量化的，而且是开源免费的项目

另一个是短视频的脚本，这个脚本的框架我们讨论了很久，最终是以较为真实的角度来拍摄

但是脚本的开头，以及发展，我们陷入了困难，就是不知道怎么去呈现，拍摄的手法又不太行...

今天晚上我们把这个脚本的大致内容给搞出来了，我想只需要在我们拍摄的过程中进行修改就可以了

如果实在不行的话那就拍纪录片吧...

以此来纪念我们为了这个扬名立万的努力，就这一个记录就够我们回忆一壶了

万一成了呢..

2026.4.11

字符串的 + 操作

String name = "黑默丁格";
System.out.println("我的名字是" + name);

输出：我的名字是黑默丁格

自增自减运算符

分类：

注意：

不管是先++，还是后++，单独写在第一行的时候，运算结果是一模一样的

int a = 10;
a++;//就是让变量a里面的值 + 1
System.out.println(a);//11
++a;//就是让变量a里面的值 + 1
System.out.println(a);//12

赋值运算：

public class OperatorDemo6 {
    public static void main(String[] args) {
        
        int a = 10;//就是把10赋值给变量a
        System.out.println(a);

        //2.如果等号右边需要进行计算。
        int b = 20;
        int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量
        System.out.println(c);

        //3.特殊的用法
        a = a + 10;// a += 10;
        System.out.println(a);//20
    }
}

扩展数值运算符：

注意：

扩展的赋值运算符中隐层还包含了一个强制转换：a += b,实际上相当于a = (byte)(a + b);

public class OperatorDemo8 {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        //a += b;
        a = (byte)(a + b);
        System.out.println(a);//30
    }
}

关系运算符：

==
！=
>=
<=
>
<

注意：

最终结果为布尔值

import java.util.Scanner;

public class OperatorDemo9 {
    static void main() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入我的身高：");
        double h1 = sc.nextDouble();

        System.out.println("请输入我好基友的身高：");
        double h2 = sc.nextDouble();

        if (h1 == h2) {
            System.out.println("他和我身高一样，什么身份啊这是和我同款升高");
        } else if (h1 < h2) {
            System.out.println("666 我居然比他矮");
        } else {
            System.out.println("我肯定是比他高的啊");
        }
    }
}

逻辑运算符

& 和 | 的使用：

&：

两边都为真，结果才为真，只要一个结果为假，结果就是假

|：

两边都为假，结果才为假，只要有一个为真，结果就为真

三元运算符：

格式：

关系表达式？表达式1：表达式2；

计算规则：

计算关表达式的值

如果为真就执行表达1

为假就执行表达2

注意：

三元表达式的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来

public class OpertaorDemo14 {
    static void main() {
        int a = 9;
        int b = 10;

        int max = a > b ? a : b;
        System.out.println("max:" + max);
    }
}

运算符的优先级：

先记一点：

小括号优先于所有

2026.4.13

流程控制语句：

判断语句 if:

if语句格式：

if (关系表达式) {
    语句体;  
}

示例：

public class IfDemo {
  public static void main(String[] args) {
    System.out.println("开始");
    //定义两个变量
    int a = 10;
    int b = 20;
    //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
    if(a == b) {
      System.out.println("a等于b");
    }    //需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
    int c = 10;
    if(a == c) {
      System.out.println("a等于c");
    }    System.out.println("结束");
  }
}

关于格式细节：

我比较喜欢K&R风格，就是平常我们写的格式
其他的了解了解就行了也不重要

比较有意思的题目（阶梯式计算）：

import java.util.Scanner;  
  
public class ifDemo9 {  
    static void main() {  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入实际用电量：");  
        double usage = sc.nextDouble();  
        double cost = 0;  
  
        if (usage <= 100) {  
            cost = usage * 0.5;  
        } else if (usage <= 200) {  
            cost = 100 * 0.5 + (usage - 100) * 0.8;  
        } else if (usage > 200){  
            cost = 100 * 0.5 + 100 * 0.8 + (usage - 200) * 1.2;  
        } else {  
            System.out.println("输入有误");  
        }  
        System.out.println("总电费：" + cost);  
    }  
}

2026.4.14

选择语句（switch）

格式：

switch (表达式) {
	case 1:
		语句体1;
		break;
	case 2:
		语句体2;
		break;
	case 3:
		语句体3;
		break;
	default:
		语句体4;
		break;
}

switch的扩展知识：

default的位置可以省略
default可以放在任意位置

case穿透：

不写break会引发case穿透现象
但有些case现象可以提高代码可读性

int number = 10;
switch (number) {
	case 1 -> System.out.println("一");
	case 2 -> System.out.println("二);
	case 3 -> System.out.println("三");
	default -> System.out.println("其他");
}

yield关键字：

int number = 10;
String name = switch (number) {
	case 1, 2, 3, 4 -> "==";
	case 5, 6, 7 -> "二";
	case 8, 9, 10 -> "三";
	default -> "没有这个星期"
};

System.out.println(name);
// 优点就是可以操作结果

2026.4.15

循环结构

格式：

  
for (初始化语句;条件判断语句;条件控制语句) {

循环体语句;

}

题目：

import java.util.Scanner;  
  
public class ForDemo5 {  
    static void main() {  
        // 键盘录入两个数字，表示一个范围。统计这个范围中，既能被3整除又能被5整除数字有多少个？  
       /* Scanner sc = new Scanner(System.in);  
        System.out.println("请输入第一个数字：");  
        int a = sc.nextInt();        System.out.println("请输入第二个数字：");  
        int b = sc.nextInt();        int sum = 0;  
        for (int i = a; i <= b; i++) {            if (i % 3 == 0 && i % 5 == 0) {                sum += 1;            }        }  
        System.out.println(sum);*/  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入第一个数字：");  
        int a = sc.nextInt();  
        System.out.println("请输入第二个数字：");  
        int b = sc.nextInt();  
        int sum = 0;  
  
        int min = a < b ? a : b;  
        int max = a < b ? b : a;  
  
        for (int i = min; i <= max; i++) {  
            if (i % 3 == 0 && i % 5 == 0) {  
                sum += 1;  
            }  
        }  
  
        System.out.println(sum);  
  
    }  
}

public class ForDemo6 {  
    static void main() {  
        // 有一组特殊的数字，从第三项开始，每一项都是前两项的数字和，请问第10项的数字是多少？  
        //0，1，1，2，3，5，8，13，21，34，55，89…  
       int a = 0;  
       int b = 1;  
       int c = 1;  
  
       for (int i = 3; i <= 10; i++) {  
          c = a + b;  
          a = b;  
          b = c;  
       }  
        System.out.println(c);  
  
    }  
}

import java.util.Scanner;  
  
public class ForDemo7 {  
    static void main() {  
        // 牛牛开始学习数列啦。现在他想计算以下数列前 n 项的和：  
        //S(n) = 1 − 2 + 3 − 4 + ⋯  
        int sum = 0;  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入项数：");  
        int n = sc.nextInt();  
  
        for (int i = 1; i <= n; i += 2) {  
            sum += i - (i + 1);  
        }  
        System.out.println(sum);  
  
    }  
}

2026.4.16

while循环

格式：

初始化语句;
while(条件判断语句){
  循环体;
  条件控制语句;
}

复利：

public class WhileDemo2 {
    static void main() {
        // 假设你在银行投资了100000元，银行给出的复利是1.7%，问多少年后能实现本金翻倍？
        //请问：用什么循环呢？代码如何实现？
       /* double money = 100000;
        double exceptmoney = 0;

        int count = 0;
        while (exceptmoney < money) {
            exceptmoney += money * 0.017;
            count++;
        }  这个代码是单利
        System.out.println(count);*/

        /*double money = 200000;
        double exceptmoney = 100000;

        int count = 0;
        while (exceptmoney < 200000) {
            exceptmoney += exceptmoney * 0.017;
            count++;
        }  这个是利滚利
        System.out.println(count);*/
    }
}

珠穆朗玛峰

public class WhileDemo3 {
    static void main() {
        // 世界最高山峰珠穆朗玛峰高度是：8848.86米=8848860毫米，
        //假如我有一张足够大的纸，它的厚度是0.1毫米。
        //请问：该纸张折叠多少次，可以折成珠穆朗玛峰的高度？

        double m = 0.1;
        double height = 8848860;

        int count = 0;
        while (m < height) {
            m *= 2;
            count++;
        }

        System.out.println(count);

    }
}

数位之和

public class WhileDemo4 {
    static void main() {
        // 给定一个整数 n，请计算其所有数位之和。若 n 为负数，请先取其绝对值。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int n = sc.nextInt();

        if (n < 0) {
            n = -n;
        }

       /* 467 % 10 = 7 // 提取出个位
        467 / 10 % 10 = 6 // 提取46的个位
        46 / 10 // 提取百位
        然后求和*/
        int sum = 0;
        while (n != 0) {
            sum += n % 10;
            n = n / 10;
        }
        System.out.println(sum);
    }
}

do...while循环


初始化语句;
do{
    循环体;
    条件控制语句;
}while(条件判断语句);

无限循环

for格式：

for(;;){
    System.out.println("循环执行一直在打印内容");
}

while格式：

while(true){
    System.out.println("循环执行一直在打印内容");
}

do...while格式：

do{
    System.out.println("循环执行一直在打印内容");
}while(true);

条件控制语句

break
continue

break：
不能单独存在的。可以用在switch和循环中，表示结束，跳出的

游戏人物：

public class BreakDemo2 {
    static void main() {

        /*初始最大生命200，受到X点伤害，技能恢复Y点血，X和Y由键盘录入而来。
        假设，游戏人物不会死亡，最少1点血
        问：最终游戏人物血量是多少？
        要考虑的情况：键盘录入必须大于0，否则需要重新输入*/

        Scanner sc = new Scanner(System.in);
        int maxHp = 200;
        int X = 0;
        int Y = 0;

        while (true) { // 循环 + break 只要录入数据是错误的，就一直录入
            System.out.println("请输入受到的伤害：");
            X = sc.nextInt();

            if (X > 0) {
                break;
            }else {
                System.out.println("输入的数据不合法");
            }

        }


        int hp = maxHp - X;

        if (hp < 1) {
            hp = 1;
        } else if (hp > 200) {
            hp = 200;
        }
        System.out.println("当前游戏人物的血量为：" + hp);

        while (true) {
            System.out.println("请输入技能恢复的血量：");
            Y = sc.nextInt();
            if (Y > 0) {
                break;
            } else {
                System.out.println("输入的数据不合法");
            }
        }

        hp = hp + Y;
        if (hp > 200) {
            hp = 200;
        }
        System.out.println("当前游戏人物的血量为：" + hp);


    }
}

找质数：

public class BreakDemo3 {
    static void main() {

        /*键盘录入一个大于等于2的整数，判断是否为质数*/

       Scanner sc = new Scanner(System.in);

       int num = 0;
       while (true) {

           System.out.println("请输入大于等于2的整数：");
           num = sc.nextInt();
           if (num >= 2) {
               break;
           } else {
               System.out.println("输入的数字不合法");
           }
       }
/*
       还有一个解法就是平方根
       1 100
       2 50
       4 25
       5 20
       10 10
       ---------------10---------------------    只需要判断一边就可以了，左边是小于10的，右边是大于10的
                                                 如果左边没有可以整除的数字的话，那么其他相乘要么大于100，要么小于100
       */
       // 质数是指只能被1和自身整除的数字
        int count = 0;
        for (int i = 2; i < num; i++) {

            if (num % i == 0) {
                count++;
                break;
            }
        }

        if (count == 0) {
            System.out.println("是质数");
        }else {
            System.out.println("不是质数");
        }

    }
}

continue语句

不能单独存在的。只能存在于循环当中。表示：跳过本次循环，继续执行下次循环

逢七过：

public class ContinueDemo2 {
    // 循环打印1~100之间的数字，如果数字包含7或者是7的倍数，输出”过”
    static void main() {

        for (int i = 1; i <= 100; i++) {
            if (i / 10 % 10 == 7 || i % 10 == 7 || i % 7 == 0) {
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }

    }
}

Random:

和Scanner一样

猜数字：

public class Test {
    static void main() {
        /*

        需求：程序自动生成一个1-100之间的随机数，在代码中使用键盘录入去猜出这个数字是多少？
        要求：使用循环猜，一直猜中为止。

        抽卡的时候有保底机制
        小保底，只要三次没有猜中，提示提示用户的猜测范围 ±5
        大保底，只要十次没猜中，就猜中了
        */
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        int num = r.nextInt(1, 101);
        System.out.println(num);

        // 加入计数器
        int countA = 0;
        int countB = 0;


        while (true) {
            System.out.println("请输入你猜的数字：");
            int n = sc.nextInt();

            countA++;
            countB++;

            if (countB > 10) {
                System.out.println("猜对了");
                break;
            }

            if (n < num) {
                System.out.println("猜小了");

            } else if (n > num) {
                System.out.println("猜大了");

            } else {
                System.out.println("猜对了");
                break;
            }

            if (countA % 3 == 0) {
                System.out.println("在" + (num - 5) + "到" + (num + 5) + "之间");
            }

            if (countB > 10) {
                System.out.println("猜对了");
                num = n;
                System.out.println(n);
                break;
            }
        }

    }
}

2026.4.17

嵌套循环

打印长方形

public class Test1 {
    static void main() {
         /*
             打印4行5列的 *
             *****
             *****
             *****
             *****
             限定：每次只能输出一个*
        */
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印正三角形

打印倒三角形

public class Test3 {
    static void main() {
       // 打印倒三角形
        /*for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 6 - i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }*/

        for (int i = 1; i <= 5; i++) {
            for (int j = i; j <= 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印梯形

public class Test4 {
    static void main() {
         /*
                 打印梯形

                      ***
                     *****
                    *******

                 限定：每次只能输出一个*
            */

        for (int i = 1; i <= 3; i++) {
            for (int j = i; j <= 3; j++) {
                System.out.print(" ");
            }

            for (int j = 1; j <= 2 * i + 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印平行四边形

public class Test5 {
    static void main() {
        // 打印平行四边形

        for (int i = 1; i <= 3; i++) {
            for (int j = i; j <= 3; j++) {
                System.out.print(" ");
            }

            for (int j = 1; j <= 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印九九乘法表

public class Test6 {
    static void main() {
        // 打印九九乘法表
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + (i * j) + "\t");
            }
            System.out.println();
        }
    }
}

关于制表符的研究

public class Test7 {
    static void main() {
        System.out.println("---------------");
        System.out.println("-----\t-------"); // 得出结论，制表符其原理就是按照4的倍数进行空格,不满4的倍数或者是超过4的倍数，按空格补齐
    }
}

2026.4.18

数组

int arr[] (我喜欢用的)
int [] arr

数组的静态初始化

int arr[] = {1, 2, 3, 4}
double arr[] = {1.2, 2.3, 4.5, 6.7}

数组元素访问

按照索引访问

public class ArrayDemo2 {
    static void main() {


    /*
    数组中的元素访问：
        1.获取数据
        2.修改数据
    */
       // 1.静态初始化数组
       int arr[] = {12, 45, 43, 78};

       // 2.获取数据
        int num = arr[2];
        System.out.println("数组的第三个元素是：" + num);

        // 3.修改数据
        arr[1] = num;
        System.out.println("数组第二个元素是：" + arr[1]);
    }
}

数组遍历

一般加入for循环遍历

数组的动态初始化

int arr[] = new int[6];

存储数据

public class ArrayDemo4 {
    static void main() {

        // 键盘录入5个的整数，存入数组当中，并进行遍历
        int arr[] = new int[5];
        Scanner sc = new Scanner(System.in);
        int num = 0;
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入数字：");
            num = sc.nextInt();
            arr[i] = num;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }


    }
}

2026.4.19

查找数据

import java.util.Scanner;

public class Test1 {
    static void main() {
        /*
        已知数组元素为 {33,5,22,44,55,33}
        键盘录入任意一个数据，查找这个数据在数组中是否存在
        如果数组中要查找的数据出现多次，只要显示第一次的索引即可
        输出要求：
        如果存在打印索引
        如果不存在，提示：“该数据不存在”
        */

       int arr[] = {33,5,22,44,55,33};
       int num = 0;
       Scanner sc = new Scanner(System.in);
       System.out.println("请输入一个数字：");
       num = sc.nextInt();

        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (num == arr[i]) {
                count++;
                System.out.println(i);
                break;
            }
        }
        if (count == 0) {
            System.out.println("该数据不存在");
        }
    }
}

求最值

public class Test2 {
    /*已知数组元素为 {33,5,22,44,55}
    请找出数组中最大值并打印在控制台*/

    // 细节：max是不能被赋值为负数的，因为当比较的值都为负数的时候，没有一个数是比零大的，所以一般是默认为数组的第一个元素的
    static void main() {
        int arr[] = {33,5,22,44,55};
        // 默认值为数组的第一个元素
        int max = arr[0];
        for (int i = 1; i < 5; i++) { // 所以就从第二个元素开始比较了，而不是从第一个元素开始比，可以提高程序的执行效率
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        System.out.println("做大值为：" + max);
    }
}

打乱数据

import java.util.Random;

public class Test3 {
    static void main() {
        /*已知数组元素为 {1,2,3,4,5,6,7,8,9,10}
        要求：打乱数组中的数据*/

        int arr[] = {1,2,3,4,5,6,7,8,9,10};
        Random r = new Random();
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            //  输入随机的索引
            int re = r.nextInt(10);
            // 简单的变量交换
            temp = arr[i];
            arr[i] = arr[re];
            arr[re] = temp;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

// 细节1：
        // 两个变量之间如何进行交换？
// 细节2：
        // 怎么生成一个随机的索引？

去除重复元素

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

public class Test4 {
   /* 获取10个1-100之间的随机数并存入到数组当中,要求保证数据是唯一的*/
   static void main() {
       // 动态创建数组
       int arr[] = new int[10];
       Random r = new Random();

       int num = 0;
       for (int i = 0; i < arr.length;i++) {
           num = r.nextInt(1, 101);
           arr[i] = num;
           int count = 0;
           for (int j = 0; j < arr.length; j++) {
               if (num == arr[j]) {
                   count++;
                   break;
               }
           }
           if (count == 0) {
               arr[i] = num;
           }
       }

       for (int i = 0; i < arr.length; i++) {
           System.out.print(arr[i] + " ");
       }
   }
}

有序数组中去除重复元素

public class Test5 {
    static void main() {
        // 给定义一个递增有序数组，去除其中重复元素
        int arr[] = {1, 2, 2, 2, 2, 3, 3, 3, 3};

        // 定义快慢指针：
        int slow = 0;
        int fast = 1;

        // 判断两个指针是否相等
       while (fast < arr.length) {
            if (arr[slow] != arr[fast]) {
                slow++;
                arr[slow] = arr[fast];
            }
           fast++;
       }

        for (int i = 0; i <= slow; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

2026.4.20

方法：

格式：

public static void 方法名 (   ) {
  // 方法体;
}

调用格式：

方法名()

无参方法：

public class MethodDemo4 {
    static void main() {
        // 调用方法打印九九乘法表
        printMultable();
    }
    public static void printMultable() {
        for(int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " * " + i + " = " + i * j + "\t");
            }
            System.out.println();
        }
    }
}

带参方法：

格式：

public static void 方法名 (参数1) {
  方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
  方法体;
}

调用格式：

方法名（）

关于形参和实参：

形参：方法定义的参数（int num）
实参：方法调用的参数

public class MethodDemo1 {
    // 定义一个方法，求两个数的和
    static void main() {
        /*int add = getSum(10, 20);
        System.out.println(add);*/
        System.out.println(getSum(10, 20));
    }

    public static int getSum(int a, int b) {
        int sum = a + b;
        return sum;
    }
}

带返回值的

格式：

public static 数据类型 方法名 ( 参数 ) {
        return 数据 ;
}

调用格式：

方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;

public class MethodDemo2 {
    /* 获取10个1-100之间的随机数并存入到数组当中,要求保证数据是唯一的*/
    static void main() {
        int[] arr = new int[10];
        Random r = new Random();
        int num = 0;

        for (int i = 0; i < arr.length;) {
            num = r.nextInt(1, 101);
            // 判断是否重复
            boolean flag = contains(num, arr);
            if (!flag) {
                arr[i] = num;
                i++;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    public static boolean contains(int num, int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            if (num == arr[i]) {
                return true;
            }
        }
        return false;
    }
}

注意：

方法不能嵌套定义：
void表示无返回值，可以不加return

方法重载：

多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

public class MethodDemo {
    public static void fn(int a) {
            
    }
    public static int fn(double a) {
           
    }
}
public class MethodDemo {
    public static float fn(int a) {
            
    }
    public static int fn(int a , int b) {
            
    }
}

2026.4.21

java运行原理：

内存分配：

栈内存
堆内存
方法区

2026.4.22

移除元素

题目：

给你一个数组 nums 和一个值 val，你需要删除所有数值等于 val 的元素

举例1：

输入：nums = [3,2,2,3] val = 3

输出：nums = [2,2] 剩余2个元素

举例1：

输入：nums = [0,1,2,2,3,0,4,2] val = 2

输出：nums = [0,1,4,0,3] 剩余5个元素

思路：

删除目前没有学删除元素的方法，但是可以用一个行的数组来存储需要的元素，而不需要的元素就不存入

其中有一个方法可以去实现，就是快慢指针

为什么这样做：

假设指定一个val为3，意思为不存入3，那么当快指针移到val的时候，是不会赋值到慢指针索引所对的数组

public class Test1 {
    /*给你一个数组 nums 和一个值 val，你需要删除所有数值等于 val 的元素
    举例1：
    输入：nums = [3,2,2,3]    val = 3
    输出：nums = [2,2]  剩余2个元素
    举例1：
    输入：nums = [0,1,2,2,3,0,4,2]    val = 2
    输出：nums = [0,1,4,0,3]  剩余5个元素*/
    static void main() {
        int[] nums = {3, 2, 2, 3};
        int val = 3;

        // 定义快慢指针
        int slow = 0;
        int fast = 0;

        for (int i = 0; i < nums.length; i++) {
            if (val == nums[i]) {
                fast++;
            } else {
                nums[slow] = nums[i];
                slow++;
                fast++;
            }
        }

        for (int i = 0; i < slow; i++) {
            System.out.print(nums[i] + " ");
        }
    }
}

2026.4.23

红包问题

题目：

给你两个整数M和N，M表示红包的总额， N表示红包的个数

现在又N个人来抽红包，每个人都是随机的，打印每个人领的红包金额

思路：

因为要确保每一个人都可以领到钱

一个极限：

5元的红包5个人分：

第一个人拿：至少需要留4元

二：至少需要3元

其中最后一个拿剩下所有的钱

import java.util.Random;

public class Test2 {
    /*给你两个整数M和N，M表示红包的总额， N表示红包的个数
    现在又N个人来抽红包，每个人都是随机的，打印每个人领的红包金额*/
    // 分析：
    // 1. 每人最少分一块钱
    // 2.至少预留 1 * N 块钱
    // 3. 最后一个人分走剩下的钱
    static void main() {
        int M = 600;
        int N = 13;
        // 定义随机函数
        Random r = new Random();

        for (int i = 1; i < N; i++) {
            int s = r.nextInt(M - (N - i)) + 1;
            M = M - s;
            System.out.println("第" + i + "个人抽取的钱为：" + s);
        }
        System.out.println("最后的一位抽取的金钱为：" + M);
    }
}

2026.4.24

中位数

题目：

给定两个正序数组 arr1和 arr2，请先合并数组，并找出合并之后数组的中位数。

举例：

1 2 3 4 5 6 7 8 9 中位数：5

1 2 3 4 5 6 中位数：（ 3 + 4 ） / 2

思路：

正序数列，首先需要把这两个数列合并起来再进行中位数操作

中位数可以通过取余来操作：

当数组长度为奇数的时候去中间值 1 2 3 4 5 元素

0 1 2 3 4 索引

可以通过举例来得出结论

public class Test3 {
    /*给定两个正序数组 arr1和 arr2，请先合并数组，并找出合并之后数组的中位数。
    举例：
            1 2 3 4 5 6 7 8 9      中位数：5
            1 2 3 4 5 6           中位数： （ 3 + 4 ） / 2*/
    static void main() {
        int[] arr1 = {1, 2, 3, 6,19,10, 7, 8, 9, 10, 34, 25};
        int[] arr2 = {1, 8, 3, 34, 11, 6};
        int[] arr = new int[arr1.length + arr2.length];

        int index1 = 0;
        int index2 = 0;

        for (int i = 0; i < arr.length; i++) {
            // 1.如果arr1是短的：
            if (index1 == arr1.length) {
                arr[i] = arr2[index2];
                index2++;
                continue;
            }

            // 2.如果arr2是短的：
            if (index2 == arr2.length) {
                arr[i] = arr1[index1];
                index1++;
                continue;
            }

            // 如果arr1的第一个元素小于arr2的第一个元素：
            if (arr1[index1] < arr2[index2]) {
                arr[i] = arr1[index1];
                index1++;
            }else {
                arr[i] = arr2[index2];
                index2++;
            }
        }

        // 元素：1 3 5 7 9
        // 索引：0 1 2 3 4
        // 当元素个数为奇数时：
        if (arr.length % 2 == 1) {
            int num = arr[arr.length / 2];
            System.out.println("中位数：" + num);
        } else {
            int num1 = arr[arr.length / 2];
            int num2 = arr[arr.length / 2 - 1];
            System.out.println("中位数：" + (num1 + num2) / 2.0);
        }

    }
}

2026.4.25

今天在下午补的java课上面最后布置的一道商品清单题目，卡了很久，差不多三个小时

原因有如下：

上课没有认真听，导致关键解法没有解出来
没有搞懂全局变量和局部变量，导致程序报错

在解决题目的时候要思考为什么要这么做，这样执行是否有意义

2026.4.26

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]

输出：6

解释：下面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）

思路：

动态规划思想：这是需要学习的，自己短时间内是想不出来的，知识储备不够，还没有创造力

当下雨的时候，两边都有水排出，那么就很难解决了

其中有一个方法，就是假设右边有一个高大的墙，可以挡住所有往右流出的水

同理左边也是

还有，如何才能留住雨水？

必须是左右两边高，中间低，这时需要两两比较，代码量很大，所以就采取了左右两边的假设，取交集

public class Test5 {
    /*给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水
    输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
    输出：6
    解释：下面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）*/

    static void main() {
        int[] height = {0,1,0,2,1,0,1,3,2,1,2,1};
        int temp = 0;
        // 设置一个变量储存最高的墙（最高的墙可以挡住后面的雨水不被流走）
        int[] arr1 = new int[height.length];
        int[] arr2 = new int[height.length];
        // 假设右边有一个高大的墙：
        for (int i = 0; i < height.length; i++) {
            if (temp <= height[i]) {
                temp = height[i];
            }
            arr1[i] = temp;
        }

        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }

        System.out.println();

        // 假设左边有一个高大的墙：
        temp = 0;
        for (int i = height.length - 1; i >= 0; i--) {
            if (temp <= height[i]) {
                temp = height[i];
            }
            arr2[i] = temp;
        }
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }

        System.out.println();

        // 两边都弄好了，接下来进行重合，取交集
        // 而且是取最小的
        int[] arr3 = new int[height.length];
        for (int i = 0; i < height.length; i++) {
            if (arr1[i] <= arr2[i]) {
                arr3[i] = arr1[i];
            } else {
                arr3[i] = arr2[i];
            }
        }

        for (int i = 0; i < height.length; i++) {
            System.out.print(arr3[i] + " ");
        }

        // 求和：
        int sum = 0;
        for (int i = 0; i < height.length; i++) {
            sum += arr3[i];
        }

        System.out.println();

        // 再减去柱子的和：
        for (int i = 0; i < height.length; i++) {
            sum = sum - height[i];
        }
        System.out.println(sum);
    }
}

2026.4.27

SQL分类：

DDL：数据定义语言,用来定义数据库对象(数据库,表,字段)
DML：数据操作语言,用来对数据库表中的数据进行增删改
DQL：数据查询语言,用来查询数据库中表的记录
DCL：数据控制语言,用来创建数据库用户、控制数据库的访问权限

DDL-数据库操作：

查询
查询所有数据库：
SHOW DATABASES；
查询当前数据库：
SELECT DATABASE();
创建
CREATE DATABASE [IF NOT EXISTS] 数据库名 [DEFAULT CHARSET 字符集] [COLLATE排序规则];
删除
DROP DATABASE[IF EXISTS] 数据库名;
使用
USE 数据库名;

DDL-表操作查询

查询当前数据所有表
SHOW TABLES;
查询表结构
DESC 表名;
指定表的建表语句
SHOW CREATE TABLE 表名;

DDL-表操作-创建

DDL-表操作-数据类型

数值类型
字符串类型
日期时间类型

DDL-表操作-修改

添加字段
ALTER TABLE 表名 ADD 字段名类型（长度）[COMMENT 注释]；
修改数据类型
ALTER TABLE 表名 MODIFY 字段名新数据类型（长度）;
修改字段名和字段类型
ALTER TABLE 表名 CHANGE 旧字段名新字段名类型（长度）[COMMENT 注释];
删除字段
ALTER TABLE 表名 DROP 字段名;
修改表名
ALTER TABLE 表名 RENAME TO 新表名;
删除表
DROP TABLE [IF EXISTS] 表名；
删除指定表，并重新创建该表
TRUUNCTE TABLE 表名;

#学习日志

#学习

小白学习日志-Nebula

https://wlw301.top//archives/1ixZsJqY

作者

五月天

发布于

2026年04月08日

更新于

2026年04月27日

许可协议

小白学习日志-yupi (26年4月7-27号) 上一篇

饥荒联机版：威尔逊/威尔逊技能树下一篇

小白学习日志-Nebula

2026.4.7

变量：

变量的注意事项：

基本数据类型：

编程的本质

2026.4.8

键盘录入（Scanner）:

算数运算符：

基本介绍：

运算特点：

关于对技能大赛的了解和启发

2026.4.9

数值拆分（算法题）：

隐式转换：

比如说：

强制转换：

背景：

书写格式：

关于服务器本地部署：

感想：

2026.4.10

2026.4.11

字符串的 + 操作

自增自减运算符

赋值运算：

扩展数值运算符：

关系运算符：

注意：

逻辑运算符

三元运算符：

运算符的优先级：

2026.4.13

流程控制语句：

分类：

判断语句 if:

比较有意思的题目（阶梯式计算）：

2026.4.14

选择语句（switch）

switch的扩展知识：

2026.4.15

循环结构

2026.4.16

while循环

复利：

珠穆朗玛峰

数位之和

do...while循环

无限循环

for格式：

while格式：

do...while格式：

条件控制语句

break：不能单独存在的。可以用在switch和循环中，表示结束，跳出的

游戏人物：

找质数：

continue语句

逢七过：

Random:

猜数字：

2026.4.17

嵌套循环

打印长方形

打印正三角形

打印倒三角形

打印梯形

打印平行四边形

打印九九乘法表

关于制表符的研究

2026.4.18

数组

数组的静态初始化

数组元素访问

数组遍历

数组的动态初始化

存储数据

2026.4.19

查找数据

求最值

打乱数据

break：
不能单独存在的。可以用在switch和循环中，表示结束，跳出的