diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionErrorReporter.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionErrorReporter.java
index c0c90ee..0749b51 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionErrorReporter.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionErrorReporter.java
@@ -63,6 +63,7 @@
 
 	class PomResourceDeltaVisitor implements IResourceDeltaVisitor {
 
+		@Override
 		public boolean visit(IResourceDelta delta) {
 			if (delta != null) {
 				IResource resource = delta.getResource();
@@ -140,7 +141,7 @@
 	 */
 	class PomVersionHandler extends DefaultHandler {
 		private Version version;
-		private Stack<String> elements = new Stack<String>();
+		private Stack<String> elements = new Stack<>();
 		private boolean checkVersion = false;
 		private boolean isFeatureProject = false;
 		private Locator locator;
@@ -350,7 +351,7 @@
 			// Get the manifest version
 			Version bundleVersion = Version.emptyVersion;
 			try {
-				Map<String, String> headers = new HashMap<String, String>();
+				Map<String, String> headers = new HashMap<>();
 				ManifestElement.parseBundleManifest(manifest.getContents(), headers);
 				String ver = headers.get(Constants.BUNDLE_VERSION);
 				if(ver == null) {
@@ -426,7 +427,7 @@
 	 */
 	void reportMarker(String message, int lineNumber, int charStart, int charEnd, String correctedVersion, IFile pom, String severity) {
 		try {
-			HashMap<String, Object> attributes = new HashMap<String, Object>();
+			HashMap<String, Object> attributes = new HashMap<>();
 			attributes.put(IMarker.MESSAGE, message);
 			if (severity.equals(IPomVersionConstants.VALUE_WARNING)){
 				attributes.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
@@ -474,9 +475,7 @@
 		return null;
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
-	 */
+	@Override
 	public void resourceChanged(IResourceChangeEvent event) {
 		IResourceDelta delta = event.getDelta();
 		if(delta != null) {
@@ -489,9 +488,7 @@
 		}
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)
-	 */
+	@Override
 	public void preferenceChange(PreferenceChangeEvent event) {
 		if(IPomVersionConstants.POM_VERSION_ERROR_LEVEL.equals(event.getKey())) {
 			final String newSeverity = (String) event.getNewValue();
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionMarkerResolution.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionMarkerResolution.java
index a4a143a..7899be1 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionMarkerResolution.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionMarkerResolution.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- *  Copyright (c) 2013 IBM Corporation and others.
+ *  Copyright (c) 2013, 2016 IBM Corporation and others.
  *  All rights reserved. This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License v1.0
  *  which accompanies this distribution, and is available at
@@ -10,25 +10,20 @@
  *******************************************************************************/
 package org.eclipse.releng.internal.tools.pomversion;
 
-import org.eclipse.osgi.util.NLS;
-import org.eclipse.releng.tools.RelEngPlugin;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.NullProgressMonitor;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IMarker;
-import org.eclipse.core.resources.IResource;
-
 import org.eclipse.core.filebuffers.FileBuffers;
 import org.eclipse.core.filebuffers.ITextFileBuffer;
 import org.eclipse.core.filebuffers.ITextFileBufferManager;
 import org.eclipse.core.filebuffers.LocationKind;
-
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.IDocument;
-
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.releng.tools.RelEngPlugin;
 import org.eclipse.ui.IMarkerResolution;
 
 
@@ -49,16 +44,12 @@
 		this.correctedVersion = correctedVersion;
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IMarkerResolution#getLabel()
-	 */
+	@Override
 	public String getLabel() {
 		return NLS.bind(Messages.PomVersionMarkerResolution_label, correctedVersion);
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IMarkerResolution#run(org.eclipse.core.resources.IMarker)
-	 */
+	@Override
 	public void run(IMarker marker) {
 		if (correctedVersion == null || correctedVersion.trim().length() == 0) {
 			return;
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionResolutionGenerator.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionResolutionGenerator.java
index be723f0..2c8cbf4 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionResolutionGenerator.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/PomVersionResolutionGenerator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 IBM Corporation and others.
+ * Copyright (c) 2013, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -21,6 +21,7 @@
 
 	private static IMarkerResolution[] NO_RESOLUTIONS = new IMarkerResolution[0];
 
+	@Override
 	public IMarkerResolution[] getResolutions(IMarker marker) {
 		int charstart = marker.getAttribute(IMarker.CHAR_START, -1);
 		int charend = marker.getAttribute(IMarker.CHAR_END, -1);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/RelEngPluginEarlyStartup.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/RelEngPluginEarlyStartup.java
index b2f8dcc..eb0488f 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/RelEngPluginEarlyStartup.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/internal/tools/pomversion/RelEngPluginEarlyStartup.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 IBM Corporation and others.
+ * Copyright (c) 2013, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -15,9 +15,7 @@
 
 public class RelEngPluginEarlyStartup implements IStartup {
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IStartup#earlyStartup()
-	 */
+	@Override
 	public void earlyStartup() {
 	}
 }
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/AdvancedCopyrightComment.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/AdvancedCopyrightComment.java
index 33e36d0..009c5d2 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/AdvancedCopyrightComment.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/AdvancedCopyrightComment.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2004, 2014 IBM Corporation and others.
+ * Copyright (c) 2004, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -100,14 +100,12 @@
             return null;
 
         StringWriter out = new StringWriter();
-        PrintWriter writer = new PrintWriter(out);
-        try {
+        
+        try (PrintWriter writer = new PrintWriter(out)) {
             writeCommentStart(writer);
             writeLegal(writer, linePrefix);
             writeCommentEnd(writer);
             return out.toString();
-        } finally {
-            writer.close();
         }
     }
 
@@ -247,7 +245,7 @@
     private static String[] getLegalLines() {
         StringTokenizer st = new StringTokenizer(getPreferenceStore().getString(
                 RelEngCopyrightConstants.COPYRIGHT_TEMPLATE_KEY), NEW_LINE, true);
-        ArrayList<String> lines = new ArrayList<String>();
+        ArrayList<String> lines = new ArrayList<>();
         String previous = NEW_LINE;
         while (st.hasMoreTokens()) {
             String current = st.nextToken();
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/AdvancedFixCopyrightAction.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/AdvancedFixCopyrightAction.java
index 102e524..71d23be 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/AdvancedFixCopyrightAction.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/AdvancedFixCopyrightAction.java
@@ -77,6 +77,7 @@
 			this.monitor = monitor;
 		}
 
+		@Override
 		public boolean visit(IResource resource) throws CoreException {
 			if (!monitor.isCanceled()) {
 				if (resource.getType() == IResource.FILE) {
@@ -100,6 +101,7 @@
 			this.fileCount = 0;
 		}
 
+		@Override
 		public boolean visit(IResource resource) throws CoreException {
 			if (resource.getType() == IResource.FILE) {
 				fileCount += UNIT_OF_WORK;
@@ -113,7 +115,7 @@
 	}
 
 	private String newLine = System.getProperty("line.separator"); //$NON-NLS-1$
-	private Map<String, List<String>> log = new HashMap<String, List<String>>();
+	private Map<String, List<String>> log = new HashMap<>();
 	private MessageConsole console;
 
 	// The current selection
@@ -129,7 +131,7 @@
 	protected IResource[] getSelectedResources() {
 		ArrayList<IResource> resources = null;
 		if (!selection.isEmpty()) {
-			resources = new ArrayList<IResource>();
+			resources = new ArrayList<>();
 			Iterator<?> elements = selection.iterator();
 			while (elements.hasNext()) {
 				addResource(elements.next(), resources);
@@ -160,14 +162,16 @@
 	/**
 	 * @see IObjectActionDelegate#setActivePart(IAction, IWorkbenchPart)
 	 */
+	@Override
 	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
 	}
 
 	/**
 	 * @see IActionDelegate#run(IAction)
 	 */
+	@Override
 	public void run(IAction action) {
-		log = new HashMap<String, List<String>>();
+		log = new HashMap<>();
 		console = new FixConsole();
 		ConsolePlugin.getDefault().getConsoleManager().addConsoles(new IConsole[] {console});
 		try {
@@ -200,7 +204,7 @@
 					} else {
 						adapter.initialize(SubMonitor.convert(monitor, 100));
 					}
-					List<CoreException> exceptions = new ArrayList<CoreException>();
+					List<CoreException> exceptions = new ArrayList<>();
 					for (int i = 0; i < results.length; i++) {
 						IResource resource = results[i];
 						stream.println(NLS.bind(
@@ -223,7 +227,7 @@
 						if (exceptions.size() == 1) {
 							throw exceptions.get(0);
 						} else {
-							List<Status> status = new ArrayList<Status>();
+							List<Status> status = new ArrayList<>();
 							for (Iterator<CoreException> iterator = exceptions.iterator(); iterator
 									.hasNext();) {
 								CoreException ce = iterator.next();
@@ -548,7 +552,7 @@
 			String errorDescription) {
 		List<String> aList = log.get(errorDescription);
 		if (aList == null) {
-			aList = new ArrayList<String>();
+			aList = new ArrayList<>();
 			log.put(errorDescription, aList);
 		}
 		aList.add(file.getFullPath().toString());
@@ -557,6 +561,7 @@
 	/**
 	 * @see IActionDelegate#selectionChanged(IAction, ISelection)
 	 */
+	@Override
 	public void selectionChanged(IAction action, ISelection selection) {
 		if (selection instanceof IStructuredSelection) {
 			this.selection = (IStructuredSelection) selection;
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/BlockComment.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/BlockComment.java
index 8a7feb1..d558aa8 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/BlockComment.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/BlockComment.java
@@ -27,7 +27,7 @@
 	private String contents;
 	private static String newLine = System.getProperty("line.separator"); //$NON-NLS-1$
 	private String copyrightHolder;
-	private List<String> nonIBMContributors = new ArrayList<String>();
+	private List<String> nonIBMContributors = new ArrayList<>();
 	private String commentEnd;
 
 	
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/BuildNotesPage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/BuildNotesPage.java
index 3fdffb1..80e1fdf 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/BuildNotesPage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/BuildNotesPage.java
@@ -89,6 +89,7 @@
 		this.settings = settings;
 	}
 
+	@Override
 	public void createControl(Composite parent) {
 		GridData data = new GridData(GridData.FILL_BOTH);
 		Composite composite = new Composite(parent, SWT.NONE);
@@ -247,15 +248,12 @@
 							buffer.append("<h1>Eclipse Platform Build Notes (3.3)<br>\n");
 							buffer.append("JFace and Workbench</h1>");
 
-							ByteArrayInputStream c = new ByteArrayInputStream(buffer.toString().getBytes());
-							try {
-								file.create(c, true, monitor);
-							} catch (CoreException e1) {
-								CVSUIPlugin.openError(getShell(), null, null, e1);
-							}
-
-							try {
-								c.close();
+							try (ByteArrayInputStream c = new ByteArrayInputStream(buffer.toString().getBytes())) {
+								try {
+									file.create(c, true, monitor);
+								} catch (CoreException e1) {
+									CVSUIPlugin.openError(getShell(), null, null, e1);
+								}
 							} catch (IOException e2) {
 								CVSUIPlugin.openError(getShell(), null, null, e2);
 							}
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CVSCopyrightAdapterFactory.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CVSCopyrightAdapterFactory.java
index b5c576f..c3c7a1e 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CVSCopyrightAdapterFactory.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CVSCopyrightAdapterFactory.java
@@ -19,6 +19,7 @@
 
 	private static final Class<?>[] ADAPTER_LIST = new Class[] { IRepositoryProviderCopyrightAdapterFactory.class };
 
+	@Override
 	@SuppressWarnings("unchecked")
 	public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
 		if (IRepositoryProviderCopyrightAdapterFactory.class
@@ -34,10 +35,12 @@
 		return this;
 	}
 
+	@Override
 	public Class<?>[] getAdapterList() {
 		return ADAPTER_LIST;
 	}
 
+	@Override
 	public RepositoryProviderCopyrightAdapter createAdapater(
 			IResource[] resources) {
 		return new CVSCopyrightAdapter(resources);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CVSTagHelper.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CVSTagHelper.java
index 8bd726a..8c8d478 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CVSTagHelper.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CVSTagHelper.java
@@ -30,7 +30,7 @@
 
 	//Returns an array of CVSTags for which no map entry could be found
 	public CVSTag[] findMissingMapEntries(IResource[] resources) {
-		defaultTags = new ArrayList<IResource>();
+		defaultTags = new ArrayList<>();
 		CVSTag[] tags = new CVSTag[resources.length];
 		for (int i = 0; i < resources.length; i++) {
 			tags[i] = getTag(resources[i]);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CommitCommentPage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CommitCommentPage.java
index 44810da..f1dab9b 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CommitCommentPage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/CommitCommentPage.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * Copyright (c) 2000, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -34,6 +34,7 @@
 		commitCommentArea = new CommitCommentArea();
 	}
 
+	@Override
 	public void createControl(Composite parent) {
 		Composite top = new Composite(parent, SWT.NONE);
 		top.setLayout(new GridLayout());
@@ -46,9 +47,6 @@
 		return commitCommentArea.getComment(true);
 	}
 	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean)
-	 */
 	@Override
 	public void setVisible(boolean visible) {
 		super.setVisible(visible);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/FixPageParticipant.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/FixPageParticipant.java
index 80e2826..eddefef 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/FixPageParticipant.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/FixPageParticipant.java
@@ -18,10 +18,12 @@
 
 public class FixPageParticipant implements IConsolePageParticipant {
 
+	@Override
 	public <T> T getAdapter(Class<T> adapter) {
 		return null;
 	}
 
+	@Override
 	public void init(IPageBookViewPage page, IConsole console) {
 		IActionBars actionBars = page.getSite().getActionBars();
 		actionBars.getToolBarManager().appendToGroup(
@@ -31,12 +33,15 @@
 				IConsoleConstants.LAUNCH_GROUP, new RemoveAllConsolesAction());
 	}
 
+	@Override
 	public void dispose() {
 	}
 
+	@Override
 	public void activated() {
 	}
 
+	@Override
 	public void deactivated() {
 	}
 
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/GetBugsOperation.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/GetBugsOperation.java
index 908f67b..4fec14d 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/GetBugsOperation.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/GetBugsOperation.java
@@ -100,7 +100,7 @@
 	protected Set<Integer> getBugNumbersFromComments(SyncInfo[] syncInfos,
 			IProgressMonitor monitor) {
 		monitor.beginTask("Scanning comments for bug numbers", syncInfos.length);
-		TreeSet<Integer> set = new TreeSet<Integer>();
+		TreeSet<Integer> set = new TreeSet<>();
 		for (int i = 0; i < syncInfos.length; i++) {
 			SyncInfo info = syncInfos[i];
 			getBugNumbersForSyncInfo(info, monitor, set);
@@ -208,7 +208,7 @@
 		DataInputStream in;
 		URLConnection url;
 		StringBuffer buffer;
-		TreeMap<Integer, String> map = new TreeMap<Integer, String>();
+		TreeMap<Integer, String> map = new TreeMap<>();
 		for (int i = 0; i < bugs.length; i++) {
 			try {
 				url = (new URL(BUG_DATABASE_PREFIX + bugs[i]
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/IBMCopyrightComment.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/IBMCopyrightComment.java
index 290ccea..6ed9b0a 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/IBMCopyrightComment.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/IBMCopyrightComment.java
@@ -92,7 +92,7 @@
    	    String contribComment = body.substring(contrib);
    	    StringTokenizer tokens = new StringTokenizer(contribComment, "\r\n"); //$NON-NLS-1$
    	    tokens.nextToken();
-   	    ArrayList<String> contributors = new ArrayList<String>();
+   	    ArrayList<String> contributors = new ArrayList<>();
         String linePrefix = getLinePrefix(commentStyle);
    	    while(tokens.hasMoreTokens()) {
    	        String contributor = tokens.nextToken();
@@ -124,15 +124,13 @@
 	        return null;
 
 	    StringWriter out = new StringWriter();
-		PrintWriter writer = new PrintWriter(out);
-		try {
+		
+		try (PrintWriter writer = new PrintWriter(out)) {
 		    writeCommentStart(writer);
 			writeLegal(writer, linePrefix);
 			writeContributions(writer, linePrefix);
 		    writeCommentEnd(writer);
 			return out.toString();
-		} finally {
-		    writer.close();
 		}
 	}
 
@@ -141,16 +139,14 @@
 	 */
 	public String getOriginalCopyrightComment() {
 	    StringWriter out = new StringWriter();
-		PrintWriter writer = new PrintWriter(out);
-		try {
+		
+		try (PrintWriter writer = new PrintWriter(out)) {
 			writer.print(originalText.substring(0, yearRangeStart));
 			writer.print(getCreationYear());
 			if (hasRevisionYear() && getRevisionYear() != getCreationYear())
 		        writer.print(", " + getRevisionYear()); //$NON-NLS-1$
 			writer.print(originalText.substring(yearRangeEnd));
 			return out.toString();
-		} finally {
-		    writer.close();
 		}
 	}
 
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/LoadMap.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/LoadMap.java
index 3e23c83..b5c07a1 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/LoadMap.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/LoadMap.java
@@ -70,7 +70,7 @@
 	 * @throws CoreException
 	 */
 	protected String[] getReferenceStrings(IResource[] mapFiles) throws CoreException {
-		List<String> allStrings = new ArrayList<String>();
+		List<String> allStrings = new ArrayList<>();
 		for (int i = 0; i < mapFiles.length; i++) {
 			IResource resource = mapFiles[i];
 			String[] referenceStrings = readReferenceStrings((IFile)resource);
@@ -86,11 +86,11 @@
 	 */
 
 	protected static String[] readReferenceStrings(IFile file) throws CoreException {
-		BufferedReader reader = new BufferedReader(new InputStreamReader(file.getContents()));
-		try {
+		
+		try (BufferedReader reader = new BufferedReader(new InputStreamReader(file.getContents()))) {
 			try {
 				String line = reader.readLine();
-				List<String> references = new ArrayList<String>();
+				List<String> references = new ArrayList<>();
 				while (line != null) {
 					String referenceString = new MapEntry(line).getReferenceString();
 					if (referenceString != null)  {
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapContentDocument.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapContentDocument.java
index e3305ed..76fb719 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapContentDocument.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapContentDocument.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -17,17 +17,13 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 
-import org.eclipse.team.internal.ccvs.core.CVSException;
-import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
-
-import org.eclipse.swt.graphics.Image;
-
-import org.eclipse.core.runtime.CoreException;
-
-import org.eclipse.core.resources.IProject;
-
 import org.eclipse.compare.IStreamContentAccessor;
 import org.eclipse.compare.ITypedElement;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.team.internal.ccvs.core.CVSException;
+import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
 
 
 public class MapContentDocument implements ITypedElement, IStreamContentAccessor{
@@ -94,35 +90,23 @@
 	public boolean isChanged() {
 		return !(oldContents.equals(newContents));
 	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.compare.ITypedElement#getName()
-	 */
+
+	@Override
 	public String getName() {
 		return mapFile.getFile().getName();
 	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.compare.ITypedElement#getImage()
-	 */
+
+	@Override
 	public Image getImage() {
 		return null;
 	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.compare.ITypedElement#getType()
-	 */
+
+	@Override
 	public String getType() {
 		return mapFile.getFile().getFileExtension();
 	}
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.compare.IStreamContentAccessor#getContents()
-	 */
+
+	@Override
 	public InputStream getContents() throws CoreException {
 		return new ByteArrayInputStream(getNewContent().getBytes());
 	}
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapEntry.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapEntry.java
index 5b5037f..8ee6d5f 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapEntry.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapEntry.java
@@ -39,7 +39,7 @@
 	private boolean valid = false;
 	private String type = EMPTY_STRING;
 	private String id = EMPTY_STRING;
-	private OrderedMap<String, String> arguments = new OrderedMap<String, String>();
+	private OrderedMap<String, String> arguments = new OrderedMap<>();
 	private boolean legacy = false;
 	private String version;
 
@@ -144,7 +144,7 @@
 	 * key=value elements. Otherwise we fill in the key based on the old format.
 	 */
 	private OrderedMap<String, String> populate(String[] entries) {
-		OrderedMap<String, String> result = new OrderedMap<String, String>();
+		OrderedMap<String, String> result = new OrderedMap<>();
 		for (int i=0; i<entries.length; i++) {
 			String entry = entries[i];
 			int index = entry.indexOf('=');
@@ -165,7 +165,7 @@
 	
 	private OrderedMap<String, String> legacyPopulate(String[] entries) {
 		legacy = true;
-		OrderedMap<String, String> result = new OrderedMap<String, String>();
+		OrderedMap<String, String> result = new OrderedMap<>();
 		// must have at least tag and connect string
 		if (entries.length >= 2) {
 			// Version
@@ -194,7 +194,7 @@
 	public static String[] getArrayFromStringWithBlank(String list, String separator) {
 		if (list == null || list.trim().length() == 0)
 			return new String[0];
-		List<String> result = new ArrayList<String>();
+		List<String> result = new ArrayList<>();
 		boolean previousWasSeparator = true;
 		for (StringTokenizer tokens = new StringTokenizer(list, separator, true); tokens.hasMoreTokens();) {
 			String token = tokens.nextToken().trim();
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFile.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFile.java
index 9ab8d33..7dd9829 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFile.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFile.java
@@ -51,11 +51,10 @@
 	}
 	
 	protected void loadEntries() throws CoreException {
-		InputStream inputStream = null;
-		List<MapEntry> list = new ArrayList<MapEntry>();		
+		List<MapEntry> list = new ArrayList<>();		
 
-		try {
-			inputStream = file.getContents();
+		try (InputStream inputStream = file.getContents();){
+			
 			BufferedReader aReader = new BufferedReader(new InputStreamReader(
 					inputStream));
 			String aLine = aReader.readLine();
@@ -67,14 +66,6 @@
 			}
 		} catch (IOException e) {
 			throw new CoreException(new Status(IStatus.ERROR, RelEngPlugin.ID, 0, "An I/O Error occurred process map file " + file.getFullPath().toString(), e));
-		} finally {
-			if (inputStream != null) {
-				try {
-					inputStream.close();
-				} catch (IOException e) {
-					// Ignore close exceptions so we don't mask another exception
-				}
-			}
 		}
 
 		this.entries = list.toArray(new MapEntry[list.size()]);
@@ -105,7 +96,7 @@
 	}
 
 	public IProject[] getAccessibleProjects() {
-		Set<IProject> list = new HashSet<IProject>();
+		Set<IProject> list = new HashSet<>();
 		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
 		if(entries == null || entries.length ==0) return null;
 		for (int i = 0; i < projects.length; i++) {
@@ -134,7 +125,7 @@
 	 * @since 3.7
 	 */
 	public static MapFile[] findAllMapFiles(IResource resource) throws CoreException {
-		final ArrayList<MapFile> mapFiles = new ArrayList<MapFile>();
+		final ArrayList<MapFile> mapFiles = new ArrayList<>();
 		IResourceProxyVisitor visitor= resourceProxy -> {
 			if (!resourceProxy.isAccessible())
 				return false;
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFileCompareEditorInput.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFileCompareEditorInput.java
index dc9b421..244bad5 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFileCompareEditorInput.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFileCompareEditorInput.java
@@ -126,7 +126,7 @@
 	private MapFile[] getChangedMapFiles() {
 		if (selectedProjects == null || selectedProjects.length == 0)
 			return null;
-		List<IProject> projectList = new ArrayList<IProject>();
+		List<IProject> projectList = new ArrayList<>();
 		CVSTag[] tags = mapProject.getTagsFor(selectedProjects );
 		for(int i = 0; i < selectedProjects.length; i++){
 			if(!tags[i].getName().equals(tag)){
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFileComparePage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFileComparePage.java
index 5c567c7..14c9b26 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFileComparePage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapFileComparePage.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2005 IBM Corporation and others.
+ * Copyright (c) 2000, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -30,11 +30,6 @@
 		super(pageName, title, image);
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean)
-	 */
 	@Override
 	public void setVisible(boolean visible) {
 		super.setVisible(visible);
@@ -44,11 +39,7 @@
 		}
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
-	 */
+	@Override
 	public void createControl(Composite parent) {
 		Font font = parent.getFont();
 		Composite composite = new Composite(parent, SWT.NONE);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProject.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProject.java
index aee30ed..da82115 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProject.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProject.java
@@ -109,7 +109,7 @@
 	}
  
 	public MapFile[] getValidMapFiles(){
-		List<MapFile> list = new ArrayList<MapFile>();
+		List<MapFile> list = new ArrayList<>();
 		for (int i = 0; i <mapFiles.length; i++){
 			IProject[] projects = mapFiles[i].getAccessibleProjects(); 
 			if( projects!= null && projects.length > 0){
@@ -130,7 +130,7 @@
 		MapContentDocument changed = new MapContentDocument(aFile);
 		changed.updateTag(aProject, tag);
 		if (changed.isChanged()) {
-			aFile.getFile().setContents(changed.getContents(), IFile.KEEP_HISTORY, null);
+			aFile.getFile().setContents(changed.getContents(), IResource.KEEP_HISTORY, null);
 		}
 	}
 	
@@ -146,7 +146,7 @@
 	}
 	
 	public MapFile[] getMapFilesFor(IProject[] projects){
-		Set<MapFile> alist = new HashSet<MapFile>();		
+		Set<MapFile> alist = new HashSet<>();		
 		for(int i = 0; i<projects.length; i++){
 			MapFile aMapFile = getMapFile(projects[i]);
 			alist.add(aMapFile);
@@ -182,6 +182,7 @@
 	/**
 	 * @see IResourceChangeListener#resourceChanged(IResourceChangeEvent)
 	 */
+	@Override
 	public void resourceChanged(IResourceChangeEvent event) {
 		IResourceDelta root = event.getDelta();
 		
@@ -239,7 +240,7 @@
 		return new MapFile(file);
 	}
 	private void addMapFile(MapFile aFile){
-		Set<MapFile> set = new HashSet<MapFile>(Arrays.asList(mapFiles));
+		Set<MapFile> set = new HashSet<>(Arrays.asList(mapFiles));
 		set.add(aFile);
 		mapFiles = set.toArray(new MapFile[set.size()]); 
 	}
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProjectSelectionPage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProjectSelectionPage.java
index 6ffd529..dd688eb 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProjectSelectionPage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProjectSelectionPage.java
@@ -57,6 +57,7 @@
 		this.settings = settings;
 	}
 
+	@Override
 	public void createControl(Composite parent) {
 		Composite topContainer = new Composite(parent, SWT.NONE);
 		topContainer.setLayout(new GridLayout());
@@ -86,12 +87,15 @@
 		tree.setLayoutData(gd);
 		ListViewer result = new ListViewer(tree);
 		result.setContentProvider(new IStructuredContentProvider() {
+			@Override
 			public Object[] getElements(Object inputElement) {
 				Set<IProject> projects=(Set<IProject>)inputElement;
 				return projects.toArray(new IProject[projects.size()]);
 			}
+			@Override
 			public void dispose() {	
 			}
+			@Override
 			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 			}
 		});
@@ -102,7 +106,7 @@
 	}	
 
 	private static Set<IProject> getMapFileProjects() {
-		Set<IProject> projects = new HashSet<IProject>();
+		Set<IProject> projects = new HashSet<>();
 		MapFile[] mapFiles;
 		try {
 			mapFiles = MapFile.findAllMapFiles(RelEngPlugin.getWorkspace().getRoot());
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProjectSelectionWizard.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProjectSelectionWizard.java
index 2ffd6e5..6fa53fe 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProjectSelectionWizard.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/MapProjectSelectionWizard.java
@@ -69,10 +69,12 @@
 		}
 
 		getShell().addControlListener(new ControlListener() {
+			@Override
 			public void controlMoved(ControlEvent e) {
 				storeBounds(e);
 			}
 
+			@Override
 			public void controlResized(ControlEvent e) {
 				storeBounds(e);
 			}
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/OrderedMap.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/OrderedMap.java
index 91f7a0a..d7d66a7 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/OrderedMap.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/OrderedMap.java
@@ -23,15 +23,15 @@
  */
 public class OrderedMap<K, V> {
 
-	private List<K> keys = new ArrayList<K>();
-	private List<V> values = new ArrayList<V>();
+	private List<K> keys = new ArrayList<>();
+	private List<V> values = new ArrayList<>();
 
 	/* (non-Javadoc)
 	 * @see java.util.Map#clear()
 	 */
 	public void clear() {
-		keys = new ArrayList<K>();
-		values = new ArrayList<V>();
+		keys = new ArrayList<>();
+		values = new ArrayList<>();
 	}
 
 	/* (non-Javadoc)
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectComparePage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectComparePage.java
index bdb18cd..6c2cc96 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectComparePage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectComparePage.java
@@ -71,6 +71,7 @@
 		this.settings = settings;
 	}
 
+	@Override
 	public void createControl(Composite parent) {
 		Font font = parent.getFont();
 		GridData data = new GridData(GridData.FILL_BOTH);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectSelectionPage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectSelectionPage.java
index a8a1e63..f6d4cb6 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectSelectionPage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectSelectionPage.java
@@ -84,6 +84,7 @@
 		this.settings = settings;
 	}
 	
+	@Override
 	public void createControl(Composite parent) {
 		Font font = parent.getFont();
 		
@@ -178,7 +179,7 @@
 	 * Returns all the checked items if they are IProject 
 	 */
 	public IProject[] getCheckedProjects(){
-		ArrayList<IProject> projectsToRelease = new ArrayList<IProject>();
+		ArrayList<IProject> projectsToRelease = new ArrayList<>();
 		Object[] obj = viewer.getCheckedElements();
 		if (obj == null)return null;
 		for(int i = 0; i < obj.length; i++){
@@ -191,7 +192,7 @@
 	private void readProjectSettings(){
 		if( settings == null) return;
 		if(settings.getArray(SELECTED_ITEMS_KEY) != null){
-			ArrayList<String> nameList = new ArrayList<String>(Arrays.asList(settings.getArray(SELECTED_ITEMS_KEY)));
+			ArrayList<String> nameList = new ArrayList<>(Arrays.asList(settings.getArray(SELECTED_ITEMS_KEY)));
 			if(nameList != null){
 				Iterator<String> iter = nameList.iterator();
 				while(iter.hasNext()){
@@ -222,7 +223,7 @@
 	 */
 	public void saveSettings(){
 		Object[] obj = viewer.getCheckedElements();
-		ArrayList<String> names = new ArrayList<String>();
+		ArrayList<String> names = new ArrayList<>();
 		for (int i = 0; i < obj.length; i++){
 			if(obj[i] instanceof IProject){
 				names.add(((IProject)obj[i]).getName());
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectValidationDialog.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectValidationDialog.java
index 6658f32..b9e5f78 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectValidationDialog.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ProjectValidationDialog.java
@@ -42,12 +42,10 @@
 			participant.refreshNow(p, Messages.getString("ReleaseWizard.20"), monitor); //$NON-NLS-1$
 			
 			if (!monitor.isCanceled() && !participant.getSyncInfoSet().isEmpty()) {
-				Display.getDefault().syncExec(new Runnable() {
-					public void run() {
-                        if (MessageDialog.openQuestion(shell, "Workspace Differs From Released Contents",
-                                "The local workspace contents does not match what is released. There is a good chance that the release failed. Do you want to see the difference?"))
-                            openValidationFailedDialog(shell, participant);
-					}
+				Display.getDefault().syncExec(() -> {
+				    if (MessageDialog.openQuestion(shell, "Workspace Differs From Released Contents",
+				            "The local workspace contents does not match what is released. There is a good chance that the release failed. Do you want to see the difference?"))
+				        openValidationFailedDialog(shell, participant);
 				});	
 			}
 		} finally {
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ReleaseWizard.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ReleaseWizard.java
index 1612f96..83d3476 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ReleaseWizard.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ReleaseWizard.java
@@ -109,10 +109,12 @@
 		
 		getShell().addControlListener(new ControlListener() {
 
+			@Override
 			public void controlMoved(ControlEvent e) {
 				storeBounds(e);
 			}
 
+			@Override
 			public void controlResized(ControlEvent e) {
 				storeBounds(e);
 			}
@@ -405,7 +407,7 @@
 		if (resources.length < 1) {
 			preSelectedProjects = null;
 		} else {
-			Set<IProject> list = new HashSet<IProject>();
+			Set<IProject> list = new HashSet<>();
 			for (int i = 0; i < resources.length; i++) {
 				list.add(resources[i].getProject());
 			}
@@ -437,9 +439,11 @@
 
 	protected IPromptCondition getPromptCondition(IResource[] resources) {
 		return new IPromptCondition() {
+			@Override
 			public boolean needsPrompt(IResource resource) {
 				return CVSLightweightDecorator.isDirty(resource);
 			}
+			@Override
 			public String promptMessage(IResource resource) {
 				return NLS.bind(Messages.getString("TagAction_uncommittedChanges"), new String[] { resource.getName() }); //$NON-NLS-1$
 			}
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/RemoveAllConsolesAction.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/RemoveAllConsolesAction.java
index ef3251b..14f7663 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/RemoveAllConsolesAction.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/RemoveAllConsolesAction.java
@@ -17,16 +17,17 @@
 import org.eclipse.releng.tools.AdvancedFixCopyrightAction.FixConsole;
 import org.eclipse.ui.console.ConsolePlugin;
 import org.eclipse.ui.console.IConsole;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
 
 public class RemoveAllConsolesAction extends Action {
 	public RemoveAllConsolesAction() {
 		super(
-				Messages.getString("RemoveAllConsolesAction.Text"), RelEngPlugin.imageDescriptorFromPlugin(RelEngPlugin.ID, "icons/full/elcl16/console_remall.png")); //$NON-NLS-1$//$NON-NLS-2$
+				Messages.getString("RemoveAllConsolesAction.Text"), AbstractUIPlugin.imageDescriptorFromPlugin(RelEngPlugin.ID, "icons/full/elcl16/console_remall.png")); //$NON-NLS-1$//$NON-NLS-2$
 	}
 
 	@Override
 	public void run() {
-		List<IConsole> consolesList = new ArrayList<IConsole>();
+		List<IConsole> consolesList = new ArrayList<>();
 
 		for (IConsole console : ConsolePlugin.getDefault().getConsoleManager()
 				.getConsoles()) {
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/RemoveConsoleAction.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/RemoveConsoleAction.java
index 337ee66..f8fad74 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/RemoveConsoleAction.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/RemoveConsoleAction.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2014 IBH SYSTEMS GmbH.
+ * Copyright (c) 2014, 2016 IBH SYSTEMS GmbH.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -13,13 +13,14 @@
 import org.eclipse.jface.action.Action;
 import org.eclipse.ui.console.ConsolePlugin;
 import org.eclipse.ui.console.IConsole;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
 
 public class RemoveConsoleAction extends Action {
 	
 	private final IConsole console;
 	
 	public RemoveConsoleAction(IConsole console) {
-		super(Messages.getString("RemoveConsoleAction.Text"), RelEngPlugin.imageDescriptorFromPlugin(RelEngPlugin.ID, "icons/full/elcl16/console_rem.png"));  //$NON-NLS-1$//$NON-NLS-2$
+		super(Messages.getString("RemoveConsoleAction.Text"), AbstractUIPlugin.imageDescriptorFromPlugin(RelEngPlugin.ID, "icons/full/elcl16/console_rem.png"));  //$NON-NLS-1$//$NON-NLS-2$
 		this.console = console;
 	}
 	
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/SourceFile.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/SourceFile.java
index cdc3a09..89ec0df 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/SourceFile.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/SourceFile.java
@@ -40,7 +40,7 @@
 public abstract class SourceFile {
 	
 	IFile file;
-	List<BlockComment> comments = new ArrayList<BlockComment>();
+	List<BlockComment> comments = new ArrayList<>();
 	StringWriter contents = new StringWriter();
 	private ITextFileBufferManager textFileBufferManager;
 	private String lineDelimiter;
@@ -118,50 +118,51 @@
 			}
 			
 			lineDelimiter= TextUtilities.getDefaultLineDelimiter(document);
-			BufferedReader aReader = new BufferedReader(new StringReader(document.get()));
-			String aLine = aReader.readLine();
-			String comment = ""; //$NON-NLS-1$
-			BufferedWriter contentsWriter = new BufferedWriter(contents);
-			int lineNumber = 0;
-			int commentStart = 0;
-			int commentEnd = 0;
-			boolean inComment = false;
-			String commentStartString = ""; //$NON-NLS-1$
-			
-			//Loop over the document, extract the comment.
-			while (aLine != null) {
-				contentsWriter.write(aLine);
-				contentsWriter.newLine();
-				if (!inComment && isCommentStart(aLine)) {
-					// start saving comment
-					inComment = true;
-					commentStart = lineNumber;
-					commentStartString = aLine;
-				}
-				
-				if (inComment) {
-					comment = comment + aLine + lineDelimiter;
-								
-					if (isCommentEnd(aLine, commentStartString) && commentStart != lineNumber) {
-						// stop saving comment
-						inComment = false;
-						commentEnd = lineNumber;
-						String commentEndString = aLine.trim();
-						commentEndString = commentEndString.substring(commentEndString.length()-2);
-						BlockComment aComment = new BlockComment(commentStart, commentEnd, comment.toString(), commentStartString, commentEndString);
-						comments.add(aComment);
-						comment = ""; //$NON-NLS-1$
-						commentStart = 0;
-						commentEnd = 0;
-						commentStartString = ""; //$NON-NLS-1$
+			try (BufferedReader aReader = new BufferedReader(new StringReader(document.get()))) {
+				String aLine = aReader.readLine();
+				String comment = ""; //$NON-NLS-1$
+				BufferedWriter contentsWriter = new BufferedWriter(contents);
+				int lineNumber = 0;
+				int commentStart = 0;
+				int commentEnd = 0;
+				boolean inComment = false;
+				String commentStartString = ""; //$NON-NLS-1$
+
+				// Loop over the document, extract the comment.
+				while (aLine != null) {
+					contentsWriter.write(aLine);
+					contentsWriter.newLine();
+					if (!inComment && isCommentStart(aLine)) {
+						// start saving comment
+						inComment = true;
+						commentStart = lineNumber;
+						commentStartString = aLine;
 					}
+
+					if (inComment) {
+						comment = comment + aLine + lineDelimiter;
+
+						if (isCommentEnd(aLine, commentStartString) && commentStart != lineNumber) {
+							// stop saving comment
+							inComment = false;
+							commentEnd = lineNumber;
+							String commentEndString = aLine.trim();
+							commentEndString = commentEndString.substring(commentEndString.length() - 2);
+							BlockComment aComment = new BlockComment(commentStart, commentEnd, comment.toString(),
+									commentStartString, commentEndString);
+							comments.add(aComment);
+							comment = ""; //$NON-NLS-1$
+							commentStart = 0;
+							commentEnd = 0;
+							commentStartString = ""; //$NON-NLS-1$
+						}
+					}
+
+					aLine = aReader.readLine();
+					lineNumber++;
 				}
-				
-				aLine = aReader.readLine();
-				lineNumber++;
+
 			}
-			
-			aReader.close();
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/TagMap.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/TagMap.java
index 42584f5..515fedc 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/TagMap.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/TagMap.java
@@ -38,7 +38,7 @@
 	@Override
 	protected ICVSRemoteResource[] getSelectedRemoteResources() {
 		IResource[] resources = getSelectedResources();
-		List<String> identifiers = new ArrayList<String>();
+		List<String> identifiers = new ArrayList<>();
 		for (int i = 0; i < resources.length; i++) {
 			IResource resource = resources[i];
 			try {
@@ -52,9 +52,9 @@
 	}
 
 	private ICVSRemoteResource[] getCVSResourcesFor(String[] referenceStrings) {
-		Map<ICVSRepositoryLocation, ICVSRepositoryLocation> previouslySelectedRepositories = new HashMap<ICVSRepositoryLocation, ICVSRepositoryLocation>();
+		Map<ICVSRepositoryLocation, ICVSRepositoryLocation> previouslySelectedRepositories = new HashMap<>();
 		int size = referenceStrings.length;
-		List<ICVSRemoteResource> result = new ArrayList<ICVSRemoteResource>(size);
+		List<ICVSRemoteResource> result = new ArrayList<>(size);
 		for (int i = 0; i < size; i++) {
 			StringTokenizer tokenizer = new StringTokenizer(referenceStrings[i], ","); //$NON-NLS-1$
 			String version = tokenizer.nextToken();
@@ -107,7 +107,7 @@
 	private ICVSRepositoryLocation getWritableRepositoryLocation(ICVSRepositoryLocation storedLocation) {
 		// Find out which repo locations are appropriate
 		ICVSRepositoryLocation[] locations = CVSUIPlugin.getPlugin().getRepositoryManager().getKnownRepositoryLocations();
-		List<ICVSRepositoryLocation> compatibleLocations = new ArrayList<ICVSRepositoryLocation>();
+		List<ICVSRepositoryLocation> compatibleLocations = new ArrayList<>();
 		for (int i = 0; i < locations.length; i++) {
 			ICVSRepositoryLocation location = locations[i];
 			// Only locations with the same host and root are eligible
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/TagPage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/TagPage.java
index e5e447c..06a611d 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/TagPage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/TagPage.java
@@ -73,6 +73,7 @@
 		this.settings = settings;
 	}
 
+	@Override
 	public void createControl(Composite parent) {
 		Font font = parent.getFont();
 		Composite composite = new Composite(parent, SWT.NONE);
@@ -308,7 +309,7 @@
 	}
 	
 	private String[] addToTagList(String[] history, String newEntry) {
-		ArrayList<String> l = new ArrayList<String>(Arrays.asList(history));
+		ArrayList<String> l = new ArrayList<>(Arrays.asList(history));
 		addToTagList(l, newEntry);
 		String[] r = new String[l.size()];
 		l.toArray(r);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ValidatePage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ValidatePage.java
index 8b47bc3..1c13e9f 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ValidatePage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/ValidatePage.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2009 IBM Corporation and others.
+ * Copyright (c) 2009, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -10,14 +10,13 @@
  *******************************************************************************/
 package org.eclipse.releng.tools;
 
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Label;
-
 import org.eclipse.jface.dialogs.Dialog;
 import org.eclipse.jface.resource.ImageDescriptor;
 import org.eclipse.jface.wizard.IWizardPage;
 import org.eclipse.jface.wizard.WizardPage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
 
 
 /**
@@ -32,21 +31,16 @@
 		setDescription(Messages.getString("ValidatePage.description")); //$NON-NLS-1$
 	}
 
+	@Override
 	public void createControl(Composite parent) {
 		setControl(new Label(parent, SWT.NONE));
 	}
 	
-	/*
-	 * @see org.eclipse.jface.wizard.WizardPage#canFlipToNextPage()
-	 */
 	@Override
 	public boolean canFlipToNextPage() {
 		return false;
 	}
 	
-	/*
-	 * @see org.eclipse.jface.wizard.WizardPage#getPreviousPage()
-	 */
 	@Override
 	public IWizardPage getPreviousPage() {
 		return null;
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/git/GitCopyrightAdapterFactory.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/git/GitCopyrightAdapterFactory.java
index 08df8aa..e14c0ea 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/git/GitCopyrightAdapterFactory.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/git/GitCopyrightAdapterFactory.java
@@ -23,6 +23,7 @@
 
 	private static final Class<?>[] ADAPTER_LIST = new Class[] { IRepositoryProviderCopyrightAdapterFactory.class };
 
+	@Override
 	@SuppressWarnings("unchecked")
 	public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {
 		if (IRepositoryProviderCopyrightAdapterFactory.class
@@ -38,10 +39,12 @@
 		return this;
 	}
 
+	@Override
 	public Class<?>[] getAdapterList() {
 		return ADAPTER_LIST;
 	}
 
+	@Override
 	public RepositoryProviderCopyrightAdapter createAdapater(
 			IResource[] resources) {
 		return new GitCopyrightAdapter(resources);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/ConfigurationBlock.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/ConfigurationBlock.java
index a924766..52f7365 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/ConfigurationBlock.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/ConfigurationBlock.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 IBM Corporation and others.
+ * Copyright (c) 2013, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -40,9 +40,11 @@
 	
 	protected void addHighlight(final Composite parent, final Label labelControl, final Combo comboBox) {
 		comboBox.addFocusListener(new FocusListener() {
+			@Override
 			public void focusLost(FocusEvent e) {
 				highlight(parent, labelControl, comboBox, HIGHLIGHT_NONE);
 			}
+			@Override
 			public void focusGained(FocusEvent e) {
 				highlight(parent, labelControl, comboBox, HIGHLIGHT_FOCUS);
 			}
@@ -68,17 +70,21 @@
 				if (! comboBox.isFocusControl())
 					highlight(parent, labelControl, comboBox, HIGHLIGHT_NONE);
 			}
+			@Override
 			public void mouseMove(MouseEvent e) {
 				int color= comboBox.isFocusControl() ? HIGHLIGHT_FOCUS : isAroundLabel(e) ? HIGHLIGHT_MOUSE : HIGHLIGHT_NONE;
 				highlight(parent, labelControl, comboBox, color);
 			}
+			@Override
 			public void mouseDown(MouseEvent e) {
 				if (isAroundLabel(e))
 					comboBox.setFocus();
 			}
+			@Override
 			public void mouseDoubleClick(MouseEvent e) {
 				// not used
 			}
+			@Override
 			public void mouseUp(MouseEvent e) {
 				// not used
 			}
@@ -111,6 +117,7 @@
 			
 			private int fColor= color;
 
+			@Override
 			public void paintControl(PaintEvent e) {
 				if (((GridData) labelControl.getLayoutData()).exclude) {
 					parent.removePaintListener(this);
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/CopyrightPreferencePage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/CopyrightPreferencePage.java
index 6b3a515..267c233 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/CopyrightPreferencePage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/CopyrightPreferencePage.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2004, 2014 IBM Corporation and others.
+ * Copyright (c) 2004, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -57,6 +57,7 @@
 	private Button fIgnoreProperties;
 	private Button fIgnoreXml;
 	
+	@Override
 	public void init(IWorkbench workbench) {
 		// TODO Auto-generated method stub
 
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/MapProjectPreferencePage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/MapProjectPreferencePage.java
index f535dc3..4b7df96 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/MapProjectPreferencePage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/MapProjectPreferencePage.java
@@ -121,7 +121,7 @@
 		data.grabExcessVerticalSpace = true;
 		projectList.setLayoutData(data);
 
-		Set<IProject> projects = new HashSet<IProject>();
+		Set<IProject> projects = new HashSet<>();
 		MapFile[] mapFiles;
 		try {
 			mapFiles = MapFile.findAllMapFiles(RelEngPlugin.getWorkspace().getRoot());
@@ -169,9 +169,7 @@
 		setValid(isValid);
 	}
 
-	/*
-	 * @see IWorkbenchPreferencePage#init(IWorkbench)
-	 */
+	@Override
 	public void init(IWorkbench workbench) {
 		// do nothing
 	}
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/PomErrorLevelBlock.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/PomErrorLevelBlock.java
index a4e2c20..32eb3eb 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/PomErrorLevelBlock.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/PomErrorLevelBlock.java
@@ -299,7 +299,7 @@
 	private void save() {
 		if(fDirty) {
 			try {
-				ArrayList<Key> changes = new ArrayList<Key>();
+				ArrayList<Key> changes = new ArrayList<>();
 				collectChanges(fLookupOrder[0], changes);
 				if(changes.size() > 0) {
 					fManager.applyChanges();
diff --git a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/PomVersionPreferencePage.java b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/PomVersionPreferencePage.java
index 343c118..c1cc558 100644
--- a/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/PomVersionPreferencePage.java
+++ b/bundles/org.eclipse.releng.tools/src/org/eclipse/releng/tools/preferences/PomVersionPreferencePage.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 IBM Corporation and others.
+ * Copyright (c) 2013, 2016 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -58,9 +58,7 @@
 		return comp;
 	}
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
-	 */
+	@Override
 	public void init(IWorkbench workbench) {
 	}
 
