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

2026-4-7

《编程的本质》

编程要的是抽象思维，将要处理的事情·拆解成数据和函数的能力（世界是由庞大的数据以及复杂的函数组成）

学习是增加自己的处理依据（数据量） 以及 优化思维方式（函数）

程序可拆分成数据和函数

函数约等功能于接受输入参数，处理，输出结果（听到呼唤，出力事情，回应结果的全过程 ）

函数的核心是函数的计算过程包括运算符号（-+*/等）以及控制过程（判断，循环）

cmd的常用命令

cd 进入单目录  cd.. 回到根目录   dir 查询当前目录内容

盘符名+ :  切换盘符

JDK java开发者工具包

多行注释的快捷方式 ctrl + shift + /

Ai时代的使用规则

1.      定规则

2.      拆业务

3.      逐个实现

4.     排除bug

5.      最终运行

配置环境变量

2026-4-8

零散的知识（浮点数Java中要分float和double是因为在二进制中无法精确表示以及计算机的储存空间有限）

技能大赛相关的知识

1.比赛的形式大概是路演的形式

2.要求对技能的熟练度（如 打字的熟练度，盲打，接线剪线的熟练度等）

3.碰上主办方就寄几了

世界职业院校技能大赛流程的基本分析

1.开场引言-体现符合国家发展的规划要求

2.展示实施的步奏-分别展示技能点，说明技能点

3.展示成果-展示说明项目的创兴点，对生产的经济效应，解决了哪些问题

4.做到技能操作零失误，体现团队中的协作能力

变量：用来存储经常发生变化的数据的容器，不是里面的数据 （只能存一个值，变量名不能重复定义，）

int a =0

a=a+1

2026-4-9

数值拆分

个位：数值 % 10

十位：数值 /10 % 10

百位：数值 /100 % 10

千位：数值 /1000 % 10

import java.util.Scanner;
public class test3 {
    static void main() {
        //获取一个值，分别获取他的个位 十位 百位
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        System.out.println(a);
        int ge = a % 10;
        System.out.println(ge);
        int shi = a /10 % 10 ;
        System.out.println(shi);
         int bai = a /100 % 10;///
         System.out.println(bai);
         //定义一个变量seconds 秒，将秒数转换为时分秒
        int seconds = 3661;
        int hour = seconds / 3600;
        int minute = seconds % 3600 / 60;
        int second = minute % 60;
        System.out.println(hour + ":" + minute + ":" + second);
    }
}

数字运算：不同类型的不能运算，要转化为相同的再运算

隐式转换（小转大，一般是先转成int ，不够再往上转 ）从小到大 byte<short<int<long<float<double      

强制转换 int a = 10 ;  // 可能出现精度丢失,；、

         byte b = (byte) a ;

如果要转的是运算的结果要用（）包起来

byte r = (byte) (e+d) ;

运维的零散知识

http 应该接到80

服务器最好用密钥（比密码安全多得多）

在服务器配置不好的情况下Linux比Windows加图形化界面要占用的内存少的多

感想：建立一个服务器索要的步骤并不复杂，但依然需要大量的知识储备，但更重要的是对于在这过程中频繁出现的小问题要保持耐心这是互通的

2026-4-10

分镜的设计

主题（梗概）：一天我因外卖被偷而上校园墙反映这一情况，却发现校园墙上净是打着找学习达子为幌子实则找暧昧对象之类的帖子，以及之前在日常中发现校园aed的位置及数量无人的情况，我深思，认为学校需要一个反应问题，理性讨论问题，共同进步的平台，于是我和有同样想法的两名同学一拍即合打算自己建立一的校园论坛，于是我们逞着兴致当天就熬夜搭建出了我们的论坛，接着我们逛遍整个校园，以此来获取素材。之后我们写了几篇文章（对学校缺少无障碍通道的讨论贴，Java问题的求助帖，养虾的心得和解答贴），写完后我们期待的等待着反馈，可论坛新建关注的人不多，这几篇帖子像石沉大海一样，我们几人对这样毫无反馈的情况感到了失落，为了转换心情我们选择出门散心，在散心的途中一人对之前的行为感到了迷茫，一股阴霾围绕在了我们的头顶，此时邮箱响了，一条回帖如同一针强心剂注入我们的体内，扫清我们心中的迷雾

“谢谢你们替我说出了这些。。。”（完）

以上是我要做的微短片的梗概，这个视频时长为5-6分钟，主演3人，采用的设备为vivo x200 pro ，拍摄及后期剪辑只是学生，非专业人员，我需要你帮我设计一个的脚本(包括各个镜头的时长，对镜头画面的文字描述，镜头的景别，拍摄场景，文案，人物台词),要求开头黄金三秒，整体节奏舒缓，但用快节奏突出情节的起伏，第一人称为主，第三人称为辅，人物台词少，更多用镜头语言表达，台词设计可以参考影视飓风，脚本做成表格的形式，将各个镜头排序并和脚本的设计(包括各个镜头的时长，对镜头画面的文字描述，镜头的景别，拍摄场景，文案，人物台词)对应

2026-4-11

大小写的转换

字符是可以和数字进行相加减

字符可以查找ASCII表转换成数字

char a = A

char cc = (char) (a + 32)

sout (cc)

字符串运算

字符串只有拼接操作

"小"+1

小1

1+2+"小"+3+6

3"小36"

++变量加一

--变量减一

a == b \\a等于b

=赋值给左边的值

int a = 1

int b = 2

a+=b

sout a=3

sout b=2

逻辑运算符 与或非(&一无全无 |一有既有 ！取反)

1<a & a <10 (1<a<10)

2026-4-12

无，赶政治的拍摄

2026-4-13

三元运算符
键盘中录入两个整数，获得其中更大的

public class sanyuan {  
    public static void main(String[] args) {  
      //三元运算符，语法：条件?表达式1:表达式2  
        int a = 10;  
        int b = 20;  
       int max =  a>b ? a : b ;//条件？表达式1:表达式2，为ture时返回表达式1，为false时返回表达式2  
        System.out.println( max);  
//        也可以简写为  
        System.out.println(a>b ? a : b);  
  
    }

java运算符的优先级

if语句的基本知识

import org.w3c.dom.ls.LSOutput;  
  
public class temproture {  
    static void main() {  
        // 定义变量表示温度，判断温度是否大于38℃，大于38℃则输出“发烧”  
        double t = 36.4;  
        if (t > 38.0) {  
            System.out.println("发烧");  
        }  
        else {  
            System.out.println("正常");  
        }  
    }  
}

import java.util.Scanner;  
  
public class game {  
    static void main() {  
        //需求:初始最大生命200,受到X点伤害,技能恢复Y点血,X和Y由键盘录入而来  
        //假设,游戏人物不会死亡,最少1点血  
        //问:最终游戏人物血量是多少?  
        int blood = 200 ;  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入伤害");  
        int hurt = sc.nextInt();  
        System.out.println("请输入技能恢复");  
        int skill = sc.nextInt();  
        blood = blood - hurt + skill;  
        //当大括号中只有一条语句时，可以省略{}  
        if(blood>1)  
            System.out.println("最终游戏人物血量是：" + blood);  
  
        System.out.println("角色死亡");  
    }  
}

if语句判断布尔型变量直接将变量写在小括号内
boolean a = ture
if（a）{
sout("为真")
}

Excel的基本用法

1.建表

2常用的函数用法

SUM (求和)、AVERAGE (平均值)

3.自动填充 ： 拖动单元格右下角的“填充柄”，可以快速生成序列（如日期、数字、星期）。

2026-4-14

&& (短路与): 如果第一个条件为 false,则不会执行第二个条件的判断
& (非短路与/按位与): 无论第一个条件是什么,都会执行两个条件的判断

// 使用 && (短路与)
int x = 5;
if (x > 10 && ++x > 0) {
    // 这里不会执行,因为 x > 10 为 false
}
System.out.println(x); // 输出: 5 (++x 没有执行)

// 使用 & (非短路与)
int y = 5;
if (y > 10 & ++y > 0) {
    // 这里不会执行
}
System.out.println(y); // 输出: 6 (++y 执行了)

小知识点
变量只在所需的大括号中有效

public class binaliang1 {  
    public static void main(String[] args) {  
        int a = 10;  
        if(a>5){  
            int b = 20;  
  
        }  
        System.out.println(a<b);//变量只在所需的大括号中有效  
    }  
}

if语句最后一章

import java.util.Scanner;  
  
public class Member {  
    public static void main(String[] args) {  
        //计算冲卡不同额度的余额  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入你冲的会员是多少；" + " ");  
        int manony = sc.nextInt();  
        /*1000+200  
        * 2000+500        * 3000+700        * 5000+1300        * 10000+2500        * 20000+6000        * 50000+15000*/        if (manony > 0) {  
            if(manony<1000) System.out.println("余额"+manony);  
            else if  (manony<2000) System.out.println("余额"+(manony+200));  
            else if (manony<3000) System.out.println("余额"+(manony+500));  
            else if (manony<5000) System.out.println("余额"+(manony+700));  
            else if (manony<10000) System.out.println("余额"+(manony+1300));  
            else if (manony<20000) System.out.println("余额"+(manony+2500));  
            else if (manony<50000) System.out.println("余额"+(manony+6000));  
            else System.out.println("余额"+(manony+15000));  
        }  
        else System.out.println("输入有误");  
    }  
}

冒泡排序

2026-4-15

switch语句

1.与if的区别：switch适用于有限的条件如月份，星期等，if适用于一个范围，条件有限时switch更简洁

2.作用

把所有条件列举出来，选一种进行匹配

switch（表达式）{

case 值 : ;//为真实的值，不能是变量，不能与下面的case的值重复

具体语句 ;//结果为（字符，字符串，整数（byte，short，int），枚举）

break

……

default.://位置不固定，但最好在最后

具体语句 ;

break ;

}

3.细节小知识点

case穿透，没有break则不结束

-> 优化语句

yield，使switch外也可以调用case的值

2026-4-16

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

public class ForDemo02 {  
    static void main() {  
        //S(n)=1-2+3-4+5-6+...+n, 求S(10)  
        int sum = 0;  
        for (int i = 0; i <10 ; i++) {  
            if (i % 2 == 0) {  
                sum = sum - i;  
        }else{  sum = sum + i;  
            }  
        }  
        System.out.println(sum);  
    }  
}

public class fordemo {  
    public static void main(String[] args) {  
        //有一组特殊的数字，从第三项开始，每项数字都是前一项数字和前两项数字的和，求第十项的值  
        int a = 0;  
        int b = 1;  
        int c = 0;  
        for (int i = 0; i < 10; i++) {  
            c = a + b;  
            a = b;  
            b = c;  
        }  
        System.out.println(c);  
        }  
         }

do while 语句

public class DoWhile01 {  
    public static void main(String[] args) {  
        //do...while循环  
        //do...while循环至少会执行一次  
        int i = 10;  
        do{  
            System.out.println("Hello World");  
            i++;  
        }while (i <= 5);  
    }  
}

while循环语句

//        while循环的格式  
//        初始语句  
//                while(条件){  
//                    循环体  
//                    循环控制语句  
//                }  
    }

public class WhileDemo02 {  
    static void main() {  
//给定一个整数n,请计算其所有数位之和。若n为负数,请先取其绝对值。  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请随意输入一个值");  
        int n = sc.nextInt();  
        int sum = 0;  
        //计算其所有数位之和  
        //取个位%10  
        //去个位/10 再循环，直到n为0  
        //获取绝对值  
        if(n<0) {  
            n = -n;  
        }  
            while(n != 0){  
                sum = sum + n % 10;  
                n = n / 10;  
            }  
            System.out.println(sum);  
    }  
}

for和 while的区别:

for循环中:知道循环次数或者循环的范围

while循环:不知道循环的次数和范围,只知道循环的结束条件。

死循环

public class infiniteDemo {  
    public static void main(String[] args) {  
        //无限循环  
        while (true) {  //最常用的死循环  
            System.out.println("Hello World");  
        }  
//        //for 循环  
//        for (; ; ) {  
//            System.out.println("Hello World");  
//            //do ... while 循环  
//            do {  
//                System.out.println("Hello ");  
//            }while ( true);  
        }  
    }

循环的快速生成方式:次数.fori+回车

break / continue
break: 跳出循环
continue：结束本次循环

Random
生成一个随机数
(了解)第一种写法:int n=r.nextInt();

(重要)第二种写法:小括号写一个数字n,表示随机的最大值,但是不包含这个数字
(重要)第三种写法:小括号写两个数字a b,表示随机的取值范围是a~b,包含a,不包含b

默认是在int的取值范围之内获取随机数

2026-4-17

循环嵌套
打印一个空心的菱形

// ... existing code ...
public class point {
    public static void main(String[] args) {
        printHollowDiamond();
    }
    
    public static void printHollowDiamond() {
        int rows = 7;
        int mid = rows / 2;
        
        // 上半部分（包含中间行）
        for (int i = 0; i <= mid; i++) {
            // 打印前置空格
            for (int j = 0; j < mid - i; j++) {
                System.out.print(" ");
            }
            
            // 打印星号
            if (i == 0) {
                // 第一行只有一个星号
                System.out.println("*");
            } else {
                System.out.print("*");
                // 中间的空格
                for (int k = 0; k < 2 * i - 1; k++) {
                    System.out.print(" ");
                }
                System.out.println("*");
            }
        }
        
        // 下半部分
        for (int i = mid - 1; i >= 0; i--) {
            // 打印前置空格
            for (int j = 0; j < mid - i; j++) {
                System.out.print(" ");
            }
            
            // 打印星号
            if (i == 0) {
                // 最后一行只有一个星号
                System.out.println("*");
            } else {
                System.out.print("*");
                // 中间的空格
                for (int k = 0; k < 2 * i - 1; k++) {
                    System.out.print(" ");
                }
                System.out.println("*");
            }
        }
    }
}
// ... existing code ...

打印99乘法表

public class ForDemo04 {  
    public static void main(String[] args) {  
      //打印99乘法表  
        //外循环  
        System.out.println("---------------------------------------------------------------");  
        for (int i = 1; i <=9 ; i++) {  
            //内循环  
            for (int j = 1; j <=i ; j++) {  
                System.out.print(j+" * "+i+" = "+(j*i) + "\t") ;  
            }  
            System.out.println();  
        }  
  }  
}

制表符:\ t
简单理解:长度可变的大空格,打印表格类数据的时候,可以让上下对其。(99乘法表)

真正的含义:
在前面的字符后面补1-4个空格,让这个整体的长度凑成4的整数倍

System.out.println("------------");  
System.out.println("----\t"+"--");

数组
数组:是一种容器,可以用来存储同种数据类型的多个值

//创建数组--静态初始化  
int[] arr = {1,2,3,4,5};  
//动态初始化(定义数组的长度，默认的初始值)  
int[] arr1 = new int[5];  
Scanner sc = new Scanner(System.in);  
for (int i = 0; i < arr.length; i++) {  
    System.out.println("请输入第" + (i+1) + "个元素");  
    arr[i] = sc.nextInt();  
}  
for (int i = 0; i < arr.length; i++) {  
    System.out.println(arr[i]);

//        数组中元素的访问:  
//        1. 获取数据  
//        2. 修改数据、  
        int[] arr = {1,2,3,4,5};  
        //获取数据  
        System.out.println(arr[0]);  
        //修改数据  
        arr[0] = 100;


//遍历数组  
int[] arr = {1,2,3,4,5};  
//遍历数组的快捷键: 数组名. fori+enter  
for (int i = 0; i < arr.length; i++) {  
    System.out.println(arr[i]);

2026-4-18

数组的练习：需求:获取10个1-100之间的随机数并存入到数组当中,要求保证数据是唯一的

public static void main(String[] args) {  
        //需求:获取10个1-100之间的随机数并存入到数组当中,要求保证数据是唯一的  
        int arr [] = new int[10];  
        Random r = new Random();  
        //遍历数组  
        for (int i = 0; i <arr.length ; ) {  
            int date = r.nextInt(100)+1;//获取1-100之间的随机数  
            //判断数据是否重复  
            int count = 0;//建立计数器  
            for (int j = 0; j <arr.length ; j++) {  
                if (arr[j]==date){  
                    count++;  
                    break;                }  
                }  
            if(count==0){  
                arr[i]=date;  
                i++;//赋值成功,i++D  
            }  
  
        }  
        for (int i = 0; i < arr.length; i++) {  
            System.out.print(arr[i] + " ");  
        }  
    }  
}

细节i++放置的位置，防止数组中出现0

快慢指针

慢指针:存入的位置
快指针:找不重复的数据
相等→舍弃快指针位置的数据
不等→快指针的数据存入慢指针位置

int arr [] = {1,2,2,3,4,4,5,6,7,8,9,9,10};  
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] + " ");  
}  
}

方法:程序中的独立功能,也是最小的执行单元

2026-4-19

方法:程序中的独立功能,也是最小的执行单元
使用场景：打包重复多次使用的代码
提高代码的复用性，可维护性

public class MethodDemo1 {  
    //定义格式:  
    //public static 返回值类型 方法名(参数1,参数2 ... ){  
    //方法体;  
    //return 返回值;  
    //}    //调用格式:  
    //方法名(参数1,参数2 ... );  
    //注意点:  
    //1. 方法跟方法之间是平级关系,不能互相嵌套  
    //2. 方法不会主动运行的,需要被调用才可以  
    //3. 小括号中的参数需要-一对应(个数,类型)  
    public static int getsum(int a , int b){  
        int sum = a + b;  
        return sum;  
    }  
    public static void main(String[] args) {  
      getsum(10086,114514);  
        System.out.println(getsum(10086,114514));  
    }  
}

练习

public class MethodDemo2 {  
    //定义一个方法打印一个99乘法表  
    public static  void print(){  
        for (int i = 1; i <=9 ; i++) {  
            for (int j = 1; j <= i; j++) {  
                System.out.print(  
                        j + "*" + i + "=" + i * j + " "  
                );  
            }  
            System.out.println();  
        }  
    }  
  
    static void main() {  
        print();  
    }  
}

方法的参数是可以空着的，void 不返回值

定义方法的小诀窍:

  1. 观察在大段的代码当中,反复使用的独立功能是什么?

  2. 这个独立功能,需要什么才能完成 ?--- 形参

  3. 方法的调用处,是否需要这个独立功能的结果继续做其他事情?//是否要返回值

反复使用 +独立功能

方法的重载
1.同一个类中,定义了多个同名的方法,这些方法具有类似的功能
2.每个方法具有不同的参数类型和参数个数,这些同名的方法,就构成了重载关系
3.简单理解:同一个类,方法名相同,参数不同（个数，类型，顺序不同）的方法,无需看返回值。

2026-4-20

#java运行原理
Java文件->class文件解码(运行在虚拟机中)->输出结果，使用虚拟机是为了实现跨平台，是一段代码可以在任意系统上运行

内存:软件在运行时,用来临时存储数据的
内存地址:内存中每一个小格子的编号，为了快速管理内存空间
64位系统:以64位的二进制表示
阅读弊端:二进制太长,转为十六进制

java中内存的分配

  1. Java虚拟机把内存分成了几个部分?
    栈内存、堆内存、方法区、本地方法栈、程序计数器

  2. 栈、堆、方法区的作用?
    栈:方法(方法被调用进栈，调用结束就栈)
    堆:new关键字(在堆内存中开辟一个空间存储)
    方法区:字节码文件（class文件临时存放）

  3. 基本数据类型在内存中的特点?
    记录的是真实的数据,传递也是真实的数据

  4. 引用数据类型在内存中的特点?
    记录的是地址值,传递也是地址值
    算法题

{  
    //给你一个数组nums和一个值val,你需要删除所有数值等于val的元素  
int nums [] = {1,1,1,1,2,2,3,3,3};  
int val = 2;  
//建立快慢指针  
    int slow = 0;  
    int fast = 0 ;  
    while (fast<nums.length){  
        if(nums[ fast]!=val){  
            nums[slow] = nums[fast];  
            slow++;  
        }  
        fast++;  
    }  
    for (int i = 0; i <slow ; i++) {  
        System.out.print(nums[i]+" ");  
  
    }  
    }

2026-4-21

删除数组中的数据

public class test04 {  
    public static void main(String[] args) {  
        //给你一个数组nums和一个值val,你需要删除所有数值等于val的元素  
    int nums [] = {1,1,1,1,2,2,3,3,3};  
    int val = 2;  
    //建立快慢指针  
        int slow = 0;  
        int fast = 0 ;  
        while (fast<nums.length){  
            if(nums[ fast]!=val){  
                nums[slow] = nums[fast];  
                slow++;  
            }  
            fast++;  
        }  
        for (int i = 0; i <slow ; i++) {  
            System.out.print(nums[i]+" ");  
  
        }  
        }  
}

红包问题

    public static void main(String[] args) {  
        //给你两个整数M和N,M表示红包的总额,N表示红包的个数  
        //现在又N个人来抽红包,每个人都是随机的,打印每个人领的红包金额  
        //注1:每个人最少1分钱  
        //注2:每个人领完红包之后,至少预留1*N分钱  
        //注3:最后一个人是拿剩余的总额  
  
        int M = 10000; // 红包总额(分),例如100元=10000分  
        int N = 10;    // 红包个数  
  
        distributeRedPacket(M, N);  
    }  
    public static void distributeRedPacket(int totalAmount, int count) {  
        if (totalAmount < count) {  
            System.out.println("红包总额不足!");  
            return;        }  
  
        Random random = new Random();  
        int remaining = totalAmount;  
  
        for (int i = 1; i <= count; i++) {  
            int amount;  
  
            if (i == count) {  
                // 最后一个人拿剩余的全部  
                amount = remaining;  
            } else {  
                // 计算当前可分配的随机范围  
                // 需要为后面的人预留至少(count-i)分钱  
                int maxAmount = remaining - (count - i);  
  
                // 随机生成红包金额(1分到maxAmount之间)  
                amount = random.nextInt(maxAmount) + 1;  
            }  
  
            remaining -= amount;  
            System.out.printf("第%d个人领取: %.2f元\n", i, amount / 100.0);  
        }  
    }  
}
/

2026-4-22

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

public static void main(String[] args) {  
        //给定两个正序数组arr1和arr2,请先合并数组,并找出合并之后数组的中位数。  
  
        int[] arr1 = {1, 3, 5, 7};  
        int[] arr2 = {2, 4, 6, 8, 10};  
  
        double median = findMedianSortedArrays(arr1, arr2);  
        System.out.println("中位数: " + median);  
    }  
  
    public static double findMedianSortedArrays(int[] arr1, int[] arr2) {  
        int m = arr1.length;  
        int n = arr2.length;  
        int[] merged = new int[m + n];  
  
        // 合并两个有序数组  
        int i = 0, j = 0, k = 0;  
        while (i < m && j < n) {  
            if (arr1[i] <= arr2[j]) {  
                merged[k++] = arr1[i++];  
            } else {  
                merged[k++] = arr2[j++];  
            }  
        }  
  
        // 处理剩余元素  
        while (i < m) {  
            merged[k++] = arr1[i++];  
        }  
        while (j < n) {  
            merged[k++] = arr2[j++];  
        }  
  
        // 计算中位数  
        int total = m + n;  
        if (total % 2 == 1) {  
            return merged[total / 2];  
        } else {  
            return (merged[total / 2 - 1] + merged[total / 2]) / 2.0;  
        }  
    }  
}

2026-4-23

选主席问题

import java.util.Random;

public class Selectpeople {
    //学校选举学生会主席,有5个候选人
    //全校1000名同学参与投票(每人一票,可以弃权,或者选1-5号)。
    //投票使用Random模拟。0:弃权,1~5:给对应的候选人投票
    
    //要求1:
    //统计每个候选人的得票数和得票率,找出得票最多的候选人?
    //要求2:
    //统计弃票数和弃票率是多少?
    
    public static void main(String[] args) {
        Random r = new Random();
        
        //创建数组,存储5个候选人得票数.及弃票的
        int[] arr = new int[6];
        
        //全校1000名同学参与投票(每人一票,可以弃权,或者选1-5号)。
        for (int i = 1; i <= 1000; i++) {
            // 投票使用Random模拟。0:弃权,1~5:给对应的候选人投票
            int vote = r.nextInt(0, 6);
            arr[vote]++; //vate 投票数/索引
        }

        //统计每个候选人的得票数和得票率,找出得票最多的候选人
        int j = 0;
        for (j = 1; j < arr.length; j++) {
            System.out.println("第" + j + "个候选人的得票数是：" + arr[j] + "，得票率是：" + arr[j] / 1000.0);
        }

        // 找出最多票数
        int max = arr[1];
        for (int i = 2; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
                j = i;
            }
        }
        
        System.out.println("第" + j + "个候选人是当选的主席");

        //统计弃票数和弃票率是多少?
        System.out.println("弃票数是：" + arr[0] + "，弃票率是：" + arr[0] / 1000.0);
    }
}

2024-4-24

接雨水问题

public int trap(int[] height) {
    if (height == null || height.length == 0) return 0;

    int left = 0, right = height.length - 1; // 左右指针
    int leftMax = 0, rightMax = 0;           // 记录左右两侧遇到的最大高度
    int totalWater = 0;

    while (left < right) {
        if (height[left] < height[right]) {
            // 如果左边较低，水能接多少取决于左边的屏障
            if (height[left] >= leftMax) {
                leftMax = height[left]; // 更新左侧最大值
            } else {
                totalWater += leftMax - height[left]; // 计算当前格子接水量
            }
            left++;
        } else {
            // 如果右边较低或相等，水能接多少取决于右边的屏障
            if (height[right] >= rightMax) {
                rightMax = height[right]; // 更新右侧最大值
            } else {
                totalWater += rightMax - height[right]; // 计算当前格子接水量
            }
            right--;
        }
    }
    return totalWater;
}

对象:把相关的数据和方法组织为一个整体来看待

面向对象:利用对象进行软件开发

2026-4-25

再次警醒自己，不要盲目的使用ai，不要让ai成为自己学习上的绊脚石，这里的盲目使用不单单是指用ai，是指我在学习时为了完成任务，而不经大脑直接套用他人的方法，事后自己依然没有成长，甚至思路更加混乱的这种行为，学习是为了消除自己的无知的。而滥用“ai”这样的行为无疑是对学习本质的背离，希望自己可以多思考，以精进的态度对待自己的学习，而不是陷入完成任务的慌乱中

主类是指含main函数的类

// 这是for-each
for (String product : products) {
    System.out.println(product);
}

// 这是对应的 fori 还原版
for (int i = 0; i < products.size(); i++) {
    String product = products.get(i); // 通过索引 i 获取元素
    System.out.println(product);
}

为什么可以这样
1.可以防止索引越界，导致程序报错
2.这样的逻辑更清晰，防止i的干扰
4.当需要改变数组本身时就不可以使用for-each

import java.util.Scanner;  
public class test06 {  
    //1.定义一个商品类，商品名称、商品单价、购买数量和小计属性，并提供对应的setter和getter方法  
      
        //保存商品信息  
        public class ShoppingReceipt {  
            public static  Product[] saveProducts(int num){  
                Scanner sc = new Scanner(System.in);  
                Product [] products = new Product[num] ;  
                System.out.println("请输入你要的商品的名字，单价，数量");  
                for (int i = 0; i < num; i++) {  
                    Product product = new Product();  
                    product.setName(sc.next());  
                    product.setPrice(sc.nextDouble());  
                    product.setNumber(sc.nextInt());  
                    products[i] =product ;  
                }  
                return products;  
            }  
        }  
        public static double sum (Product[] products){  
            double sum = 0 ;  
            for (Product product : products){  
                sum+= product.getSubtotal() ;  
            }  
            return sum ;  
        }  
        //打印小票  
        public  static  void  printproduct (Product[]products){  
            System.out.println("商品名 数量 单价，小计");  
            for (Product product1 : products){  
                System.out.print(product1.getName()+" ");  
                System.out.print(product1.getNumber()+" ");  
                System.out.print(product1.getPrice()+"元"+" ");  
                System.out.println(product1.getSubtotal()+"元  ");  
            }  
            System.out.print("总共为："+sum(products));  
        }  
        public static void main(String[] args) {  
            Scanner sc = new Scanner(System.in);  
            System.out.println("请输入你购买的商品数");  
            int num = sc.nextInt();  
            Product[] products = ShoppingReceipt.saveProducts(num);  
            printproduct(products);  
        }  
    }

2026-4-26

创建类与对象的基本格式

public class dog {  
    String name;  
    int age;  
    double weight;  
    String color;  
  
}

//对象的定义格式：类名 对象名 = new 类名();  
public static void main(String[] args) {  
    dog d = new dog();  
    d.name = "小花";  
    d.age = 2;  
    d.weight = 5.5;  
    d.color = "白色";  
    System.out.println(d.name);  
    System.out.println(d.age);  
    System.out.println(d.weight);  
    System.out.println(d.color);  
  
}

描述一类事物的类叫Javabean类
带有main方法的类叫测试类
Javabean类可以写属性和行为

解决类中的安全问题
private 私有化成员变量，让外部不能直接访问修改
get/set方法

public class Dog {
private int age;

//set(赋值)
public void setAge(int num){
判断num是否满足要求
}

//get(获取)
public int getAge(){
return age;
}
}

//Dog d = new Dog();
//d.name = "/]";
//d.setAge (2); 正确
//d.setAge (-200);错误

2026-4-27

  public static void main(String[] args) {
//        1.生成彩票
       int lottery[] =generateLottery();
       printLottery(lottery);
       //2.买彩票
        int myLottery[] = buyLottery();
        printLottery(myLottery);
        //3.开奖
        countSameNumber(lottery,myLottery);
       //4.判断中几等奖
        int count1 = getcount(lottery,myLottery,0,4);
        int count2 = getcount(lottery,myLottery,5,6);
        if (count1 == 5 && count2 == 2){
            System.out.println("恭喜中奖一等奖");
        }
        else  if (count1 == 5 && count2 == 1){
            System.out.println("恭喜中奖二等奖");
        }
        //三等奖:5+0/4+2
        else  if (count1 == 5 && count2 == 0|| count1 == 4 && count2 == 2){
            System.out.println("恭喜中奖三等奖");
        }
        else  if (count1 == 4 && count2 == 1|| count1 == 3 && count2 == 2){
            System.out.println("恭喜中奖四等奖");
        }
        else  if (count1 == 4 && count2 == 0|| count1 == 3 && count2 == 1|| count1 == 2 && count2 == 2){
            System.out.println("恭喜中奖五等奖");
        }
        else  if (count1 == 3 && count2 == 0|| count1 == 1 && count2 == 2|| count1 == 2 && count2 == 1 || count2 == 2){
            System.out.println("恭喜中奖六等奖");
        }
        else {
            System.out.println("未中奖");
        }
        }
    //判断数据是否重复的方法
    public static boolean contains(int number, int arr[],int start,int end) {
        for (int i = start; i <= end; i++) {
            if (number == arr[i]) {
                return true;
            }
        }
        return false;
    }
    //生成彩票的方法
    public static int[] generateLottery() {
        int lottery[] = new int[7];
        Random r = new Random();
        //生成彩票的前区
        for (int i = 0; i <= 4; ) {
            int date = r.nextInt(35) + 1;
            //判断数据是否重复，调用contains方法0-4
            boolean flag =contains(date, lottery, 0, 4);
            if (!flag){
                lottery[i] = date;
                i++;
            }
        }

        //生成彩票的后区
        for (int i = 5; i <= 6; ) {
            int date = r.nextInt(12) + 1;
            //判断数据是否重复，调用contains方法,5-6
            boolean flag =contains(date, lottery,5,6);
            if (!flag){
                lottery[i] = date;
                i++;
            }
        }
        return lottery;
    }
    //购买彩票的方法
    public  static  int [] buyLottery(){
        int lottery[] = new int[7];
        System.out.println(" 请输入你要买的彩票号的前区");
        Scanner sc = new Scanner(System.in);
        //生成前区
        //2.买彩票
        //符合范围
        //不重复1
        for (int i = 0 ; i < 5; ) {
            int number = sc.nextInt();
            //符合范围
            if (number<1|| number>35){
                System.out.println("请输入正确的数据");
                continue;
            }
            //不重复1
            boolean flag = contains(number, lottery, 0, 4);
            if (flag){
                System.out.println("请勿重复输入");
                continue;
            }
            if (!flag){
                lottery[i] = number;
                i++;
            }
            }
        //生成后区
        System.out.println(" 请输入你要买的彩票号的后区");
        for (int i = 5; i < 7; ) {
            int number = sc.nextInt();
            //符合范围
            if (number<1|| number>12){
                System.out.println("请输入正确数据");
                continue;
            }
            //不重复1
            boolean flag = contains(number, lottery, 5, 6);
            if (flag){
                System.out.println("请勿重复输入");
                continue;
            }
            if (!flag){
                lottery[i] = number;
                i++;
            }
        }
        return lottery;
        }
        //打印彩票的方法
    public static void printLottery(int lottery[]){
        System.out.print("[");
        for (int i = 0; i < lottery.length; i++) {
            if (i==lottery.length-1){
                System.out.print(lottery[i]);
            }
            else{
                System.out.print(lottery[i]+",");
            }
        }
        System.out.print("]");
        System.out.println();
    }
    //统计中奖的方法
    public static void countSameNumber(int lottery[],int myLottery[]){
       int count1 = getcount(lottery,myLottery,0,4);
       int count2 = getcount(lottery,myLottery,5,6);
        System.out.println("前区中奖:"+count1+"个");
        System.out.println("后区中奖:"+count2+"个");

    }
    //判断有多少相同的数字的方法
    public static int getcount(int lottery[],int myLottery[],int start,int end){
        int count = 0;
        //统计前区相同数字的个数
        for (int i = start; i <= end;) {
                boolean flag=contains(lottery[i],myLottery,start, end);
                if (flag){
                    count++;
                }
            i++;
            }
        //循环结束后，start到end，中了几个
        return count;
    }
    }

#学习日志
#学习
小白学习日志-yupi (26年4月7-27号)
https://wlw301.top//archives/OO9OFwe8
作者
yu'qi
发布于
2026年04月08日
更新于
2026年05月09日
许可协议