java迷宫move类意思

这个没啥含义啊，一个对象类

private int x;

private int y;

两个属性，从字面意义上说x是横坐标，y是纵坐标。

public Move(){

}无参数的构造方法

public Move(int x, int y){

thisx = x;

thisy = y;

}有参数的构造方法

下面那些get方法时用来访问对象属性的，set方法是给对象属性赋值的。

给你举个例子你就知道了

Move m1=new Move()；这里声明了一个Move类的对象，调用的是无参数的构造方法，也就是说m1的x和y都是没有赋值的。但是呢，int类型默认值是0；

然后你可以通过set方法去给属性赋值m1setX(2),然后通过get方法取值m1getX()这个时候就能取到2了。

而有参数的构造方法就是在声明对象的时候直接赋值给元素

Move m2=new Move(1,2)；这个时候你再用get方法去取，就会有x=1,y=2了，就是省掉了用set方法赋值的一步。

你还是先看看什么是对象，什么是构造函数，还有get，set方法的作用吧

通过遗传算法走迷宫。虽然图1和图2均成功走出迷宫，但是图1比图2的路径长的多，且复杂，遗传算法可以计算出有多少种可能性，并选择其中最简洁的作为运算结果。

示例图1：

示例图2：

实现代码：

import javautilArrayList;

import javautilCollections;

import javautilIterator;

import javautilLinkedList;

import javautilList;

import javautilRandom;

/

用遗传算法走迷宫

@author Orisun

/

public class GA {

int gene_len; // 基因长度

int chrom_len; // 染色体长度

int population; // 种群大小

double cross_ratio; // 交叉率

double muta_ratio; // 变异率

int iter_limit; // 最多进化的代数

List<boolean[]> individuals; // 存储当代种群的染色体

Labyrinth labyrinth;

int width;      //迷宫一行有多少个格子

int height;     //迷宫有多少行

public class BI {

double fitness;

boolean[] indv;

public BI(double f, boolean[] ind) {

fitness = f;

indv = ind;

}

public double getFitness() {

return fitness;

}

public boolean[] getIndv() {

return indv;

}

}

List<BI> best_individual; // 存储每一代中最优秀的个体

public GA(Labyrinth labyrinth) {

thislabyrinth=labyrinth;

thiswidth = labyrinthmap[0]length;

thisheight = labyrinthmaplength;

chrom_len = 4  (width+height);

gene_len = 2;

population = 20;

cross_ratio = 083;

muta_ratio = 0002;

iter_limit = 300;

individuals = new ArrayList<boolean[]>(population);

best_individual = new ArrayList<BI>(iter_limit);

}

public int getWidth() {

return width;

}

public void setWidth(int width) {

thiswidth = width;

}

public double getCross_ratio() {

return cross_ratio;

}

public List<BI> getBest_individual() {

return best_individual;

}

public Labyrinth getLabyrinth() {

return labyrinth;

}

public void setLabyrinth(Labyrinth labyrinth) {

thislabyrinth = labyrinth;

}

public void setChrom_len(int chrom_len) {

thischrom_len = chrom_len;

}

public void setPopulation(int population) {

thispopulation = population;

}

public void setCross_ratio(double cross_ratio) {

thiscross_ratio = cross_ratio;

}

public void setMuta_ratio(double muta_ratio) {

thismuta_ratio = muta_ratio;

}

public void setIter_limit(int iter_limit) {

thisiter_limit = iter_limit;

}

// 初始化种群

public void initPopulation() {

Random r = new Random(SystemcurrentTimeMillis());

for (int i = 0; i < population; i++) {

int len = gene_len chrom_len;

boolean[] ind = new boolean[len];

for (int j = 0; j < len; j++)

ind[j] = rnextBoolean();

individualsadd(ind);

}

}

// 交叉

public void cross(boolean[] arr1, boolean[] arr2) {

Random r = new Random(SystemcurrentTimeMillis());

int length = arr1length;

int slice = 0;

do {

slice = rnextInt(length);

} while (slice == 0);

if (slice < length / 2) {

for (int i = 0; i < slice; i++) {

boolean tmp = arr1[i];

arr1[i] = arr2[i];

arr2[i] = tmp;

}

} else {

for (int i = slice; i < length; i++) {

boolean tmp = arr1[i];

arr1[i] = arr2[i];

arr2[i] = tmp;

}

}

}

// 变异

public void mutation(boolean[] individual) {

int length = individuallength;

Random r = new Random(SystemcurrentTimeMillis());

individual[rnextInt(length)] ^= false;

}

// 轮盘法选择下一代,并返回当代最高的适应度值

public double selection() {

boolean[][] next_generation = new boolean[population][]; // 下一代

int length = gene_len chrom_len;

for (int i = 0; i < population; i++)

next_generation[i] = new boolean[length];

double[] cumulation = new double[population];

int best_index = 0;

double max_fitness = getFitness(individualsget(best_index));

cumulation[0] = max_fitness;

for (int i = 1; i < population; i++) {

double fit = getFitness(individualsget(i));

cumulation[i] = cumulation[i - 1] + fit;

// 寻找当代的最优个体

if (fit > max_fitness) {

best_index = i;

max_fitness = fit;

}

}

Random rand = new Random(SystemcurrentTimeMillis());

for (int i = 0; i < population; i++)

next_generation[i] = individualsget(findByHalf(cumulation,

randnextDouble() cumulation[population - 1]));

// 把当代的最优个体及其适应度放到best_individual中

BI bi = new BI(max_fitness, individualsget(best_index));

// printPath(individualsget(best_index));

//Systemoutprintln(max_fitness);

best_individualadd(bi);

// 新一代作为当前代

for (int i = 0; i < population; i++)

individualsset(i, next_generation[i]);

return max_fitness;

}

// 折半查找

public int findByHalf(double[] arr, double find) {

if (find < 0 || find == 0 || find > arr[arrlength - 1])

return -1;

int min = 0;

int max = arrlength - 1;

int medium = min;

do {

if (medium == (min + max) / 2)

break;

medium = (min + max) / 2;

if (arr[medium] < find)

min = medium;

else if (arr[medium] > find)

max = medium;

else

return medium;

} while (min < max);

return max;

}

// 计算适应度

public double getFitness(boolean[] individual) {

int length = individuallength;

// 记录当前的位置,入口点是（1,0）

int x = 1;

int y = 0;

// 根据染色体中基因的指导向前走

for (int i = 0; i < length; i++) {

boolean b1 = individual[i];

boolean b2 = individual[++i];

// 00向左走

if (b1 == false && b2 == false) {

if (x > 0 && labyrinthmap[y][x - 1] == true) {

x--;

}

}

// 01向右走

else if (b1 == false && b2 == true) {

if (x + 1 < width && labyrinthmap[y][x + 1] == true) {

x++;

}

}

// 10向上走

else if (b1 == true && b2 == false) {

if (y > 0 && labyrinthmap[y - 1][x] == true) {

y--;

}

}

// 11向下走

else if (b1 == true && b2 == true) {

if (y + 1 < height && labyrinthmap[y + 1][x] == true) {

y++;

}

}

}

int n = Mathabs(x - labyrinthx_end) + Mathabs(y -labyrinthy_end) + 1;

//      if(n==1)

//          printPath(individual);

return 10 / n;

}

// 运行遗传算法

public boolean run() {

// 初始化种群

initPopulation();

Random rand = new Random(SystemcurrentTimeMillis());

boolean success = false;

while (iter_limit-- > 0) {

// 打乱种群的顺序

Collectionsshuffle(individuals);

for (int i = 0; i < population - 1; i += 2) {

// 交叉

if (randnextDouble() < cross_ratio) {

cross(individualsget(i), individualsget(i + 1));

}

// 变异

if (randnextDouble() < muta_ratio) {

mutation(individualsget(i));

}

}

// 种群更替

if (selection() == 1) {

success = true;

break;

}

}

return success;

}

//  public static void main(String[] args) {

//      GA ga = new GA(8, 8);

//      if (!garun()) {

//          Systemoutprintln("没有找到走出迷宫的路径");

//      } else {

//          int gen = gabest_individualsize();

//          boolean[] individual = gabest_individualget(gen - 1)indv;

//          Systemoutprintln(gagetPath(individual));

//      }

//  }

// 根据染色体打印走法

public String getPath(boolean[] individual) {

int length = individuallength;

int x = 1;

int y = 0;

LinkedList<String> stack=new LinkedList<String>();

for (int i = 0; i < length; i++) {

boolean b1 = individual[i];

boolean b2 = individual[++i];

if (b1 == false && b2 == false) {

if (x > 0 && labyrinthmap[y][x - 1] == true) {

x--;

if(!stackisEmpty() && stackpeek()=="右")

stackpoll();

else

stackpush("左");

}

} else if (b1 == false && b2 == true) {

if (x + 1 < width && labyrinthmap[y][x + 1] == true) {

x++;

if(!stackisEmpty() && stackpeek()=="左")

stackpoll();

else

stackpush("右");

}

} else if (b1 == true && b2 == false) {

if (y > 0 && labyrinthmap[y - 1][x] == true) {

y--;

if(!stackisEmpty() && stackpeek()=="下")

stackpoll();

else

stackpush("上");

}

} else if (b1 == true && b2 == true) {

if (y + 1 < height && labyrinthmap[y + 1][x] == true) {

y++;

if(!stackisEmpty() && stackpeek()=="上")

stackpoll();

else

stackpush("下");

}

}

}

StringBuilder sb=new StringBuilder(length/4);

Iterator<String> iter=stackdescendingIterator();

while(iterhasNext())

sbappend(iternext());

return sbtoString();

}

}

以上就是关于java迷宫move类意思全部的内容，包括:java迷宫move类意思、如何用Java实现遗传算法、等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！