diff --git a/examples/src/main/java/org/apache/poi/examples/hpsf/ModifyDocumentSummaryInformation.java b/examples/src/main/java/org/apache/poi/examples/hpsf/ModifyDocumentSummaryInformation.java
index cf26fee..b42b936 100644
--- a/examples/src/main/java/org/apache/poi/examples/hpsf/ModifyDocumentSummaryInformation.java
+++ b/examples/src/main/java/org/apache/poi/examples/hpsf/ModifyDocumentSummaryInformation.java
@@ -63,7 +63,7 @@
  *
  * <li><p>Write the POI filesystem back to the original file.</p></li>
  *
- * </ol>
+ * </ul>
  */
 @SuppressWarnings({"java:S106","java:S4823"})
 public final class ModifyDocumentSummaryInformation {
diff --git a/examples/src/main/java/org/apache/poi/examples/hssf/eventusermodel/XLS2CSVmra.java b/examples/src/main/java/org/apache/poi/examples/hssf/eventusermodel/XLS2CSVmra.java
index 61764ee..a0b393c 100644
--- a/examples/src/main/java/org/apache/poi/examples/hssf/eventusermodel/XLS2CSVmra.java
+++ b/examples/src/main/java/org/apache/poi/examples/hssf/eventusermodel/XLS2CSVmra.java
@@ -48,7 +48,7 @@
 import org.apache.poi.poifs.filesystem.POIFSFileSystem;
 
 /**
- * A XLS -> CSV processor, that uses the MissingRecordAware
+ * A XLS -&gt; CSV processor, that uses the MissingRecordAware
  *  EventModel code to ensure it outputs all columns and rows.
  * @author Nick Burch
  */
@@ -83,7 +83,7 @@
 	private boolean outputNextStringRecord;
 
 	/**
-	 * Creates a new XLS -> CSV converter
+	 * Creates a new XLS -&gt; CSV converter
 	 * @param fs The POIFSFileSystem to process
 	 * @param output The PrintStream to output the CSV to
 	 * @param minColumns The minimum number of columns to output, or -1 for no minimum
@@ -95,9 +95,11 @@
 	}
 
 	/**
-	 * Creates a new XLS -> CSV converter
+	 * Creates a new XLS -&gt; CSV converter
 	 * @param filename The file to process
 	 * @param minColumns The minimum number of columns to output, or -1 for no minimum
+	 *
+	 * @throws IOException if the file cannot be read or parsing the file fails
 	 */
 	public XLS2CSVmra(String filename, int minColumns) throws IOException {
 		this(
@@ -108,6 +110,8 @@
 
 	/**
 	 * Initiates the processing of the XLS file to CSV
+	 *
+	 * @throws IOException if the workbook contained errors
 	 */
 	public void process() throws IOException {
 		MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(this);
diff --git a/examples/src/main/java/org/apache/poi/examples/ss/CalendarDemo.java b/examples/src/main/java/org/apache/poi/examples/ss/CalendarDemo.java
index 9253153..ead4093 100644
--- a/examples/src/main/java/org/apache/poi/examples/ss/CalendarDemo.java
+++ b/examples/src/main/java/org/apache/poi/examples/ss/CalendarDemo.java
@@ -43,7 +43,7 @@
  * A  monthly calendar created using Apache POI. Each month is on a separate sheet.
  * <pre>
  * Usage:
- * CalendarDemo -xls|xlsx <year>
+ * CalendarDemo -xls|xlsx &lt;year&gt;
  * </pre>
  *
  * @author Yegor Kozlov
diff --git a/examples/src/main/java/org/apache/poi/examples/ss/ToCSV.java b/examples/src/main/java/org/apache/poi/examples/ss/ToCSV.java
index 91a603f..1c39838 100644
--- a/examples/src/main/java/org/apache/poi/examples/ss/ToCSV.java
+++ b/examples/src/main/java/org/apache/poi/examples/ss/ToCSV.java
@@ -40,7 +40,7 @@
 /**
  * Demonstrates <em>one</em> way to convert an Excel spreadsheet into a CSV
  * file. This class makes the following assumptions;
- * <list>
+ * <ul>
  * <li>1. Where the Excel workbook contains more than one worksheet, then a single
  *    CSV file will contain the data from all of the worksheets.</li>
  * <li>2. The data matrix contained in the CSV file will be square. This means that
@@ -51,7 +51,7 @@
  * <li>3. Empty fields will represent missing cells.</li>
  * <li>4. A record consisting of empty fields will be used to represent an empty row
  *    in the Excel workbook.</li>
- * </list>
+ * </ul>
  * Therefore, if the worksheet looked like this;
  *
  * <pre>
diff --git a/examples/src/main/java/org/apache/poi/examples/xssf/eventusermodel/XLSX2CSV.java b/examples/src/main/java/org/apache/poi/examples/xssf/eventusermodel/XLSX2CSV.java
index 81235f0..a9772b0 100644
--- a/examples/src/main/java/org/apache/poi/examples/xssf/eventusermodel/XLSX2CSV.java
+++ b/examples/src/main/java/org/apache/poi/examples/xssf/eventusermodel/XLSX2CSV.java
@@ -46,7 +46,7 @@
 import org.xml.sax.XMLReader;
 
 /**
- * A rudimentary XLSX -> CSV processor modeled on the
+ * A rudimentary XLSX -&gt; CSV processor modeled on the
  * POI sample program XLS2CSVmra from the package
  * org.apache.poi.hssf.eventusermodel.examples.
  * As with the HSSF version, this tries to spot missing
@@ -171,7 +171,7 @@
     private final PrintStream output;
 
     /**
-     * Creates a new XLSX -> CSV examples
+     * Creates a new XLSX -&gt; CSV examples
      *
      * @param pkg        The XLSX package to process
      * @param output     The PrintStream to output the CSV to
diff --git a/examples/src/main/java/org/apache/poi/examples/xssf/usermodel/CalendarDemo.java b/examples/src/main/java/org/apache/poi/examples/xssf/usermodel/CalendarDemo.java
index 28f2c48..fa06960 100644
--- a/examples/src/main/java/org/apache/poi/examples/xssf/usermodel/CalendarDemo.java
+++ b/examples/src/main/java/org/apache/poi/examples/xssf/usermodel/CalendarDemo.java
@@ -45,7 +45,7 @@
  *
  * <pre>
  * Usage:
- * CalendarDemo <year>
+ * CalendarDemo &lt;year&gt;
  * </pre>
  *
  * @author Yegor Kozlov
diff --git a/examples/src/main/java/org/apache/poi/examples/xssf/usermodel/LoadPasswordProtectedXlsx.java b/examples/src/main/java/org/apache/poi/examples/xssf/usermodel/LoadPasswordProtectedXlsx.java
index 6e376f0..1ca5c34 100644
--- a/examples/src/main/java/org/apache/poi/examples/xssf/usermodel/LoadPasswordProtectedXlsx.java
+++ b/examples/src/main/java/org/apache/poi/examples/xssf/usermodel/LoadPasswordProtectedXlsx.java
@@ -35,7 +35,7 @@
  * <p><ul>
  * <li>The example demonstrates that all temp files are removed.
  * <li><code>AesZipFileZipEntrySource</code> is used to ensure that temp files are encrypted.
- * </ul><p>
+ * </ul></p>
  */
 @SuppressWarnings({"java:S106","java:S4823","java:S1192"})
 public final class LoadPasswordProtectedXlsx {
