簡單介紹

2020年註定是不平凡的一年，新冠肺炎肆虐全球，傳染性特別強，目前全球感人人數還在逐漸攀升，作為中華兒女特別感謝政府作出的努力，非常感謝並致敬醫護人員，是他們的努力為我們創造安全的環境，向你們致敬！

模擬方案

以下是程式粗略的模擬病毒傳染過程，具體方案如下：

首先需要構造一個200 * 200的格子介面有四種不同的顏色狀態標記著程式執行的過程程式執行10次，初始化格子也就是0的時候，需要在整個格子最中心的100個格子標記為紅色，剩餘資料隨機抽取四千（且不能重複）標記為黑色，其餘沒有標記的為白色。之後第2次到第10次的所有資料隨機轉化為不同顏色

#說明

紅色代表已確診黑色代表已死亡白色代表隔離期綠色代表未感染

模擬結果

執行原始碼

import java.awt.Color;
import java.awt.Container;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

import javax.swing.JFrame;

public class DrawSee extends JFrame {

	private static final long serialVersionUID = -3469074514775590338L;
	private static final int sx = 20;// 遊戲區域200*200方塊的起始橫座標
	private static final int sy = 40;// 遊戲區域200*200方塊的起始縱座標
	private static final int w = 3;// 每個小方格的邊長
	private static final int rw = 600;// 遊戲區域200*200方塊的邊長

	private Graphics jg;
	private Color rectColor = new Color(0xf5f5f5);
	/**
	* DrawSee構造方法
	*/
	public DrawSee() {
		Container p = getContentPane();
		setBounds(100,100,650,650);
		setVisible(true);
		p.setBackground(rectColor);
		setLayout(null);
		setResizable(false);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		try {
			Thread.sleep(500);
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 獲取專門用於在視窗介面上繪圖的物件
		jg = this.getGraphics();
		// 繪製遊戲區域
		paintComponents(jg);
	}

	/**
	* 開始
	*/
	public void paintComponents(Graphics g) {
		try {
			// 設定線條顏色為紅色
			g.setColor(Color.WHITE);

			// 繪製外層矩形框
			g.drawRect(sx,sy,rw,rw);

			int N = 200;
			/*
			* 繪製水平200個，垂直200個方格。 即水平方向199條線，垂直方向199條線， 外圍四周4條線已經畫過了，不需要再畫。
			*/
			for (int i = 1; i < N; i++) {
				// 繪製第i條豎直線
				g.drawLine(sx + (i * w),sx + (i * w),sy + rw);
				// 繪製第i條水平線
				g.drawLine(sx,sy + (i * w),sx + rw,sy + (i * w));
			}
			// 填寫第i行從第1個方格到第N個方格里面的背景顏色（方格序號從0開始）
			int[][] s = new int[N][N];
			int sl = s.length;
			List<Object> list1 = new ArrayList<Object>();
			HashMap<String,String> map = new HashMap<String,String>();
			for (int t = 0; t < 70; t++) {
				if (t == 0) {
					t0(N,sl,s);
				} else {
					if (t < 60) {
						tn(N,s,map,list1,t);
					}
					dataChange(list1,t);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	* 資料是保留10個步長之後並根據round 向其他狀態轉變
	* 
	* @param list
	* @param s
	* @param t
	*/
	private void dataChange(List<Object> list,int[][] s,int t) {
		int a1 = 0,a2 = 0,a3 = 0,a4 = 0;
		for (int x = list.size() - 1; x >= 0; x--) {
			a3 = Integer.parseInt(list.get(x).toString().split("a")[2].toString());
			if (a3 - t > 1) {
				a1 = Integer.parseInt(list.get(x).toString().split("a")[0].toString());
				a2 = Integer.parseInt(list.get(x).toString().split("a")[1].toString());
				a4 = Integer.parseInt(list.get(x).toString().split("a")[3].toString());

				// 修改概率
				if (a4 > 0 && a4 <= 3000) {
					s[a1][a2] = -1;
				} else if (a4 > 3000 && a4 <= 9000) {
					s[a1][a2] = 2;
				} else {
					s[a1][a2] = 1;
				}
				list.remove(x);
			}
		}

	}

	/**
	* tn時刻資料
	* 
	* @param N
	* @param slt
	* @param sl
	* @param s
	* @param map
	* @param map1
	* @param list1
	* @param t
	*/
	private void tn(int N,int sl,HashMap<String,String> map,List<Object> list1,int t) {
		int slt = 0;
		int round = 0;
		HashMap<String,String> map1 = new HashMap<String,String>();
		for (int k = 0; k < s.length; k++) {
			slt = s[k].length;
			for (int k2 = 0; k2 < slt; k2++) {
				// 狀態為1記錄並且去除步長在10以內的重複資料 放到list1中
				if (s[k][k2] == 1) {
					round = new Random().nextInt(10000);
					if (map.containsKey(k + "a" + k2 + "a")) {
						if (t - Integer.parseInt(map.get(k + "a" + k2 + "a").split("a")[2].toString()) > 10) {
							map.put(k + "a" + k2 + "a",k + "a" + k2 + "a" + t + "a" + round + "a");
							map1.put(k + "a" + k2 + "a",k + "a" + k2 + "a" + t + "a" + round + "a");
							list1.add(map1.get(k + "a" + k2 + "a"));
						}
					} else {
						map.put(k + "a" + k2 + "a",k + "a" + k2 + "a" + t + "a" + round + "a");
						map1.put(k + "a" + k2 + "a",k + "a" + k2 + "a" + t + "a" + round + "a");
						list1.add(map1.get(k + "a" + k2 + "a"));
					}

				}

				// 狀態為0向其他狀態改變
				if (s[k][k2] == 0) {
					round = new Random().nextInt(10000);
					// 修改概率
					if (round > 0 && round <= 1000) {
						s[k][k2] = -1;
					} else if (round > 9000 && round <= getrNum(10000,0)) {
						System.out.println("round:" + round);
						s[k][k2] = 1;
					} else if (round > 1000 && round <= 9000) {
						s[k][k2] = 2;
					} else {
						s[k][k2] = 0;
					}
				}

				// 狀態為-1向其他狀態改變
				if (s[k][k2] == -1) {
					round = new Random().nextInt(10000);
					// 修改概率
					if (round > 0 && round <= 4000) {
						s[k][k2] = 0;
					} else {
						s[k][k2] = -1;
					}
				}

				// 狀態為2向其他狀態改變
				if (s[k][k2] == 2) {
					round = new Random().nextInt(10000);
					// 修改概率
					if (round > 0 && round <= 1000) {
						s[k][k2] = 0;
					} else {
						s[k][k2] = 2;
					}
				}

			}
		}
		// 上色
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				color(i,j,s);
			}
		}
		map1 = null;
	}

	/**
	* t0時刻
	* 
	* @param N
	* @param slt
	* @param sl
	* @param s
	*/
	private void t0(int N,int[][] s) {
		int slt = 0,a1 = 0,a2 = 0;
		List<Object> list = new ArrayList<Object>();
		// 初始化1的值
		for (int k = 0; k < sl; k++) {
			slt = s[k].length;
			for (int k2 = 0; k2 < slt; k2++) {
				if (k >= 80 && k < 100 && k2 >= 80 && k2 < 100) {
					s[k][k2] = 1;
				} else {
					// 剩餘資料
					list.add(k + "a" + k2 + "a");
				}
			}
		}
		// 剩餘資料全部轉換為0
		for (int x = 0; x < list.size(); x++) {
			a1 = Integer.parseInt(list.get(x).toString().split("a")[0].toString());
			a2 = Integer.parseInt(list.get(x).toString().split("a")[1].toString());
			s[a1][a2] = 0;
		}

		// 在為0 的基礎上抽取4000 資料賦值為-1
		Set<Integer> sets = getRandom(4000,list.size());
		for (Integer itg : sets) {
			a1 = Integer.parseInt(list.get(itg).toString().split("a")[0].toString());
			a2 = Integer.parseInt(list.get(itg).toString().split("a")[1].toString());
			s[a1][a2] = -1;
		}

		// 上色
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				color(i,s);
			}
		}
	}

	/**
	* 講制定小方格設定為指定背景顏色
	* 
	* @param cx
	*      方格的水平方向序號
	* @param cy
	*      方格的垂直方向序號
	* @param color
	*/
	private void setGrid(int cx,int cy,Color color) {
		// 將繪圖物件設定為灰色，後面會將方格背景設定為此顏色
		jg.setColor(color);
		/**
		* 方格上繪製一個小一點的矩形，矩形背景顏色為color,*/
		jg.fillRect(sx + (cx * w),sy + (cy * w),w - 1,w - 1);

	}

	/**
	* 根據nlength 長度 產生 num 隨機數(並且不重複)
	* 
	* @param num
	* @param nlength
	* @return
	*/
	public Set<Integer> getRandom(int num,int nlength) {
		if (nlength < num) {
			return null;
		}
		int index = 0;
		Set<Integer> set = new HashSet<Integer>();
		for (int i = 0; i < nlength; i++) {
			index = (int) (Math.random() * nlength);
			if (set.size() >= 4000) {
				break;
			} else {
				set.add(index);
			}

		}
		return set;
	}

	/**
	* main
	* 
	* @param args
	*/
	public static void main(String[] args) {
		new DrawSee();
	}

	/**
	* 隨機生成最小到最大的資料
	* 
	* @param max
	* @param min
	* @return
	*/
	private int getrNum(int max,int min) {
		Random random = new Random();
		return random.nextInt(max) % (max - min + 1) + min;

	}

	/**
	* 設定每種狀態的背景顏色
	* 
	* @param i
	* @param j
	* @param s
	*/
	private void color(int i,int j,int[][] s) {
		if (s[i][j] == -1) {
			// 狀態為空
			setGrid(i,Color.BLACK);
		} else if (s[i][j] == 0) {
			// 易感冒
			setGrid(i,Color.WHITE);
		} else if (s[i][j] == 1) {
			// 感染者
			setGrid(i,Color.RED);
		} else if (s[i][j] == 2) {
			// 恢復者
			setGrid(i,Color.GREEN);
		}
	}

}

說明

本文只做學習參考，如有任何不準確的地方歡迎指正。

到此這篇關於使用Java程式模擬實現新冠病毒傳染效果的文章就介紹到這了,更多相關Java實現新冠病毒傳染內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！