Apply minor code refactoring

http/http-api/src/main/java/com/okta/commons/http/HttpHeaders.java

@@ -23,19 +23,7 @@
 import java.nio.charset.Charset;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.EnumSet;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.TimeZone;
+import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -158,15 +146,11 @@ public List<MediaType> getAccept() {
      * @param acceptableCharsets the acceptable charsets
      */
     public void setAcceptCharset(List<Charset> acceptableCharsets) {
-        StringBuilder builder = new StringBuilder();
-        for (Iterator<Charset> iterator = acceptableCharsets.iterator(); iterator.hasNext(); ) {
-            Charset charset = iterator.next();
-            builder.append(charset.name().toLowerCase(Locale.ENGLISH));
-            if (iterator.hasNext()) {
-                builder.append(", ");
-            }
-        }
-        set(ACCEPT_CHARSET, builder.toString());
+        String accept = acceptableCharsets.stream()
+            .map(c -> c.name().toLowerCase(Locale.ENGLISH))
+            .collect(Collectors.joining(", "));
+
+        set(ACCEPT_CHARSET, accept);
     }
 
     /**
@@ -410,15 +394,7 @@ public void setIfNoneMatch(String ifNoneMatch) {
      * @param ifNoneMatchList the new value of the header
      */
     public void setIfNoneMatch(List<String> ifNoneMatchList) {
-        StringBuilder builder = new StringBuilder();
-        for (Iterator<String> iterator = ifNoneMatchList.iterator(); iterator.hasNext(); ) {
-            String ifNoneMatch = iterator.next();
-            builder.append(ifNoneMatch);
-            if (iterator.hasNext()) {
-                builder.append(", ");
-            }
-        }
-        set(IF_NONE_MATCH, builder.toString());
+        set(IF_NONE_MATCH, String.join(", ", ifNoneMatchList));
     }
 
     /**
@@ -515,14 +491,14 @@ public Map<String, String> getLinkMap() {
             List<String> headerValues = headers.get(LINK);
             return headerValues.stream()
                     .map(HttpHeaders::parseLinkHeader)
-                    .filter(link -> link != null)
+                    .filter(Objects::nonNull)
                     .collect(Collectors.toMap(Link::getRelationType, Link::getHref));
         }
         return Collections.emptyMap();
     }
 
     private static Link parseLinkHeader(String rawHeader) {
-        Pattern pattern = Pattern.compile("<(.*)>;.*rel=\"?([^;|,|\"]*)\"?.*");
+        Pattern pattern = Pattern.compile("<(.*)>;.*rel=\"?([^;|,\"]*)\"?.*");
         Matcher matcher = pattern.matcher(rawHeader);
         if (matcher.matches()) {
             return new DefaultLink(matcher.group(2), matcher.group(1));
@@ -581,7 +557,7 @@ public String getFirst(String headerName) {
     public void add(String headerName, String headerValue) {
         List<String> headerValues = headers.get(headerName);
         if (headerValues == null) {
-            headerValues = new LinkedList<String>();
+            headerValues = new LinkedList<>();
             this.headers.put(headerName, headerValues);
         }
         headerValues.add(headerValue);
@@ -597,7 +573,7 @@ public void add(String headerName, String headerValue) {
      * @see #add(String, String)
      */
     public void set(String headerName, String headerValue) {
-        List<String> headerValues = new LinkedList<String>();
+        List<String> headerValues = new LinkedList<>();
         headerValues.add(headerValue);
         headers.put(headerName, headerValues);
     }
@@ -609,7 +585,9 @@ public void setAll(Map<String, String> values) {
     }
 
     public Map<String, String> toSingleValueMap() {
-        LinkedHashMap<String, String> singleValueMap = new LinkedHashMap<String, String>(this.headers.size());
+        // Sets the initial capacity while keeping the default load factor in mind.
+        int capacity = (int) ((this.headers.size())/0.75+1);
+        LinkedHashMap<String, String> singleValueMap = new LinkedHashMap<>(capacity);
         for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
             singleValueMap.put(entry.getKey(), entry.getValue().get(0));
         }

http/http-api/src/main/java/com/okta/commons/http/MediaType.java

@@ -618,7 +618,7 @@ public static String toString(Collection<MediaType> mediaTypes) {
     public static void sortBySpecificity(List<MediaType> mediaTypes) {
         Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
         if (mediaTypes.size() > 1) {
-            Collections.sort(mediaTypes, SPECIFICITY_COMPARATOR);
+            mediaTypes.sort(SPECIFICITY_COMPARATOR);
         }
     }
 
@@ -645,7 +645,7 @@ public static void sortBySpecificity(List<MediaType> mediaTypes) {
     public static void sortByQualityValue(List<MediaType> mediaTypes) {
         Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
         if (mediaTypes.size() > 1) {
-            Collections.sort(mediaTypes, QUALITY_VALUE_COMPARATOR);
+            mediaTypes.sort(QUALITY_VALUE_COMPARATOR);
         }
     }
 
@@ -658,8 +658,7 @@ public static void sortByQualityValue(List<MediaType> mediaTypes) {
     public static void sortBySpecificityAndQuality(List<MediaType> mediaTypes) {
         Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
         if (mediaTypes.size() > 1) {
-            Collections.sort(mediaTypes,
-                    MediaType.SPECIFICITY_COMPARATOR.thenComparing(MediaType.QUALITY_VALUE_COMPARATOR));
+            mediaTypes.sort(MediaType.SPECIFICITY_COMPARATOR.thenComparing(MediaType.QUALITY_VALUE_COMPARATOR));
         }
     }
 
@@ -697,7 +696,7 @@ else if (!mediaType1.getSubtype().equals(mediaType2.getSubtype())) { // audio/ba
                 int paramsSize1 = mediaType1.getParameters().size();
                 int paramsSize2 = mediaType2.getParameters().size();
                 // audio/basic;level=1 < audio/basic
-                return (paramsSize2 < paramsSize1 ? -1 : (paramsSize2 == paramsSize1 ? 0 : 1));
+                return (Integer.compare(paramsSize2, paramsSize1));
             }
         }
     };

http/http-api/src/main/java/com/okta/commons/http/MimeType.java

@@ -224,7 +224,7 @@ private boolean isQuotedString(String s) {
             return false;
         }
         else {
-            return ((s.startsWith("\"") && s.endsWith("\"")) || (s.startsWith("'") && s.endsWith("'")));
+            return (s.charAt(0) == '"' && s.endsWith("\"")) || (s.charAt(0) == '\'' && s.endsWith("'"));
         }
     }
 
@@ -458,18 +458,13 @@ public String toString() {
     }
 
     protected void appendTo(StringBuilder builder) {
-        builder.append(this.type);
-        builder.append('/');
-        builder.append(this.subtype);
+        builder.append(this.type).append('/').append(this.subtype);
         appendTo(this.parameters, builder);
     }
 
     private void appendTo(Map<String, String> map, StringBuilder builder) {
         for (Map.Entry<String, String> entry : map.entrySet()) {
-            builder.append(';');
-            builder.append(entry.getKey());
-            builder.append('=');
-            builder.append(entry.getValue());
+            builder.append(';').append(entry.getKey()).append('=').append(entry.getValue());
         }
     }
 
@@ -570,7 +565,7 @@ else if (!mimeType1.getSubtype().equals(mimeType2.getSubtype())) { // audio/basi
         protected int compareParameters(T mimeType1, T mimeType2) {
             int paramsSize1 = mimeType1.getParameters().size();
             int paramsSize2 = mimeType2.getParameters().size();
-            return (paramsSize2 < paramsSize1 ? -1 : (paramsSize2 == paramsSize1 ? 0 : 1)); // audio/basic;level=1 < audio/basic
+            return (Integer.compare(paramsSize2, paramsSize1)); // audio/basic;level=1 < audio/basic
         }
     }
 

http/http-api/src/main/java/com/okta/commons/http/MimeTypeUtils.java

@@ -200,7 +200,7 @@ public static MimeType parseMimeType(String mimeType) {
             throw new InvalidMimeTypeException(mimeType, "does not contain subtype after '/'");
         }
         String type = fullType.substring(0, subIndex);
-        String subtype = fullType.substring(subIndex + 1, fullType.length());
+        String subtype = fullType.substring(subIndex + 1);
         if (MimeType.WILDCARD_TYPE.equals(type) && !MimeType.WILDCARD_TYPE.equals(subtype)) {
             throw new InvalidMimeTypeException(mimeType, "wildcard type is legal only in '*/*' (all mime types)");
         }
@@ -229,7 +229,7 @@ else if (ch == '"') {
                 int eqIndex = parameter.indexOf('=');
                 if (eqIndex >= 0) {
                     String attribute = parameter.substring(0, eqIndex);
-                    String value = parameter.substring(eqIndex + 1, parameter.length());
+                    String value = parameter.substring(eqIndex + 1);
                     parameters.put(attribute, value);
                 }
             }
@@ -312,7 +312,7 @@ public static String toString(Collection<? extends MimeType> mimeTypes) {
     public static void sortBySpecificity(List<MimeType> mimeTypes) {
         Assert.notNull(mimeTypes, "'mimeTypes' must not be null");
         if (mimeTypes.size() > 1) {
-            Collections.sort(mimeTypes, SPECIFICITY_COMPARATOR);
+            mimeTypes.sort(SPECIFICITY_COMPARATOR);
         }
     }
 

http/http-api/src/main/java/com/okta/commons/http/QueryString.java

@@ -91,7 +91,7 @@ public String toString(boolean canonical) {
                 sb.append('&');
             }
 
-            sb.append(key).append("=").append(value);
+            sb.append(key).append('=').append(value);
         }
 
         return sb.toString();

lang/src/main/java/com/okta/commons/lang/Assert.java

@@ -153,7 +153,7 @@ public static void hasText(String text) {
      */
     public static void doesNotContain(String textToSearch, String substring, String message) {
         if (Strings.hasLength(textToSearch) && Strings.hasLength(substring) &&
-                textToSearch.indexOf(substring) != -1) {
+            textToSearch.contains(substring)) {
             throw new IllegalArgumentException(message);
         }
     }
@@ -205,8 +205,8 @@ public static void notEmpty(Object[] array) {
      */
     public static void noNullElements(Object[] array, String message) {
         if (array != null) {
-            for (int i = 0; i < array.length; i++) {
-                if (array[i] == null) {
+            for (Object o : array) {
+                if (o == null) {
                     throw new IllegalArgumentException(message);
                 }
             }