Implementasi Weighted Product Model menggunakan Java

Pada tulisan sebelumnya kita telah mengetahui perhitungan metode Weighted Product. Pada tulisan ini kita akan mengimplementasikan metode tersebut ke dalam bahasa pemrograman Java. Minimal versi JDK yang digunakan dalam implementasi ini adalah versi 1.8 agar mendukung Stream API.

Pertama kita buat class model:

class Kriteria {

  String kode, nama;
  boolean benefit;
  double bobot;

  Kriteria(String kode, String nama,
      boolean benefit, double bobot) {
    this.kode = kode;
    this.nama = nama;
    this.benefit = benefit;
    this.bobot = bobot;
  }

  // Perbaikan bobot
  double weighted(double total) {
    double w = bobot / total;
    return benefit ? w : w * -1;
  }
}

class Alternatif implements Comparable<Alternatif> {

  String kode, nama;
  double nilai = 0d;

  Alternatif(String kode, String nama) {
    this.kode = kode;
    this.nama = nama;
  }

  @Override
  public String toString() {
    return String.format("%s-%s:%.3f", kode, nama, nilai);
  }

  @Override
  public int compareTo(Alternatif a) {
    return Double.compare(this.nilai, a.nilai);
  }
}

Class Alternatif ini kita buat inherit interface Comparable dan yang kita compare adalah nilai V dari alternatif untuk menentukan nilai tertinggi dari setiap alternatif.

class KriteriaAlternatif {

  String alternatifKode, kriteriaKode;
  double nilai, temp;

  KriteriaAlternatif(String alternatif,
      String kriteriaKode, double nilai) {
    this.alternatifKode = alternatif;
    this.kriteriaKode = kriteriaKode;
    this.nilai = nilai;
  }
}

Lalu buat class interface untuk penilaian tingkat kepentingan:

interface Bobot {

  double SANGAT_TIDAK_PENTING = 1d,
         TIDAK_PENTING = 2d,
         CUKUP_PENTING = 3d,
         PENTING = 4d,
         SANGAT_PENTING = 5d;
}

Buat class utama dengan nama bebas untuk membuat fungsi atau method perhitungannya, misal class WeightedProduct.java. Pada class tersebut kita buat dulu hardcode datanya dalam list class model, sesuai dengan contoh kasus pada tulisan sebelumnya.

List<Alternatif> alternatif = Arrays.asList(
    new Alternatif("A1", "Samsung Galaxy J5"),
    new Alternatif("A2", "Xiaomi Redmi 4X"),
    new Alternatif("A3", "Oppo A57"));

List<Kriteria> kriteria = Arrays.asList(
    new Kriteria("C1", "Harga", false, Bobot.CUKUP_PENTING),
    new Kriteria("C2", "Kapasitas RAM/ROM", true, Bobot.SANGAT_PENTING),
    new Kriteria("C3", "Kualitas Kamera", true, Bobot.CUKUP_PENTING),
    new Kriteria("C4", "Kapasitas Baterai", true, Bobot.PENTING));

List<KriteriaAlternatif> kriteriaAlternatif = Arrays.asList(
    new KriteriaAlternatif("A1", "C1", 82d),
    new KriteriaAlternatif("A1", "C2", 76d),
    new KriteriaAlternatif("A1", "C3", 85d),
    new KriteriaAlternatif("A1", "C4", 76d),

    new KriteriaAlternatif("A2", "C1", 75d),
    new KriteriaAlternatif("A2", "C2", 80d),
    new KriteriaAlternatif("A2", "C3", 75d),
    new KriteriaAlternatif("A2", "C4", 82d),

    new KriteriaAlternatif("A3", "C1", 80d),
    new KriteriaAlternatif("A3", "C2", 76d),
    new KriteriaAlternatif("A3", "C3", 79d),
    new KriteriaAlternatif("A3", "C4", 75d));

Lalu method perhitungannya,

KriteriaAlternatif pangkatW(KriteriaAlternatif ka) {
  // Total nilai bobot untuk perhitungan perbaikan bobot (∑Wj)
  final double totalW = kriteria.stream()
          .mapToDouble(k -> k.bobot)
          .sum();

  // Perhitungan nilai kriteria berpangkat bobot perbaikan
  kriteria.stream()
          .filter(k -> ka.kriteriaKode.equals(k.kode))
          .forEach(k -> ka.temp = Math.pow(ka.nilai, k.weighted(totalW)));

  return ka;
}

Alternatif vecktorS(Alternatif a) {
  // Perhitungan nilai vektor S
  kriteriaAlternatif.stream()
          .map(this::pangkatW)
          .filter(ka -> (a.kode.equals(ka.alternatifKode)))
          .forEach(ka -> a.nilai = a.nilai == 0d ? ka.temp : a.nilai * ka.temp);
  return a;
}

List<Alternatif> hitung() {
  // Total niali S (∑Sj)
  final double totalS = alternatif.stream()
          .map(this::vecktorS)
          .mapToDouble(a -> a.nilai)
          .sum();

  // Nilai V (Sj / ∑Sj)
  alternatif.forEach(a -> a.nilai = a.nilai / totalS);
  return alternatif;
}

Kemudian pada main method kita panggil method hitung dan tentukan nilai tertinggi dengan Collections API.

public static void main(String[] args) {
  final List<Alternatif> hasil = new WeightedProduct().hitung();
  final String highest = Collections.max(hasil).kode;
  hasil.forEach(a -> System.out.println(a.kode
          .equals(highest) ? "" + a + " ✓" : a));
}

Jika semua sudah selesai, kita run programnya maka hasilnya akan seperti ini:

Jika kita bandingkan dengan perhitungan manual pada tulisan sebelumnya akan mendapatkan hasil yang sama.