1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
/* * @(#)Boolean.java 1.53 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.lang; /** * The Boolean class wraps a value of the primitive type * <code>boolean</code> in an object. An object of type * <code>Boolean</code> contains a single field whose type is * <code>boolean</code>. * <p> * In addition, this class provides many methods for * converting a <code>boolean</code> to a <code>String</code> and a * <code>String</code> to a <code>boolean</code>, as well as other * constants and methods useful when dealing with a * <code>boolean</code>. * * @author Arthur van Hoff * @version 1.53, 11/17/05 * @since JDK1.0 */ public final class Boolean implements java.io.Serializable, Comparable<Boolean> { /** * The <code>Boolean</code> object corresponding to the primitive * value <code>true</code>. */ public static final Boolean TRUE = new Boolean(true); /** * The <code>Boolean</code> object corresponding to the primitive * value <code>false</code>. */ public static final Boolean FALSE = new Boolean(false); /** * The Class object representing the primitive type boolean. * * @since JDK1.1 */ public static final Class<Boolean> TYPE = Class.getPrimitiveClass("boolean"); /** * The value of the Boolean. * * @serial */ private final boolean value; /** use serialVersionUID from JDK 1.0.2 for interoperability */ private static final long serialVersionUID = -3665804199014368530L; /** * Allocates a <code>Boolean</code> object representing the * <code>value</code> argument. * * <p><b>Note: It is rarely appropriate to use this constructor. * Unless a <i>new</i> instance is required, the static factory * {@link #valueOf(boolean)} is generally a better choice. It is * likely to yield significantly better space and time performance.</b> * * @param value the value of the <code>Boolean</code>. */ public Boolean(boolean value) { this.value = value; } /** * Allocates a <code>Boolean</code> object representing the value * <code>true</code> if the string argument is not <code>null</code> * and is equal, ignoring case, to the string {@code "true"}. * Otherwise, allocate a <code>Boolean</code> object representing the * value <code>false</code>. Examples:<p> * {@code new Boolean("True")} produces a <tt>Boolean</tt> object * that represents <tt>true</tt>.<br> * {@code new Boolean("yes")} produces a <tt>Boolean</tt> object * that represents <tt>false</tt>. * * @param s the string to be converted to a <code>Boolean</code>. */ public Boolean(String s) { this(toBoolean(s)); } /** * Parses the string argument as a boolean. The <code>boolean</code> * returned represents the value <code>true</code> if the string argument * is not <code>null</code> and is equal, ignoring case, to the string * {@code "true"}. <p> * Example: {@code Boolean.parseBoolean("True")} returns <tt>true</tt>.<br> * Example: {@code Boolean.parseBoolean("yes")} returns <tt>false</tt>. * * @param s the <code>String</code> containing the boolean * representation to be parsed * @return the boolean represented by the string argument * @since 1.5 */ public static boolean parseBoolean(String s) { return toBoolean(s); } /** * Returns the value of this <tt>Boolean</tt> object as a boolean * primitive. * * @return the primitive <code>boolean</code> value of this object. */ public boolean booleanValue() { return value; } /** * Returns a <tt>Boolean</tt> instance representing the specified * <tt>boolean</tt> value. If the specified <tt>boolean</tt> value * is <tt>true</tt>, this method returns <tt>Boolean.TRUE</tt>; * if it is <tt>false</tt>, this method returns <tt>Boolean.FALSE</tt>. * If a new <tt>Boolean</tt> instance is not required, this method * should generally be used in preference to the constructor * {@link #Boolean(boolean)}, as this method is likely to yield * significantly better space and time performance. * * @param b a boolean value. * @return a <tt>Boolean</tt> instance representing <tt>b</tt>. * @since 1.4 */ public static Boolean valueOf(boolean b) { return (b ? TRUE : FALSE); } /** * Returns a <code>Boolean</code> with a value represented by the * specified string. The <code>Boolean</code> returned represents a * true value if the string argument is not <code>null</code> * and is equal, ignoring case, to the string {@code "true"}. * * @param s a string. * @return the <code>Boolean</code> value represented by the string. */ public static Boolean valueOf(String s) { return toBoolean(s) ? TRUE : FALSE; } /** * Returns a <tt>String</tt> object representing the specified * boolean. If the specified boolean is <code>true</code>, then * the string {@code "true"} will be returned, otherwise the * string {@code "false"} will be returned. * * @param b the boolean to be converted * @return the string representation of the specified <code>boolean</code> * @since 1.4 */ public static String toString(boolean b) { return b ? "true" : "false"; } /** * Returns a <tt>String</tt> object representing this Boolean's * value. If this object represents the value <code>true</code>, * a string equal to {@code "true"} is returned. Otherwise, a * string equal to {@code "false"} is returned. * * @return a string representation of this object. */ public String toString() { return value ? "true" : "false"; } /** * Returns a hash code for this <tt>Boolean</tt> object. * * @return the integer <tt>1231</tt> if this object represents * <tt>true</tt>; returns the integer <tt>1237</tt> if this * object represents <tt>false</tt>. */ public int hashCode() { return value ? 1231 : 1237; } /** * Returns <code>true</code> if and only if the argument is not * <code>null</code> and is a <code>Boolean</code> object that * represents the same <code>boolean</code> value as this object. * * @param obj the object to compare with. * @return <code>true</code> if the Boolean objects represent the * same value; <code>false</code> otherwise. */ public boolean equals(Object obj) { if (obj instanceof Boolean) { return value == ((Boolean)obj).booleanValue(); } return false; } /** * Returns <code>true</code> if and only if the system property * named by the argument exists and is equal to the string * {@code "true"}. (Beginning with version 1.0.2 of the * Java<small><sup>TM</sup></small> platform, the test of * this string is case insensitive.) A system property is accessible * through <code>getProperty</code>, a method defined by the * <code>System</code> class. * <p> * If there is no property with the specified name, or if the specified * name is empty or null, then <code>false</code> is returned. * * @param name the system property name. * @return the <code>boolean</code> value of the system property. * @see java.lang.System#getProperty(java.lang.String) * @see java.lang.System#getProperty(java.lang.String, java.lang.String) */ public static boolean getBoolean(String name) { boolean result = false; try { result = toBoolean(System.getProperty(name)); } catch (IllegalArgumentException e) { } catch (NullPointerException e) { } return result; } /** * Compares this <tt>Boolean</tt> instance with another. * * @param b the <tt>Boolean</tt> instance to be compared * @return zero if this object represents the same boolean value as the * argument; a positive value if this object represents true * and the argument represents false; and a negative value if * this object represents false and the argument represents true * @throws NullPointerException if the argument is <tt>null</tt> * @see Comparable * @since 1.5 */ public int compareTo(Boolean b) { return (b.value == value ? 0 : (value ? 1 : -1)); } private static boolean toBoolean(String name) { return ((name != null) && name.equalsIgnoreCase("true")); } }