利用方法bindCloudletsToVmsSimple()将一组任务顺序分配给一组虚拟机，当所有的虚拟机都有任务后，再从第一个虚拟机开始重头分配任务，该方法尽量保证每个虚拟机运行相同数量的任务以均衡负载。利用方法bindCloudletsToVmsTimeAwared对时间做贪心，希望使所有任务的完成时间最短。对比利用贪心策略和顺序分配策略完成所有任务所消耗的时间。JAVA IDEA完整代码

下面是一个简单的实现，包括任务和虚拟机的定义，以及使用两种不同的方法进行任务调度的示例代码：

import java.util.*;

public class Cloudlet {
    private int id;
    private long length;
    private long finishTime;

    public Cloudlet(int id, long length) {
        this.id = id;
        this.length = length;
        this.finishTime = -1;
    }

    public int getId() {
        return id;
    }

    public long getLength() {
        return length;
    }

    public long getFinishTime() {
        return finishTime;
    }

    public void setFinishTime(long finishTime) {
        this.finishTime = finishTime;
    }
}

public class Vm {
    private int id;
    private long capacity;
    private List<Cloudlet> cloudlets;

    public Vm(int id, long capacity) {
        this.id = id;
        this.capacity = capacity;
        this.cloudlets = new ArrayList<>();
    }

    public int getId() {
        return id;
    }

    public long getCapacity() {
        return capacity;
    }

    public List<Cloudlet> getCloudlets() {
        return cloudlets;
    }

    public void addCloudlet(Cloudlet cloudlet) {
        cloudlets.add(cloudlet);
    }
}

public class CloudletScheduler {
    public static void bindCloudletsToVmsSimple(List<Cloudlet> cloudlets, List<Vm> vms) {
        int numVms = vms.size();
        int currentVm = 0;
        for (Cloudlet cloudlet : cloudlets) {
            Vm vm = vms.get(currentVm);
            vm.addCloudlet(cloudlet);
            currentVm = (currentVm + 1) % numVms;
        }
    }

    public static void bindCloudletsToVmsTimeAware(List<Cloudlet> cloudlets, List<Vm> vms) {
        PriorityQueue<Vm> queue = new PriorityQueue<>((vm1, vm2) -> {
            long time1 = vm1.getCloudlets().stream().mapToLong(Cloudlet::getLength).sum();
            long time2 = vm2.getCloudlets().stream().mapToLong(Cloudlet::getLength).sum();
            return Long.compare(time1, time2);
        });
        queue.addAll(vms);
        for (Cloudlet cloudlet : cloudlets) {
            Vm vm = queue.poll();
            vm.addCloudlet(cloudlet);
            queue.offer(vm);
        }
    }

    public static void main(String[] args) {
        List<Cloudlet> cloudlets = new ArrayList<>();
        cloudlets.add(new Cloudlet(1, 100));
        cloudlets.add(new Cloudlet(2, 200));
        cloudlets.add(new Cloudlet(3, 150));
        cloudlets.add(new Cloudlet(4, 80));

        List<Vm> vms = new ArrayList<>();
        vms.add(new Vm(1, 300));
        vms.add(new Vm(2, 200));

        bindCloudletsToVmsSimple(cloudlets, vms);
        System.out.println("Simple strategy:");
        for (Vm vm : vms) {
            System.out.println("VM " + vm.getId() + ":");
            for (Cloudlet cloudlet : vm.getCloudlets()) {
                System.out.println("\tCloudlet " + cloudlet.getId() + ": " + cloudlet.getLength());
            }
        }

        bindCloudletsToVmsTimeAware(cloudlets, vms);
        System.out.println("Time-aware strategy:");
        for (Vm vm : vms) {
            System.out.println("VM " + vm.getId() + ":");
            for (Cloudlet cloudlet : vm.getCloudlets()) {
                System.out.println("\tCloudlet " + cloudlet.getId() + ": " + cloudlet.getLength());
            }
        }
    }
}

在这个示例代码中，我们首先定义了Cloudlet和Vm两个类，分别表示任务和虚拟机。Cloudlet类包含任务的ID、任务长度和完成时间等属性，Vm类包含虚拟机的ID、容量和已分配的任务列表等属性。

然后，我们定义了CloudletScheduler类，其中包含两个静态方法bindCloudletsToVmsSimple和bindCloudletsToVmsTimeAware，分别对应顺序分配和时间贪心两种策略。这两个方法接受两个参数：任务列表和虚拟机列表。在bindCloudletsToVmsSimple方法中，我们使用一个循环将任务顺序分配给虚拟机，保证每个虚拟机运行相同数量的任务以均衡负载。在bindCloudletsToVmsTimeAware方法中，我们使用一个优先队列来维护虚拟机的任务完成时间，每次将任务分配给完成时间最早的虚拟机，以期望使所有任务的完成时间最短。

最后，在main方法中，我们创建了一个简单的测试用例，包含四个任务和两个虚拟机，并依次使用两种方法进行任务调度，输出每个虚拟机分配的任务列表。