Optimize imports

Reformatted code (Java convention; tab is 4 spaces)

pom.xml

@@ -1,4 +1,5 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>org.ahocorasick</groupId>

src/main/java/org/ahocorasick/interval/Interval.java

@@ -67,7 +67,7 @@ public class Interval implements Intervalable {
         if (!(o instanceof Intervalable)) {
             return false;
         }
-        Intervalable other = (Intervalable)o;
+        Intervalable other = (Intervalable) o;
         return this.start == other.getStart() &&
                 this.end == other.getEnd();
     }
@@ -82,7 +82,7 @@ public class Interval implements Intervalable {
         if (!(o instanceof Intervalable)) {
             return -1;
         }
-        Intervalable other = (Intervalable)o;
+        Intervalable other = (Intervalable) o;
         int comparison = this.start - other.getStart();
         return comparison != 0 ? comparison : this.end - other.getEnd();
     }

src/main/java/org/ahocorasick/interval/IntervalNode.java

@@ -6,7 +6,7 @@ import java.util.List;
 
 public class IntervalNode {
 
-    private enum Direction { LEFT, RIGHT }
+    private enum Direction {LEFT, RIGHT}
 
     private IntervalNode left = null;
     private IntervalNode right = null;
@@ -93,12 +93,12 @@ public class IntervalNode {
         List<Intervalable> overlaps = new ArrayList<Intervalable>();
         for (Intervalable currentInterval : this.intervals) {
             switch (direction) {
-                case LEFT :
+                case LEFT:
                     if (currentInterval.getStart() <= interval.getEnd()) {
                         overlaps.add(currentInterval);
                     }
                     break;
-                case RIGHT :
+                case RIGHT:
                     if (currentInterval.getEnd() >= interval.getStart()) {
                         overlaps.add(currentInterval);
                     }

src/main/java/org/ahocorasick/interval/Intervalable.java

@@ -3,7 +3,9 @@ package org.ahocorasick.interval;
 public interface Intervalable extends Comparable {
 
     public int getStart();
+
     public int getEnd();
+
     public int size();
 
 }

src/main/java/org/ahocorasick/trie/State.java

@@ -6,7 +6,7 @@ import java.util.*;
  * <p>
  * A state has various important tasks it must attend to:
  * </p>
- *
+ * <p>
  * <ul>
  * <li>success; when a character points to another state, it must return that state</li>
  * <li>failure; when a character has no matching state, the algorithm must be able to fall back on a
@@ -14,7 +14,7 @@ import java.util.*;
  * <li>emits; when this state is passed and keywords have been matched, the matches must be
  * 'emitted' so that they can be used later on.</li>
  * </ul>
- *
+ * <p>
  * <p>
  * The root state is special in the sense that it has no failure state; it cannot fail. If it 'fails'
  * it will still parse the next character and start from the root node. This ensures that the algorithm
@@ -25,22 +25,30 @@ import java.util.*;
  */
 public class State {
 
-    /** effective the size of the keyword */
+    /**
+     * effective the size of the keyword
+     */
     private final int depth;
 
-    /** only used for the root state to refer to itself in case no matches have been found */
+    /**
+     * only used for the root state to refer to itself in case no matches have been found
+     */
     private final State rootState;
 
     /**
      * referred to in the white paper as the 'goto' structure. From a state it is possible to go
      * to other states, depending on the character passed.
      */
-    private final Map<Character,State> success = new HashMap<>();
+    private final Map<Character, State> success = new HashMap<>();
 
-    /** if no matching states are found, the failure state will be returned */
+    /**
+     * if no matching states are found, the failure state will be returned
+     */
     private State failure;
 
-    /** whenever this state is reached, it will emit the matches keywords for future reference */
+    /**
+     * whenever this state is reached, it will emit the matches keywords for future reference
+     */
     private Set<String> emits;
 
     public State() {
@@ -70,7 +78,7 @@ public class State {
         return nextState(character, true);
     }
 
-    public State addState( String keyword ) {
+    public State addState(String keyword) {
         State state = this;
 
         for (final Character character : keyword.toCharArray()) {
@@ -83,7 +91,7 @@ public class State {
     public State addState(Character character) {
         State nextState = nextStateIgnoreRootState(character);
         if (nextState == null) {
-            nextState = new State(this.depth+1);
+            nextState = new State(this.depth + 1);
             this.success.put(character, nextState);
         }
         return nextState;
@@ -107,7 +115,7 @@ public class State {
     }
 
     public Collection<String> emit() {
-        return this.emits == null ? Collections.<String> emptyList() : this.emits;
+        return this.emits == null ? Collections.<String>emptyList() : this.emits;
     }
 
     public State failure() {

src/main/java/org/ahocorasick/trie/Trie.java

@@ -1,15 +1,17 @@
 package org.ahocorasick.trie;
 
-import static java.lang.Character.isWhitespace;
+import org.ahocorasick.interval.IntervalTree;
+import org.ahocorasick.interval.Intervalable;
+import org.ahocorasick.trie.handler.DefaultEmitHandler;
+import org.ahocorasick.trie.handler.EmitHandler;
+
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Queue;
 import java.util.concurrent.LinkedBlockingDeque;
-import org.ahocorasick.interval.IntervalTree;
+
-import org.ahocorasick.interval.Intervalable;
+import static java.lang.Character.isWhitespace;
-import org.ahocorasick.trie.handler.DefaultEmitHandler;
-import org.ahocorasick.trie.handler.EmitHandler;
 
 /**
  * Based on the Aho-Corasick white paper, Bell technologies:
@@ -32,15 +34,14 @@ public class Trie {
      * Used by the builder to add a text search keyword.
      *
      * @param keyword The search term to add to the list of search terms.
-     * 
      * @throws NullPointerException if the keyword is null.
      */
     private void addKeyword(String keyword) {
-        if( keyword.isEmpty() ) {
+        if (keyword.isEmpty()) {
             return;
         }
 
-        if( isCaseInsensitive() ) {
+        if (isCaseInsensitive()) {
             keyword = keyword.toLowerCase();
         }
 
@@ -52,9 +53,9 @@ public class Trie {
      *
      * @param keywords List of search term to add to the list of search terms.
      */
-    private void addKeywords( final String[] keywords ) {
+    private void addKeywords(final String[] keywords) {
-      for( final String keyword : keywords ) {
+        for (final String keyword : keywords) {
-        addKeyword( keyword );
+            addKeyword(keyword);
         }
     }
 
@@ -63,9 +64,9 @@ public class Trie {
      *
      * @param keywords List of search term to add to the list of search terms.
      */
-    private void addKeywords( final Collection<String> keywords ) {
+    private void addKeywords(final Collection<String> keywords) {
-      for( final String keyword : keywords ) {
+        for (final String keyword : keywords) {
-        addKeyword( keyword );
+            addKeyword(keyword);
         }
     }
 
@@ -95,11 +96,11 @@ public class Trie {
     }
 
     private Token createFragment(final Emit emit, final String text, final int lastCollectedPosition) {
-        return new FragmentToken(text.substring(lastCollectedPosition+1, emit == null ? text.length() : emit.getStart()));
+        return new FragmentToken(text.substring(lastCollectedPosition + 1, emit == null ? text.length() : emit.getStart()));
     }
 
     private Token createMatch(Emit emit, String text) {
-        return new MatchToken(text.substring(emit.getStart(), emit.getEnd()+1), emit);
+        return new MatchToken(text.substring(emit.getStart(), emit.getEnd() + 1), emit);
     }
 
     @SuppressWarnings("unchecked")
@@ -118,7 +119,7 @@ public class Trie {
         }
 
         if (!trieConfig.isAllowOverlaps()) {
-            IntervalTree intervalTree = new IntervalTree((List<Intervalable>)(List<?>)collectedEmits);
+            IntervalTree intervalTree = new IntervalTree((List<Intervalable>) (List<?>) collectedEmits);
             intervalTree.removeOverlaps((List<Intervalable>) (List<?>) collectedEmits);
         }
 
@@ -314,7 +315,8 @@ public class Trie {
         /**
          * Default (empty) constructor.
          */
-        private TrieBuilder() {}
+        private TrieBuilder() {
+        }
 
         /**
          * Configure the Trie to ignore case when searching for keywords in
@@ -343,7 +345,6 @@ public class Trie {
          * Adds a keyword to the Trie's list of text search keywords.
          *
          * @param keyword The keyword to add to the list.
-         * 
          * @return This builder.
          * @throws NullPointerException if the keyword is null.
          */
@@ -356,7 +357,6 @@ public class Trie {
          * Adds a list of keywords to the Trie's list of text search keywords.
          *
          * @param keywords The keywords to add to the list.
-         * 
          * @return This builder.
          */
         public TrieBuilder addKeywords(final String... keywords) {
@@ -368,7 +368,6 @@ public class Trie {
          * Adds a list of keywords to the Trie's list of text search keywords.
          *
          * @param keywords The keywords to add to the list.
-         * 
          * @return This builder.
          */
         public TrieBuilder addKeywords(final Collection<String> keywords) {
@@ -420,18 +419,16 @@ public class Trie {
         }
 
         /**
-         * @deprecated Use ignoreCase()
-         * 
          * @return This builder.
+         * @deprecated Use ignoreCase()
          */
         public TrieBuilder caseInsensitive() {
             return ignoreCase();
         }
 
         /**
-         * @deprecated Use ignoreOverlaps()
-         * 
          * @return This builder.
+         * @deprecated Use ignoreOverlaps()
          */
         public TrieBuilder removeOverlaps() {
             return ignoreOverlaps();

src/main/java/org/ahocorasick/trie/TrieConfig.java

@@ -12,9 +12,13 @@ public class TrieConfig {
 
     private boolean stopOnHit = false;
 
-    public boolean isStopOnHit() { return stopOnHit; }
+    public boolean isStopOnHit() {
+        return stopOnHit;
+    }
 
-    public void setStopOnHit(boolean stopOnHit) { this.stopOnHit = stopOnHit; }
+    public void setStopOnHit(boolean stopOnHit) {
+        this.stopOnHit = stopOnHit;
+    }
 
     public boolean isAllowOverlaps() {
         return allowOverlaps;
@@ -32,7 +36,9 @@ public class TrieConfig {
         this.onlyWholeWords = onlyWholeWords;
     }
 
-    public boolean isOnlyWholeWordsWhiteSpaceSeparated() { return onlyWholeWordsWhiteSpaceSeparated; }
+    public boolean isOnlyWholeWordsWhiteSpaceSeparated() {
+        return onlyWholeWordsWhiteSpaceSeparated;
+    }
 
     public void setOnlyWholeWordsWhiteSpaceSeparated(boolean onlyWholeWordsWhiteSpaceSeparated) {
         this.onlyWholeWordsWhiteSpaceSeparated = onlyWholeWordsWhiteSpaceSeparated;

src/test/java/org/ahocorasick/interval/IntervalTest.java

@@ -2,29 +2,29 @@ package org.ahocorasick.interval;
 
 import org.junit.Test;
 
-import java.util.*;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.TreeSet;
 
-import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.*;
-import static junit.framework.Assert.assertFalse;
-import static junit.framework.Assert.assertTrue;
 
 public class IntervalTest {
 
     @Test
     public void construct() {
-        Interval i = new Interval(1,3);
+        Interval i = new Interval(1, 3);
         assertEquals(1, i.getStart());
         assertEquals(3, i.getEnd());
     }
 
     @Test
     public void size() {
-        assertEquals(3, new Interval(0,2).size());
+        assertEquals(3, new Interval(0, 2).size());
     }
 
     @Test
     public void intervaloverlaps() {
-        assertTrue(new Interval(1,3).overlapsWith(new Interval(2,4)));
+        assertTrue(new Interval(1, 3).overlapsWith(new Interval(2, 4)));
     }
 
     @Test
@@ -34,7 +34,7 @@ public class IntervalTest {
 
     @Test
     public void pointOverlaps() {
-        assertTrue(new Interval(1,3).overlapsWith(2));
+        assertTrue(new Interval(1, 3).overlapsWith(2));
     }
 
     @Test

src/test/java/org/ahocorasick/interval/IntervalTreeTest.java

@@ -20,7 +20,7 @@ public class IntervalTreeTest {
         intervals.add(new Interval(4, 6));
         intervals.add(new Interval(5, 7));
         IntervalTree intervalTree = new IntervalTree(intervals);
-        List<Intervalable> overlaps = intervalTree.findOverlaps(new Interval(1,3));
+        List<Intervalable> overlaps = intervalTree.findOverlaps(new Interval(1, 3));
         assertEquals(3, overlaps.size());
         Iterator<Intervalable> overlapsIt = overlaps.iterator();
         assertOverlap(overlapsIt.next(), 2, 4);

src/test/java/org/ahocorasick/interval/IntervalableComparatorByPositionTest.java

@@ -13,9 +13,9 @@ public class IntervalableComparatorByPositionTest {
     @Test
     public void sortOnPosition() {
         List<Intervalable> intervals = new ArrayList<Intervalable>();
-        intervals.add(new Interval(4,5));
+        intervals.add(new Interval(4, 5));
-        intervals.add(new Interval(1,4));
+        intervals.add(new Interval(1, 4));
-        intervals.add(new Interval(3,8));
+        intervals.add(new Interval(3, 8));
         Collections.sort(intervals, new IntervalableComparatorByPosition());
         assertEquals(4, intervals.get(0).size());
         assertEquals(6, intervals.get(1).size());

src/test/java/org/ahocorasick/interval/IntervalableComparatorBySizeTest.java

@@ -13,9 +13,9 @@ public class IntervalableComparatorBySizeTest {
     @Test
     public void sortOnSize() {
         List<Intervalable> intervals = new ArrayList<Intervalable>();
-        intervals.add(new Interval(4,5));
+        intervals.add(new Interval(4, 5));
-        intervals.add(new Interval(1,4));
+        intervals.add(new Interval(1, 4));
-        intervals.add(new Interval(3,8));
+        intervals.add(new Interval(3, 8));
         Collections.sort(intervals, new IntervalableComparatorBySize());
         assertEquals(6, intervals.get(0).size());
         assertEquals(4, intervals.get(1).size());
@@ -25,8 +25,8 @@ public class IntervalableComparatorBySizeTest {
     @Test
     public void sortOnSizeThenPosition() {
         List<Intervalable> intervals = new ArrayList<Intervalable>();
-        intervals.add(new Interval(4,7));
+        intervals.add(new Interval(4, 7));
-        intervals.add(new Interval(2,5));
+        intervals.add(new Interval(2, 5));
         Collections.sort(intervals, new IntervalableComparatorBySize());
         assertEquals(2, intervals.get(0).getStart());
         assertEquals(4, intervals.get(1).getStart());

src/test/java/org/ahocorasick/trie/StateTest.java

@@ -1,6 +1,5 @@
 package org.ahocorasick.trie;
 
-import org.ahocorasick.trie.State;
 import org.junit.Test;
 
 import static junit.framework.Assert.assertEquals;

src/test/java/org/ahocorasick/trie/TrieTest.java

@@ -1,14 +1,16 @@
 package org.ahocorasick.trie;
 
+import org.ahocorasick.trie.handler.EmitHandler;
+import org.junit.Test;
+
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.ThreadLocalRandom;
+
 import static junit.framework.Assert.assertEquals;
-import org.ahocorasick.trie.handler.EmitHandler;
 import static org.junit.Assert.assertTrue;
-import org.junit.Test;
 
 public class TrieTest {
     private final static String[] ALPHABET = new String[]{
@@ -406,7 +408,7 @@ public class TrieTest {
                 .onlyWholeWordsWhiteSpaceSeparated()
                 .addKeyword("#sugar-123")
                 .build();
-        Collection < Emit > emits = trie.parseText("#sugar-123 #sugar-1234"); // left, middle, right test
+        Collection<Emit> emits = trie.parseText("#sugar-123 #sugar-1234"); // left, middle, right test
         assertEquals(1, emits.size()); // Match must not be made
         checkEmit(emits.iterator().next(), 0, 9, "#sugar-123");
     }
@@ -415,19 +417,19 @@ public class TrieTest {
     public void testLargeString() {
         final int interval = 100;
         final int textSize = 1000000;
-        final String keyword = FOOD[ 1 ];
+        final String keyword = FOOD[1];
-        final StringBuilder text = randomNumbers( textSize );
+        final StringBuilder text = randomNumbers(textSize);
 
-        injectKeyword( text, keyword, interval );
+        injectKeyword(text, keyword, interval);
 
         Trie trie = Trie.builder()
                 .onlyWholeWords()
-            .addKeyword( keyword )
+                .addKeyword(keyword)
                 .build();
 
-        final Collection<Emit> emits = trie.parseText( text );
+        final Collection<Emit> emits = trie.parseText(text);
 
-        assertEquals( textSize / interval, emits.size() );
+        assertEquals(textSize / interval, emits.size());
     }
 
     /**
@@ -436,11 +438,11 @@ public class TrieTest {
      * @param count The number of numbers to generate.
      * @return A character sequence filled with random digits.
      */
-    private StringBuilder randomNumbers( int count ) {
+    private StringBuilder randomNumbers(int count) {
-        final StringBuilder sb = new StringBuilder( count );
+        final StringBuilder sb = new StringBuilder(count);
 
-        while( --count > 0 ) {
+        while (--count > 0) {
-            sb.append( randomInt( 0, 10 ) );
+            sb.append(randomInt(0, 10));
         }
 
         return sb;
@@ -457,15 +459,15 @@ public class TrieTest {
     private void injectKeyword(
             final StringBuilder source,
             final String keyword,
-        final int interval ) {
+            final int interval) {
         final int length = source.length();
-        for( int i = 0; i < length; i += interval ) {
+        for (int i = 0; i < length; i += interval) {
-            source.replace( i, i + keyword.length(), keyword );
+            source.replace(i, i + keyword.length(), keyword);
         }
     }
 
-    private int randomInt( final int min, final int max ) {
+    private int randomInt(final int min, final int max) {
-        return ThreadLocalRandom.current().nextInt( min, max );
+        return ThreadLocalRandom.current().nextInt(min, max);
     }
 
     private void checkEmit(Emit next, int expectedStart, int expectedEnd, String expectedKeyword) {