C语言第十课(下)：优化井字棋游戏

news2024/10/7 4:36:07

目录

前言：

一、优手着棋判定：

        1.防守型着棋优化：

        2.进攻型着棋优化：

二、界面格式优化：

        1.Sleep休眠语句：

        2.system语句：

三、优化后最终全部代码：

        1.头文件game.h:

        2.函数功能文件game.h：

        3.程序主体文件test.c：

四、总结：

前言：

        在上一篇文章中，我和各位小伙伴们一起，通过使用我们前面学习的C语言知识，编写出了一个基础版的井字棋游戏。不过我们也发现，作为基础版的井字棋游戏，它存在着很多缺陷，而在本文中，我们将要对基础版井字棋进行着棋、界面两个方面的优化。

一、优手着棋判定：

        1.防守型着棋优化：

        对于一个程序的优化，首先我们应当对其功能缺陷进行优化，而在基础版井字棋中，最大的功能缺陷便是电脑在进行着棋时，没有进行着棋优手判定，在玩家着棋后不会对玩家的进攻性着棋进行围堵，于是这里的优化便是要尝试解决这个问题。

        电脑着棋的优化，主要在于其着棋时应当对当前场上的局势进行判断，倘若在玩家横向、纵向、斜向三个方向上出现两子连子，且第三个位置上仍为空时，就应当在第三个空位上进行着棋以实现对玩家的拦截。

        原理大致了解之后，我们来研究一下具体情况的实现。首先判定应当分为三个方向，即横向，纵向与斜向。而在每个方向上，根据规则连成三子即为胜利可以得出，当下一步即将出现胜利情况时，就应当进行阻止。

        以横向为例，会出现三种情况，即在一行中前两个位置相同而第三个位置空缺，此时应当着棋于位置三；第二种情况是在一行中后两个位置相同而首位置空缺，此时应当着棋于位置一；第三种情况为一三位置相同而中间位置空缺，此时则应当着棋于中间位置。

        则纵向与斜向原理也相同。根据我们整理出来的拦截原理，我们可以轻松地写出优手拦截的程序代码：

{
	int i = 0;
	//遍历行优手判断：
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][0] == '*' && board[i][2] == ' ')
		{
			board[i][2] = 'O';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == '*' && board[i][0] == ' ')
		{
			board[i][0] = 'O';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == '*' && board[i][1] == ' ')
		{
			board[i][1] = 'O';
			return 1;
		}
	}
	//遍历列优手判断：
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == '*' && board[2][i] == ' ')
		{
			board[2][i] = 'O';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == '*' && board[0][i] == ' ')
		{
			board[0][i] = 'O';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == '*' && board[1][i] == ' ')
		{
			board[1][i] = 'O';
			return 1;
		}
	}
	//右斜对角线优手判断：
	if (board[0][0] == board[1][1] && board[0][0] == '*' && board[2][2] == ' ')
	{
		board[2][2] = 'O';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == '*' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == '*' && board[0][0] == ' ')
	{
		board[0][0] = 'O';
		return 1;
	}
	//左斜对角线优手判断：
	if (board[0][2] == board[1][1] && board[0][2] == '*' && board[2][0] == ' ')
	{
		board[2][0] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == '*' && board[0][2] == ' ')
	{
		board[0][2] = 'O';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == '*' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	return 0;
}

        如此，优手判断模块就完成了，接着我们只需要让电脑在着棋时进行判断，若是符合优手的着棋便进行优手着棋，若没有出现需要拦截的情况，再根据我们之前定义的随机值确定着棋坐标：

void computer_move(char board[ROW][COL], int row, int col)
{
	printf("电脑正在着棋！\n");
	if (computer_better_move(board, row, col))
	{
		;
	}
	else
	{
		while (1)
		{
			int x = rand() % row;
			int y = rand() % col;
			if (board[x][y] == ' ')
			{
				board[x][y] = 'O';
				break;
			}
		}
	}
}

        这里的执行逻辑是，if 语句的判断条件为函数“ 优手判断的返回值 ”。在优手判断函数中，若符合优手着棋的条件，便进行优手着棋，同时返回值为1，此时电脑着棋函数中的if语句判断为真，随机着棋便不再进行；若局面情况均不符合优手着棋情况，不进行优手着棋则右手判断函数返回值为0，电脑着棋函数中if语句判断为假，执行随机着棋操作。

        2.进攻型着棋优化：

        以上即为井字棋游戏的防守型着棋优化。我们还可以对电脑的进攻进行优化，即在进行防守判断前先进行判断，若电脑方已有连字或隔子，即拥有直接获胜条件时，走出进攻型着棋。

        原理很简单且与防守相同，不过这次的着棋优化判断对象为电脑自己的着棋，只需对防守着棋优化稍加改动即可：

int computer_Better_move(char board[ROW][COL], int row, int col)
{
	int i = 0;
	//遍历行优手判断：
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][0] == 'O' && board[i][2] == ' ')
		{
			board[i][2] = 'O';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == 'O' && board[i][0] == ' ')
		{
			board[i][0] = 'O';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == 'O' && board[i][1] == ' ')
		{
			board[i][1] = 'O';
			return 1;
		}
	}
	//遍历列优手判断：
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == 'O' && board[2][i] == ' ')
		{
			board[2][i] = 'O';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == 'O' && board[0][i] == ' ')
		{
			board[0][i] = 'O';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == 'O' && board[1][i] == ' ')
		{
			board[1][i] = 'O';
			return 1;
		}
	}
	//右斜对角线优手判断：
	if (board[0][0] == board[1][1] && board[0][0] == 'O' && board[2][2] == ' ')
	{
		board[2][2] = 'O';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == 'O' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == 'O' && board[0][0] == ' ')
	{
		board[0][0] = 'O';
		return 1;
	}
	//左斜对角线优手判断：
	if (board[0][2] == board[1][1] && board[0][2] == 'O' && board[2][0] == ' ')
	{
		board[2][0] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == 'O' && board[0][2] == ' ')
	{
		board[0][2] = 'O';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == 'O' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	return 0;
}

        定义出进攻型着棋优化后，我们同样对电脑着棋函数进行改动：

void computer_move(char board[ROW][COL], int row, int col)
{
	printf("电脑正在着棋！\n");
	if (computer_Better_move(board, row, col))
	{
		;
	}
	else
	{
		if (computer_better_move(board, row, col))
		{
			;
		}
		else
		{
			while (1)
			{
				int x = rand() % row;
				int y = rand() % col;
				if (board[x][y] == ' ')
				{
					board[x][y] = 'O';
					break;
				}
			}
		}
	}
}

        其实现逻辑与防守型着棋优化完全一致，不同的是此处采用了嵌套判断，先进行进攻型判断，没有进攻条件时进行防守，既没有进攻条件也无需进行防守时，再进行随机着棋。

        至此，我们关于井字棋的着棋优化就完成了。

二、界面格式优化：

       我们目前写出的代码，运行起来后是这样的：

        这样一大串的打印形式，使得我们的界面看起来非常的不美观，那么有没有办法能够使得我们的界面看起来整洁一些呢？答案是，有。 

        我们可以通过使用下面两个语句来实现对界面的优化：

        1.Sleep休眠语句：

Sleep(num);

        它的作用是， 使程序在延长预定时间后继续执行下一个步骤，设置休眠时间的方式是修改Sleep后方括号内的参数num的数值，单位为毫秒。

        要注意的是该语句在使用时，需要引用头文件Windows.h：

#include<Windows.h>

        2.system语句：

int system(const char * command)

        该函数功能为执行 dos(windows系统) 或 shell(Linux/Unix系统) 命令，参数字符串command为命令名。另，在windows系统下参数字符串不区分大小写。

        我们一般情况下使用的系统为Windows系统，故针对Windows系统进行说明。在windows系统中，system函数直接在控制台调用一个command命令。

        该函数语句在使用时需引用头文件stdlib.h：

#include<stdlib.h>

        在这里对我们的井字棋游戏界面进行优化时需要用到的命令是：

system("cls");

        这个命令的作用通俗来讲就是“ 清屏 ”，使用该函数命令，可以实现将之前打印在屏幕上的内容进行清空，并继续打印接下来的内容。运用在我们的程序中，就可以实现在每一个步骤完成后进行清屏，再继续执行接下来的步骤。

        通过灵活的结合使用上面的两种语句，我们可以使我们的游戏程序界面变得简洁而流畅。

三、优化后最终全部代码：

        1.头文件game.h:

#pragma once

#define ROW 3
#define COL 3
//进行宏定义，好处是进行游戏修改时不需要对每个参数都进行修改

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<Windows.h>
//因为此头文件会被引用，故在此头文件中引用的其它头文件也会被包含引用

//头文件中进行函数的声明：
void init_board(char board[ROW][COL], int row, int col);
void print_board(char board[ROW][COL], int row, int col);
void player_move(char board[ROW][COL], int row, int col);
int computer_better_move(char board[ROW][COL], int row, int col);
void computer_move(char board[ROW][COL], int row, int col);
char is_win(char board[ROW][COL], int row, int col);

        2.函数功能文件game.h：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

//棋盘初始化（使无着棋位置均使用空格占位）：
void init_board(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}

//打印棋盘：
void print_board(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf("   %c   ", board[i][j]);
			if (j < col - 1)
			{
				printf("|");
			}
		}
		printf("\n");
		if (i < row - 1)
		{
			for (j = 0; j < col; j++)
			{
				printf("-------");
				if (j < col - 1)
				{
					printf("|");
				}
			}
			printf("\n");
		}
	}
}

//玩家着棋：
void player_move(char board[ROW][COL], int row, int col)
{
	while (1)
	{
		int x, y;
		x = y = 0;
		printf("请着棋：\n");
		printf("您想下在第几行：");
		scanf("%d", &x);
		Sleep(1000);
		printf("您想下在第几列：");
		scanf("%d", &y);
		Sleep(500);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (board[x - 1][y - 1] == ' ')
			{
				board[x - 1][y - 1] = '*';
				system("cls");
				break;
			}
			else
			{
				system("cls");
				printf("这个位置已经有棋子了喔！请重新输入！\n");
				Sleep(1500);
				system("cls");
				print_board(board, ROW, COL);
			}
		}
		else
		{
			system("cls");
			printf("输入坐标有误，请重新输入！\n");
			Sleep(1500);
			system("cls");
			print_board(board, ROW, COL);
		}
	}
}

//电脑防守型着棋优手判定：
int computer_better_move(char board[ROW][COL], int row, int col)
{
	int i = 0;
	//遍历行优手判断：
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][0] == '*' && board[i][2] == ' ')
		{
			board[i][2] = 'O';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == '*' && board[i][0] == ' ')
		{
			board[i][0] = 'O';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == '*' && board[i][1] == ' ')
		{
			board[i][1] = 'O';
			return 1;
		}
	}
	//遍历列优手判断：
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == '*' && board[2][i] == ' ')
		{
			board[2][i] = 'O';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == '*' && board[0][i] == ' ')
		{
			board[0][i] = 'O';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == '*' && board[1][i] == ' ')
		{
			board[1][i] = 'O';
			return 1;
		}
	}
	//右斜对角线优手判断：
	if (board[0][0] == board[1][1] && board[0][0] == '*' && board[2][2] == ' ')
	{
		board[2][2] = 'O';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == '*' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == '*' && board[0][0] == ' ')
	{
		board[0][0] = 'O';
		return 1;
	}
	//左斜对角线优手判断：
	if (board[0][2] == board[1][1] && board[0][2] == '*' && board[2][0] == ' ')
	{
		board[2][0] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == '*' && board[0][2] == ' ')
	{
		board[0][2] = 'O';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == '*' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	return 0;
}

//电脑进攻型着棋判定：
int computer_Better_move(char board[ROW][COL], int row, int col)
{
	int i = 0;
	//遍历行优手判断：
	for (i = 0; i < row; i++)
	{
		if (board[i][0] == board[i][1] && board[i][0] == 'O' && board[i][2] == ' ')
		{
			board[i][2] = 'O';
			return 1;
		}
		if (board[i][1] == board[i][2] && board[i][1] == 'O' && board[i][0] == ' ')
		{
			board[i][0] = 'O';
			return 1;
		}
		if (board[i][0] == board[i][2] && board[i][0] == 'O' && board[i][1] == ' ')
		{
			board[i][1] = 'O';
			return 1;
		}
	}
	//遍历列优手判断：
	for (i = 0; i < col; i++)
	{
		if (board[0][i] == board[1][i] && board[0][i] == 'O' && board[2][i] == ' ')
		{
			board[2][i] = 'O';
			return 1;
		}
		if (board[1][i] == board[2][i] && board[1][i] == 'O' && board[0][i] == ' ')
		{
			board[0][i] = 'O';
			return 1;
		}
		if (board[0][i] == board[2][i] && board[0][i] == 'O' && board[1][i] == ' ')
		{
			board[1][i] = 'O';
			return 1;
		}
	}
	//右斜对角线优手判断：
	if (board[0][0] == board[1][1] && board[0][0] == 'O' && board[2][2] == ' ')
	{
		board[2][2] = 'O';
		return 1;
	}
	if (board[0][0] == board[2][2] && board[0][0] == 'O' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][2] && board[1][1] == 'O' && board[0][0] == ' ')
	{
		board[0][0] = 'O';
		return 1;
	}
	//左斜对角线优手判断：
	if (board[0][2] == board[1][1] && board[0][2] == 'O' && board[2][0] == ' ')
	{
		board[2][0] = 'O';
		return 1;
	}
	if (board[1][1] == board[2][0] && board[1][1] == 'O' && board[0][2] == ' ')
	{
		board[0][2] = 'O';
		return 1;
	}
	if (board[0][2] == board[2][0] && board[0][2] == 'O' && board[1][1] == ' ')
	{
		board[1][1] = 'O';
		return 1;
	}
	return 0;
}

//电脑着棋：
//随机生成坐标，只要没有被占用，就着棋
void computer_move(char board[ROW][COL], int row, int col)
{
	printf("电脑正在着棋！\n");
	Sleep(1000);
	if (computer_Better_move(board, row, col))
	{
		;
	}
	else
	{
		if (computer_better_move(board, row, col))
		{
			;
		}
		else
		{
			while (1)
			{
				int x = rand() % row;
				int y = rand() % col;
				if (board[x][y] == ' ')
				{
					board[x][y] = 'O';
					break;
				}
			}
		}
	}
	system("cls");
}
	

//平局判定：
int is_full(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
			{
				return 0;
			}
		}
	}
	return 1;
}

//胜利判定：
char is_win(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
		//判断每行
	{
		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
		{
			return board[i][0];
			//返回赢家
		}
	}
	for (i = 0; i < col; i++)
		//判断每列
	{
		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')
		{
			return board[0][i];
			//返回赢家
		}
	}
	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
	{
		return board[1][1];
	}
	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
	{
		return board[1][1];
	}
	if (is_full(board, row, col) == 1)
	{
		return 'Q';
	}
	return 'C';
}

        3.程序主体文件test.c：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"
//引用自定头文件

void menu()
{
	printf("************************\n");
	printf("************************\n");
	printf("**** 欢迎游玩三子棋 ****\n");
	printf("****     请选择     ****\n");
	printf("****   1.开始游戏   ****\n");
	printf("****   0.退出游戏   ****\n");
	printf("************************\n");
	printf("************************\n");
}

void game()
{
	char board[ROW][COL];
	//创建九宫格数组，用于处理着棋
	char ret = 0;
	//定义字符，用于判断输赢后跳出着棋循环
	init_board(board, ROW, COL);
	//将数组与行列数传递给封装函数进行初始化
	print_board(board, ROW, COL);
	//将初始化完成的棋盘进行打印
	while (1)
	{
		player_move(board, ROW, COL);
		//玩家进行着棋
		print_board(board, ROW, COL);
		ret = is_win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
		//判断输赢
		computer_move(board, ROW, COL);
		//电脑进行着棋
		print_board(board, ROW, COL);
		ret = is_win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
	}
	system("cls");
	if (ret == '*')
	{
		printf("恭喜玩家获得胜利！\n");
		Sleep(2000);
	}
	else if (ret == 'O')
	{
		printf("很遗憾，电脑取得了胜利。\n");
		Sleep(2000);
	}
	else if (ret == 'Q')
	{
		printf("棋逢对手！战至平局！\n");
		Sleep(2000);
	}
	system("cls");
}


void test()
{
	srand((unsigned int)time(NULL));
	//用时间戳来生成随机数，用于电脑着棋位置判断
	int input = 0;
	do
	{
		menu();
		printf("请您进行选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Sleep(500);
			system("cls");
			game();
			break;
		case 0:
			break;
		default:
			printf("输入错误，请重新输入！\n");
			break;
		}
	} while (input);
}

int main()
{
	test();

	return 0;
}

四、总结：

        当我们完成以上优化后，一个游戏程序的雏形就完成了，我们对其功能和界面都进行了相当程度的优化。但是我们对于一个程序的优化过程，不仅仅如此而已，在以后的学习过程中，我们会学到更多知识，到时候我们还可以使用更高深的知识来对我们的游戏程序进行更深层次的优化。

        到这里我们今天的学习过程就告一段落啦，各位小伙伴们下去以后一定要多看多敲多理解，牢固的将知识掌握才是我们的最终目的！靠自己的力量一步步跨过泥泞，才能离想要的生活越来越近，人生中最好的贵人，永远是努力的自己！

        新人初来乍到，辛苦各位小伙伴们动动小手，三连走一走 ~ ~ ~  最后，本文仍有许多不足之处，欢迎各位看官老爷随时私信批评指正！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/13997.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MFIF:Deep Regression Pair Learning

MFIF:Deep Regression Pair Learning

DRPL: Deep Regression Pair Learning for Multi-Focus Image Fusion 本文提出了一种用于多焦点图像融合的新型深度网络&#xff0c;称为深度回归对学习 (DRPL)。与现有的深度融合方法将输入图像分割成小的补丁并应用分类器来判断补丁是否聚焦相比&#xff0c;DRPL直接将整个图…
阅读更多...
java springboot获取GitLab上的文件内容

java springboot获取GitLab上的文件内容

这里以最简单的方式获取git上的文件，并读取文件 第一步：获取主域名host 进入网页版的git，链接为：https://gitlab.***.com 第二步：获取access_token 在git网页端登录后的右上角用户头像下拉菜单的settings页面===>再点击settings页面的左侧菜单栏中的Access Tokens选…
阅读更多...
Shell 脚本编程(二) —— 条件判断 (test命令) + 多路分支语句（if 、case）

Shell 脚本编程(二) —— 条件判断 (test命令) + 多路分支语句（if 、case）

test 命令可以用于判断文件类型以及值的比较&#xff0c;test 判断条件为真&#xff0c;返回 0&#xff1b;条件为假&#xff0c;返回 1。 目录 一、条件判断 (1) 整数判断 (2) 字符串判断 (3) 文件判断 二、if 语句 1、语法结构 2、实际运用 三、case语句 一、条件判断…
阅读更多...
【毕业设计】图像识别跌倒检测算法研究与实现 - python 深度学习 机器学习

【毕业设计】图像识别跌倒检测算法研究与实现 - python 深度学习 机器学习

文章目录0 前言1 简介2 实现方法2.1 传统机器视觉算法2.2 基于机器学习的跌倒检测2.2.1 SVM简介2.2.2 SVM跌倒检测原理2.2.3 算法流程2.2.4 算法效果2.3 深度学习跌倒检测2.3.1 最终效果2.3.2 网络原理3 最后0 前言 &#x1f525; Hi&#xff0c;大家好&#xff0c;这里是丹成…
阅读更多...
Java集合框架【二容器(Collection)[ArrayList]】

Java集合框架【二容器(Collection)[ArrayList]】

文章目录1 容器/集合简介2 容器的结构2.1 结构图2.1.1 单例集合2.1.2 双例集合3 单例集合的使用3.1 Collection接口的介绍3.2 Collection接口中的接口方法3.3 List接口3.3.1 List接口特点3.3.2List的常用方法3.4 ArrayList容器类3.4.1 添加元素3.4.2 获取元素3.4.3 根据索引删除…
阅读更多...
水尺监测识别系统

水尺监测识别系统

水尺监测识别系统利用计算机视觉机器学习技术对河道湖泊进行实时检测&#xff0c;当水尺监测识别系统监测到河道水位异常时&#xff0c;立即告警。水尺监测识别系统同时将告警截图和视频保存下来&#xff0c;推送给后台。水尺监测识别系统极大提升现场区域的管控效率&#xff0…
阅读更多...
android EventBus

android EventBus

EventBus使用小案例 文件目录结构 MainActivity.java package com.example.myeventbus;import androidx.appcompat.app.AppCompatActivity;import android.content.Intent; import android.os.Bundle; import android.view.View; import android.widget.Button; import andro…
阅读更多...
两万字长文带你深入Go语言GC源码

两万字长文带你深入Go语言GC源码

介绍 三色标记法 三色标记法将对象的颜色分为了黑、灰、白&#xff0c;三种颜色。 黑色&#xff1a;该对象已经被标记过了&#xff0c;且该对象下的属性也全部都被标记过了&#xff08;程序所需要的对象&#xff09;&#xff1b;灰色&#xff1a;该对象已经被标记过了&#…
阅读更多...
一段JS去除畅言免费版广告

一段JS去除畅言免费版广告

畅言广告怎么去掉&#xff1f;去除畅言免费版广告方法是什么&#xff1f;现在很多站长都使用的社会化评论系统&#xff0c;可以让网站拥有免费的评论区&#xff0c;活化你的网站&#xff0c;但是随着很多社会化评论提供网站的关闭&#xff0c;畅言一家独大&#xff0c;现在免费…
阅读更多...
企业网络自动化配置

企业网络自动化配置

更新的技术、合规性标准和不断变化的业务需求使管理当今的网络成为一项具有挑战性的任务。这解释了网络自动化在当今世界的重要性。IT 管理员现在的任务是确保网络的敏捷性和演进不会影响提供给最终用户的网络服务的稳定性、可用性和可靠性。但是&#xff0c;在此任务中&#x…
阅读更多...
【JMX】JMX远程监控JVM参数配置

【JMX】JMX远程监控JVM参数配置

目录基本用法命令示例jconsole连接新建连接确认连接方式查看监控信息jvisualvm连接添加主机增加JMX连接查看监控信息参数说明基本参数jmxremote.access文件说明jmxremote.password文件说明文件权限异常无法验证基本用法 命令示例 #参考命令 java -Dcom.sun.management.jmxrem…
阅读更多...
【Java学习】语法：包、权限修饰符、final、常量、枚举、抽象类、接口

【Java学习】语法：包、权限修饰符、final、常量、枚举、抽象类、接口

文章目录一、包二、权限修饰符三、final四、常量五、枚举六、抽象类七、接口一、包 什么是包? 包是用来分门别类的管理各种不同类的&#xff0c;类似于文件夹、建包利于程序的管理和维护。建包的语法格式: package公司域名倒写.技术名称。报名建议全部英文小写&#xff0c;且…
阅读更多...
WebRTC系列＜二＞ 案例与工具

WebRTC系列＜二＞ 案例与工具

阅读关于webRTC的其他文章&#xff1a; WebRTC系列&#xff1c;一&#xff1e; 什么是WebRTC&#xff1f; WebRTC系列&#xff1c;二&#xff1e; 案例与工具 ---------------------------------案例--------------------------------- webrtc官网 : 官网示例代码github地址…
阅读更多...
【Raspberry Pi】搭建NAS流媒体播放器 + ARIA2 + YAAW + 迅雷下载系统

【Raspberry Pi】搭建NAS流媒体播放器 + ARIA2 + YAAW + 迅雷下载系统

由于种&#xff08;gu&#xff09;种&#xff08;ji&#xff09;原&#xff08;cuo&#xff09;因&#xff08;wu&#xff09;新买的Pi并没有用于任何项目上&#xff0c;看着它一天一天的封尘&#xff0c;于心不忍终于让它也做了点事。恰好这几天家里网络晚上有点卡&#xff0c…
阅读更多...
数字集成电路设计（四、Verilog HDL数字逻辑设计方法）（二）

数字集成电路设计（四、Verilog HDL数字逻辑设计方法）（二）

文章目录3. 时序电路的设计3.1 触发器3.1.1 最简单的D触发器3.1.2 带复位端的D触发器3.1.3 复杂功能的D触发器&#xff08;没有太大必要&#xff09;3.1.4 T触发器3.2 计数器3.2.1 二进制计数器3.2.2 &#xff08;重要&#xff09;任意进制计数器3.3 移位寄存器3.4 序列信号发生…
阅读更多...
docker命令整理

docker命令整理

第一次安装 查看docker是否安装成功 docker version 测试hello-world docker run hello-world –help 帮助 查看详细信息 docker info 搜索docker镜像网址&#xff1a;https://hub.docker.com/search 查看 查看cpu实时内存 docker stats 镜像关键字&#xff1a;images -…
阅读更多...
MySQL-Redis进阶生成全局唯一ID

MySQL-Redis进阶生成全局唯一ID

单体全局ID 场景一、随着我们商城规模越来越大&#xff0c;mysql的单表的容量不宜超过500W&#xff0c;数据量过大之后&#xff0c;我们要进行拆库拆表&#xff0c;但拆分表了之后&#xff0c;他们从逻辑上讲他们是同一张表&#xff0c;所以他们的id是不能一样的&#xff0c; …
阅读更多...
阿里最新财报：中国商业分部收入下滑1%，年内股价累计下跌34%

阿里最新财报：中国商业分部收入下滑1%，年内股价累计下跌34%

11月17日&#xff0c;阿里巴巴集团&#xff08;下称“阿里巴巴”&#xff0c;HK:09988、NYSE:BABA&#xff09;公布2023财年第二季度&#xff08;对应自然年2022年第三季度&#xff09;业绩。财报显示&#xff0c;阿里巴巴2022年第三季度的收入为人民币2071.76亿元&#xff08;…
阅读更多...
[附源码]java毕业设计流浪动物领养系统

[附源码]java毕业设计流浪动物领养系统

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
计算机中的加法器和比较器

计算机中的加法器和比较器

本节展示了计算机中的加法器和比较器的底层实现电路设计。 加法器 计算机中加法器的实现依赖门的结构&#xff0c;如果是两个十进制进行加减&#xff0c;则首先把右边的两个0-9之间的数相加&#xff0c;它们的总和在0-18之间&#xff0c;如果答案是0-9之间&#xff0c;则直接写…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023