在使用Java，通过遗传算法和mapreduce来计算城市路线的最短问题，固定起点和终点，用经纬度去计算距离，给出示例代码

这里提供一个简单的Java代码示例，用遗传算法和MapReduce计算城市路线的最短问题：

首先，我们需要定义一个City类，表示每个城市的坐标和名称：

public class City {
    private String name;
    private double latitude;
    private double longitude;

    public City(String name, double latitude, double longitude) {
        this.name = name;
        this.latitude = latitude;
        this.longitude = longitude;
    }

    public String getName() {
        return name;
    }

    public double getLatitude() {
        return latitude;
    }

    public double getLongitude() {
        return longitude;
    }
}

然后，我们定义一个CityMap类，用于存储所有城市和计算两个城市之间的距离：

import java.util.ArrayList;

public class CityMap {
    private ArrayList<City> cities;

    public CityMap(ArrayList<City> cities) {
        this.cities = cities;
    }

    public double getDistance(City city1, City city2) {
        double lat1 = city1.getLatitude();
        double lon1 = city1.getLongitude();
        double lat2 = city2.getLatitude();
        double lon2 = city2.getLongitude();

        double theta = lon1 - lon2;
        double dist = Math.sin(Math.toRadians(lat1)) * Math.sin(Math.toRadians(lat2)) + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) * Math.cos(Math.toRadians(theta));
        dist = Math.acos(dist);
        dist = Math.toDegrees(dist);
        dist = dist * 60 * 1.1515 * 1.609344;

        return dist;
    }

    public ArrayList<City> getCities() {
        return cities;
    }
}

接下来，我们定义一个Chromosome类，表示一个个体（即一条路线），并实现遗传算法的相关方法：

import java.util.ArrayList;
import java.util.Collections;

public class Chromosome implements Comparable<Chromosome> {
    private ArrayList<Integer> genes;
    private double fitness;

    public Chromosome(ArrayList<Integer> genes) {
        this.genes = genes;
        this.fitness = -1;
    }

    public ArrayList<Integer> getGenes() {
        return genes;
    }

    public double getFitness() {
        return fitness;
    }

    public void setFitness(double fitness) {
        this.fitness = fitness;
    }

    public void mutate() {
        int index1 = (int) (Math.random() * genes.size());
        int index2 = (int) (Math.random() * genes.size());
        Collections.swap(genes, index1, index2);
    }

    public Chromosome crossover(Chromosome other) {
        int size = genes.size();
        int start = (int) (Math.random() * size);
        int end = (int) (Math.random() * size);

        if (start > end) {
            int temp = start;
            start = end;
            end = temp;
        }

        ArrayList<Integer> child = new ArrayList<Integer>();
        for (int i = start; i <= end; i++) {
            child.add(genes.get(i));
        }

        for (int i = 0; i < size; i++) {
            int gene = other.getGenes().get(i);
            if (!child.contains(gene)) {
                child.add(gene);
            }
        }

        return new Chromosome(child);
    }

    @Override
    public int compareTo(Chromosome other) {
        if (fitness > other.getFitness()) {
            return 1;
        } else if (fitness < other.getFitness()) {
            return -1;
        } else {
            return 0;
        }
    }
}

最后，我们实现MapReduce任务，用于计算所有可能的路线中的最短路线：

import java.util.ArrayList;
import java.util.Collections;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class TSP {
    private static final int POPULATION_SIZE = 100;
    private static final int MAX_GENERATIONS = 1000;
    private static final double MUTATION_RATE = 0.01;
    private static final double ELITE_RATE = 0.1;

    public static class TSPMapper extends Mapper<Object, Text, NullWritable, Chromosome> {
        private CityMap cityMap;
        private int cityCount;

        @Override
        protected void setup(Context context) throws java.io.IOException, InterruptedException {
            Configuration conf = context.getConfiguration();
            String citiesFile = conf.get("citiesFile");

            ArrayList<City> cities = new ArrayList<City>();
            FileSystem fs = FileSystem.get(conf);
            Path citiesPath = new Path(citiesFile);
            BufferedReader reader = new BufferedReader(new InputStreamReader(fs.open(citiesPath)));
            String line = null;
            while ((line = reader.readLine()) != null) {
                String[] fields = line.split(",");
                String name = fields[0];
                double latitude = Double.parseDouble(fields[1]);
                double longitude = Double.parseDouble(fields[2]);
                cities.add(new City(name, latitude, longitude));
            }
            reader.close();

            cityMap = new CityMap(cities);
            cityCount = cities.size();
        }

        @Override
        public void map(Object key, Text value, Context context) throws java.io.IOException, InterruptedException {
            ArrayList<Chromosome> population = new ArrayList<Chromosome>();
            for (int i = 0; i < POPULATION_SIZE; i++) {
                ArrayList<Integer> genes = new ArrayList<Integer>();
                for (int j = 0; j < cityCount; j++) {
                    genes.add(j);
                }
                Collections.shuffle(genes);
                population.add(new Chromosome(genes));
            }

            for (int i = 0; i < MAX_GENERATIONS; i++) {
                for (Chromosome chromosome : population) {
                    double distance = 0;
                    ArrayList<Integer> genes = chromosome.getGenes();
                    for (int j = 0; j < cityCount - 1; j++) {
                        City city1 = cityMap.getCities().get(genes.get(j));
                        City city2 = cityMap.getCities().get(genes.get(j + 1));
                        distance += cityMap.getDistance(city1, city2);
                    }
                    City city1 = cityMap.getCities().get(genes.get(cityCount - 1));
                    City city2 = cityMap.getCities().get(genes.get(0));
                    distance += cityMap.getDistance(city1, city2);
                    chromosome.setFitness(1.0 / distance);
                }

                Collections.sort(population);

                ArrayList<Chromosome> newPopulation = new ArrayList<Chromosome>();
                int eliteCount = (int) (ELITE_RATE * POPULATION_SIZE);
                for (int j = 0; j < eliteCount; j++) {
                    newPopulation.add(population.get(j));
                }
                for (int j = eliteCount; j < POPULATION_SIZE; j++) {
                    Chromosome parent1 = selectParent(population);
                    Chromosome parent2 = selectParent(population);
                    Chromosome child = parent1.crossover(parent2);
                    if (Math.random() < MUTATION_RATE) {
                        child.mutate();
                    }
                    newPopulation.add(child);
                }

                population = newPopulation;
            }

            Collections.sort(population);
            Chromosome best = population.get(0);
            context.write(NullWritable.get(), best);
        }

        private Chromosome selectParent(ArrayList<Chromosome> population) {
            int index1 = (int) (Math.random() * population.size());
            int index2 = (int) (Math.random() * population.size());
            if (population.get(index1).getFitness() > population.get(index2).getFitness()) {
                return population.get(index1);
            } else {
                return population.get(index2);
            }
        }
    }

    public static class TSPReducer extends Reducer<NullWritable, Chromosome, IntWritable, DoubleWritable> {
        @Override
        public void reduce(NullWritable key, Iterable<Chromosome> values, Context context) throws java.io.IOException, InterruptedException {
            Chromosome best = null;
            for (Chromosome chromosome : values) {
                if (best == null || chromosome.getFitness() > best.getFitness()) {
                    best = chromosome;
                }
            }

            ArrayList<Integer> genes = best.getGenes();
            int cityCount = genes.size();
            double distance = 0;
            for (int i = 0; i < cityCount - 1; i++) {
                City city1 = bestMap.getCities().get(genes.get(i));
                City city2 = bestMap.getCities().get(genes.get(i + 1));
                distance += bestMap.getDistance(city1, city2);
            }
            City city1 = bestMap.getCities().get(genes.get(cityCount - 1));
            City city2 = bestMap.getCities().get(genes.get(0));
            distance += bestMap.getDistance(city1, city2);

            context.write(new IntWritable(cityCount), new DoubleWritable(distance));
        }
    }

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        conf.set("citiesFile", args[0]);

        Job job = Job.getInstance(conf, "TSP");
        job.setJarByClass(TSP.class);
        job.setMapperClass(TSPMapper.class);
        job.setReducerClass(TSPReducer.class);
        job.setOutputKeyClass(IntWritable.class);
        job.setOutputValueClass(DoubleWritable.class);
        FileInputFormat.addInputPath(job, new Path(args[1]));
        FileOutputFormat.setOutputPath(job, new Path(args[2]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

这个示例代码中使用了Hadoop的MapReduce框架来实现分布式计算。在运行程序之前，需要下载Hadoop并配置好环境。