diff --git a/jdk/test/java/text/Format/DateFormat/Bug4322313.java b/jdk/test/java/text/Format/DateFormat/Bug4322313.java
index bea772e63e6..b6ddef99a1b 100644
--- a/jdk/test/java/text/Format/DateFormat/Bug4322313.java
+++ b/jdk/test/java/text/Format/DateFormat/Bug4322313.java
@@ -50,110 +50,110 @@ public class Bug4322313 extends IntlTest {
 
         Object[][] valids = {
           /* given ID      offset                format('z'), ('Z')    index */
-            {"GMT+03:04",  new Long(-184 * mpm), "GMT+03:04", "+0304", new Integer(9)},
-            {"GMT+13:42",  new Long(-822 * mpm), "GMT+13:42", "+1342", new Integer(9)},
-            {"GMT+00:00",  new Long(0),          "GMT+00:00", "+0000", new Integer(9)},
-            {"GMT+1:11",   new Long(-71 * mpm),  "GMT+01:11", "+0111", new Integer(8)},
-            {"GMT +13:42", new Long(0),          "GMT",       "+0000", new Integer(3)},
-            {" GMT",       new Long(0),          "GMT",       "+0000", new Integer(4)},
-            {"+0304",      new Long(-184 * mpm), "GMT+03:04", "+0304", new Integer(5)},
-            {"+1342",      new Long(-822 * mpm), "GMT+13:42", "+1342", new Integer(5)},
-            {"+0000",      new Long(0),          "GMT+00:00", "+0000", new Integer(5)},
-            {" +1342",     new Long(-822 * mpm), "GMT+13:42", "+1342", new Integer(6)},
+            {"GMT+03:04",  -184L * mpm, "GMT+03:04", "+0304", 9},
+            {"GMT+13:42",  -822L * mpm, "GMT+13:42", "+1342", 9},
+            {"GMT+00:00",   0L,         "GMT+00:00", "+0000", 9},
+            {"GMT+1:11",   -71L * mpm,  "GMT+01:11", "+0111", 8},
+            {"GMT +13:42",  0L,         "GMT",       "+0000", 3},
+            {" GMT",        0L,         "GMT",       "+0000", 4},
+            {"+0304",      -184L * mpm, "GMT+03:04", "+0304", 5},
+            {"+1342",      -822L * mpm, "GMT+13:42", "+1342", 5},
+            {"+0000",       0L,         "GMT+00:00", "+0000", 5},
+            {" +1342",     -822L * mpm, "GMT+13:42", "+1342", 6},
             /* ISO-LATIN-1 digits */
-            {"GMT+\u0030\u0031:\u0032\u0033", new Long(-83 * mpm), "GMT+01:23", "+0123", new Integer(9)},
+            {"GMT+\u0030\u0031:\u0032\u0033", -83L * mpm, "GMT+01:23", "+0123", 9},
 
            /* In fact, this test case is skipped because TimeZone class can't
             * recognize TimeZone IDs like "+00234" or "-00234".
             */
-            {"+00234",     new Long(-23 * mpm), "GMT+00:23", "+0023", new Integer(5)},
+            {"+00234",     -23L * mpm, "GMT+00:23", "+0023", 5},
 
-            {"GMT-03:04",  new Long(184 * mpm), "GMT-03:04", "-0304", new Integer(9)},
-            {"GMT-13:42",  new Long(822 * mpm), "GMT-13:42", "-1342", new Integer(9)},
-            {"GMT-00:00",  new Long(0),         "GMT+00:00", "+0000", new Integer(9)},
-            {"GMT-1:11",   new Long(71 * mpm),  "GMT-01:11", "-0111", new Integer(8)},
-            {"GMT -13:42", new Long(0),         "GMT",       "+0000", new Integer(3)},
-            {"-0304",      new Long(184 * mpm), "GMT-03:04", "-0304", new Integer(5)},
-            {"-1342",      new Long(822 * mpm), "GMT-13:42", "-1342", new Integer(5)},
-            {" -1342",     new Long(822 * mpm), "GMT-13:42", "-1342", new Integer(6)},
+            {"GMT-03:04",  184L * mpm, "GMT-03:04", "-0304", 9},
+            {"GMT-13:42",  822L * mpm, "GMT-13:42", "-1342", 9},
+            {"GMT-00:00",  0L,         "GMT+00:00", "+0000", 9},
+            {"GMT-1:11",   71L * mpm,  "GMT-01:11", "-0111", 8},
+            {"GMT -13:42", 0L,         "GMT",       "+0000", 3},
+            {"-0304",      184L * mpm, "GMT-03:04", "-0304", 5},
+            {"-1342",      822L * mpm, "GMT-13:42", "-1342", 5},
+            {" -1342",     822L * mpm, "GMT-13:42", "-1342", 6},
             /* ISO-LATIN-1 digits */
-            {"GMT-\u0030\u0031:\u0032\u0033", new Long(83 * mpm), "GMT-01:23", "-0123", new Integer(9)},
+            {"GMT-\u0030\u0031:\u0032\u0033", 83L * mpm, "GMT-01:23", "-0123", 9},
            /* In fact, this test case is skipped because TimeZone class can't
             * recognize TimeZone IDs like "+00234" or "-00234".
             */
-            {"-00234",     new Long(23 * mpm),  "GMT+00:23", "-0023", new Integer(5)},
+            {"-00234",     23L * mpm,  "GMT+00:23", "-0023", 5},
         };
 
         Object[][] invalids = {
           /* given ID       error index   */
-            {"GMT+8",       new Integer(5)},
-            {"GMT+18",      new Integer(6)},
-            {"GMT+208",     new Integer(6)},
-            {"GMT+0304",    new Integer(6)},
-            {"GMT+42195",   new Integer(5)},
-            {"GMT+5:8",     new Integer(7)},
-            {"GMT+23:60",   new Integer(8)},
-            {"GMT+11:1",    new Integer(8)},
-            {"GMT+24:13",   new Integer(5)},
-            {"GMT+421:950", new Integer(5)},
-            {"GMT+0a:0A",   new Integer(5)},
-            {"GMT+ 13:42",  new Integer(4)},
-            {"GMT+13 :42",  new Integer(6)},
-            {"GMT+13: 42",  new Integer(7)},
-            {"GMT+-13:42",  new Integer(4)},
-            {"G M T",       new Integer(0)},
-            {"+8",          new Integer(2)},
-            {"+18",         new Integer(3)},
-            {"+208",        new Integer(4)},
-            {"+2360",       new Integer(4)},
-            {"+2413",       new Integer(2)},
-            {"+42195",      new Integer(2)},
-            {"+0AbC",       new Integer(2)},
-            {"+ 1342",      new Integer(1)},
-            {"+-1342",      new Integer(1)},
-            {"1342",        new Integer(0)},
+            {"GMT+8",       5},
+            {"GMT+18",      6},
+            {"GMT+208",     6},
+            {"GMT+0304",    6},
+            {"GMT+42195",   5},
+            {"GMT+5:8",     7},
+            {"GMT+23:60",   8},
+            {"GMT+11:1",    8},
+            {"GMT+24:13",   5},
+            {"GMT+421:950", 5},
+            {"GMT+0a:0A",   5},
+            {"GMT+ 13:42",  4},
+            {"GMT+13 :42",  6},
+            {"GMT+13: 42",  7},
+            {"GMT+-13:42",  4},
+            {"G M T",       0},
+            {"+8",          2},
+            {"+18",         3},
+            {"+208",        4},
+            {"+2360",       4},
+            {"+2413",       2},
+            {"+42195",      2},
+            {"+0AbC",       2},
+            {"+ 1342",      1},
+            {"+-1342",      1},
+            {"1342",        0},
           /* Arabic-Indic digits */
-            {"GMT+\u0660\u0661:\u0662\u0663", new Integer(4)},
+            {"GMT+\u0660\u0661:\u0662\u0663", 4},
           /* Extended Arabic-Indic digits */
-            {"GMT+\u06f0\u06f1:\u06f2\u06f3", new Integer(4)},
+            {"GMT+\u06f0\u06f1:\u06f2\u06f3", 4},
           /* Devanagari digits */
-            {"GMT+\u0966\u0967:\u0968\u0969", new Integer(4)},
+            {"GMT+\u0966\u0967:\u0968\u0969", 4},
           /* Fullwidth digits */
-            {"GMT+\uFF10\uFF11:\uFF12\uFF13", new Integer(4)},
+            {"GMT+\uFF10\uFF11:\uFF12\uFF13", 4},
 
-            {"GMT-8",       new Integer(5)},
-            {"GMT-18",      new Integer(6)},
-            {"GMT-208",     new Integer(6)},
-            {"GMT-0304",    new Integer(6)},
-            {"GMT-42195",   new Integer(5)},
-            {"GMT-5:8",     new Integer(7)},
-            {"GMT-23:60",   new Integer(8)},
-            {"GMT-11:1",    new Integer(8)},
-            {"GMT-24:13",   new Integer(5)},
-            {"GMT-421:950", new Integer(5)},
-            {"GMT-0a:0A",   new Integer(5)},
-            {"GMT- 13:42",  new Integer(4)},
-            {"GMT-13 :42",  new Integer(6)},
-            {"GMT-13: 42",  new Integer(7)},
-            {"GMT-+13:42",  new Integer(4)},
-            {"-8",          new Integer(2)},
-            {"-18",         new Integer(3)},
-            {"-208",        new Integer(4)},
-            {"-2360",       new Integer(4)},
-            {"-2413",       new Integer(2)},
-            {"-42195",      new Integer(2)},
-            {"-0AbC",       new Integer(2)},
-            {"- 1342",      new Integer(1)},
-            {"--1342",      new Integer(1)},
-            {"-802",        new Integer(2)},
+            {"GMT-8",       5},
+            {"GMT-18",      6},
+            {"GMT-208",     6},
+            {"GMT-0304",    6},
+            {"GMT-42195",   5},
+            {"GMT-5:8",     7},
+            {"GMT-23:60",   8},
+            {"GMT-11:1",    8},
+            {"GMT-24:13",   5},
+            {"GMT-421:950", 5},
+            {"GMT-0a:0A",   5},
+            {"GMT- 13:42",  4},
+            {"GMT-13 :42",  6},
+            {"GMT-13: 42",  7},
+            {"GMT-+13:42",  4},
+            {"-8",          2},
+            {"-18",         3},
+            {"-208",        4},
+            {"-2360",       4},
+            {"-2413",       2},
+            {"-42195",      2},
+            {"-0AbC",       2},
+            {"- 1342",      1},
+            {"--1342",      1},
+            {"-802",        2},
           /* Arabic-Indic digits */
-            {"GMT-\u0660\u0661:\u0662\u0663", new Integer(4)},
+            {"GMT-\u0660\u0661:\u0662\u0663", 4},
           /* Extended Arabic-Indic digits */
-            {"GMT-\u06f0\u06f1:\u06f2\u06f3", new Integer(4)},
+            {"GMT-\u06f0\u06f1:\u06f2\u06f3", 4},
           /* Devanagari digits */
-            {"GMT-\u0966\u0967:\u0968\u0969", new Integer(4)},
+            {"GMT-\u0966\u0967:\u0968\u0969", 4},
           /* Fullwidth digits */
-            {"GMT-\uFF10\uFF11:\uFF12\uFF13", new Integer(4)},
+            {"GMT-\uFF10\uFF11:\uFF12\uFF13", 4},
         };
 
         try {
diff --git a/jdk/test/java/text/Format/DateFormat/Bug4736959.java b/jdk/test/java/text/Format/DateFormat/Bug4736959.java
index cdb9cad20b4..00fa8d0840a 100644
--- a/jdk/test/java/text/Format/DateFormat/Bug4736959.java
+++ b/jdk/test/java/text/Format/DateFormat/Bug4736959.java
@@ -30,6 +30,7 @@
 import java.text.*;
 import java.util.*;
 
+@SuppressWarnings("deprecation")
 public class Bug4736959 {
     /**
      * 4736959: JSpinner won't work for AM/PM field
diff --git a/jdk/test/java/text/Format/DateFormat/Bug4823811.java b/jdk/test/java/text/Format/DateFormat/Bug4823811.java
index c2d35e9f64f..b1f6c9d5b9d 100644
--- a/jdk/test/java/text/Format/DateFormat/Bug4823811.java
+++ b/jdk/test/java/text/Format/DateFormat/Bug4823811.java
@@ -685,8 +685,8 @@ public class Bug4823811 {
         testNumberFormatFormatting(nfEG, -456, "456-", "ar_EG");
 
         System.out.println("*** DecimalFormat.parse test in ar_EG");
-        testNumberFormatParsing(nfEG, "123-", new Long(-123), "ar_EG");
-        testNumberFormatParsing(nfEG, "123--", new Long(-123), "ar_EG");
+        testNumberFormatParsing(nfEG, "123-", -123L, "ar_EG");
+        testNumberFormatParsing(nfEG, "123--",-123L, "ar_EG");
         testNumberFormatParsingCheckException(nfEG, "-123", 0, "ar_EG");
 
         System.out.println("*** DecimalFormat.format test in en_US");
@@ -694,8 +694,8 @@ public class Bug4823811 {
         testNumberFormatFormatting(nfUS, -456, "-456", "en_US");
 
         System.out.println("*** DecimalFormat.parse test in en_US");
-        testNumberFormatParsing(nfUS, "123-", new Long(123), "en_US");
-        testNumberFormatParsing(nfUS, "-123", new Long(-123), "en_US");
+        testNumberFormatParsing(nfUS, "123-", 123L, "en_US");
+        testNumberFormatParsing(nfUS, "-123",-123L, "en_US");
         testNumberFormatParsingCheckException(nfUS, "--123", 0, "en_US");
     }
 
diff --git a/jdk/test/java/text/Format/DateFormat/Bug4845901.java b/jdk/test/java/text/Format/DateFormat/Bug4845901.java
index a88b47a761e..363a3518bf0 100644
--- a/jdk/test/java/text/Format/DateFormat/Bug4845901.java
+++ b/jdk/test/java/text/Format/DateFormat/Bug4845901.java
@@ -55,6 +55,7 @@ public class Bug4845901 {
         }
     }
 
+    @SuppressWarnings("deprecation")
     static void testParse(SimpleDateFormat sdf, String str, int expectedHour) {
         try {
             Date parsedDate = sdf.parse(str);
diff --git a/jdk/test/java/text/Format/DateFormat/Bug6609750.java b/jdk/test/java/text/Format/DateFormat/Bug6609750.java
index ccd5d5e814b..5529bc6c812 100644
--- a/jdk/test/java/text/Format/DateFormat/Bug6609750.java
+++ b/jdk/test/java/text/Format/DateFormat/Bug6609750.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -37,6 +37,7 @@ public class Bug6609750 {
         Locale defaultLocale = Locale.getDefault();
         Locale.setDefault(Locale.US);
 
+        @SuppressWarnings("deprecation")
         Date[] dates = {
             new Date(9-1900,     Calendar.JUNE, 12),
             new Date(99-1900,    Calendar.JUNE, 12),
diff --git a/jdk/test/java/text/Format/DateFormat/Bug6683975.java b/jdk/test/java/text/Format/DateFormat/Bug6683975.java
index 1f401058e5a..0afdcd74c4a 100644
--- a/jdk/test/java/text/Format/DateFormat/Bug6683975.java
+++ b/jdk/test/java/text/Format/DateFormat/Bug6683975.java
@@ -66,6 +66,7 @@ public class Bug6683975 {
             System.err.println("\tth_TH: " + str_th_TH);
         }
 
+        @SuppressWarnings("deprecation")
         Date date = new Date(2008-1900, Calendar.SEPTEMBER, 30, 8, 0, 0);
         str_th = df_th.format(date);
         if (!expected_th[style].equals(str_th)) {
diff --git a/jdk/test/java/text/Format/DateFormat/DateFormatRegression.java b/jdk/test/java/text/Format/DateFormat/DateFormatRegression.java
index 5c416b0dc53..d4230fb2cb7 100644
--- a/jdk/test/java/text/Format/DateFormat/DateFormatRegression.java
+++ b/jdk/test/java/text/Format/DateFormat/DateFormatRegression.java
@@ -41,7 +41,7 @@ public class DateFormatRegression extends IntlTest {
     }
 
     public void Test4029195() {
-
+        @SuppressWarnings("deprecation")
         Date today = new Date();
 
         logln("today: " + today);
@@ -74,19 +74,20 @@ public class DateFormatRegression extends IntlTest {
     public void Test4052408() {
         DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.SHORT,
                                                         DateFormat.SHORT, Locale.US);
+        @SuppressWarnings("deprecation")
         Date date = new Date(97, Calendar.MAY, 3, 8, 55);
         String str;
         logln(str = fmt.format(date));
 
         if (!str.equals("5/3/97 8:55 AM"))
             errln("Fail: Test broken; Want 5/3/97 8:55 AM Got " + str);
-        Hashtable expected = new Hashtable();
-        expected.put(new Integer(DateFormat.MONTH_FIELD), "5");
-        expected.put(new Integer(DateFormat.DATE_FIELD), "3");
-        expected.put(new Integer(DateFormat.YEAR_FIELD), "97");
-        expected.put(new Integer(DateFormat.HOUR1_FIELD), "8");
-        expected.put(new Integer(DateFormat.MINUTE_FIELD), "55");
-        expected.put(new Integer(DateFormat.AM_PM_FIELD), "AM");
+        Map<Integer,String> expected = new HashMap<>();
+        expected.put(DateFormat.MONTH_FIELD, "5");
+        expected.put(DateFormat.DATE_FIELD, "3");
+        expected.put(DateFormat.YEAR_FIELD, "97");
+        expected.put(DateFormat.HOUR1_FIELD, "8");
+        expected.put(DateFormat.MINUTE_FIELD, "55");
+        expected.put(DateFormat.AM_PM_FIELD, "AM");
 
         StringBuffer buf = new StringBuffer();
         String fieldNames[] = {
@@ -120,7 +121,7 @@ public class DateFormatRegression extends IntlTest {
                              ", \"" + str + "\", " +
                              pos.getBeginIndex() + ", " +
                              pos.getEndIndex());
-            String exp = (String) expected.get(new Integer(i));
+            String exp = expected.get(i);
             if ((exp == null && str.length() == 0) ||
                 str.equals(exp))
                 logln(" ok");
@@ -135,6 +136,7 @@ public class DateFormatRegression extends IntlTest {
     /**
      * Verify the function of the [s|g]et2DigitYearStart() API.
      */
+    @SuppressWarnings("deprecation")
     public void Test4056591() {
         try {
             SimpleDateFormat fmt = new SimpleDateFormat("yyMMdd", Locale.US);
@@ -255,6 +257,7 @@ public class DateFormatRegression extends IntlTest {
         if (!ok) errln("Fail: Lenient not working");
     }
 
+    @SuppressWarnings("deprecation")
     public void Test4065240() {
         Date curDate;
         DateFormat shortdate, fulldate;
@@ -297,6 +300,7 @@ public class DateFormatRegression extends IntlTest {
 
       Currently this bug breaks MessageFormat.toPattern
       */
+    @SuppressWarnings("deprecation")
     public void Test4071441() {
         DateFormat fmtA = DateFormat.getInstance();
         DateFormat fmtB = DateFormat.getInstance();
@@ -488,6 +492,7 @@ public class DateFormatRegression extends IntlTest {
     public void Test4101483() {
         SimpleDateFormat sdf = new SimpleDateFormat("z", Locale.US);
         FieldPosition fp = new FieldPosition(DateFormat.TIMEZONE_FIELD);
+        @SuppressWarnings("deprecation")
         Date d= new Date(9234567890L);
         StringBuffer buf = new StringBuffer("");
         logln(sdf.format(d, buf, fp).toString());
@@ -508,6 +513,7 @@ public class DateFormatRegression extends IntlTest {
     public void Test4103340() {
         // choose a date that is the FIRST of some month
         // and some arbitrary time
+        @SuppressWarnings("deprecation")
         Date d=new Date(97, 3, 1, 1, 1, 1);
         SimpleDateFormat df=new SimpleDateFormat("MMMM", Locale.US);
 
@@ -538,6 +544,7 @@ public class DateFormatRegression extends IntlTest {
         sdf.applyPattern(pattern);
         logln("pattern: \"" + pattern + "\"");
 
+        @SuppressWarnings("deprecation")
         Object[] DATA = {
             "time 10:30", new ParsePosition(10), new Date(70, Calendar.JANUARY, 1, 10, 30),
             "time 10:x", new ParsePosition(0), null,
@@ -698,6 +705,7 @@ public class DateFormatRegression extends IntlTest {
         String pattern = "'TO_DATE('''dd'-'MM'-'yyyy HH:mm:ss''' , ''DD-MM-YYYY HH:MI:SS'')'";
         logln("pattern=" + pattern);
         SimpleDateFormat format = new SimpleDateFormat(pattern, Locale.US);
+        @SuppressWarnings("deprecation")
         String result = format.format(new Date(1998-1900, Calendar.JUNE, 30, 13, 30, 0));
         if (!result.equals("TO_DATE('30-06-1998 13:30:00' , 'DD-MM-YYYY HH:MI:SS')")) {
             errln("Fail: result=" + result);
@@ -711,6 +719,7 @@ public class DateFormatRegression extends IntlTest {
      * 'z' at end of date format throws index exception in SimpleDateFormat
      * CANNOT REPRODUCE THIS BUG ON 1.2FCS
      */
+    @SuppressWarnings("deprecation")
     public void Test4151706() {
         SimpleDateFormat fmt =
             new SimpleDateFormat("EEEE, dd-MMM-yy HH:mm:ss z", Locale.US);
@@ -755,6 +764,7 @@ public class DateFormatRegression extends IntlTest {
      * Confirm that "EST"(GMT-5:00) and "CST"(GMT-6:00) are used in US
      * as "EST" or "CST", not Australian "EST" and "CST".
      */
+    @SuppressWarnings("deprecation")
     public void Test4406615() {
       Locale savedLocale = Locale.getDefault();
       TimeZone savedTimeZone = TimeZone.getDefault();
@@ -823,6 +833,7 @@ public class DateFormatRegression extends IntlTest {
          * greater than "99", are treated as literal years.  So "1/2/3456"
          * becomes 3456 AD.  Likewise, "1/2/-3" becomes -3 AD == 2 BC.
          */
+        @SuppressWarnings("deprecation")
         Object[] DATA = {
             "02/29/00",   new Date(2000-1900, Calendar.FEBRUARY, 29),
             "01/23/01",   new Date(2001-1900, Calendar.JANUARY,  23),
@@ -878,6 +889,7 @@ public class DateFormatRegression extends IntlTest {
         DateFormat fmt = new SimpleDateFormat(pattern,
                                               DateFormatSymbols.getInstance(Locale.US));
         fmt.getCalendar().setLenient(false);
+        @SuppressWarnings("deprecation")
         Date d = new Date(2000-1900, Calendar.FEBRUARY, 29);
         String s = fmt.format(d);
         logln(d + " x " + pattern + " => " + s);
@@ -957,6 +969,7 @@ public class DateFormatRegression extends IntlTest {
         }
     }
 
+    @SuppressWarnings("deprecation")
     public void Test4253490() throws ParseException {
         SimpleDateFormat fmt = new SimpleDateFormat("S", Locale.US);
 
@@ -1026,6 +1039,7 @@ public class DateFormatRegression extends IntlTest {
     public void Test4250359() {
         DateFormat df = DateFormat.getTimeInstance(DateFormat.SHORT,
                                                    Locale.US);
+        @SuppressWarnings("deprecation")
         Date d = new Date(1999-1900, Calendar.DECEMBER, 25,
                           1, 2, 3);
         String s = df.format(d);
@@ -1052,6 +1066,7 @@ public class DateFormatRegression extends IntlTest {
         // pick up another time zone when L10N is done to that file.
         TimeZone.setDefault(TimeZone.getTimeZone("PST"));
         SimpleDateFormat fmt = new SimpleDateFormat("yy/MM/dd hh:ss zzz", Locale.JAPAN);
+        @SuppressWarnings("deprecation")
         String result = fmt.format(new Date(1999, 0, 1));
         logln("format()=>" + result);
         if (!result.endsWith("PST")) {
diff --git a/jdk/test/java/text/Format/DateFormat/DateFormatRoundTripTest.java b/jdk/test/java/text/Format/DateFormat/DateFormatRoundTripTest.java
index 73d023163f1..9bf3ac3835a 100644
--- a/jdk/test/java/text/Format/DateFormat/DateFormatRoundTripTest.java
+++ b/jdk/test/java/text/Format/DateFormat/DateFormatRoundTripTest.java
@@ -104,7 +104,7 @@ public class DateFormatRoundTripTest extends IntlTest {
         String pat = null;
         Date date = null;
 
-        Vector newArgs = new Vector();
+        List<String> newArgs = new ArrayList<>();
         for (int i=0; i<args.length; ++i) {
             if (args[i].equals("-locale")
                 && (i+1) < args.length) {
@@ -131,13 +131,13 @@ public class DateFormatRoundTripTest extends IntlTest {
                 seed = Long.parseLong(args[i+1]);
                 ++i;
             } else {
-                newArgs.addElement(args[i]);
+                newArgs.add(args[i]);
             }
         }
 
         if (newArgs.size() != args.length) {
             args = new String[newArgs.size()];
-            newArgs.copyInto(args);
+            newArgs.addAll(Arrays.asList(args));
         }
 
         new DateFormatRoundTripTest(random, seed, infinite, date, pat, loc).run(args);
@@ -193,6 +193,7 @@ public class DateFormatRoundTripTest extends IntlTest {
          * Return the Date of this test case; must be called with the default
          * zone set to this TestCase's zone.
          */
+        @SuppressWarnings("deprecation")
         Date getDate() {
             if (_date == null) {
                 // Date constructor will work right iff we are in the target zone
diff --git a/jdk/test/java/text/Format/DateFormat/DateFormatSymbolsCloneTest.java b/jdk/test/java/text/Format/DateFormat/DateFormatSymbolsCloneTest.java
index 7214d1fa8d5..99b59a1a713 100644
--- a/jdk/test/java/text/Format/DateFormat/DateFormatSymbolsCloneTest.java
+++ b/jdk/test/java/text/Format/DateFormat/DateFormatSymbolsCloneTest.java
@@ -29,6 +29,7 @@
  */
 import java.text.DateFormatSymbols;
 
+@SuppressWarnings("serial")
 public class DateFormatSymbolsCloneTest extends DateFormatSymbols {
     private int value;
 
diff --git a/jdk/test/java/text/Format/DateFormat/NonGregorianFormatTest.java b/jdk/test/java/text/Format/DateFormat/NonGregorianFormatTest.java
index b811900901d..93e2a9ffeee 100644
--- a/jdk/test/java/text/Format/DateFormat/NonGregorianFormatTest.java
+++ b/jdk/test/java/text/Format/DateFormat/NonGregorianFormatTest.java
@@ -36,6 +36,7 @@ import static java.util.Calendar.*;
 public class NonGregorianFormatTest {
     static int errors;
 
+    @SuppressWarnings("deprecation")
     static final Object[][] JAPANESE_EN = {
         { "GGGG yyyy MMMM d", "Showa 1 December 31", new Date(1926-1900, DECEMBER, 31) },
         { "GGGG yyyy MMMM d", "Showa 64 January 6", new Date(1989-1900, JANUARY, 6) },
@@ -58,6 +59,7 @@ public class NonGregorianFormatTest {
         { "Gyy.MM.dd", "H01.01.01" },
     };
 
+    @SuppressWarnings("deprecation")
     static final Object[][] BUDDHIST_EN = {
         { "GGGG yyyy MMMM d", "B.E. 2469 December 31", new Date(1926-1900, DECEMBER, 31) },
         { "GGGG yyyy MMMM d", "B.E. 2532 January 6", new Date(1989-1900, JANUARY, 6) },
@@ -71,6 +73,7 @@ public class NonGregorianFormatTest {
 
     static final String FULL_DATE_FORMAT_JA = "GGGGyyyy'\u5e74'M'\u6708'd'\u65e5'";
 
+    @SuppressWarnings("deprecation")
     static final Object[][] JAPANESE_JA = {
         { FULL_DATE_FORMAT_JA, "\u662d\u548c\u5143\u5e7412\u670831\u65e5", new Date(1926-1900, DECEMBER, 31) },
         { FULL_DATE_FORMAT_JA, "\u662d\u548c64\u5e741\u67086\u65e5", new Date(1989-1900, JANUARY, 6) },
@@ -93,6 +96,7 @@ public class NonGregorianFormatTest {
         { "Gyy.MM.dd", "H01.01.01" },
     };
 
+    @SuppressWarnings("deprecation")
     static final Object[][] BUDDHIST_JA = {
         { FULL_DATE_FORMAT_JA, "\u4ecf\u66a62469\u5e7412\u670831\u65e5", new Date(1926-1900, DECEMBER, 31) },
         { FULL_DATE_FORMAT_JA, "\u4ecf\u66a62532\u5e741\u67086\u65e5", new Date(1989-1900, JANUARY, 6) },
@@ -137,6 +141,7 @@ public class NonGregorianFormatTest {
                             locale == Locale.ENGLISH ? BUDDHIST_EN : BUDDHIST_JA);
     }
 
+    @SuppressWarnings("deprecation")
     private static void testRoundTrip(Locale calendarLocale) {
         DateFormat df = DateFormat.getDateTimeInstance(DateFormat.FULL,
                                                        DateFormat.FULL,
diff --git a/jdk/test/java/text/Format/DateFormat/bug4358730.java b/jdk/test/java/text/Format/DateFormat/bug4358730.java
index fa67be47c9c..d1b8f395127 100644
--- a/jdk/test/java/text/Format/DateFormat/bug4358730.java
+++ b/jdk/test/java/text/Format/DateFormat/bug4358730.java
@@ -60,6 +60,7 @@ public class bug4358730 extends IntlTest {
             SimpleDateFormat sdf = new SimpleDateFormat();
 
             for (int i = 0; i < datasize; i++) {
+                @SuppressWarnings("deprecation")
                 Date d = new Date(year[i]-1900, 10, 15);
                 for (int j = 0; j < nPatterns; j++) {
                     sdf.applyPattern(patterns[j]);
diff --git a/jdk/test/java/text/Format/MessageFormat/Bug4185816Test.java b/jdk/test/java/text/Format/MessageFormat/Bug4185816Test.java
index 65609941f53..f0354c670ba 100644
--- a/jdk/test/java/text/Format/MessageFormat/Bug4185816Test.java
+++ b/jdk/test/java/text/Format/MessageFormat/Bug4185816Test.java
@@ -98,7 +98,7 @@ public class Bug4185816Test extends IntlTest {
             final InputStream is = HexDumpReader.getStreamFromHexDump(fileName + ".txt");
             final ObjectInputStream in = new ObjectInputStream(is);
             final MessageFormat form = (MessageFormat)in.readObject();
-            final Object[] testArgs = {new Long(12373), "MyDisk"};
+            final Object[] testArgs = {12373L, "MyDisk"};
             final String result = form.format(testArgs);
             in.close();
         } catch (Exception e) {
diff --git a/jdk/test/java/text/Format/MessageFormat/LargeMessageFormat.java b/jdk/test/java/text/Format/MessageFormat/LargeMessageFormat.java
index 55c9869c373..9ff3b1c62c8 100644
--- a/jdk/test/java/text/Format/MessageFormat/LargeMessageFormat.java
+++ b/jdk/test/java/text/Format/MessageFormat/LargeMessageFormat.java
@@ -56,18 +56,19 @@ public class LargeMessageFormat {
 
     private static void testFormat() {
         // construct large argument array
+        @SuppressWarnings("deprecation")
         Object[] sample = {
-                new Integer(0), // replace with running count below
+                 0, // replace with running count below
                 "hello",
                 new Date(89, 10, 9),
-                new Integer(567890),
-                new Double(1234.50)
+                567890,
+                1234.50
         };
         int samples = sample.length;
         Object[] arguments = new Object[REPEATS * (samples + 1)];
         for (int i = 0; i < REPEATS; i++) {
             System.arraycopy(sample, 0, arguments, i * samples, samples);
-            arguments[i * samples] = new Integer(i);
+            arguments[i * samples] = i;
         }
 
         // construct large template
diff --git a/jdk/test/java/text/Format/MessageFormat/MessageRegression.java b/jdk/test/java/text/Format/MessageFormat/MessageRegression.java
index 329506ffa35..1d71cc09892 100644
--- a/jdk/test/java/text/Format/MessageFormat/MessageRegression.java
+++ b/jdk/test/java/text/Format/MessageFormat/MessageRegression.java
@@ -136,7 +136,7 @@ public class MessageRegression extends IntlTest {
         try {
             logln("Apply with pattern : " + pattern1);
             messageFormatter.applyPattern(pattern1);
-            Object[] params = {new Integer(7)};
+            Object[] params = {7};
             String tempBuffer = messageFormatter.format(params);
             if (!tempBuffer.equals("Impossible {1} has occurred -- status code is 7 and message is {2}."))
                 errln("Tests arguments < substitution failed. Formatted text=" +
@@ -455,7 +455,7 @@ public class MessageRegression extends IntlTest {
             errln("argument0: \"" + objs[0] + "\"");
         mf.setLocale(Locale.US);
         mf.applyPattern("{0,number,#.##}, {0,number,#.#}");
-        Object[] oldobjs = {new Double(3.1415)};
+        Object[] oldobjs = {3.1415};
         String result = mf.format( oldobjs );
         logln("pattern: \"" + mf.toPattern() + "\"");
         logln("text for parsing: \"" + result + "\"");
@@ -481,7 +481,7 @@ public class MessageRegression extends IntlTest {
         ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
         form1.setFormat(1, fileform);
         form2.setFormat(0, fileform);
-        Object[] testArgs = {new Long(12373), "MyDisk"};
+        Object[] testArgs = {12373L, "MyDisk"};
         logln(form1.format(testArgs));
         logln(form2.format(testArgs));
     }
@@ -531,7 +531,7 @@ public class MessageRegression extends IntlTest {
         };
 
         for (int i=0; i<3; i++) {
-            String out = mf.format(new Object[]{new Integer(i)});
+            String out = mf.format(new Object[]{i});
             if (SUFFIX[i] == null) {
                 if (!out.equals(PREFIX[i]))
                     errln("" + i + ": Got \"" + out + "\"; Want \"" + PREFIX[i] + "\"");
@@ -607,8 +607,7 @@ public class MessageRegression extends IntlTest {
      */
     public void Test4169959() {
         // This works
-        logln(MessageFormat.format( "This will {0}",
-                                    new String[]{"work"} ) );
+        logln(MessageFormat.format( "This will {0}", "work"));
 
         // This fails
         logln(MessageFormat.format( "This will {0}",
diff --git a/jdk/test/java/text/Format/MessageFormat/MessageTest.java b/jdk/test/java/text/Format/MessageFormat/MessageTest.java
index 9234ae90c9f..a7542689563 100644
--- a/jdk/test/java/text/Format/MessageFormat/MessageTest.java
+++ b/jdk/test/java/text/Format/MessageFormat/MessageTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -52,7 +52,7 @@ public class MessageTest extends IntlTest {
 
    public void TestMSGPatternTest() {
         Object[] testArgs = {
-            new Double (1), new Double(3456),
+             1D, 3456D,
             "Disk", new Date(10000000000L)};
 
         String[] testCases = {
diff --git a/jdk/test/java/text/Format/NumberFormat/BigDecimalCompatibilityTest.java b/jdk/test/java/text/Format/NumberFormat/BigDecimalCompatibilityTest.java
index 1a2e7bf3945..2af23a4c82d 100644
--- a/jdk/test/java/text/Format/NumberFormat/BigDecimalCompatibilityTest.java
+++ b/jdk/test/java/text/Format/NumberFormat/BigDecimalCompatibilityTest.java
@@ -118,7 +118,7 @@ public class BigDecimalCompatibilityTest {
            bd = bd.divide(new BigDecimal(multiplier));
         }
         catch (ArithmeticException e) {
-           bd = bd.divide(new BigDecimal(multiplier), BigDecimal.ROUND_HALF_EVEN);
+           bd = bd.divide(new BigDecimal(multiplier), RoundingMode.HALF_EVEN);
         }
         check(num, bd, multiplier);
     }
diff --git a/jdk/test/java/text/Format/NumberFormat/BigDecimalFormat.java b/jdk/test/java/text/Format/NumberFormat/BigDecimalFormat.java
index 14b3a9fec62..2803bc8228e 100644
--- a/jdk/test/java/text/Format/NumberFormat/BigDecimalFormat.java
+++ b/jdk/test/java/text/Format/NumberFormat/BigDecimalFormat.java
@@ -793,7 +793,7 @@ public class BigDecimalFormat extends IntlTest {
         formatted.setLength(0);
         from = "123456789";
         to   = sep_zero.substring(0, 399) + ",123,456,789";
-        nf.format(new Long(from), formatted, new FieldPosition(0));
+        nf.format(123456789L, formatted, new FieldPosition(0));
         checkFormat(from, formatted, to, ((DecimalFormat)nf).getMultiplier());
 
         /* ------------------------------------------------------------------ */
@@ -810,7 +810,7 @@ public class BigDecimalFormat extends IntlTest {
         from = "123456789";
         to   = "-" + nonsep_zero.substring(0, 300) + "123456789." +
                nonsep_zero.substring(0, 340);
-        nf.format(new Long(from), formatted, new FieldPosition(0));
+        nf.format(123456789L, formatted, new FieldPosition(0));
         checkFormat(from, formatted, to, ((DecimalFormat)nf).getMultiplier());
 
         /* ------------------------------------------------------------------ */
@@ -827,7 +827,7 @@ public class BigDecimalFormat extends IntlTest {
         from = Long.toString(Long.MAX_VALUE);
         to   = sep_zero.substring(0, 373) +
                "19,807,040,619,342,712,359,383,728,129";
-        nf.format(new Long(from), formatted, new FieldPosition(0));
+        nf.format(Long.MAX_VALUE, formatted, new FieldPosition(0));
         checkFormat(from, formatted, to, ((DecimalFormat)nf).getMultiplier());
 
         /* ------------------------------------------------------------------ */
@@ -844,7 +844,7 @@ public class BigDecimalFormat extends IntlTest {
         from = Long.toString(Long.MAX_VALUE);
         to   = "-1.9807040628566084396238503936" +
                nonsep_zero.substring(0, 312) + "E28";
-        nf.format(new Long(from), formatted, new FieldPosition(0));
+        nf.format(Long.MAX_VALUE, formatted, new FieldPosition(0));
         checkFormat(from, formatted, to, ((DecimalFormat)nf).getMultiplier());
 
         /* ------------------------------------------------------------------ */
@@ -862,7 +862,7 @@ public class BigDecimalFormat extends IntlTest {
         to   = "-19807040619342712361531211776" +
                nonsep_zero.substring(0, 280) + "." +
                nonsep_zero.substring(0, 340) + "E-280";
-        nf.format(new Long(from), formatted, new FieldPosition(0));
+        nf.format(Long.MIN_VALUE, formatted, new FieldPosition(0));
         checkFormat(from, formatted, to, ((DecimalFormat)nf).getMultiplier());
 
         /* ------------------------------------------------------------------ */
@@ -880,7 +880,7 @@ public class BigDecimalFormat extends IntlTest {
         to   = sep_zero.substring(0, 373) +
                "19,807,040,628,566,084,398,385,987,584." +
                nonsep_zero.substring(0, 340);
-        nf.format(new Long(from), formatted, new FieldPosition(0));
+        nf.format(Long.MIN_VALUE, formatted, new FieldPosition(0));
         checkFormat(from, formatted, to, ((DecimalFormat)nf).getMultiplier());
     }
 
diff --git a/jdk/test/java/text/Format/NumberFormat/BigDecimalParse.java b/jdk/test/java/text/Format/NumberFormat/BigDecimalParse.java
index be206052d06..972cfa2851f 100644
--- a/jdk/test/java/text/Format/NumberFormat/BigDecimalParse.java
+++ b/jdk/test/java/text/Format/NumberFormat/BigDecimalParse.java
@@ -199,15 +199,15 @@ public class BigDecimalParse extends IntlTest {
 
         // From: 1000.000
         // To:   Double.POSITIVE_INFINITY
-        check("1000.000", new Double(Double.POSITIVE_INFINITY));
+        check("1000.000", Double.POSITIVE_INFINITY);
 
         // From: -1000
         // To:   Double.NEGATIVE_INFINITY
-        check("-1000", new Double(Double.NEGATIVE_INFINITY));
+        check("-1000", Double.NEGATIVE_INFINITY);
 
         // From: -0.00
         // To:   Double.NaN
-        check("-0.00", new Double(Double.NaN));
+        check("-0.00", Double.NaN);
     }
 
     /**
@@ -220,31 +220,31 @@ public class BigDecimalParse extends IntlTest {
 
         // From: 1000.000
         // To:   Double.POSITIVE_INFINITY
-        check("1000.000", new Double(Double.POSITIVE_INFINITY));
+        check("1000.000", Double.POSITIVE_INFINITY);
 
         // From: -1000.000
         // To:   Double.NEGATIVE_INFINITY
-        check("-1000.000", new Double(Double.NEGATIVE_INFINITY));
+        check("-1000.000", Double.NEGATIVE_INFINITY);
 
         // From: 0.0
         // To:   Double.NaN
-        check("0.0", new Double(Double.NaN));
+        check("0.0", Double.NaN);
 
         // From: -0.0 (Double)
         // To:   Double.NaN
-        check("-0.0", new Double(Double.NaN));
+        check("-0.0", Double.NaN);
 
         // From: Double.NaN
         // To:   Double.NaN
-        check("\ufffd", new Double(Double.NaN));
+        check("\ufffd", Double.NaN);
 
         // From: Double.POSITIVE_INFINITY
         // To:   Double.NaN
-        check("\u221e", new Double(Double.POSITIVE_INFINITY));
+        check("\u221e", Double.POSITIVE_INFINITY);
 
         // From: Double.NEGATIVE_INFINITY
         // To:   Double.NaN
-        check("-\u221e", new Double(Double.NEGATIVE_INFINITY));
+        check("-\u221e", Double.NEGATIVE_INFINITY);
     }
 
     /**
@@ -257,15 +257,15 @@ public class BigDecimalParse extends IntlTest {
 
         // From: 1000
         // To:   Double.POSITIVE_INFINITY
-        check("1000", new Double(Double.POSITIVE_INFINITY));
+        check("1000", Double.POSITIVE_INFINITY);
 
         // From: -1000
         // To:   Double.NEGATIVE_INFINITY
-        check("-1000", new Double(Double.NEGATIVE_INFINITY));
+        check("-1000", Double.NEGATIVE_INFINITY);
 
         // From: -000 (Long)
         // To:   Double.NaN
-        check("-000", new Double(Double.NaN));
+        check("-000", Double.NaN);
     }
 
     /**
@@ -350,20 +350,20 @@ public class BigDecimalParse extends IntlTest {
             {
                 new BigDecimal("0"), new BigDecimal("0.0"), new BigDecimal("5"),
                 new BigDecimal("5.0"), new BigDecimal("5.1"),
-                new Double(Double.POSITIVE_INFINITY), new Double(Double.NaN),
+                Double.POSITIVE_INFINITY, Double.NaN,
                 new BigDecimal("0"), new BigDecimal("0.0"),
                 new BigDecimal("-5"), new BigDecimal("-5.0"),
                 new BigDecimal("-5.1"),
-                new Double(Double.NEGATIVE_INFINITY), new Double(Double.NaN),
+                Double.NEGATIVE_INFINITY, Double.NaN,
             },
             {
                 new BigDecimal("0"), new BigDecimal("0.0"),
                 new BigDecimal("-5"), new BigDecimal("-5.0"),
                 new BigDecimal("-5.1"),
-                new Double(Double.NEGATIVE_INFINITY), new Double(Double.NaN),
+                Double.NEGATIVE_INFINITY, Double.NaN,
                 new BigDecimal("0"), new BigDecimal("0.0"), new BigDecimal("5"),
                 new BigDecimal("5.0"), new BigDecimal("5.1"),
-                new Double(Double.POSITIVE_INFINITY),
+                Double.POSITIVE_INFINITY,
             },
         };
 
diff --git a/jdk/test/java/text/Format/NumberFormat/Bug4208135.java b/jdk/test/java/text/Format/NumberFormat/Bug4208135.java
index 3f5785b6f6c..1d641226ab7 100644
--- a/jdk/test/java/text/Format/NumberFormat/Bug4208135.java
+++ b/jdk/test/java/text/Format/NumberFormat/Bug4208135.java
@@ -47,12 +47,12 @@ public class Bug4208135 {
         df.applyPattern("0.#E0");
 
         df.setDecimalSeparatorAlwaysShown(true);
-        checkFormat(new Double(0.0), "0.E0");
-        checkFormat(new Double(10.0), "1.E1");
-        checkFormat(new Double(1000.0), "1.E3");
-        checkFormat(new Long(0), "0.E0");
-        checkFormat(new Long(10), "1.E1");
-        checkFormat(new Long(1000), "1.E3");
+        checkFormat(0.0, "0.E0");
+        checkFormat(10.0, "1.E1");
+        checkFormat(1000.0, "1.E3");
+        checkFormat(0L, "0.E0");
+        checkFormat(10L, "1.E1");
+        checkFormat(1000L, "1.E3");
         checkFormat(new BigDecimal("0.0"), "0.E0");
         checkFormat(new BigDecimal("10.0"), "1.E1");
         checkFormat(new BigDecimal("1000.0"), "1.E3");
@@ -61,12 +61,12 @@ public class Bug4208135 {
         checkFormat(new BigInteger("1000"), "1.E3");
 
         df.setDecimalSeparatorAlwaysShown(false);
-        checkFormat(new Double(0.0), "0E0");
-        checkFormat(new Double(10.0), "1E1");
-        checkFormat(new Double(1000.0), "1E3");
-        checkFormat(new Long(0), "0E0");
-        checkFormat(new Long(10), "1E1");
-        checkFormat(new Long(1000), "1E3");
+        checkFormat(0.0, "0E0");
+        checkFormat(10.0, "1E1");
+        checkFormat(1000.0, "1E3");
+        checkFormat(0L, "0E0");
+        checkFormat(10L, "1E1");
+        checkFormat(1000L, "1E3");
         checkFormat(new BigDecimal("0.0"), "0E0");
         checkFormat(new BigDecimal("10.0"), "1E1");
         checkFormat(new BigDecimal("1000.0"), "1E3");
@@ -77,12 +77,12 @@ public class Bug4208135 {
         df.applyPattern("0.###");
 
         df.setDecimalSeparatorAlwaysShown(true);
-        checkFormat(new Double(0.0), "0.");
-        checkFormat(new Double(10.0), "10.");
-        checkFormat(new Double(1000.0), "1000.");
-        checkFormat(new Long(0), "0.");
-        checkFormat(new Long(10), "10.");
-        checkFormat(new Long(1000), "1000.");
+        checkFormat(0.0, "0.");
+        checkFormat(10.0, "10.");
+        checkFormat(1000.0, "1000.");
+        checkFormat(0L, "0.");
+        checkFormat(10L, "10.");
+        checkFormat(1000L, "1000.");
         checkFormat(new BigDecimal("0.0"), "0.");
         checkFormat(new BigDecimal("10.0"), "10.");
         checkFormat(new BigDecimal("1000.0"), "1000.");
@@ -91,12 +91,12 @@ public class Bug4208135 {
         checkFormat(new BigInteger("1000"), "1000.");
 
         df.setDecimalSeparatorAlwaysShown(false);
-        checkFormat(new Double(0.0), "0");
-        checkFormat(new Double(10.0), "10");
-        checkFormat(new Double(1000.0), "1000");
-        checkFormat(new Long(0), "0");
-        checkFormat(new Long(10), "10");
-        checkFormat(new Long(1000), "1000");
+        checkFormat(0.0, "0");
+        checkFormat(10.0, "10");
+        checkFormat(1000.0, "1000");
+        checkFormat(0L, "0");
+        checkFormat(10L, "10");
+        checkFormat(1000L, "1000");
         checkFormat(new BigDecimal("0.0"), "0");
         checkFormat(new BigDecimal("10.0"), "10");
         checkFormat(new BigDecimal("1000.0"), "1000");
diff --git a/jdk/test/java/text/Format/NumberFormat/Bug4833877.java b/jdk/test/java/text/Format/NumberFormat/Bug4833877.java
index 5f3c5056014..195a6c76fcd 100644
--- a/jdk/test/java/text/Format/NumberFormat/Bug4833877.java
+++ b/jdk/test/java/text/Format/NumberFormat/Bug4833877.java
@@ -51,20 +51,20 @@ public class Bug4833877 {
         /*
          * Test for double/Double
          */
-        checkFormat(new Double(252.5252525252525), "1,010.10101010101");
-        checkParse("-1,010.10101010101", new Double(-252.5252525252525));
+        checkFormat(252.5252525252525, "1,010.10101010101");
+        checkParse("-1,010.10101010101", -252.5252525252525);
 
-        checkFormat(new Double(-2222.2222), "-8,888.8888");
-        checkParse("8888.8888", new Double(2222.2222));
+        checkFormat(-2222.2222, "-8,888.8888");
+        checkParse("8888.8888", 2222.2222);
 
         /*
          * Test for long/Long
          */
-        checkFormat(new Long(1000), "4,000");
-        checkParse("-4,000", new Long(-1000));
+        checkFormat(1000L, "4,000");
+        checkParse("-4,000", -1000L);
 
-        checkFormat(new Long(-250), "-1,000");
-        checkParse("1000", new Long(250));
+        checkFormat(-250L, "-1,000");
+        checkParse("1000", 250L);
 
         /* ---------------------------------------------------------------- */
 
@@ -104,20 +104,20 @@ public class Bug4833877 {
         /*
          * Test for double/Double
          */
-        checkFormat(new Double(252.5252525252525), "-1,010.10101010101");
-        checkParse("-1,010.10101010101", new Double(252.5252525252525));
+        checkFormat(252.5252525252525, "-1,010.10101010101");
+        checkParse("-1,010.10101010101", 252.5252525252525);
 
-        checkFormat(new Double(-2222.2222), "8,888.8888");
-        checkParse("8888.8888", new Double(-2222.2222));
+        checkFormat(-2222.2222, "8,888.8888");
+        checkParse("8888.8888", -2222.2222);
 
         /*
          * Test for long/Long
          */
-        checkFormat(new Long(1000), "-4,000");
-        checkParse("-4,000", new Long(1000));
+        checkFormat(1000L, "-4,000");
+        checkParse("-4,000", 1000L);
 
-        checkFormat(new Long(-250), "1,000");
-        checkParse("1000", new Long(-250));
+        checkFormat(-250L, "1,000");
+        checkParse("1000", -250L);
 
         /* ---------------------------------------------------------------- */
 
@@ -157,30 +157,30 @@ public class Bug4833877 {
         /*
          * Test for double/Double
          */
-        checkFormat(new Double(3333.3333333), "-9,999.9999999");
-        checkParse("-10,000.00000000000", new Double(3333.3333333333335));// rounding error
+        checkFormat(3333.3333333, "-9,999.9999999");
+        checkParse("-10,000.00000000000", 3333.3333333333335);// rounding error
 
         df.setParseIntegerOnly(true);
-        checkFormat(new Double(-3333.3333333), "9,999.9999999");
-        checkParse("10,000.00000000000", new Long(-3333));
+        checkFormat(-3333.3333333, "9,999.9999999");
+        checkParse("10,000.00000000000", -3333L);
         df.setParseIntegerOnly(false);
-        checkFormat(new Double(-3333.3333333), "9,999.9999999");
-        checkParse("10,000.00000000000", new Double(-3333.3333333333335));// rounding error
+        checkFormat(-3333.3333333, "9,999.9999999");
+        checkParse("10,000.00000000000", -3333.3333333333335);// rounding error
 
         /*
          * Test for long/Long
          */
-        checkFormat(new Long(3333), "-9,999");
+        checkFormat(3333L, "-9,999");
         df.setParseIntegerOnly(true);
-        checkParse("-10,000", new Long(3333));
+        checkParse("-10,000", 3333L);
         df.setParseIntegerOnly(false);
-        checkParse("-10000", new Double(3333.3333333333335));// rounding error
+        checkParse("-10000", 3333.3333333333335);// rounding error
 
-        checkFormat(new Long(-3333), "9,999");
+        checkFormat(-3333L, "9,999");
         df.setParseIntegerOnly(true);
-        checkParse("10,000", new Long(-3333));
+        checkParse("10,000", -3333L);
         df.setParseIntegerOnly(false);
-        checkParse("10000", new Double(-3333.3333333333335));// rounding error
+        checkParse("10000", -3333.3333333333335);// rounding error
 
         /* ---------------------------------------------------------------- */
 
@@ -225,20 +225,20 @@ public class Bug4833877 {
         /*
          * Test for double/Double
          */
-        checkFormat(new Double(252.5252525252525), "1.01010101010101E3");
-        checkParse("-1.01010101010101E3", new Double(-2.525252525252525E2));
+        checkFormat(252.5252525252525, "1.01010101010101E3");
+        checkParse("-1.01010101010101E3", -2.525252525252525E2);
 
-        checkFormat(new Double(-2222.2222), "-8.8888888E3");
-        checkParse("8888.8888", new Double(2.2222222E3));
+        checkFormat(-2222.2222, "-8.8888888E3");
+        checkParse("8888.8888", 2.2222222E3);
 
         /*
          * Test for long/Long
          */
-        checkFormat(new Long(1000), "4E3");
-        checkParse("-4E3", new Long(-1000));
+        checkFormat(1000L, "4E3");
+        checkParse("-4E3", -1000L);
 
-        checkFormat(new Long(-250), "-1E3");
-        checkParse("1000", new Long(250));
+        checkFormat(-250L, "-1E3");
+        checkParse("1000", 250L);
 
         /* ---------------------------------------------------------------- */
 
@@ -279,20 +279,20 @@ public class Bug4833877 {
         /*
          * Test for double/Double
          */
-        checkFormat(new Double(252.5252525252525), "-1.01010101010101E3");
-        checkParse("-1.01010101010101E3", new Double(2.525252525252525E2));
+        checkFormat(252.5252525252525, "-1.01010101010101E3");
+        checkParse("-1.01010101010101E3", 2.525252525252525E2);
 
-        checkFormat(new Double(-2222.2222), "8.8888888E3");
-        checkParse("8888.8888", new Double(-2.2222222E3));
+        checkFormat(-2222.2222, "8.8888888E3");
+        checkParse("8888.8888", -2.2222222E3);
 
         /*
          * Test for long/Long
          */
-        checkFormat(new Long(1000), "-4E3");
-        checkParse("-4E3", new Long(1000));
+        checkFormat(1000L, "-4E3");
+        checkParse("-4E3", 1000L);
 
-        checkFormat(new Long(-250), "1E3");
-        checkParse("1000", new Long(-250));
+        checkFormat(-250L, "1E3");
+        checkParse("1000", -250L);
 
         /* ---------------------------------------------------------------- */
 
@@ -333,30 +333,30 @@ public class Bug4833877 {
         /*
          * Test for double/Double
          */
-        checkFormat(new Double(3333.3333333), "-9.9999999999E3");
-        checkParse("-1.00000000000000E3", new Double(3.33333333333333333E2));
+        checkFormat(3333.3333333, "-9.9999999999E3");
+        checkParse("-1.00000000000000E3", 3.33333333333333333E2);
 
         df.setParseIntegerOnly(true);
-        checkFormat(new Double(-3333.3333333), "9.9999999999E3");
-        checkParse("10.00000000000000E3", new Long(-3));
+        checkFormat(-3333.3333333, "9.9999999999E3");
+        checkParse("10.00000000000000E3",-3L);
         df.setParseIntegerOnly(false);
-        checkFormat(new Double(-3333.3333333), "9.9999999999E3");
-        checkParse("10.00000000000000E3", new Double(-3.33333333333333333E3));
+        checkFormat(-3333.3333333, "9.9999999999E3");
+        checkParse("10.00000000000000E3", -3.33333333333333333E3);
 
         /*
          * Test for long/Long
          */
-        checkFormat(new Long(3333), "-9.999E3");
+        checkFormat(3333L, "-9.999E3");
         df.setParseIntegerOnly(true);
-        checkParse("-1.0E4", new Long(0));
+        checkParse("-1.0E4", 0L);
         df.setParseIntegerOnly(false);
-        checkParse("-1.0E4", new Double(3333.3333333333335));
+        checkParse("-1.0E4", 3333.3333333333335);
 
-        checkFormat(new Long(-3333), "9.999E3");
+        checkFormat(-3333L, "9.999E3");
         df.setParseIntegerOnly(true);
-        checkParse("10.0E4", new Long(-3));
+        checkParse("10.0E4", -3L);
         df.setParseIntegerOnly(false);
-        checkParse("10.0E4", new Double(-33333.3333333333336));
+        checkParse("10.0E4", -33333.3333333333336);
 
         /* ---------------------------------------------------------------- */
 
diff --git a/jdk/test/java/text/Format/NumberFormat/Bug4838107.java b/jdk/test/java/text/Format/NumberFormat/Bug4838107.java
index a15d537d8e6..72cad141174 100644
--- a/jdk/test/java/text/Format/NumberFormat/Bug4838107.java
+++ b/jdk/test/java/text/Format/NumberFormat/Bug4838107.java
@@ -71,47 +71,47 @@ public class Bug4838107 extends IntlTest {
         dfs = df.getDecimalFormatSymbols();
 
         /* Test with default pattern */
-        test(new Double(1234),    "1,234");
-        test(new Double(0.1234),  "0.123");     // rounded
-        test(new Double(-1234),   "-1,234");
-        test(new Double(-0.1234), "-0.123");    // rounded
+        test(1234D,    "1,234");
+        test(0.1234,  "0.123");     // rounded
+        test(-1234D,   "-1,234");
+        test(-0.1234, "-0.123");    // rounded
 
-        test(new Double(Double.POSITIVE_INFINITY), "\u221e");
-        test(new Double(Double.NEGATIVE_INFINITY), "-\u221e");
-        test(new Double(Double.NaN), "\ufffd"); // without prefix and suffix
-        test(new Double(0.0),  "0");
-        test(new Double(-0.0), "-0");   // with the minus sign
+        test(Double.POSITIVE_INFINITY, "\u221e");
+        test(Double.NEGATIVE_INFINITY, "-\u221e");
+        test(Double.NaN, "\ufffd"); // without prefix and suffix
+        test(0.0,  "0");
+        test(-0.0, "-0");   // with the minus sign
 
         /* Specify a pattern and the minus sign. */
         prepareFormatter("<P>#.###E00<S>", 'm');
-        test(new Double(1234),    "<P>1.234E03<S>");
-        test(new Double(0.1234),  "<P>1.234Em01<S>");
-        test(new Double(-1234),   "m<P>1.234E03<S>");
-        test(new Double(-0.1234), "m<P>1.234Em01<S>");
+        test(1234D,    "<P>1.234E03<S>");
+        test(0.1234,  "<P>1.234Em01<S>");
+        test(-1234D,   "m<P>1.234E03<S>");
+        test(-0.1234, "m<P>1.234Em01<S>");
 
         prepareFormatter("<P>#.###E00<S>;#.###E00", 'm');
-        test(new Double(1234),    "<P>1.234E03<S>");
-        test(new Double(0.1234),  "<P>1.234Em01<S>");
-        test(new Double(-1234),   "1.234E03");
-        test(new Double(-0.1234), "1.234Em01");
+        test(1234D,    "<P>1.234E03<S>");
+        test(0.1234,  "<P>1.234Em01<S>");
+        test(-1234D,   "1.234E03");
+        test(-0.1234, "1.234Em01");
 
         prepareFormatter("#.###E00;<P>#.###E00<S>", 'm');
-        test(new Double(1234),    "1.234E03");
-        test(new Double(0.1234),  "1.234Em01");
-        test(new Double(-1234),   "<P>1.234E03<S>");
-        test(new Double(-0.1234), "<P>1.234Em01<S>");
+        test(1234D,    "1.234E03");
+        test(0.1234,  "1.234Em01");
+        test(-1234D,   "<P>1.234E03<S>");
+        test(-0.1234, "<P>1.234Em01<S>");
 
         prepareFormatter("<P>#.###E00<S>;<p>-#.###E00<s>", 'm');
-        test(new Double(1234),    "<P>1.234E03<S>");
-        test(new Double(0.1234),  "<P>1.234Em01<S>");
-        test(new Double(-1234),   "<p>m1.234E03<s>");
-        test(new Double(-0.1234), "<p>m1.234Em01<s>");
+        test(1234D,    "<P>1.234E03<S>");
+        test(0.1234,  "<P>1.234Em01<S>");
+        test(-1234D,   "<p>m1.234E03<s>");
+        test(-0.1234, "<p>m1.234Em01<s>");
 
-        test(new Double(Double.POSITIVE_INFINITY), "<P>\u221e<S>");
-        test(new Double(Double.NEGATIVE_INFINITY), "<p>m\u221e<s>");
-        test(new Double(Double.NaN), "\ufffd"); // without prefix and suffix
-        test(new Double(0.0),  "<P>0E00<S>");
-        test(new Double(-0.0), "<p>m0E00<s>");  // with the minus sign
+        test(Double.POSITIVE_INFINITY, "<P>\u221e<S>");
+        test(Double.NEGATIVE_INFINITY, "<p>m\u221e<s>");
+        test(Double.NaN, "\ufffd"); // without prefix and suffix
+        test(0.0,  "<P>0E00<S>");
+        test(-0.0, "<p>m0E00<s>");  // with the minus sign
     }
 
     static void test_BigDecimal() {
@@ -151,19 +151,19 @@ public class Bug4838107 extends IntlTest {
         dfs = df.getDecimalFormatSymbols();
 
         /* Test with default pattern */
-        test(new Long(123456789),  "123,456,789");
-        test(new Long(-123456789), "-123,456,789");
+        test(123456789L,  "123,456,789");
+        test(-123456789L, "-123,456,789");
 
-        test(new Long(0), "0");
-        test(new Long(-0), "0");
+        test(0L, "0");
+        test(-0L, "0");
 
         /* Specify a pattern and the minus sign. */
         prepareFormatter("<P>#,###<S>;<p>-#,###<s>", 'm');
-        test(new Long(123456789),  "<P>123,456,789<S>");
-        test(new Long(-123456789), "<p>m123,456,789<s>");
+        test(123456789L,  "<P>123,456,789<S>");
+        test(-123456789L, "<p>m123,456,789<s>");
 
-        test(new Long(0), "<P>0<S>");
-        test(new Long(-0), "<P>0<S>");
+        test(0L, "<P>0<S>");
+        test(-0L, "<P>0<S>");
     }
 
     static void test_BigInteger() {
diff --git a/jdk/test/java/text/Format/NumberFormat/Bug4944439.java b/jdk/test/java/text/Format/NumberFormat/Bug4944439.java
index beb4d77c235..0e85a98119d 100644
--- a/jdk/test/java/text/Format/NumberFormat/Bug4944439.java
+++ b/jdk/test/java/text/Format/NumberFormat/Bug4944439.java
@@ -84,7 +84,7 @@ public class Bug4944439 {
         }
 
         int index = s.indexOf('.');
-        Long l = new Long(s.substring(0, index));
+        Long l = Long.valueOf(s.substring(0, index));
         if (!l.equals(number)) {
             err = true;
             System.err.println("Failed: DecimalFormat.parse(" + s +
@@ -101,7 +101,7 @@ public class Bug4944439 {
                 number.getClass().getName());
         }
 
-        Double d = new Double(s);
+        Double d = Double.valueOf(s);
         if (!d.equals(number)) {
             err = true;
             System.err.println("Failed: DecimalFormat.parse(" + s +
diff --git a/jdk/test/java/text/Format/NumberFormat/Bug4990596.java b/jdk/test/java/text/Format/NumberFormat/Bug4990596.java
index a8c03b8a035..2b311fb1b5f 100644
--- a/jdk/test/java/text/Format/NumberFormat/Bug4990596.java
+++ b/jdk/test/java/text/Format/NumberFormat/Bug4990596.java
@@ -35,6 +35,7 @@ public class Bug4990596 {
         new DecimalFormat().format(new MutableInteger(0));
     }
 
+    @SuppressWarnings("serial")
     public static class MutableInteger extends Number {
         public int value;
 
diff --git a/jdk/test/java/text/Format/NumberFormat/Bug6278616.java b/jdk/test/java/text/Format/NumberFormat/Bug6278616.java
index 9066a7da02e..b1684b4d177 100644
--- a/jdk/test/java/text/Format/NumberFormat/Bug6278616.java
+++ b/jdk/test/java/text/Format/NumberFormat/Bug6278616.java
@@ -47,7 +47,7 @@ public class Bug6278616 {
         NumberFormat nf = NumberFormat.getInstance();
 
         for (int j = 0; j < ints.length; j++) {
-            String s_i = nf.format(new Integer(ints[j]));
+            String s_i = nf.format(ints[j]);
             String s_ai = nf.format(new AtomicInteger(ints[j]));
             if (!s_i.equals(s_ai)) {
                 throw new RuntimeException("format(AtomicInteger " + s_ai +
@@ -57,7 +57,7 @@ public class Bug6278616 {
         }
 
         for (int j = 0; j < longs.length; j++) {
-            String s_l = nf.format(new Long(longs[j]));
+            String s_l = nf.format(longs[j]);
             String s_al = nf.format(new AtomicLong(longs[j]));
             if (!s_l.equals(s_al)) {
                 throw new RuntimeException("format(AtomicLong " + s_al +
diff --git a/jdk/test/java/text/Format/NumberFormat/NumberRegression.java b/jdk/test/java/text/Format/NumberFormat/NumberRegression.java
index b194d270a5c..48147f35d2a 100644
--- a/jdk/test/java/text/Format/NumberFormat/NumberRegression.java
+++ b/jdk/test/java/text/Format/NumberFormat/NumberRegression.java
@@ -289,7 +289,7 @@ public class NumberRegression extends IntlTest {
         DecimalFormat df = new DecimalFormat();
         Double d = (Double)df.parse("123.55456", pos=new ParsePosition(0));
         if (!d.toString().equals("123.55456")) {
-            errln("Result -> " + d.doubleValue());
+            errln("Result -> " + d);
         }
         Locale.setDefault(savedLocale);
     }
@@ -395,11 +395,11 @@ public class NumberRegression extends IntlTest {
         Locale.setDefault(Locale.US);
         DecimalFormat df = new DecimalFormat();
         String str = "0.1234";
-        Double d1 = new Double(str);
+        Double d1 = 0.1234;
         Double d2 = (Double) df.parse(str, new ParsePosition(0));
         logln(d1.toString());
         if (d2.doubleValue() != d1.doubleValue())
-            errln("Bug 4095713 test failed, new double value : " + d2.doubleValue());
+            errln("Bug 4095713 test failed, new double value : " + d2);
         Locale.setDefault(savedLocale);
     }
 
@@ -870,7 +870,7 @@ public class NumberRegression extends IntlTest {
         DecimalFormat fmt = new DecimalFormat("#,##0.00");
         StringBuffer formatted = new StringBuffer();
         FieldPosition field = new FieldPosition(0);
-        Double num = new Double(1234.5);
+        Double num = 1234.5;
         fmt.format(num, formatted, field);
         if (field.getBeginIndex() != 0 && field.getEndIndex() != 5)
             errln("Format 1234.5 failed. Begin index: " + field.getBeginIndex() + " End index: " + field.getEndIndex());
@@ -1416,7 +1416,7 @@ public class NumberRegression extends IntlTest {
         DecimalFormat fmt = new DecimalFormat("#",
                 DecimalFormatSymbols.getInstance(Locale.US));
         for (int i=0; i<DATA.length; i+=3) {
-            double in = Double.valueOf(DATA[i]).doubleValue();
+            double in = Double.valueOf(DATA[i]);
             String pat = DATA[i+1];
             String exp = DATA[i+2];
             fmt.applyPattern(pat);
@@ -1622,7 +1622,7 @@ public class NumberRegression extends IntlTest {
             String str = Long.toString(DATA[i]);
             for (int m = 1; m <= 100; m++) {
                 fmt.setMultiplier(m);
-                long n = ((Number) fmt.parse(str)).longValue();
+                long n = fmt.parse(str).longValue();
                 if (n > 0 != DATA[i] > 0) {
                     errln("\"" + str + "\" parse(x " + fmt.getMultiplier() +
                           ") => " + n);
@@ -1637,15 +1637,15 @@ public class NumberRegression extends IntlTest {
      */
     public void Test4217661() {
         Object[] DATA = {
-            new Double(0.001), "0",
-            new Double(1.001), "1",
-            new Double(0.006), "0.01",
-            new Double(1.006), "1.01",
+            0.001, "0",
+            1.001, "1",
+            0.006, "0.01",
+            1.006, "1.01",
         };
         NumberFormat fmt = NumberFormat.getInstance(Locale.US);
         fmt.setMaximumFractionDigits(2);
         for (int i=0; i<DATA.length; i+=2) {
-            String s = fmt.format(((Double) DATA[i]).doubleValue());
+            String s = fmt.format((Double) DATA[i]);
             if (!s.equals(DATA[i+1])) {
                 errln("FAIL: Got " + s + ", exp " + DATA[i+1]);
             }
@@ -1804,6 +1804,7 @@ public class NumberRegression extends IntlTest {
     }
 }
 
+@SuppressWarnings("serial")
 class myformat implements Serializable
 {
     DateFormat _dateFormat = DateFormat.getDateInstance();
@@ -1817,6 +1818,7 @@ class myformat implements Serializable
     }
 }
 
+@SuppressWarnings("serial")
 class MyNumberFormatTest extends NumberFormat {
     public StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos) {
         return new StringBuffer("");
@@ -1825,6 +1827,6 @@ class MyNumberFormatTest extends NumberFormat {
         return new StringBuffer("");
     }
     public Number parse(String text, ParsePosition parsePosition) {
-        return new Integer(0);
+        return 0;
     }
 }
diff --git a/jdk/test/java/text/Format/NumberFormat/NumberRoundTrip.java b/jdk/test/java/text/Format/NumberFormat/NumberRoundTrip.java
index 8d0b586beab..42561b39583 100644
--- a/jdk/test/java/text/Format/NumberFormat/NumberRoundTrip.java
+++ b/jdk/test/java/text/Format/NumberFormat/NumberRoundTrip.java
@@ -130,11 +130,11 @@ public class NumberRoundTrip extends IntlTest {
     }
 
     public void doTest(NumberFormat fmt, double value) {
-        doTest(fmt, new Double(value));
+        doTest(fmt, Double.valueOf(value));
     }
 
     public void doTest(NumberFormat fmt, long value) {
-        doTest(fmt, new Long(value));
+        doTest(fmt, Long.valueOf(value));
     }
 
     static double proportionalError(Number a, Number b) {
diff --git a/jdk/test/java/text/Format/NumberFormat/NumberTest.java b/jdk/test/java/text/Format/NumberFormat/NumberTest.java
index cf64a431a55..fd78223ccca 100644
--- a/jdk/test/java/text/Format/NumberFormat/NumberTest.java
+++ b/jdk/test/java/text/Format/NumberFormat/NumberTest.java
@@ -403,7 +403,7 @@ public class NumberTest extends IntlTest
         float[] parseExpected = { 0, 0, 12345, -12345 };
 
         for (int i = 0; i < parseInput.length; i++) {
-            float result = ((Number) format.parse(parseInput[i])).floatValue();
+            float result = format.parse(parseInput[i]).floatValue();
             if (result != parseExpected[i]) {
                 errln("FAIL: Expected " + parseExpected[i] + ", got " + result);
             }
diff --git a/jdk/test/java/text/Format/NumberFormat/SerializationLoadTest.java b/jdk/test/java/text/Format/NumberFormat/SerializationLoadTest.java
index 3499e1c553f..7267f0b7f39 100644
--- a/jdk/test/java/text/Format/NumberFormat/SerializationLoadTest.java
+++ b/jdk/test/java/text/Format/NumberFormat/SerializationLoadTest.java
@@ -62,6 +62,7 @@ public class SerializationLoadTest {
     }
 }
 
+@SuppressWarnings("serial")
 class CheckDecimalFormat implements Serializable
 {
     DecimalFormat _decFormat = (DecimalFormat)NumberFormat.getInstance();
@@ -73,6 +74,7 @@ class CheckDecimalFormat implements Serializable
     }
 }
 
+@SuppressWarnings("serial")
 class CheckDecimalFormatSymbols implements Serializable
 {
     DecimalFormatSymbols _decFormatSymbols = new DecimalFormatSymbols();
diff --git a/jdk/test/java/text/Format/NumberFormat/SerializationSaveTest.java b/jdk/test/java/text/Format/NumberFormat/SerializationSaveTest.java
index 2f298adeb0e..0332efeca0f 100644
--- a/jdk/test/java/text/Format/NumberFormat/SerializationSaveTest.java
+++ b/jdk/test/java/text/Format/NumberFormat/SerializationSaveTest.java
@@ -57,6 +57,7 @@ public class SerializationSaveTest {
     }
 }
 
+@SuppressWarnings("serial")
 class CheckDecimalFormat implements Serializable
 {
     DecimalFormat _decFormat = (DecimalFormat)NumberFormat.getInstance();
@@ -68,6 +69,7 @@ class CheckDecimalFormat implements Serializable
     }
 }
 
+@SuppressWarnings("serial")
 class CheckDecimalFormatSymbols implements Serializable
 {
     DecimalFormatSymbols _decFormatSymbols = new DecimalFormatSymbols();
diff --git a/jdk/test/java/text/Format/common/FormatIteratorTest.java b/jdk/test/java/text/Format/common/FormatIteratorTest.java
index 7102f59dec2..fede7df2012 100644
--- a/jdk/test/java/text/Format/common/FormatIteratorTest.java
+++ b/jdk/test/java/text/Format/common/FormatIteratorTest.java
@@ -37,6 +37,7 @@ import java.text.*;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
+import java.text.AttributedCharacterIterator.Attribute;
 
 /**
  * FormatTester creates Formats, and tests the resulting FieldPositions
@@ -94,7 +95,6 @@ import java.util.concurrent.atomic.AtomicLong;
  * Any lines starting with {@code '#'} are comment lines and ignored.
  */
 public class FormatIteratorTest extends IntlTest {
-    private static HashMap attrs;
     private Format format;
     private Object value;
     private String text;
@@ -143,30 +143,31 @@ public class FormatIteratorTest extends IntlTest {
                        "dateFormat.props"));
     }
 
+    @SuppressWarnings("unchecked")
     private void _test(File file) {
         try {
-            attrs = new HashMap();
             logln("testing: " + file);
             PParser parser = new PParser();
-            Hashtable contents = parser.parse(new BufferedReader(
+            Map<String,Object> contents = parser.parse(new BufferedReader(
                 new FileReader(file)));
-            Vector test = (Vector)contents.get("tests");
+            List<Object> test = (List)contents.get("tests");
 
             for (int counter = 0; counter < test.size(); counter++) {
                 logln("creating: " + (counter / 2));
 
                 AttributedCharacterIterator iterator =
-                    create((Hashtable)test.get(counter));
+                    create((Map)test.get(counter));
 
                 logln("verifying: " + (counter / 2));
-                verify(iterator, (Hashtable)test.get(++counter));
+                verify(iterator, (Map)test.get(++counter));
             }
         } catch (IOException ioe) {
             errln("Error reading: " + ioe);
         }
     }
 
-    public void verify(AttributedCharacterIterator iterator,Hashtable table) {
+    @SuppressWarnings("unchecked")
+    public void verify(AttributedCharacterIterator iterator,Map<String,Object> table) {
         int length = Integer.parseInt((String)table.get("length"));
 
         // Verify the text
@@ -185,10 +186,10 @@ public class FormatIteratorTest extends IntlTest {
         for (int counter = 0; counter < length; counter++) {
             iterator.setIndex(counter);
             if (!verifyAttributes(iterator.getAttributes().keySet(),
-                    makeAttributes((Vector)table.get(Integer.
+                    makeAttributes((List)table.get(Integer.
                                                       toString(counter))))) {
                 errln("Attributes don't match at " + counter + " expecting " +
-                      makeAttributes((Vector)table.get(Integer.toString
+                      makeAttributes((List)table.get(Integer.toString
                                                        (counter))) + " got " +
                       iterator.getAttributes().keySet());
             }
@@ -196,10 +197,10 @@ public class FormatIteratorTest extends IntlTest {
         for (int counter = length - 1; counter >= 0; counter--) {
             iterator.setIndex(counter);
             if (!verifyAttributes(iterator.getAttributes().keySet(),
-                    makeAttributes((Vector)table.get(Integer.
+                    makeAttributes((List)table.get(Integer.
                                                       toString(counter))))) {
                 errln("Attributes don't match at " + counter + " expecting " +
-                      makeAttributes((Vector)table.get(Integer.toString
+                      makeAttributes((List)table.get(Integer.toString
                                                        (counter))) + " got " +
                       iterator.getAttributes().keySet());
             }
@@ -207,31 +208,33 @@ public class FormatIteratorTest extends IntlTest {
         verifyLimits(iterator, table);
 
         text = escapeIfNecessary((String)table.get("text"));
-        Vector fps = (Vector)table.get("fieldPositions");
+        List<Object> fps = (List)table.get("fieldPositions");
 
         if (fps != null) {
             for (int counter = 0; counter < fps.size(); counter++) {
-                verifyFieldPosition(counter, (Hashtable)fps.get(counter));
+                verifyFieldPosition(counter,(Map)fps.get(counter));
             }
         }
     }
 
+    @SuppressWarnings("unchecked")
     private void verifyLimits(AttributedCharacterIterator iterator,
-                              Hashtable table) {
-        Vector limits = (Vector)table.get("limits");
+                              Map<String,Object> table) {
+        List<Object> limits = (List)table.get("limits");
 
         if (limits != null) {
             for (int counter = 0; counter < limits.size(); counter++) {
-                verifyLimit(iterator, (Hashtable)limits.get(counter));
+                verifyLimit(iterator, (Map)limits.get(counter));
             }
         }
     }
 
     private void verifyLimit(AttributedCharacterIterator iterator,
-                             Hashtable table) {
+                             Map<String,Object> table) {
         int begin = Integer.parseInt((String)table.get("begin"));
         int end = Integer.parseInt((String)table.get("end"));
-        Set attrs = makeAttributes((Vector)table.get("attributes"));
+        @SuppressWarnings("unchecked")
+        Set<Attribute> attrs = makeAttributes((List)table.get("attributes"));
         String begin2S = (String)table.get("begin2");
         int begin2 = (begin2S != null) ? Integer.parseInt(begin2S) : begin;
         String end2S = (String)table.get("end2");
@@ -262,9 +265,9 @@ public class FormatIteratorTest extends IntlTest {
         }
     }
 
-    private boolean verifyAttributes(Set a, Set b) {
-        boolean aEmpty = (a.size() == 0);
-        boolean bEmpty = (b.size() == 0);
+    private boolean verifyAttributes(Set<Attribute> a, Set<Attribute> b) {
+        boolean aEmpty = a.isEmpty();
+        boolean bEmpty = b.isEmpty();
 
         if (aEmpty && bEmpty) {
             return true;
@@ -284,14 +287,14 @@ public class FormatIteratorTest extends IntlTest {
         return buffer.toString();
     }
 
-    private void verifyFieldPosition(int index, Hashtable table) {
+    private void verifyFieldPosition(int index, Map<String,Object> table) {
         Object o = table.get("field");
         int begin = Integer.parseInt((String)table.get("begin"));
         int end = Integer.parseInt((String)table.get("end"));
 
         if (o != null) {
             FieldPosition fp = new FieldPosition(((Integer)
-                                          lookupField((String)o)).intValue());
+                                          lookupField((String)o)));
 
             verifyFieldPosition(fp, begin, end, index);
         }
@@ -322,11 +325,11 @@ public class FormatIteratorTest extends IntlTest {
         }
     }
 
-    public AttributedCharacterIterator create(Hashtable table) {
+    public AttributedCharacterIterator create(Map<String,Object> table) {
         format = (Format)createInstance((String)table.get("class"),
-                                        ((Vector)table.get("args")).toArray());
+                                        ((List)table.get("args")).toArray());
         value = createInstance((String)table.get("valueClass"),
-                               ((Vector)table.get("valueArgs")).toArray());
+                               ((List)table.get("valueArgs")).toArray());
 
         logln("Created format: " + format + " value " + value);
         AttributedCharacterIterator aci = format.
@@ -343,11 +346,12 @@ public class FormatIteratorTest extends IntlTest {
     private Object createInstance(String className, Object[] args) {
         if (className.equals("java.lang.reflect.Array")) {
             for (int counter = 0; counter < args.length; counter++) {
-                if (args[counter] instanceof Vector) {
-                    Vector v = (Vector)args[counter];
+                if (args[counter] instanceof List) {
+                    @SuppressWarnings("unchecked")
+                    List<Object> v = (List<Object>)args[counter];
 
                     args[counter] = createInstance((String)v.get(0),
-                                               ((Vector)v.get(1)).toArray());
+                                               ((List)v.get(1)).toArray());
                 }
             }
             return args;
@@ -361,9 +365,9 @@ public class FormatIteratorTest extends IntlTest {
             } else if (className.equals("java.util.concurrent.atomic.AtomicLong")) {
                 return new AtomicLong(Long.valueOf((String)args[0]));
             } else {
-                Class klass = lookupClass(className);
-                Constructor cons = klass.getConstructor(
-                    new Class[] { String.class });
+                Class<?> klass = lookupClass(className);
+                Constructor<?> cons = klass.getConstructor(
+                    new Class<?>[] { String.class });
                 Object value = cons.newInstance(args);
 
                 return value;
@@ -374,20 +378,20 @@ public class FormatIteratorTest extends IntlTest {
         }
     }
 
-    private Class lookupClass(String name) throws ClassNotFoundException {
+    private  Class<?> lookupClass(String name) throws ClassNotFoundException {
         try {
-            Class klass = Class.forName(name);
+            Class<?> klass = Class.forName(name);
 
             return klass;
         } catch (ClassNotFoundException e1) {}
 
         try {
-            Class klass = Class.forName("java.lang." + name);
+            Class<?> klass = Class.forName("java.lang." + name);
 
             return klass;
         } catch (ClassNotFoundException e1) {}
 
-        Class klass = Class.forName("java.text." + name);
+        Class<?> klass = Class.forName("java.text." + name);
 
         return klass;
     }
@@ -397,7 +401,7 @@ public class FormatIteratorTest extends IntlTest {
 
         try {
             int dotIndex = name.indexOf('.');
-            Class klass = lookupClass(name.substring(0, dotIndex));
+            Class<?> klass = lookupClass(name.substring(0, dotIndex));
             String fieldName = name.substring(dotIndex + 1);
             Field[] fields = klass.getFields();
 
@@ -429,8 +433,8 @@ public class FormatIteratorTest extends IntlTest {
         return string;
     }
 
-    public Set makeAttributes(Vector names) {
-        HashSet set = new HashSet(Math.max(1, names.size()));
+    public Set<Attribute> makeAttributes(List<Object> names) {
+        Set<Attribute> set = new HashSet<>(Math.max(1, names.size()));
 
         for (int counter = 0; counter < names.size(); counter++) {
             set.add(makeAttribute((String)names.get(counter)));
diff --git a/jdk/test/java/text/Format/common/PParser.java b/jdk/test/java/text/Format/common/PParser.java
index 6ada76b1059..eb7ccd11315 100644
--- a/jdk/test/java/text/Format/common/PParser.java
+++ b/jdk/test/java/text/Format/common/PParser.java
@@ -58,7 +58,7 @@ public class PParser {
     public PParser() {
     }
 
-    public Hashtable parse(Reader r) throws IOException {
+    public Map<String,Object> parse(Reader r) throws IOException {
         this.reader = r;
         bufferedToken = false;
         lineNumber = 0;
@@ -91,23 +91,23 @@ public class PParser {
     }
 
     protected Object parseArray() throws IOException {
-        Vector       array = new Vector();
-        int          token;
+        List<Object> array = new ArrayList<>();
+        int token;
 
         while ((token = getToken()) != CLOSE_ARRAY) {
             if (token == MORE) {
                 token = getToken();
             }
             if (token != CLOSE_ARRAY) {
-                array.addElement(parseValue(token));
+                array.add(parseValue(token));
             }
         }
         return array;
     }
 
-    protected Hashtable parsePair() throws IOException {
-        Hashtable           ht = new Hashtable(11);
-        int                 token;
+    protected Map<String,Object> parsePair() throws IOException {
+        Map<String,Object> ht = new HashMap<>(11);
+        int token;
 
         while ((token = getToken()) != CLOSE_PAIR) {
             if (token != STRING) {
@@ -133,11 +133,12 @@ public class PParser {
     }
 
     protected int getToken() throws IOException {
-        int            token = getToken(false, false);
+        int token = getToken(false, false);
 
         return token;
     }
 
+    @SuppressWarnings("fallthrough")
     protected int getToken(boolean wantsWS, boolean inString)
         throws IOException {
         if (bufferedToken) {
@@ -225,31 +226,26 @@ public class PParser {
         throw new RuntimeException(errorString + " at line " + lineNumber + " column " + column);
     }
 
+    @SuppressWarnings("unchecked")
     public static void dump(Object o) {
         if (o instanceof String) {
             System.out.print(o);
-        } else if(o instanceof Vector) {
-            Enumeration     e = ((Vector)o).elements();
-
+        } else if(o instanceof List) {
             dump(" (");
-            while (e.hasMoreElements()) {
-                dump(e.nextElement());
+            ((List)o).forEach((l) -> {
+                dump(l);
                 dump(" -- ");
-            }
+            });
             dump(" )");
         } else {
-            Hashtable       ht = (Hashtable)o;
-            Enumeration     e = ht.keys();
-
+            Map<String,Object> ht = (Map<String,Object>)o;
             dump(" {");
-            while (e.hasMoreElements()) {
-                Object       key = e.nextElement();
-
-                dump(key);
+            ht.keySet().forEach(l -> {
+                dump(l);
                 dump(" = ");
-                dump(ht.get(key));
+                dump(ht.get(l));
                 dump(";");
-            }
+            });
             dump(" }");
         }
     }
@@ -259,9 +255,9 @@ public class PParser {
             System.out.println("need filename");
         } else {
             try {
-                FileReader          fr = new FileReader(args[0]);
-                PParser             parser = new PParser();
-                Hashtable           ht = parser.parse(fr);
+                FileReader fr = new FileReader(args[0]);
+                PParser parser = new PParser();
+                Map<String,Object> ht = parser.parse(fr);
 
                 dump(ht);
                 System.out.println();