Merge pull request #1071 from t0dd/nix-public-access

Nix public access

exercises/custom-set/.meta/src/reference/java/CustomSet.java

 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
-public class CustomSet<T> {
+class CustomSet<T> {
 
     private Set<T> set;
 
-    public CustomSet() {
+    CustomSet() {
         this(Collections.emptyList());
     }
 
-    public CustomSet(Collection<T> data) {
+    CustomSet(Collection<T> data) {
         set = new HashSet<>(data.size());
         this.set.addAll(data);
     }
 
-    public boolean isEmpty() {
+    boolean isEmpty() {
         return set.isEmpty();
     }
 
-    public boolean contains(T element) {
+    boolean contains(T element) {
         return set.contains(element);
     }
 
-    public boolean isSubset(CustomSet<T> anotherSet) {
+    boolean isSubset(CustomSet<T> anotherSet) {
         return set.containsAll(anotherSet.set);
     }
 
-    public boolean isDisjoint(CustomSet<T> anotherSet) {
+    boolean isDisjoint(CustomSet<T> anotherSet) {
         if (set.isEmpty() || anotherSet.set.isEmpty()) {
             return true;
         }
                 .count() == 0;
     }
 
-    public boolean equals(CustomSet<T> anotherSet) {
+    boolean equals(CustomSet<T> anotherSet) {
         return set.equals(anotherSet.set);
     }
 
-    public boolean add(T element) {
+    boolean add(T element) {
         return set.add(element);
     }
 
-    public CustomSet<T> getIntersection(CustomSet<T> anotherSet) {
+    CustomSet<T> getIntersection(CustomSet<T> anotherSet) {
         return new CustomSet<>(
                 set.stream()
                         .filter(anotherSet.set::contains)
         );
     }
 
-    public CustomSet<T> getUnion(CustomSet<T> anotherSet) {
+    CustomSet<T> getUnion(CustomSet<T> anotherSet) {
         final Set<T> union = new HashSet<>(set);
         union.addAll(anotherSet.set);
         return new CustomSet<>(union);
     }
 
-    public CustomSet<T> getDifference(CustomSet<T> anotherSet) {
+    CustomSet<T> getDifference(CustomSet<T> anotherSet) {
         final Predicate<T> predicate = anotherSet::contains;
         return new CustomSet<>(
                 set.stream()

exercises/food-chain/.meta/src/reference/java/FoodChain.java

 import java.util.stream.IntStream;
 
-public class FoodChain {
+class FoodChain {
 
     private static final String[] ANIMALS = {
         "fly",
         "I don't know how she swallowed a cow!"
     };
 
-    public String verse(int verse) {
+    String verse(int verse) {
         return verseBeginning(verse) + verseMiddle(verse) + verseEnding(verse);
     }
 
-    public String verses(int startVerse, int endVerse) {
+    String verses(int startVerse, int endVerse) {
 
         String[] verses = new String[endVerse - startVerse + 1];
 

exercises/hamming/.meta/src/reference/java/Hamming.java

-public class Hamming {
+class Hamming {
     private final int hammingDistance;
 
-    public Hamming(String leftStrand, String rightStrand) {
+    Hamming(String leftStrand, String rightStrand) {
         hammingDistance = computeHammingDistance(leftStrand, rightStrand);
     }
 
-    public int getHammingDistance() {
+    int getHammingDistance() {
         return hammingDistance;
     }
 

exercises/hexadecimal/.meta/src/reference/java/Hexadecimal.java

 import java.util.Arrays;
 
-public class Hexadecimal {
+class Hexadecimal {
     private static final String HEXES = "0123456789abcdef";
-    public static int toDecimal(String input){
+    static int toDecimal(String input){
         boolean  isHex = input.matches("^[0-9a-f]+");
         if (!isHex) return 0;
         return Arrays.stream(input.split(""))
 
     }
 }
-
-