From 4df0f9d9058c96590ccf90d71c1fd7337b43b853 Mon Sep 17 00:00:00 2001
From: Bendik Samseth <b.samseth@gmail.com>
Date: Tue, 7 Aug 2018 23:14:29 +0200
Subject: [PATCH 1/2] Implement Java version of stable marriage problem.

---
 .../code/java/stable-marriage.java            | 146 ++++++++++++++++++
 .../stable_marriage_problem.md                |   2 +
 2 files changed, 148 insertions(+)
 create mode 100644 contents/stable_marriage_problem/code/java/stable-marriage.java

diff --git a/contents/stable_marriage_problem/code/java/stable-marriage.java b/contents/stable_marriage_problem/code/java/stable-marriage.java
new file mode 100644
index 000000000..be9bbec8f
--- /dev/null
+++ b/contents/stable_marriage_problem/code/java/stable-marriage.java
@@ -0,0 +1,146 @@
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Collections;
+
+class StableMarriage {
+
+    /*
+     * Use the stable marriage algorithm to find stable pairs from the
+     * lists of men and women.
+     */
+    public static void findStableMarriages(List<Woman> women, List<Man> men) {
+        boolean keep_going;
+
+        // We might have more men/women than women/men. In this case, not everybody can
+        // get a mate. We should aim to give every member of the less numerous gender a mate,
+        // as this is always possible.
+        List<? extends Person> leastCommonGender = women.size() <= men.size() ? women : men;
+        do {
+            // Every single man proposes to a woman.
+            for (Man man : men)
+                if (man.isLonely())
+                    man.propose();
+
+            // The women pick their favorite suitor.
+            for (Woman woman : women)
+                woman.chooseMate();
+
+            // Repeat the process if someone is left without a partner.
+            keep_going = false;
+            for (Person person : leastCommonGender) {
+                if (keep_going |= person.isLonely()) {
+                    break;
+                }
+            }
+
+        } while (keep_going);
+
+        women.forEach(w -> System.out.println(w + " married to " + w.getMate()));
+    }
+
+    public static void main(String[] args) {
+        int nPairs = 5;
+        List<Woman> women = new LinkedList<>();
+        List<Man> men = new LinkedList<>();
+        for (char i = 'A'; i < 'A' + nPairs; ++i) {
+            women.add(new Woman("" + i));
+            men.add(new Man("" + i));
+        }
+        // Make the genders unbalanced:
+        women.add(new Woman("X"));
+
+        women.forEach(w -> {
+            w.receiveOptions(men);
+            System.out.println(w + " prefers " + w.getPreferedMates());
+        });
+        men.forEach(m -> {
+            m.receiveOptions(women);
+            System.out.println(m + " prefers " + m.getPreferedMates());
+        });
+
+        findStableMarriages(women, men);
+    }
+
+}
+
+class Person {
+    private final String name;
+    protected Person mate;
+    protected List<Person> preferedMates;
+
+    public Person(String name) {
+        this.name = name;
+    }
+
+    public boolean isLonely() {
+        return mate == null;
+    }
+
+    public void setMate(Person mate) {
+        // Only set mates if there is a change.
+        if (this.mate != mate) {
+            // Remove old mates mate.
+            if (this.mate != null)
+                this.mate.mate = null;
+
+            // Set the new mate.
+            this.mate = mate;
+
+            // If new mate is someone, update their mate.
+            if (mate != null)
+                mate.mate = this;
+        }
+    }
+
+    public Person getMate() {
+        return mate;
+    }
+
+    public void receiveOptions(List<? extends Person> mates) {
+        // Preferences are subjective.
+        preferedMates = new LinkedList<>(mates);
+        Collections.shuffle(preferedMates);
+    }
+
+    public List<Person> getPreferedMates() {
+        return preferedMates;
+    }
+
+    public String toString() {
+        return getClass().getName() + "(" + name + ")";
+    }
+}
+
+class Woman extends Person {
+    private List<Man> suitors = new LinkedList<>();
+
+    public Woman(String name) {
+        super(name);
+    }
+
+    public void recieveProposal(Man suitor) {
+        suitors.add(suitor);
+    }
+
+    public void chooseMate() {
+        for (Person mostDesired : preferedMates) {
+            if (mostDesired == mate || suitors.contains(mostDesired)) {
+                setMate(mostDesired);
+                break;
+            }
+        }
+    }
+}
+
+class Man extends Person {
+    public Man(String name) {
+        super(name);
+    }
+
+    public void propose() {
+        if (!preferedMates.isEmpty()) {
+            Woman fiance = (Woman) preferedMates.remove(0);
+            fiance.recieveProposal(this);
+        }
+    }
+}
diff --git a/contents/stable_marriage_problem/stable_marriage_problem.md b/contents/stable_marriage_problem/stable_marriage_problem.md
index 41df485a1..fc47c0910 100644
--- a/contents/stable_marriage_problem/stable_marriage_problem.md
+++ b/contents/stable_marriage_problem/stable_marriage_problem.md
@@ -42,6 +42,8 @@ Program.cs
 [import, lang:"csharp"](code/csharp/Program.cs)
 ListExtensions.cs
 [import, lang:"csharp"](code/csharp/ListExtensions.cs)
+{% sample lang="java" %}
+[import, lang:"java"](code/java/stable-marriage.java)
 {% endmethod %}
 
 <script>

From aa4ab4bdbd5feeb7c0e1e49a04f3d55ea23dc556 Mon Sep 17 00:00:00 2001
From: Bendik Samseth <b.samseth@gmail.com>
Date: Thu, 9 Aug 2018 16:03:47 +0200
Subject: [PATCH 2/2] Improve Java stable marriage implementation.

---
 .../code/java/stable-marriage.java            | 42 ++++++++-----------
 1 file changed, 18 insertions(+), 24 deletions(-)

diff --git a/contents/stable_marriage_problem/code/java/stable-marriage.java b/contents/stable_marriage_problem/code/java/stable-marriage.java
index be9bbec8f..e57ba56bf 100644
--- a/contents/stable_marriage_problem/code/java/stable-marriage.java
+++ b/contents/stable_marriage_problem/code/java/stable-marriage.java
@@ -1,5 +1,5 @@
 import java.util.List;
-import java.util.LinkedList;
+import java.util.ArrayList;
 import java.util.Collections;
 
 class StableMarriage {
@@ -9,8 +9,6 @@ class StableMarriage {
      * lists of men and women.
      */
     public static void findStableMarriages(List<Woman> women, List<Man> men) {
-        boolean keep_going;
-
         // We might have more men/women than women/men. In this case, not everybody can
         // get a mate. We should aim to give every member of the less numerous gender a mate,
         // as this is always possible.
@@ -25,23 +23,19 @@ public static void findStableMarriages(List<Woman> women, List<Man> men) {
             for (Woman woman : women)
                 woman.chooseMate();
 
-            // Repeat the process if someone is left without a partner.
-            keep_going = false;
-            for (Person person : leastCommonGender) {
-                if (keep_going |= person.isLonely()) {
-                    break;
-                }
-            }
+            // End the process if everybody has a mate.
+            if (!leastCommonGender.stream().anyMatch(Person::isLonely))
+                break;
 
-        } while (keep_going);
+        } while (true);
 
         women.forEach(w -> System.out.println(w + " married to " + w.getMate()));
     }
 
     public static void main(String[] args) {
         int nPairs = 5;
-        List<Woman> women = new LinkedList<>();
-        List<Man> men = new LinkedList<>();
+        List<Woman> women = new ArrayList<>();
+        List<Man> men = new ArrayList<>();
         for (char i = 'A'; i < 'A' + nPairs; ++i) {
             women.add(new Woman("" + i));
             men.add(new Man("" + i));
@@ -51,11 +45,11 @@ public static void main(String[] args) {
 
         women.forEach(w -> {
             w.receiveOptions(men);
-            System.out.println(w + " prefers " + w.getPreferedMates());
+            System.out.println(w + " prefers " + w.getPreferredMates());
         });
         men.forEach(m -> {
             m.receiveOptions(women);
-            System.out.println(m + " prefers " + m.getPreferedMates());
+            System.out.println(m + " prefers " + m.getPreferredMates());
         });
 
         findStableMarriages(women, men);
@@ -66,7 +60,7 @@ public static void main(String[] args) {
 class Person {
     private final String name;
     protected Person mate;
-    protected List<Person> preferedMates;
+    protected List<Person> preferredMates;
 
     public Person(String name) {
         this.name = name;
@@ -98,12 +92,12 @@ public Person getMate() {
 
     public void receiveOptions(List<? extends Person> mates) {
         // Preferences are subjective.
-        preferedMates = new LinkedList<>(mates);
-        Collections.shuffle(preferedMates);
+        preferredMates = new ArrayList<>(mates);
+        Collections.shuffle(preferredMates);
     }
 
-    public List<Person> getPreferedMates() {
-        return preferedMates;
+    public List<Person> getPreferredMates() {
+        return preferredMates;
     }
 
     public String toString() {
@@ -112,7 +106,7 @@ public String toString() {
 }
 
 class Woman extends Person {
-    private List<Man> suitors = new LinkedList<>();
+    private List<Man> suitors = new ArrayList<>();
 
     public Woman(String name) {
         super(name);
@@ -123,7 +117,7 @@ public void recieveProposal(Man suitor) {
     }
 
     public void chooseMate() {
-        for (Person mostDesired : preferedMates) {
+        for (Person mostDesired : preferredMates) {
             if (mostDesired == mate || suitors.contains(mostDesired)) {
                 setMate(mostDesired);
                 break;
@@ -138,8 +132,8 @@ public Man(String name) {
     }
 
     public void propose() {
-        if (!preferedMates.isEmpty()) {
-            Woman fiance = (Woman) preferedMates.remove(0);
+        if (!preferredMates.isEmpty()) {
+            Woman fiance = (Woman) preferredMates.remove(0);
             fiance.recieveProposal(this);
         }
     }