Java 遗传算法

遗传算法（Genetic Algorithm, GA）是一种基于自然选择和遗传学原理的优化算法，用于求解复杂的搜索和优化问题。在Java中实现遗传算法通常包括以下几个步骤：

1. 初始化种群：生成一组随机解作为初始种群。
2. 适应度评估：定义一个适应度函数，用于评估每个解的优劣。
3. 选择：根据适应度选择适应度较高的个体作为父代，用于生成下一代。
4. 交叉（Crossover）：通过交换父代的部分基因来生成子代。
5. 变异（Mutation）：以一定的概率随机改变子代的基因，增加种群的多样性。
6. 替代：用子代替代部分或全部父代，形成新的种群。
7. 终止条件：设定终止条件（如达到最大迭代次数或适应度达到某个阈值），终止算法。

以下是一个简单的Java实现遗传算法的示例，用于解决一个优化问题（如最大化某个函数）。

import java.util.ArrayList;  
import java.util.Collections;  
import java.util.List;  
import java.util.Random;  
  
class Individual {  
    private int[] genes;  
    private double fitness;  
  
    public Individual(int geneLength) {  
        genes = new int[geneLength];  
        Random rand = new Random();  
        for (int i = 0; i < geneLength; i++) {  
            genes[i] = rand.nextInt(2); // 0 or 1  
        }  
    }  
  
    public double getFitness() {  
        return fitness;  
    }  
  
    public void setFitness(double fitness) {  
        this.fitness = fitness;  
    }  
  
    public int[] getGenes() {  
        return genes;  
    }  
  
    @Override  
    public String toString() {  
        StringBuilder sb = new StringBuilder();  
        for (int gene : genes) {  
            sb.append(gene);  
        }  
        return sb.toString();  
    }  
}  
  
class GeneticAlgorithm {  
    private static final int POPULATION_SIZE = 100;  
    private static final int GENE_LENGTH = 10;  
    private static final int MAX_GENERATIONS = 1000;  
    private static final double MUTATION_RATE = 0.01;  
  
    public static void main(String[] args) {  
        List<Individual> population = initializePopulation(POPULATION_SIZE, GENE_LENGTH);  
  
        for (int generation = 0; generation < MAX_GENERATIONS; generation++) {  
            evaluateFitness(population);  
            List<Individual> newPopulation = generateNewPopulation(population);  
            population = newPopulation;  
  
            // 输出当前最优解  
            Collections.sort(population, (i1, i2) -> Double.compare(i2.getFitness(), i1.getFitness()));  
            System.out.println("Generation " + generation + ": Best Fitness = " + population.get(0).getFitness());  
        }  
    }  
  
    private static List<Individual> initializePopulation(int populationSize, int geneLength) {  
        List<Individual> population = new ArrayList<>();  
        for (int i = 0; i < populationSize; i++) {  
            population.add(new Individual(geneLength));  
        }  
        return population;  
    }  
  
    private static void evaluateFitness(List<Individual> population) {  
        for (Individual individual : population) {  
            // 示例适应度函数：计算二进制字符串中1的个数（可以根据具体问题修改）  
            int countOnes = 0;  
            for (int gene : individual.getGenes()) {  
                if (gene == 1) {  
                    countOnes++;  
                }  
            }  
            individual.setFitness(countOnes);  
        }  
    }  
  
    private static List<Individual> generateNewPopulation(List<Individual> population) {  
        List<Individual> newPopulation = new ArrayList<>();  
        while (newPopulation.size() < POPULATION_SIZE) {  
            Individual parent1 = selectParent(population);  
            Individual parent2 = selectParent(population);  
            Individual child = crossover(parent1, parent2);  
            mutate(child);  
            newPopulation.add(child);  
        }  
        return newPopulation;  
    }  
  
    private static Individual selectParent(List<Individual> population) {  
        // 轮盘赌选择  
        double totalFitness = population.stream().mapToDouble(Individual::getFitness).sum();  
        double randomValue = new Random().nextDouble() * totalFitness;  
        double cumulativeFitness = 0.0;  
  
        for (Individual individual : population) {  
            cumulativeFitness += individual.getFitness();  
            if (cumulativeFitness >= randomValue) {  
                return individual;  
            }  
        }  
        return population.get(population.size() - 1); // 如果没有匹配，返回最后一个  
    }  
  
    private static Individual crossover(Individual parent1, Individual parent2) {  
        int crossoverPoint = new Random().nextInt(parent1.getGenes().length);  
        int[] childGenes = new int[parent1.getGenes().length];  
  
        System.arraycopy(parent1.getGenes(), 0, childGenes, 0, crossoverPoint);  
        System.arraycopy(parent2.getGenes(), crossoverPoint, childGenes, crossoverPoint, parent2.getGenes().length - crossoverPoint);  
  
        return new Individual() {  
            {  
                this.genes = childGenes;  
            }  
        };  
    }  
  
    private static void mutate(Individual individual) {  
        Random rand = new Random();  
        for (int i = 0; i < individual.getGenes().length; i++) {  
            if (rand.nextDouble() < MUTATION_RATE) {  
                individual.getGenes()[i] = 1 - individual.getGenes()[i]; // 0变1，1变0  
            }  
        }  
    }  
}

注意事项

1. 适应度函数：根据具体问题定义，这里示例的是计算二进制字符串中1的个数。
2. 选择方法：这里使用了轮盘赌选择（Roulette Wheel Selection），但还有其他选择方法如锦标赛选择（Tournament Selection）等。
3. 交叉和变异：交叉和变异操作的具体实现可以根据问题需求进行调整。
4. 性能优化：可以根据实际需求对算法进行优化，比如使用精英保留策略（Elite Preservation）等。

这个示例展示了基本的遗传算法框架，你可以根据具体需求进行扩展和修改。