Character, Byte, Short valueOf instead of new instance (original) (raw)

Sat Jun 14 16:38:21 UTC 2014

           result = new Character(value.charAt(0));
           result = value.charAt(0);
       } else {
           result = newStringConstructor(
                   ((Class<?>) primitiveToWrapper.get(type)).getName(),
                   value);
       }
   } else if (type.equals(Character.class.getName())) {
       result = new Character(value.charAt(0));
       result = value.charAt(0);
   } else if (Number.class.isAssignableFrom(Utils.getClass(type))) {
       result = createNumberFromStringValue(value);
   } else if (value == null || value.equals("null")) {
   {new Byte(DerValue.tag_IA5String)},   // EMailAddress
   {new Byte(DerValue.tag_IA5String),   // UnstructuredName
    new Byte(DerValue.tag_PrintableString)},
   {new Byte(DerValue.tag_ObjectId)},    // ContentType
   {new Byte(DerValue.tag_OctetString)}, // MessageDigest
   {new Byte(DerValue.tag_UtcTime)},     // SigningTime
   {new Byte(DerValue.tag_Sequence)},    // Countersignature
   {new Byte(DerValue.tag_PrintableString),
    new Byte(DerValue.tag_T61String)},   // ChallengePassword
   {new Byte(DerValue.tag_PrintableString),
    new Byte(DerValue.tag_T61String)},   // UnstructuredAddress
   {new Byte(DerValue.tag_SetOf)},       // ExtendedCertificateAttributes
   {new Byte(DerValue.tag_Sequence)},    // issuerAndSerialNumber
   {DerValue.tag_IA5String},   // EMailAddress
   {DerValue.tag_IA5String,   // UnstructuredName
    DerValue.tag_PrintableString},
   {DerValue.tag_ObjectId},    // ContentType
   {DerValue.tag_OctetString}, // MessageDigest
   {DerValue.tag_UtcTime},     // SigningTime
   {DerValue.tag_Sequence},    // Countersignature
   {DerValue.tag_PrintableString,
    DerValue.tag_T61String},   // ChallengePassword
   {DerValue.tag_PrintableString,
    DerValue.tag_T61String},   // UnstructuredAddress
   {DerValue.tag_SetOf},       // ExtendedCertificateAttributes
   {DerValue.tag_Sequence},    // issuerAndSerialNumber
   null,
   null,
   null,
   {new Byte(DerValue.tag_Sequence)},    // extensionRequest
   {new Byte(DerValue.tag_Sequence)},    // SMIMECapability
   {new Byte(DerValue.tag_Sequence)},    // SigningCertificate
   {new Byte(DerValue.tag_Sequence)}     // SignatureTimestampToken
   {DerValue.tag_Sequence},    // extensionRequest
   {DerValue.tag_Sequence},    // SMIMECapability
   {DerValue.tag_Sequence},    // SigningCertificate
   {DerValue.tag_Sequence}     // SignatureTimestampToken
       tag = new Byte(elems[i].tag);
       tag = elems[i].tag;

       if (indexOf(tag, PKCS9_VALUE_TAGS[index], 0) == -1)
           throwTagException(tag);
           return new Byte((byte)((hi<<4) + lo));
           return (byte)((hi<<4) + lo);
       } else {
           throw new IOException
                   ("escaped hex value must include two valid digits");
           map.put(key, new Short(i));
           map.put(key, i);
           return i;
       }
   }
           map.put(e, new Short(i));
           map.put(e, i);
           return i;
       }
   }
       Byte[] result = { new Byte(bitmap[0]), new Byte(bitmap[1]) };
       Byte[] result = {bitmap[0], bitmap[1]};
       return result;
   }
               new Byte((byte) readInt(items[readUnsignedShort(v)])));
               (byte) readInt(items[readUnsignedShort(v)]));
       v += 2;
       break;
   case 'Z': // pointer to CONSTANT_Boolean
       av.visit(name, new Short(
               (short) readInt(items[readUnsignedShort(v)])));
       av.visit(name, 
               (short) readInt(items[readUnsignedShort(v)]));
       v += 2;
       break;
   case 'C': // pointer to CONSTANT_Char
       av.visit(name, new Character(
               (char) readInt(items[readUnsignedShort(v)])));
       av.visit(name, (char) readInt(items[readUnsignedShort(v)]));
       v += 2;
       break;
   case 's': // pointer to CONSTANT_Utf8
        return new Byte(param);
        return Byte.valueOf(param);
   if (type.compareTo("java.lang.Short") == 0)
        return new Short(param);
        return Short.valueOf(param);
   if (type.compareTo("java.lang.Long") == 0)
        return new Long(param);
   if (type.compareTo("java.lang.Integer") == 0)
               return new Character(((String)arguments[0]).charAt(0));
               return ((String)arguments[0]).charAt(0);
           }
           try {
               m = ConstructorFinder.findConstructor((Class)target, argClasses);
   firePropertyChange(propertyName, new Character(oldValue), new Character(newValue));
   firePropertyChange(propertyName, oldValue, newValue);
   return add(new Byte(b));
   return add(b);
   return add(new Character(c));
   return add(c);
   return add(new Short(s));
   return add(s);
   return set(new Byte(b), index);
   return set(b, index);
   return set(new Character(c), index);
   return set(c, index);
   return set(new Short(s), index);
   return set(s, index);
                       new Byte(msgWithPadding[msgWithPadding.length - 1]));
                       msgWithPadding[msgWithPadding.length - 1]);
               }
               return EMPTY_BYTE_ARRAY;
           }
               new Byte(gssOutToken[0]));
               gssOutToken[0]);
       }

       // Client selects preferred protection
               new Object[]{new Byte(selectedQop),
               new Object[]{selectedQop,
                            Boolean.valueOf(privacy),
                            Boolean.valueOf(integrity)});
       }
               new Object[]{new Byte(allQop),
               new Object[]{allQop,
                            new Integer(recvMaxBufSize)});
       }
               new Object[]{new Byte(selectedQop),
               new Object[]{selectedQop,
                            Boolean.valueOf(privacy),
                            Boolean.valueOf(integrity)});
           logger.log(Level.FINE,
         if (logger.isLoggable(Level.FINE)) {
             logger.logp(Level.FINE, myClassName, "constructor",
               "SASLIMPL02:Preferred qop mask: {0}", new Byte(allQop));
               "SASLIMPL02:Preferred qop mask: {0}", allQop);

           if (qop.length > 0) {
               StringBuffer qopbuf = new StringBuffer();
       if(proto.equals(new Character(WILDCARD_TOKEN).toString())) {
       if(proto.equals(Character.valueOf(WILDCARD_TOKEN).toString())) {
           if(debug) {System.out.println("simple presence assertion");}
           return true;
       }
       result[i] = new Byte(value[i]) ;
       result[i] = value[i];
   }
   return result ;
       "PasswordField.echoChar", new XPValue(new Character((char)0x25CF),
                                             new Character('*')),
       "PasswordField.echoChar", new XPValue((char)0x25CF, '*'),

       // *** ProgressBar
       "ProgressBar.font", ControlFont,