Assorted tidying.

src/com/dmdirc/Channel.java

         // Needs to be published synchronously so that nicklists are cleared before the parser
         // is disconnected (which happens synchronously after this method returns).
         getEventBus().publish(
-                new NickListClientsChangedEvent(this, Collections.<GroupChatUser>emptyList()));
+                new NickListClientsChangedEvent(this, Collections.emptyList()));
     }
 
     @Override

src/com/dmdirc/FrameContainer.java

     /** The connection associated with this model. */
     private Optional<Connection> connection = Optional.empty();
     /** The ID for this window. */
-    @Nullable private String id = null;
+    @Nullable private String id;
 
     /**
      * Instantiate new frame container.
 
     @Override
     public String getId() {
-        if (this.id == null) {
+        if (id == null) {
             throw new IllegalStateException("ID has not been set");
         }
         return id;

src/com/dmdirc/commandline/CommandLineParser.java

             }
 
             System.out.print("   -" + arg[0] + needsArg);
-            System.out.println(" --" + desc + needsArg + " " + arg[2]);
+            System.out.println(" --" + desc + needsArg + ' ' + arg[2]);
             System.out.println();
         }
 

src/com/dmdirc/commandparser/CommandArguments.java

     public String getWordsAsString(final int start, final int end) {
         checkPositionIndex(start, end);
 
-        final Pattern pattern = Pattern.compile("(\\S+\\s+){" + start + "}"
+        final Pattern pattern = Pattern.compile("(\\S+\\s+){" + start + '}'
                 + "((\\S+\\s+){" + Math.max(0, end - start) + "}\\S+(\\s+$)?).*?");
         final Matcher matcher = pattern.matcher(line);
 

src/com/dmdirc/commandparser/commands/PreviousCommand.java

             return false;
         }
         final PreviousCommand other = (PreviousCommand) obj;
-        return Objects.equals(this.line, other.line) && this.time == other.time;
+        return Objects.equals(line, other.line) && time == other.time;
     }
 
 }

src/com/dmdirc/commandparser/commands/flags/CommandFlag.java

      * @param enabled The flags which will be enabled
      */
     public void addEnabled(final CommandFlag... enabled) {
-        this.enables.addAll(Arrays.asList(enabled));
+        enables.addAll(Arrays.asList(enabled));
     }
 
     /**
      * @param disabled The flags which will be disabled
      */
     public void addDisabled(final CommandFlag... disabled) {
-        this.disables.addAll(Arrays.asList(disabled));
+        disables.addAll(Arrays.asList(disabled));
     }
 
     /**

src/com/dmdirc/commandparser/commands/server/Umode.java

 
         connection.getParser().get().sendRawMessage("MODE "
                 + connection.getParser().get().getLocalClient().getNickname()
-                + " " + args.getArgumentsAsString());
+                + ' ' + args.getArgumentsAsString());
     }
 
 }

src/com/dmdirc/commandparser/parsers/QueryCommandParser.java

 package com.dmdirc.commandparser.parsers;
 
 import com.dmdirc.DMDircMBassador;
-import com.dmdirc.Query;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandType;

src/com/dmdirc/config/ConfigFileBackedConfigProvider.java

             final boolean forceDefault) throws IOException, InvalidIdentityFileException {
         this.identityManager = null;
         this.file = new ConfigFile(stream);
-        this.file.setAutomake(true);
+        file.setAutomake(true);
         initFile(forceDefault);
         myTarget = getTarget(forceDefault);
     }
             final ConfigFile configFile, final ConfigTarget target) {
         this.identityManager = identityManager;
         this.file = configFile;
-        this.file.setAutomake(true);
+        file.setAutomake(true);
         this.myTarget = target;
     }
 
     private void initFile(final boolean forceDefault)
             throws InvalidIdentityFileException, IOException {
         try {
-            this.file.read();
+            file.read();
         } catch (InvalidConfigFileException ex) {
             throw new InvalidIdentityFileException(ex);
         }

src/com/dmdirc/config/prefs/PreferencesSetting.java

 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
 /**
  * Represents a single setting.
      * Dismisses changes to this setting.
      */
     public void dismiss() {
-        if (original != null && original.equals(value)
-                || original == null && value == null) {
+        if (Objects.equals(original, value)) {
             return;
         }
 
      * @return true iif the setting will be changed if saved
      */
     public boolean needsSaving() {
-        return (value == null || !value.equals(original))
+        return (!Objects.equals(value, original))
                 && (value != null || original != null)
                 && (validator == null || !validator.validate(value).isFailure());
     }

src/com/dmdirc/interfaces/Connection.java

 
 import java.net.URI;
 import java.util.Collection;
-import java.util.Date;
 import java.util.Optional;
 
 import javax.annotation.Nonnull;

src/com/dmdirc/ui/core/about/CoreAboutDialogModel.java

 
 package com.dmdirc.ui.core.about;
 
-import com.dmdirc.ClientModule.GlobalConfig;
 import com.dmdirc.DMDircMBassador;
-import com.dmdirc.commandline.CommandLineOptionsModule;
 import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
+import com.dmdirc.commandline.CommandLineOptionsModule.DirectoryType;
 import com.dmdirc.commandline.CommandLineParser;
 import com.dmdirc.events.ClientInfoRequestEvent;
-import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.ui.AboutDialogModel;
 import com.dmdirc.plugins.PluginManager;
 import com.dmdirc.util.ClientInfo;
 public class CoreAboutDialogModel implements AboutDialogModel {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(CoreAboutDialogModel.class);
-    private final AggregateConfigProvider globalConfig;
     private final Path baseDirectory;
     private final ClientInfo clientInfo;
     private final DMDircMBassador eventBus;
     private final PluginManager pluginManager;
+    private final CommandLineParser commandLineParser;
     private String about;
     private List<Developer> mainDevelopers;
     private List<Developer> otherDevelopers;
     private List<InfoItem> info;
     private List<LicensedComponent> licences;
-    private CommandLineParser commandLineParser;
 
     @Inject
-    public CoreAboutDialogModel(@GlobalConfig final AggregateConfigProvider globalConfig,
-            @Directory(CommandLineOptionsModule.DirectoryType.BASE) final Path baseDirectory,
+    public CoreAboutDialogModel(@Directory(DirectoryType.BASE) final Path baseDirectory,
             final ClientInfo clientInfo, final DMDircMBassador eventBus,
             final PluginManager pluginManager, final CommandLineParser commandLineParser) {
-        this.globalConfig = globalConfig;
         this.baseDirectory = baseDirectory;
         this.clientInfo = clientInfo;
         this.eventBus = eventBus;

src/com/dmdirc/ui/core/aliases/CoreAliasDialogModel.java

         final Alias alias = aliases.get(name);
         aliases.remove(name);
         if (getSelectedAlias().isPresent() && getSelectedAlias().get().equals(alias)) {
-            setSelectedAlias(Optional.<Alias>empty());
+            setSelectedAlias(Optional.empty());
         }
         listeners.getCallable(AliasDialogModelListener.class).aliasRemoved(alias);
     }
 
     @Override
     public void save() {
-        setSelectedAlias(Optional.<Alias>empty());
+        setSelectedAlias(Optional.empty());
         aliasManager.getAliases().forEach(aliasManager::removeAlias);
         aliases.values().forEach(aliasManager::addAlias);
     }

src/com/dmdirc/ui/messages/Formatter.java

 
         final String res = config.hasOptionString("formatter", messageType)
                 ? config.getOption("formatter", messageType).replace("%-1$", "%"
-                        + arguments.length + "$") : null;
+                        + arguments.length + '$') : null;
 
         if (res == null) {
-            return "<No format string for message type " + messageType + ">";
+            return "<No format string for message type " + messageType + '>';
         } else {
             try {
                 final Object[] newArgs = castArguments(res, arguments);
                 return String.format(res.replaceAll("(%[0-9]+\\$)u", "$1s"), newArgs);
             } catch (IllegalFormatConversionException ex) {
                 return "<Invalid format string for message type " + messageType
-                        + "; Error: Illegal format conversion: " + ex.getMessage() + ">";
+                        + "; Error: Illegal format conversion: " + ex.getMessage() + '>';
             } catch (UnknownFormatConversionException ex) {
                 return "<Invalid format string for message type " + messageType
-                        + "; Error: Unknown format conversion: " + ex.getMessage() + ">";
+                        + "; Error: Unknown format conversion: " + ex.getMessage() + '>';
             } catch (MissingFormatArgumentException ex) {
                 return "<Invalid format string for message type " + messageType
-                        + "; Error: Missing format argument: " + ex.getMessage() + ">";
+                        + "; Error: Missing format argument: " + ex.getMessage() + '>';
             } catch (NumberFormatException ex) {
                 return "<Invalid format string for message type " + messageType
-                        + "; Error: Invalid number conversion: " + ex.getMessage() + ">";
+                        + "; Error: Invalid number conversion: " + ex.getMessage() + '>';
             }
         }
     }
         final Character[] types = new Character[args.length];
 
         for (int i = 0; i < args.length; i++) {
-            final int index = format.indexOf("%" + (i + 1) + "$");
+            final int index = format.indexOf("%" + (i + 1) + '$');
 
             if (index > -1) {
                 types[i] = format.charAt(index + 3);

src/com/dmdirc/ui/messages/IRCTextAttribute.java

      */
     protected IRCTextAttribute(final String name) {
         super(name);
-        if (this.getClass() == IRCTextAttribute.class) {
+        if (getClass() == IRCTextAttribute.class) {
             INSTANCE_MAP.put(name, this);
         }
     }
      */
     @Override
     protected Object readResolve() throws InvalidObjectException {
-        if (this.getClass() != IRCTextAttribute.class) {
+        if (getClass() != IRCTextAttribute.class) {
             throw new InvalidObjectException("subclass didn't correctly implement readResolve");
         }
 

src/com/dmdirc/updater/Version.java

 
     @Override
     public int compareTo(@Nonnull final Version o) {
-        if (o.intVersion > Integer.MIN_VALUE && this.intVersion > Integer.MIN_VALUE) {
-            return this.intVersion - o.intVersion;
-        } else if (o.strVersion == null && this.strVersion == null) {
+        if (o.intVersion > Integer.MIN_VALUE && intVersion > Integer.MIN_VALUE) {
+            return intVersion - o.intVersion;
+        } else if (o.strVersion == null && strVersion == null) {
             return 0;
-        } else if (o.strVersion == null && this.strVersion != null) {
+        } else if (o.strVersion == null && strVersion != null) {
             return 1;
-        } else if (o.strVersion != null && this.strVersion == null) {
+        } else if (o.strVersion != null && strVersion == null) {
             return -1;
         } else {
-            final String[] myParts = this.strVersion.split("-");
+            final String[] myParts = strVersion.split("-");
             final String[] thParts = o.strVersion.split("-");
 
             final String[] myFirstParts = myParts[0].split("\\.|(?=a|b|rc|m)");

src/com/dmdirc/updater/manager/DMDircUpdateManager.java

                 new LinkedBlockingQueue<>(), new NamedThreadFactory()),
                 consolidator, updatePolicy);
 
-        checkStrategies.forEach(DMDircUpdateManager.this::addCheckStrategy);
-
-        retrievalStrategies.forEach(DMDircUpdateManager.this::addRetrievalStrategy);
-
-        installationStrategies.forEach(DMDircUpdateManager.this::addInstallationStrategy);
-
-        components.forEach(DMDircUpdateManager.this::addComponent);
+        checkStrategies.forEach(this::addCheckStrategy);
+        retrievalStrategies.forEach(this::addRetrievalStrategy);
+        installationStrategies.forEach(this::addInstallationStrategy);
+        components.forEach(this::addComponent);
     }
 
     /**

src/com/dmdirc/updater/manager/UpdateManagerImpl.java

     @Override
     public void addCheckStrategy(final UpdateCheckStrategy strategy) {
         LOG.trace("Adding new check strategy: {}", strategy);
-        this.checkers.add(strategy);
+        checkers.add(strategy);
     }
 
     @Override
     public void addRetrievalStrategy(final UpdateRetrievalStrategy strategy) {
         LOG.trace("Adding new retrieval strategy: {}", strategy);
         strategy.addUpdateRetrievalListener(retrievalListener);
-        this.retrievers.add(strategy);
+        retrievers.add(strategy);
     }
 
     @Override
     public void addInstallationStrategy(final UpdateInstallationStrategy strategy) {
         LOG.trace("Adding new installation strategy: {}", strategy);
         strategy.addUpdateInstallationListener(installationListener);
-        this.installers.add(strategy);
+        installers.add(strategy);
     }
 
     @Override
     public void addComponent(final UpdateComponent component) {
         LOG.trace("Adding new component: {}", component);
         synchronized (componentsLock) {
-            this.components.put(component.getName(), component);
+            components.put(component.getName(), component);
         }
     }
 
     public void removeComponent(final UpdateComponent component) {
         LOG.trace("Removing component: {}", component);
         synchronized (componentsLock) {
-            this.components.remove(component.getName());
+            components.remove(component.getName());
         }
 
-        this.checkResults.remove(component);
-        this.retrievalResults.remove(component);
+        checkResults.remove(component);
+        retrievalResults.remove(component);
     }
 
     @Override
     public Collection<UpdateComponent> getComponents() {
         synchronized (componentsLock) {
-            return Collections.unmodifiableCollection(this.components.values());
+            return Collections.unmodifiableCollection(components.values());
         }
     }
 

src/com/dmdirc/util/resourcemanager/ResourceManager.java

         } else if (url.startsWith("jar://") || url.startsWith("zip://")) {
             return new ZipResourceManager(url.substring(6));
         } else {
-            throw new IllegalArgumentException("Unknown resource manager type (" + url + ")");
+            throw new IllegalArgumentException("Unknown resource manager type (" + url + ')');
         }
     }
 
 
         if (usePath && resourceName.indexOf('/') > -1) {
             newDir = new File(directory,
-                    resourceName.substring(0, resourceName.lastIndexOf('/')) + "/");
+                    resourceName.substring(0, resourceName.lastIndexOf('/')) + '/');
         } else {
             newDir = new File(directory);
         }

src/com/dmdirc/util/resourcemanager/ZipResourceManager.java

     @Override
     public URL getResourceURL(final String resource) throws MalformedURLException {
         if (resourceExists(resource)) {
-            return new URL("jar:file:/" + zipFile.getName() + "!"
-                    + (resource.charAt(0) == '/' ? resource : "/" + resource));
+            return new URL("jar:file:/" + zipFile.getName() + '!'
+                    + (resource.charAt(0) == '/' ? resource : '/' + resource));
         } else {
             return null;
         }

test/com/dmdirc/ui/core/about/CoreAboutDialogModelTest.java

 
 import com.dmdirc.DMDircMBassador;
 import com.dmdirc.commandline.CommandLineParser;
-import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.plugins.PluginManager;
 import com.dmdirc.plugins.PluginMetaData;
 public class CoreAboutDialogModelTest {
 
     @Mock private ClientInfo clientInfo;
-    @Mock private AggregateConfigProvider globalConfig;
     @Mock private Path path;
     @Mock private DMDircMBassador eventBus;
     @Mock private PluginManager pluginManager;
         when(clientInfo.getVersionInformation()).thenReturn("DMDirc Version");
         when(clientInfo.getOperatingSystemInformation()).thenReturn("OS Version");
         when(clientInfo.getJavaInformation()).thenReturn("Java Version");
-        when(globalConfig.getOption("identity", "modealiasversion")).thenReturn("ModeAlias Version");
         when(pluginManager.getPluginInfos()).thenReturn(Lists.newArrayList(pluginInfo1, pluginInfo2));
         when(pluginInfo1.getPath("/META-INF/licences/")).thenReturn(pluginPath1);
         when(pluginInfo2.getPath("/META-INF/licences/")).thenReturn(pluginPath2);
         when(pluginMetaData1.getFriendlyName()).thenReturn("Plugin1");
         when(pluginMetaData2.getFriendlyName()).thenReturn("Plugin2");
         when(commandLineParser.getLauncherVersion()).thenReturn(Optional.of("Unknown"));
-        instance = new CoreAboutDialogModel(globalConfig, path, clientInfo, eventBus,
-                pluginManager, commandLineParser);
+        instance = new CoreAboutDialogModel(path, clientInfo, eventBus, pluginManager,
+                commandLineParser);
         instance.load();
     }