[github-340] make more use of StandardCharsets. Thanks to XenoAmess. This closes #340

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1902755 13f79535-47bb-0310-9956-ffa450edef68

poi-examples/src/main/java/org/apache/poi/examples/hsmf/Msg2txt.java

 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintWriter;
+import java.nio.charset.StandardCharsets;
 
 import org.apache.poi.hsmf.MAPIMessage;
 import org.apache.poi.hsmf.datatypes.AttachmentChunks;
     public void processMessage() throws IOException {
         String txtFileName = fileNameStem + ".txt";
         String attDirName = fileNameStem + "-att";
-        try (PrintWriter txtOut = new PrintWriter(txtFileName, "UTF-8")) {
+        try (PrintWriter txtOut = new PrintWriter(txtFileName, StandardCharsets.UTF_8.name())) {
             try {
                 String displayFrom = msg.getDisplayFrom();
                 txtOut.println("From: " + displayFrom);

poi-examples/src/main/java/org/apache/poi/examples/ss/html/ToHtml.java

             return;
         }
 
-        try (PrintWriter pw = new PrintWriter(args[1], "UTF-8")) {
+        try (PrintWriter pw = new PrintWriter(args[1], StandardCharsets.UTF_8.name())) {
             ToHtml toHtml = create(args[0], pw);
             toHtml.setCompleteHTML(true);
             toHtml.printPage();

poi-examples/src/main/java/org/apache/poi/examples/xssf/usermodel/BigGridDemo.java

 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
+import java.nio.charset.StandardCharsets;
 import java.util.Calendar;
 import java.util.Enumeration;
 import java.util.HashMap;
  */
 public final class BigGridDemo {
     private static final Logger LOG = LogManager.getLogger(BigGridDemo.class);
-    private static final String XML_ENCODING = "UTF-8";
 
     private static final Random rnd = new Random();
 
             tmp = TempFile.createTempFile("sheet", ".xml");
             try (
                     FileOutputStream stream = new FileOutputStream(tmp);
-                    Writer fw = new OutputStreamWriter(stream, XML_ENCODING)
+                    Writer fw = new OutputStreamWriter(stream, StandardCharsets.UTF_8)
                 ) {
                 generate(fw, styles);
             }
         }
 
         void beginSheet() throws IOException {
-            _out.write("<?xml version=\"1.0\" encoding=\""+XML_ENCODING+"\"?>" +
+            _out.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                     "<worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">" );
             _out.write("<sheetData>\n");
         }

poi-examples/src/test/java/org/apache/poi/integration/TestXLSX2CSV.java

         // remember and replace default error streams
         err = System.err;
 
-        PrintStream error = new PrintStream(errorBytes, true, "UTF-8");
+        PrintStream error = new PrintStream(errorBytes, true, StandardCharsets.UTF_8.name());
         System.setErr(error);
     }
 
         // returns with some System.err
         XLSX2CSV.main(new String[] { "not-existing-file.xlsx" });
 
-        String output = errorBytes.toString("UTF-8");
+        String output = errorBytes.toString(StandardCharsets.UTF_8);
         assertTrue(output.contains("Not found or not a file: not-existing-file.xlsx"), "Had: " + output);
     }
 
     @Test
     public void testSampleFile() throws Exception {
         final UnsynchronizedByteArrayOutputStream outputBytes = new UnsynchronizedByteArrayOutputStream();
-        PrintStream out = new PrintStream(outputBytes, true, "UTF-8");
+        PrintStream out = new PrintStream(outputBytes, true, StandardCharsets.UTF_8.name());
 
         // The package open is instantaneous, as it should be.
         try (OPCPackage p = OPCPackage.open(XSSFTestDataSamples.getSampleFile("sample.xlsx").getAbsolutePath(), PackageAccess.READ)) {
     @Test
     public void testMinColumns() throws Exception {
         final UnsynchronizedByteArrayOutputStream outputBytes = new UnsynchronizedByteArrayOutputStream();
-        PrintStream out = new PrintStream(outputBytes, true, "UTF-8");
+        PrintStream out = new PrintStream(outputBytes, true, StandardCharsets.UTF_8.name());
 
         // The package open is instantaneous, as it should be.
         try (OPCPackage p = OPCPackage.open(XSSFTestDataSamples.getSampleFile("sample.xlsx").getAbsolutePath(), PackageAccess.READ)) {

poi-ooxml/src/main/java/org/apache/poi/xdgf/util/HierarchyPrinter.java

 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
 
 import org.apache.poi.xdgf.usermodel.XDGFPage;
 import org.apache.poi.xdgf.usermodel.XDGFShape;
 
         try (
                 OutputStream os = new FileOutputStream(pageFile);
-                PrintStream pos = new PrintStream(os, false, "utf-8")
+                PrintStream pos = new PrintStream(os, false, StandardCharsets.UTF_8.name())
             ) {
             printHierarchy(page, pos);
         }

poi-ooxml/src/main/java/org/apache/poi/xssf/streaming/StreamingSheetWriter.java

 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
+import java.nio.charset.StandardCharsets;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
      * @param out the output stream to write to
      */
     protected static Writer createWriter(OutputStream out) throws IOException {
-        return new BufferedWriter(new OutputStreamWriter(out, "UTF-8"));
+        return new BufferedWriter(new OutputStreamWriter(out, StandardCharsets.UTF_8));
     }
 
     @Override

poi-ooxml/src/test/java/org/apache/poi/xssf/extractor/TestXSSFExportToXML.java

                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xml = os.toString("UTF-8");
+                String xml = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xml);
                 assertFalse(xml.isEmpty());
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xml = os.toString("UTF-8");
+                String xml = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xml);
                 assertFalse(xml.isEmpty());
                     String xml;
                     try (UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream()) {
                         exporter.exportToXML(os, true);
-                        xml = os.toString("UTF-8");
+                        xml = os.toString(StandardCharsets.UTF_8);
                     }
                     assertNotNull(xml);
 
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
 
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, false);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
                 XSSFExportToXml exporter = new XSSFExportToXml(map);
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, true);
-                String xmlData = os.toString("UTF-8");
+                String xmlData = os.toString(StandardCharsets.UTF_8);
 
                 assertNotNull(xmlData);
                 assertFalse(xmlData.isEmpty());
 
                 UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(os, false);
-                assertNotNull(os.toString("UTF-8"));
+                assertNotNull(os.toString(StandardCharsets.UTF_8));
             }
         }
     }
                 UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
                 exporter.exportToXML(bos, true);
                 assertNotNull(DocumentHelper.readDocument(bos.toInputStream()));
-                String exportedXml = bos.toString("UTF-8");
+                String exportedXml = bos.toString(StandardCharsets.UTF_8);
                 assertEquals("<Test><Test>1</Test></Test>", exportedXml.replaceAll("\\s+", ""));
             }
         }

poi-scratchpad/src/main/java/org/apache/poi/hdgf/chunks/Chunk.java

                     }
 
                     int strLen = endsAt - startsAt;
-                    command.value = new String(contents, startsAt, strLen, header.getChunkCharset().name());
+                    command.value = new String(contents, startsAt, strLen, header.getChunkCharset());
                     break;
                 case 25:
                     command.value = LittleEndian.getShort(contents, offset);

poi-scratchpad/src/main/java/org/apache/poi/hdgf/chunks/ChunkHeaderV4V5.java

 package org.apache.poi.hdgf.chunks;
 
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 
 /**
  * A chunk header from v4 or v5
 
     @Override
     public Charset getChunkCharset() {
-        return Charset.forName("ASCII");
+        return StandardCharsets.US_ASCII;
     }
 
     void setUnknown2(short unknown2) {

poi-scratchpad/src/main/java/org/apache/poi/hdgf/chunks/ChunkHeaderV6.java

 package org.apache.poi.hdgf.chunks;
 
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 
 /**
  * A chunk header from v6
 
     @Override
     public Charset getChunkCharset() {
-        return Charset.forName("ASCII");
+        return StandardCharsets.US_ASCII;
     }
 
     void setUnknown2(short unknown2) {

poi-scratchpad/src/main/java/org/apache/poi/hsmf/datatypes/MessageSubmissionChunk.java

 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.Calendar;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
     public void readValue(InputStream value) throws IOException {
         // Stored in the file as us-ascii
         byte[] data = IOUtils.toByteArray(value);
-        rawId = new String(data, Charset.forName("ASCII"));
+        rawId = new String(data, StandardCharsets.US_ASCII);
 
         // Now process the date
         String[] parts = rawId.split(";");
 
     @Override
     public void writeValue(OutputStream out) throws IOException {
-        byte[] data = rawId.getBytes(Charset.forName("ASCII"));
+        final byte[] data = rawId.getBytes(StandardCharsets.US_ASCII);
         out.write(data);
     }
 

poi/src/test/java/org/apache/poi/ss/formula/function/ExcelCetabFunctionExtractor.java

 
     private static void processFile(InputStream input, File outFile) throws IOException {
         try (OutputStream os = new SimpleAsciiOutputStream(new FileOutputStream(outFile));
-        PrintStream ps = new PrintStream(os, true, "UTF-8")) {
+        PrintStream ps = new PrintStream(os, true, StandardCharsets.UTF_8.name())) {
 
             outputLicenseHeader(ps);
             Class<?> genClass = ExcelCetabFunctionExtractor.class;

poi/src/test/java/org/apache/poi/ss/formula/function/ExcelFileFormatDocFunctionExtractor.java

 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLConnection;
+import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.util.ArrayList;
 import java.util.Arrays;
         os = new SimpleAsciiOutputStream(os);
         PrintStream ps;
         try {
-            ps = new PrintStream(os, true, "UTF-8");
+            ps = new PrintStream(os, true, StandardCharsets.UTF_8.name());
         } catch(UnsupportedEncodingException e) {
             throw new RuntimeException(e);
         }