1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * https://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.lang3;
18
19 import java.util.Arrays;
20 import java.util.Collections;
21 import java.util.List;
22 import java.util.function.Consumer;
23
24 import org.apache.commons.lang3.math.NumberUtils;
25
26 /**
27 * Operations on boolean primitives and Boolean objects.
28 *
29 * <p>
30 * This class tries to handle {@code null} input gracefully.
31 * An exception will not be thrown for a {@code null} input.
32 * Each method documents its behavior in more detail.
33 * </p>
34 *
35 * <p>
36 * #ThreadSafe#
37 * </p>
38 *
39 * @since 2.0
40 */
41 public class BooleanUtils {
42
43 private static final List<Boolean> BOOLEAN_LIST = Collections.unmodifiableList(Arrays.asList(Boolean.FALSE, Boolean.TRUE));
44
45 /**
46 * The false String {@code "false"}.
47 *
48 * @since 3.12.0
49 */
50 public static final String FALSE = "false";
51
52 /**
53 * The no String {@code "no"}.
54 *
55 * @since 3.12.0
56 */
57 public static final String NO = "no";
58
59 /**
60 * The off String {@code "off"}.
61 *
62 * @since 3.12.0
63 */
64 public static final String OFF = "off";
65
66 /**
67 * The on String {@code "on"}.
68 *
69 * @since 3.12.0
70 */
71 public static final String ON = "on";
72
73 /**
74 * The true String {@code "true"}.
75 *
76 * @since 3.12.0
77 */
78 public static final String TRUE = "true";
79
80 /**
81 * The yes String {@code "yes"}.
82 *
83 * @since 3.12.0
84 */
85 public static final String YES = "yes";
86
87 /**
88 * Performs an 'and' operation on a set of booleans.
89 *
90 * <pre>
91 * BooleanUtils.and(true, true) = true
92 * BooleanUtils.and(false, false) = false
93 * BooleanUtils.and(true, false) = false
94 * BooleanUtils.and(true, true, false) = false
95 * BooleanUtils.and(true, true, true) = true
96 * </pre>
97 *
98 * @param array An array of {@code boolean}s
99 * @return The result of the logical 'and' operation. That is {@code false}
100 * if any of the parameters is {@code false} and {@code true} otherwise.
101 * @throws NullPointerException Thrown if {@code array} is {@code null}.
102 * @throws IllegalArgumentException Thrown if {@code array} is empty.
103 * @since 3.0.1
104 */
105 public static boolean and(final boolean... array) {
106 ObjectUtils.requireNonEmpty(array, "array");
107 for (final boolean element : array) {
108 if (!element) {
109 return false;
110 }
111 }
112 return true;
113 }
114
115 /**
116 * Performs an 'and' operation on an array of Booleans.
117 * <pre>
118 * BooleanUtils.and(Boolean.TRUE, Boolean.TRUE) = Boolean.TRUE
119 * BooleanUtils.and(Boolean.FALSE, Boolean.FALSE) = Boolean.FALSE
120 * BooleanUtils.and(Boolean.TRUE, Boolean.FALSE) = Boolean.FALSE
121 * BooleanUtils.and(Boolean.TRUE, Boolean.TRUE, Boolean.TRUE) = Boolean.TRUE
122 * BooleanUtils.and(Boolean.FALSE, Boolean.FALSE, Boolean.TRUE) = Boolean.FALSE
123 * BooleanUtils.and(Boolean.TRUE, Boolean.FALSE, Boolean.TRUE) = Boolean.FALSE
124 * BooleanUtils.and(null, null) = Boolean.FALSE
125 * </pre>
126 * <p>
127 * Null array elements map to false, like {@code Boolean.parseBoolean(null)} and its callers return false.
128 * </p>
129 *
130 * @param array An array of {@link Boolean}s
131 * @return The result of the logical 'and' operation. That is {@code false}
132 * if any of the parameters is {@code false} and {@code true} otherwise.
133 * @throws NullPointerException Thrown if {@code array} is {@code null}.
134 * @throws IllegalArgumentException Thrown if {@code array} is empty.
135 * @since 3.0.1
136 */
137 public static Boolean and(final Boolean... array) {
138 ObjectUtils.requireNonEmpty(array, "array");
139 return and(ArrayUtils.toPrimitive(array)) ? Boolean.TRUE : Boolean.FALSE;
140 }
141
142 /**
143 * Returns a new array of possible values (like an enum would).
144 *
145 * @return A new array of possible values (like an enum would).
146 * @since 3.12.0
147 */
148 public static Boolean[] booleanValues() {
149 return new Boolean[] {Boolean.FALSE, Boolean.TRUE};
150 }
151
152 /**
153 * Compares two {@code boolean} values. This is the same functionality as provided in Java 7.
154 *
155 * @param x The first {@code boolean} to compare
156 * @param y The second {@code boolean} to compare
157 * @return The value {@code 0} if {@code x == y};
158 * a value less than {@code 0} if {@code !x && y}; and
159 * a value greater than {@code 0} if {@code x && !y}
160 * @since 3.4
161 */
162 public static int compare(final boolean x, final boolean y) {
163 if (x == y) {
164 return 0;
165 }
166 return x ? 1 : -1;
167 }
168
169 /**
170 * Performs the given action for each Boolean {@link BooleanUtils#values()}.
171 *
172 * @param action The action to be performed for each element
173 * @since 3.13.0
174 */
175 public static void forEach(final Consumer<Boolean> action) {
176 values().forEach(action);
177 }
178
179 /**
180 * Tests whether a {@link Boolean} value is {@code false}, handling {@code null} by returning {@code false}.
181 *
182 * <pre>
183 * BooleanUtils.isFalse(Boolean.TRUE) = false
184 * BooleanUtils.isFalse(Boolean.FALSE) = true
185 * BooleanUtils.isFalse(null) = false
186 * </pre>
187 *
188 * @param bool The boolean to check, null returns {@code false}
189 * @return {@code true} only if the input is non-{@code null} and {@code false}
190 * @since 2.1
191 */
192 public static boolean isFalse(final Boolean bool) {
193 return Boolean.FALSE.equals(bool);
194 }
195
196 /**
197 * Tests whether a {@link Boolean} value is <em>not</em> {@code false}, handling {@code null} by returning {@code true}.
198 *
199 * <pre>
200 * BooleanUtils.isNotFalse(Boolean.TRUE) = true
201 * BooleanUtils.isNotFalse(Boolean.FALSE) = false
202 * BooleanUtils.isNotFalse(null) = true
203 * </pre>
204 *
205 * @param bool The boolean to check, null returns {@code true}
206 * @return {@code true} if the input is {@code null} or {@code true}
207 * @since 2.3
208 */
209 public static boolean isNotFalse(final Boolean bool) {
210 return !isFalse(bool);
211 }
212
213 /**
214 * Tests whether a {@link Boolean} value is <em>not</em> {@code true}, handling {@code null} by returning {@code true}.
215 *
216 * <pre>
217 * BooleanUtils.isNotTrue(Boolean.TRUE) = false
218 * BooleanUtils.isNotTrue(Boolean.FALSE) = true
219 * BooleanUtils.isNotTrue(null) = true
220 * </pre>
221 *
222 * @param bool The boolean to check, null returns {@code true}
223 * @return {@code true} if the input is null or false
224 * @since 2.3
225 */
226 public static boolean isNotTrue(final Boolean bool) {
227 return !isTrue(bool);
228 }
229
230 /**
231 * Tests whether a {@link Boolean} value is {@code true}, handling {@code null} by returning {@code false}.
232 *
233 * <pre>
234 * BooleanUtils.isTrue(Boolean.TRUE) = true
235 * BooleanUtils.isTrue(Boolean.FALSE) = false
236 * BooleanUtils.isTrue(null) = false
237 * </pre>
238 *
239 * @param bool The boolean to check, {@code null} returns {@code false}
240 * @return {@code true} only if the input is non-null and true
241 * @since 2.1
242 */
243 public static boolean isTrue(final Boolean bool) {
244 return Boolean.TRUE.equals(bool);
245 }
246
247 /**
248 * Negates the specified boolean.
249 *
250 * <p>
251 * If {@code null} is passed in, {@code null} will be returned.
252 * </p>
253 *
254 * <p>
255 * NOTE: This returns {@code null} and will throw a {@link NullPointerException}
256 * if unboxed to a boolean.
257 * </p>
258 *
259 * <pre>
260 * BooleanUtils.negate(Boolean.TRUE) = Boolean.FALSE;
261 * BooleanUtils.negate(Boolean.FALSE) = Boolean.TRUE;
262 * BooleanUtils.negate(null) = null;
263 * </pre>
264 *
265 * @param bool The Boolean to negate, may be null
266 * @return The negated Boolean, or {@code null} if {@code null} input
267 */
268 public static Boolean negate(final Boolean bool) {
269 if (bool == null) {
270 return null;
271 }
272 return bool.booleanValue() ? Boolean.FALSE : Boolean.TRUE;
273 }
274
275 /**
276 * Performs a one-hot on an array of booleans.
277 * <p>
278 * This implementation returns true if one, and only one, of the supplied values is true.
279 * </p>
280 * <p>
281 * See also <a href="https://en.wikipedia.org/wiki/One-hot">One-hot</a>.
282 * </p>
283 *
284 * @param array An array of {@code boolean}s
285 * @return The result of the one-hot operations
286 * @throws NullPointerException Thrown if {@code array} is {@code null}.
287 * @throws IllegalArgumentException Thrown if {@code array} is empty.
288 */
289 public static boolean oneHot(final boolean... array) {
290 ObjectUtils.requireNonEmpty(array, "array");
291 boolean result = false;
292 for (final boolean element: array) {
293 if (element) {
294 if (result) {
295 return false;
296 }
297 result = true;
298 }
299 }
300 return result;
301 }
302
303 /**
304 * Performs a one-hot on an array of booleans.
305 * <p>
306 * This implementation returns true if one, and only one, of the supplied values is true.
307 * </p>
308 * <p>
309 * Null array elements map to false, like {@code Boolean.parseBoolean(null)} and its callers return false.
310 * </p>
311 * <p>
312 * See also <a href="https://en.wikipedia.org/wiki/One-hot">One-hot</a>.
313 * </p>
314 *
315 * @param array An array of {@code boolean}s
316 * @return The result of the one-hot operations
317 * @throws NullPointerException Thrown if {@code array} is {@code null}.
318 * @throws IllegalArgumentException Thrown if {@code array} is empty.
319 */
320 public static Boolean oneHot(final Boolean... array) {
321 return Boolean.valueOf(oneHot(ArrayUtils.toPrimitive(array)));
322 }
323
324 /**
325 * Performs an 'or' operation on a set of booleans.
326 *
327 * <pre>
328 * BooleanUtils.or(true, true) = true
329 * BooleanUtils.or(false, false) = false
330 * BooleanUtils.or(true, false) = true
331 * BooleanUtils.or(true, true, false) = true
332 * BooleanUtils.or(true, true, true) = true
333 * BooleanUtils.or(false, false, false) = false
334 * </pre>
335 *
336 * @param array An array of {@code boolean}s
337 * @return {@code true} if any of the arguments is {@code true}, and it returns {@code false} otherwise.
338 * @throws NullPointerException Thrown if {@code array} is {@code null}.
339 * @throws IllegalArgumentException Thrown if {@code array} is empty.
340 * @since 3.0.1
341 */
342 public static boolean or(final boolean... array) {
343 ObjectUtils.requireNonEmpty(array, "array");
344 for (final boolean element : array) {
345 if (element) {
346 return true;
347 }
348 }
349 return false;
350 }
351
352 /**
353 * Performs an 'or' operation on an array of Booleans.
354 * <pre>
355 * BooleanUtils.or(Boolean.TRUE, Boolean.TRUE) = Boolean.TRUE
356 * BooleanUtils.or(Boolean.FALSE, Boolean.FALSE) = Boolean.FALSE
357 * BooleanUtils.or(Boolean.TRUE, Boolean.FALSE) = Boolean.TRUE
358 * BooleanUtils.or(Boolean.TRUE, Boolean.TRUE, Boolean.TRUE) = Boolean.TRUE
359 * BooleanUtils.or(Boolean.FALSE, Boolean.FALSE, Boolean.TRUE) = Boolean.TRUE
360 * BooleanUtils.or(Boolean.TRUE, Boolean.FALSE, Boolean.TRUE) = Boolean.TRUE
361 * BooleanUtils.or(Boolean.FALSE, Boolean.FALSE, Boolean.FALSE) = Boolean.FALSE
362 * BooleanUtils.or(Boolean.TRUE, null) = Boolean.TRUE
363 * BooleanUtils.or(Boolean.FALSE, null) = Boolean.FALSE
364 * </pre>
365 * <p>
366 * Null array elements map to false, like {@code Boolean.parseBoolean(null)} and its callers return false.
367 * </p>
368 *
369 * @param array An array of {@link Boolean}s
370 * @return {@code true} if any of the arguments is {@code true}, and it returns {@code false} otherwise.
371 * @throws NullPointerException Thrown if {@code array} is {@code null}.
372 * @throws IllegalArgumentException Thrown if {@code array} is empty.
373 * @since 3.0.1
374 */
375 public static Boolean or(final Boolean... array) {
376 ObjectUtils.requireNonEmpty(array, "array");
377 return or(ArrayUtils.toPrimitive(array)) ? Boolean.TRUE : Boolean.FALSE;
378 }
379
380 /**
381 * Returns a new array of possible values (like an enum would).
382 *
383 * @return A new array of possible values (like an enum would).
384 * @since 3.12.0
385 */
386 public static boolean[] primitiveValues() {
387 return new boolean[] {false, true};
388 }
389
390 /**
391 * Converts a Boolean to a boolean handling {@code null}
392 * by returning {@code false}.
393 *
394 * <pre>
395 * BooleanUtils.toBoolean(Boolean.TRUE) = true
396 * BooleanUtils.toBoolean(Boolean.FALSE) = false
397 * BooleanUtils.toBoolean(null) = false
398 * </pre>
399 *
400 * @param bool The boolean to convert
401 * @return {@code true} or {@code false}, {@code null} returns {@code false}
402 */
403 public static boolean toBoolean(final Boolean bool) {
404 return bool != null && bool.booleanValue();
405 }
406
407 /**
408 * Converts an int to a boolean using the convention that {@code zero}
409 * is {@code false}, everything else is {@code true}.
410 *
411 * <pre>
412 * BooleanUtils.toBoolean(0) = false
413 * BooleanUtils.toBoolean(1) = true
414 * BooleanUtils.toBoolean(2) = true
415 * </pre>
416 *
417 * @param value The int to convert
418 * @return {@code true} if non-zero, {@code false}
419 * if zero
420 */
421 public static boolean toBoolean(final int value) {
422 return value != 0;
423 }
424
425 /**
426 * Converts an int to a boolean specifying the conversion values.
427 *
428 * <p>
429 * If the {@code trueValue} and {@code falseValue} are the same number then
430 * the return value will be {@code true} in case {@code value} matches it.
431 * </p>
432 *
433 * <pre>
434 * BooleanUtils.toBoolean(0, 1, 0) = false
435 * BooleanUtils.toBoolean(1, 1, 0) = true
436 * BooleanUtils.toBoolean(1, 1, 1) = true
437 * BooleanUtils.toBoolean(2, 1, 2) = false
438 * BooleanUtils.toBoolean(2, 2, 0) = true
439 * </pre>
440 *
441 * @param value The {@link Integer} to convert
442 * @param trueValue The value to match for {@code true}
443 * @param falseValue The value to match for {@code false}
444 * @return {@code true} or {@code false}
445 * @throws IllegalArgumentException Thrown if {@code value} does not match neither {@code trueValue} no {@code falseValue}.
446 */
447 public static boolean toBoolean(final int value, final int trueValue, final int falseValue) {
448 if (value == trueValue) {
449 return true;
450 }
451 if (value == falseValue) {
452 return false;
453 }
454 throw new IllegalArgumentException("The Integer did not match either specified value");
455 }
456
457 /**
458 * Converts an Integer to a boolean specifying the conversion values.
459 *
460 * <pre>
461 * BooleanUtils.toBoolean(Integer.valueOf(0), Integer.valueOf(1), Integer.valueOf(0)) = false
462 * BooleanUtils.toBoolean(Integer.valueOf(1), Integer.valueOf(1), Integer.valueOf(0)) = true
463 * BooleanUtils.toBoolean(Integer.valueOf(2), Integer.valueOf(1), Integer.valueOf(2)) = false
464 * BooleanUtils.toBoolean(Integer.valueOf(2), Integer.valueOf(2), Integer.valueOf(0)) = true
465 * BooleanUtils.toBoolean(null, null, Integer.valueOf(0)) = true
466 * </pre>
467 *
468 * @param value The Integer to convert
469 * @param trueValue The value to match for {@code true}, may be {@code null}
470 * @param falseValue The value to match for {@code false}, may be {@code null}
471 * @return {@code true} or {@code false}
472 * @throws IllegalArgumentException Thrown if no match.
473 */
474 public static boolean toBoolean(final Integer value, final Integer trueValue, final Integer falseValue) {
475 if (value == null) {
476 if (trueValue == null) {
477 return true;
478 }
479 if (falseValue == null) {
480 return false;
481 }
482 } else if (value.equals(trueValue)) {
483 return true;
484 } else if (value.equals(falseValue)) {
485 return false;
486 }
487 throw new IllegalArgumentException("The Integer did not match either specified value");
488 }
489
490 /**
491 * Converts a String to a boolean (optimized for performance).
492 *
493 * <p>
494 * {@code 'true'}, {@code 'on'}, {@code 'y'}, {@code 't'} or {@code 'yes'}
495 * (case insensitive) will return {@code true}. Otherwise,
496 * {@code false} is returned.
497 * </p>
498 *
499 * <p>
500 * This method performs 4 times faster (JDK1.4) than
501 * {@code Boolean.valueOf(String)}. However, this method accepts
502 * 'on' and 'yes', 't', 'y' as true values.
503 *
504 * <pre>
505 * BooleanUtils.toBoolean(null) = false
506 * BooleanUtils.toBoolean("true") = true
507 * BooleanUtils.toBoolean("TRUE") = true
508 * BooleanUtils.toBoolean("tRUe") = true
509 * BooleanUtils.toBoolean("on") = true
510 * BooleanUtils.toBoolean("yes") = true
511 * BooleanUtils.toBoolean("false") = false
512 * BooleanUtils.toBoolean("x gti") = false
513 * BooleanUtils.toBoolean("y") = true
514 * BooleanUtils.toBoolean("n") = false
515 * BooleanUtils.toBoolean("t") = true
516 * BooleanUtils.toBoolean("f") = false
517 * </pre>
518 *
519 * @param str The String to check
520 * @return The boolean value of the string, {@code false} if no match or the String is null
521 */
522 public static boolean toBoolean(final String str) {
523 return toBooleanObject(str) == Boolean.TRUE;
524 }
525
526 /**
527 * Converts a String to a Boolean throwing an exception if no match found.
528 *
529 * <pre>
530 * BooleanUtils.toBoolean("true", "true", "false") = true
531 * BooleanUtils.toBoolean("false", "true", "false") = false
532 * </pre>
533 *
534 * @param str The String to check
535 * @param trueString The String to match for {@code true} (case-sensitive), may be {@code null}
536 * @param falseString The String to match for {@code false} (case-sensitive), may be {@code null}
537 * @return The boolean value of the string
538 * @throws IllegalArgumentException Thrown if the String doesn't match.
539 */
540 public static boolean toBoolean(final String str, final String trueString, final String falseString) {
541 if (str == trueString) {
542 return true;
543 }
544 if (str == falseString) {
545 return false;
546 }
547 if (str != null) {
548 if (str.equals(trueString)) {
549 return true;
550 }
551 if (str.equals(falseString)) {
552 return false;
553 }
554 }
555 throw new IllegalArgumentException("The String did not match either specified value");
556 }
557
558 /**
559 * Converts a Boolean to a boolean handling {@code null}.
560 *
561 * <pre>
562 * BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, false) = true
563 * BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, true) = true
564 * BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, true) = false
565 * BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, false) = false
566 * BooleanUtils.toBooleanDefaultIfNull(null, true) = true
567 * BooleanUtils.toBooleanDefaultIfNull(null, false) = false
568 * </pre>
569 *
570 * @param bool The boolean object to convert to primitive
571 * @param valueIfNull The boolean value to return if the parameter {@code bool} is {@code null}
572 * @return {@code true} or {@code false}
573 */
574 public static boolean toBooleanDefaultIfNull(final Boolean bool, final boolean valueIfNull) {
575 if (bool == null) {
576 return valueIfNull;
577 }
578 return bool.booleanValue();
579 }
580
581 /**
582 * Converts an int to a Boolean using the convention that {@code zero}
583 * is {@code false}, everything else is {@code true}.
584 *
585 * <pre>
586 * BooleanUtils.toBoolean(0) = Boolean.FALSE
587 * BooleanUtils.toBoolean(1) = Boolean.TRUE
588 * BooleanUtils.toBoolean(2) = Boolean.TRUE
589 * </pre>
590 *
591 * @param value The int to convert
592 * @return Boolean.TRUE if non-zero, Boolean.FALSE if zero,
593 * {@code null} if {@code null}
594 */
595 public static Boolean toBooleanObject(final int value) {
596 return value == 0 ? Boolean.FALSE : Boolean.TRUE;
597 }
598
599 /**
600 * Converts an int to a Boolean specifying the conversion values.
601 *
602 * <p>
603 * NOTE: This method may return {@code null} and may throw a {@link NullPointerException}
604 * if unboxed to a {@code boolean}.
605 * </p>
606 *
607 * <p>
608 * The checks are done first for the {@code trueValue}, then for the {@code falseValue} and
609 * finally for the {@code nullValue}.
610 * </p>
611 *
612 * <pre>
613 * BooleanUtils.toBooleanObject(0, 0, 2, 3) = Boolean.TRUE
614 * BooleanUtils.toBooleanObject(0, 0, 0, 3) = Boolean.TRUE
615 * BooleanUtils.toBooleanObject(0, 0, 0, 0) = Boolean.TRUE
616 * BooleanUtils.toBooleanObject(2, 1, 2, 3) = Boolean.FALSE
617 * BooleanUtils.toBooleanObject(2, 1, 2, 2) = Boolean.FALSE
618 * BooleanUtils.toBooleanObject(3, 1, 2, 3) = null
619 * </pre>
620 *
621 * @param value The Integer to convert
622 * @param trueValue The value to match for {@code true}
623 * @param falseValue The value to match for {@code false}
624 * @param nullValue The value to match for {@code null}
625 * @return Boolean.TRUE, Boolean.FALSE, or {@code null}
626 * @throws IllegalArgumentException Thrown if no match.
627 */
628 public static Boolean toBooleanObject(final int value, final int trueValue, final int falseValue, final int nullValue) {
629 if (value == trueValue) {
630 return Boolean.TRUE;
631 }
632 if (value == falseValue) {
633 return Boolean.FALSE;
634 }
635 if (value == nullValue) {
636 return null;
637 }
638 throw new IllegalArgumentException("The Integer did not match any specified value");
639 }
640
641 /**
642 * Converts an Integer to a Boolean using the convention that {@code zero}
643 * is {@code false}, every other numeric value is {@code true}.
644 *
645 * <p>
646 * {@code null} will be converted to {@code null}.
647 * </p>
648 *
649 * <p>
650 * NOTE: This method may return {@code null} and may throw a {@link NullPointerException}
651 * if unboxed to a {@code boolean}.
652 * </p>
653 *
654 * <pre>
655 * BooleanUtils.toBooleanObject(Integer.valueOf(0)) = Boolean.FALSE
656 * BooleanUtils.toBooleanObject(Integer.valueOf(1)) = Boolean.TRUE
657 * BooleanUtils.toBooleanObject(Integer.valueOf(null)) = null
658 * </pre>
659 *
660 * @param value The Integer to convert
661 * @return Boolean.TRUE if non-zero, Boolean.FALSE if zero,
662 * {@code null} if {@code null} input
663 */
664 public static Boolean toBooleanObject(final Integer value) {
665 if (value == null) {
666 return null;
667 }
668 return value.intValue() == 0 ? Boolean.FALSE : Boolean.TRUE;
669 }
670
671 /**
672 * Converts an Integer to a Boolean specifying the conversion values.
673 *
674 * <p>
675 * NOTE: This method may return {@code null} and may throw a {@link NullPointerException}
676 * if unboxed to a {@code boolean}.
677 * </p>
678 *
679 * <p>
680 * The checks are done first for the {@code trueValue}, then for the {@code falseValue} and
681 * finally for the {@code nullValue}.
682 * </p>
683 **
684 * <pre>
685 * BooleanUtils.toBooleanObject(Integer.valueOf(0), Integer.valueOf(0), Integer.valueOf(2), Integer.valueOf(3)) = Boolean.TRUE
686 * BooleanUtils.toBooleanObject(Integer.valueOf(0), Integer.valueOf(0), Integer.valueOf(0), Integer.valueOf(3)) = Boolean.TRUE
687 * BooleanUtils.toBooleanObject(Integer.valueOf(0), Integer.valueOf(0), Integer.valueOf(0), Integer.valueOf(0)) = Boolean.TRUE
688 * BooleanUtils.toBooleanObject(Integer.valueOf(2), Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)) = Boolean.FALSE
689 * BooleanUtils.toBooleanObject(Integer.valueOf(2), Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(2)) = Boolean.FALSE
690 * BooleanUtils.toBooleanObject(Integer.valueOf(3), Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)) = null
691 * </pre>
692 *
693 * @param value The Integer to convert
694 * @param trueValue The value to match for {@code true}, may be {@code null}
695 * @param falseValue The value to match for {@code false}, may be {@code null}
696 * @param nullValue The value to match for {@code null}, may be {@code null}
697 * @return Boolean.TRUE, Boolean.FALSE, or {@code null}
698 * @throws IllegalArgumentException Thrown if no match.
699 */
700 public static Boolean toBooleanObject(final Integer value, final Integer trueValue, final Integer falseValue, final Integer nullValue) {
701 if (value == null) {
702 if (trueValue == null) {
703 return Boolean.TRUE;
704 }
705 if (falseValue == null) {
706 return Boolean.FALSE;
707 }
708 if (nullValue == null) {
709 return null;
710 }
711 } else if (value.equals(trueValue)) {
712 return Boolean.TRUE;
713 } else if (value.equals(falseValue)) {
714 return Boolean.FALSE;
715 } else if (value.equals(nullValue)) {
716 return null;
717 }
718 throw new IllegalArgumentException("The Integer did not match any specified value");
719 }
720
721 /**
722 * Converts a String to a Boolean.
723 *
724 * <p>
725 * {@code 'true'}, {@code 'on'}, {@code 'y'}, {@code 't'}, {@code 'yes'}
726 * or {@code '1'} (case insensitive) will return {@code true}.
727 * {@code 'false'}, {@code 'off'}, {@code 'n'}, {@code 'f'}, {@code 'no'}
728 * or {@code '0'} (case insensitive) will return {@code false}.
729 * Otherwise, {@code null} is returned.
730 * </p>
731 *
732 * <p>
733 * NOTE: This method may return {@code null} and may throw a {@link NullPointerException}
734 * if unboxed to a {@code boolean}.
735 * </p>
736 *
737 * <pre>
738 * // Case is not significant
739 * BooleanUtils.toBooleanObject(null) = null
740 * BooleanUtils.toBooleanObject("true") = Boolean.TRUE
741 * BooleanUtils.toBooleanObject("T") = Boolean.TRUE // i.e. T[RUE]
742 * BooleanUtils.toBooleanObject("false") = Boolean.FALSE
743 * BooleanUtils.toBooleanObject("f") = Boolean.FALSE // i.e. f[alse]
744 * BooleanUtils.toBooleanObject("No") = Boolean.FALSE
745 * BooleanUtils.toBooleanObject("n") = Boolean.FALSE // i.e. n[o]
746 * BooleanUtils.toBooleanObject("on") = Boolean.TRUE
747 * BooleanUtils.toBooleanObject("ON") = Boolean.TRUE
748 * BooleanUtils.toBooleanObject("off") = Boolean.FALSE
749 * BooleanUtils.toBooleanObject("oFf") = Boolean.FALSE
750 * BooleanUtils.toBooleanObject("yes") = Boolean.TRUE
751 * BooleanUtils.toBooleanObject("Y") = Boolean.TRUE // i.e. Y[ES]
752 * BooleanUtils.toBooleanObject("1") = Boolean.TRUE
753 * BooleanUtils.toBooleanObject("0") = Boolean.FALSE
754 * BooleanUtils.toBooleanObject("blue") = null
755 * BooleanUtils.toBooleanObject("true ") = null // trailing space (too long)
756 * BooleanUtils.toBooleanObject("ono") = null // does not match on or no
757 * </pre>
758 *
759 * @param str The String to check; upper and lower case are treated as the same
760 * @return The Boolean value of the string, {@code null} if no match or {@code null} input
761 */
762 public static Boolean toBooleanObject(final String str) {
763 // Previously used equalsIgnoreCase, which was fast for interned 'true'.
764 // Non interned 'true' matched 15 times slower.
765 //
766 // Optimization provides same performance as before for interned 'true'.
767 // Similar performance for null, 'false', and other strings not length 2/3/4.
768 // 'true'/'TRUE' match 4 times slower, 'tRUE'/'True' 7 times slower.
769 if (str == TRUE) {
770 return Boolean.TRUE;
771 }
772 if (str == null) {
773 return null;
774 }
775 switch (str.length()) {
776 case 1: {
777 final char ch0 = str.charAt(0);
778 if (ch0 == 'y' || ch0 == 'Y' ||
779 ch0 == 't' || ch0 == 'T' ||
780 ch0 == '1') {
781 return Boolean.TRUE;
782 }
783 if (ch0 == 'n' || ch0 == 'N' ||
784 ch0 == 'f' || ch0 == 'F' ||
785 ch0 == '0') {
786 return Boolean.FALSE;
787 }
788 break;
789 }
790 case 2: {
791 final char ch0 = str.charAt(0);
792 final char ch1 = str.charAt(1);
793 if ((ch0 == 'o' || ch0 == 'O') &&
794 (ch1 == 'n' || ch1 == 'N')) {
795 return Boolean.TRUE;
796 }
797 if ((ch0 == 'n' || ch0 == 'N') &&
798 (ch1 == 'o' || ch1 == 'O')) {
799 return Boolean.FALSE;
800 }
801 break;
802 }
803 case 3: {
804 final char ch0 = str.charAt(0);
805 final char ch1 = str.charAt(1);
806 final char ch2 = str.charAt(2);
807 if ((ch0 == 'y' || ch0 == 'Y') &&
808 (ch1 == 'e' || ch1 == 'E') &&
809 (ch2 == 's' || ch2 == 'S')) {
810 return Boolean.TRUE;
811 }
812 if ((ch0 == 'o' || ch0 == 'O') &&
813 (ch1 == 'f' || ch1 == 'F') &&
814 (ch2 == 'f' || ch2 == 'F')) {
815 return Boolean.FALSE;
816 }
817 break;
818 }
819 case 4: {
820 final char ch0 = str.charAt(0);
821 final char ch1 = str.charAt(1);
822 final char ch2 = str.charAt(2);
823 final char ch3 = str.charAt(3);
824 if ((ch0 == 't' || ch0 == 'T') &&
825 (ch1 == 'r' || ch1 == 'R') &&
826 (ch2 == 'u' || ch2 == 'U') &&
827 (ch3 == 'e' || ch3 == 'E')) {
828 return Boolean.TRUE;
829 }
830 break;
831 }
832 case 5: {
833 final char ch0 = str.charAt(0);
834 final char ch1 = str.charAt(1);
835 final char ch2 = str.charAt(2);
836 final char ch3 = str.charAt(3);
837 final char ch4 = str.charAt(4);
838 if ((ch0 == 'f' || ch0 == 'F') &&
839 (ch1 == 'a' || ch1 == 'A') &&
840 (ch2 == 'l' || ch2 == 'L') &&
841 (ch3 == 's' || ch3 == 'S') &&
842 (ch4 == 'e' || ch4 == 'E')) {
843 return Boolean.FALSE;
844 }
845 break;
846 }
847 default:
848 break;
849 }
850
851 return null;
852 }
853
854 /**
855 * Converts a String to a Boolean throwing an exception if no match.
856 *
857 * <p>
858 * NOTE: This method may return {@code null} and may throw a {@link NullPointerException}
859 * if unboxed to a {@code boolean}.
860 * </p>
861 *
862 * <pre>
863 * BooleanUtils.toBooleanObject("true", "true", "false", "null") = Boolean.TRUE
864 * BooleanUtils.toBooleanObject(null, null, "false", "null") = Boolean.TRUE
865 * BooleanUtils.toBooleanObject(null, null, null, "null") = Boolean.TRUE
866 * BooleanUtils.toBooleanObject(null, null, null, null) = Boolean.TRUE
867 * BooleanUtils.toBooleanObject("false", "true", "false", "null") = Boolean.FALSE
868 * BooleanUtils.toBooleanObject("false", "true", "false", "false") = Boolean.FALSE
869 * BooleanUtils.toBooleanObject(null, "true", null, "false") = Boolean.FALSE
870 * BooleanUtils.toBooleanObject(null, "true", null, null) = Boolean.FALSE
871 * BooleanUtils.toBooleanObject("null", "true", "false", "null") = null
872 * </pre>
873 *
874 * @param str The String to check
875 * @param trueString The String to match for {@code true} (case-sensitive), may be {@code null}
876 * @param falseString The String to match for {@code false} (case-sensitive), may be {@code null}
877 * @param nullString The String to match for {@code null} (case-sensitive), may be {@code null}
878 * @return The Boolean value of the string, {@code null} if either the String matches {@code nullString}
879 * or if {@code null} input and {@code nullString} is {@code null}
880 * @throws IllegalArgumentException Thrown if the String doesn't match.
881 */
882 public static Boolean toBooleanObject(final String str, final String trueString, final String falseString, final String nullString) {
883 if (str == null) {
884 if (trueString == null) {
885 return Boolean.TRUE;
886 }
887 if (falseString == null) {
888 return Boolean.FALSE;
889 }
890 if (nullString == null) {
891 return null;
892 }
893 } else if (str.equals(trueString)) {
894 return Boolean.TRUE;
895 } else if (str.equals(falseString)) {
896 return Boolean.FALSE;
897 } else if (str.equals(nullString)) {
898 return null;
899 }
900 // no match
901 throw new IllegalArgumentException("The String did not match any specified value");
902 }
903
904 /**
905 * Converts a boolean to an int using the convention that
906 * {@code true} is {@code 1} and {@code false} is {@code 0}.
907 *
908 * <pre>
909 * BooleanUtils.toInteger(true) = 1
910 * BooleanUtils.toInteger(false) = 0
911 * </pre>
912 *
913 * @param bool The boolean to convert
914 * @return one if {@code true}, zero if {@code false}
915 */
916 public static int toInteger(final boolean bool) {
917 return bool ? 1 : 0;
918 }
919
920 /**
921 * Converts a boolean to an int specifying the conversion values.
922 *
923 * <pre>
924 * BooleanUtils.toInteger(true, 1, 0) = 1
925 * BooleanUtils.toInteger(false, 1, 0) = 0
926 * </pre>
927 *
928 * @param bool The to convert
929 * @param trueValue The value to return if {@code true}
930 * @param falseValue The value to return if {@code false}
931 * @return The appropriate value
932 */
933 public static int toInteger(final boolean bool, final int trueValue, final int falseValue) {
934 return bool ? trueValue : falseValue;
935 }
936
937 /**
938 * Converts a Boolean to an int specifying the conversion values.
939 *
940 * <pre>
941 * BooleanUtils.toInteger(Boolean.TRUE, 1, 0, 2) = 1
942 * BooleanUtils.toInteger(Boolean.FALSE, 1, 0, 2) = 0
943 * BooleanUtils.toInteger(null, 1, 0, 2) = 2
944 * </pre>
945 *
946 * @param bool The Boolean to convert
947 * @param trueValue The value to return if {@code true}
948 * @param falseValue The value to return if {@code false}
949 * @param nullValue The value to return if {@code null}
950 * @return The appropriate value
951 */
952 public static int toInteger(final Boolean bool, final int trueValue, final int falseValue, final int nullValue) {
953 if (bool == null) {
954 return nullValue;
955 }
956 return bool.booleanValue() ? trueValue : falseValue;
957 }
958
959 /**
960 * Converts a boolean to an Integer using the convention that
961 * {@code true} is {@code 1} and {@code false} is {@code 0}.
962 *
963 * <pre>
964 * BooleanUtils.toIntegerObject(true) = Integer.valueOf(1)
965 * BooleanUtils.toIntegerObject(false) = Integer.valueOf(0)
966 * </pre>
967 *
968 * @param bool The boolean to convert
969 * @return one if {@code true}, zero if {@code false}
970 */
971 public static Integer toIntegerObject(final boolean bool) {
972 return bool ? NumberUtils.INTEGER_ONE : NumberUtils.INTEGER_ZERO;
973 }
974
975 /**
976 * Converts a boolean to an Integer specifying the conversion values.
977 *
978 * <pre>
979 * BooleanUtils.toIntegerObject(true, Integer.valueOf(1), Integer.valueOf(0)) = Integer.valueOf(1)
980 * BooleanUtils.toIntegerObject(false, Integer.valueOf(1), Integer.valueOf(0)) = Integer.valueOf(0)
981 * </pre>
982 *
983 * @param bool The to convert
984 * @param trueValue The value to return if {@code true}, may be {@code null}
985 * @param falseValue The value to return if {@code false}, may be {@code null}
986 * @return The appropriate value
987 */
988 public static Integer toIntegerObject(final boolean bool, final Integer trueValue, final Integer falseValue) {
989 return bool ? trueValue : falseValue;
990 }
991
992 /**
993 * Converts a Boolean to an Integer using the convention that
994 * {@code zero} is {@code false}.
995 *
996 * <p>
997 * {@code null} will be converted to {@code null}.
998 * </p>
999 *
1000 * <pre>
1001 * BooleanUtils.toIntegerObject(Boolean.TRUE) = Integer.valueOf(1)
1002 * BooleanUtils.toIntegerObject(Boolean.FALSE) = Integer.valueOf(0)
1003 * </pre>
1004 *
1005 * @param bool The Boolean to convert
1006 * @return one if Boolean.TRUE, zero if Boolean.FALSE, {@code null} if {@code null}
1007 */
1008 public static Integer toIntegerObject(final Boolean bool) {
1009 if (bool == null) {
1010 return null;
1011 }
1012 return bool.booleanValue() ? NumberUtils.INTEGER_ONE : NumberUtils.INTEGER_ZERO;
1013 }
1014
1015 /**
1016 * Converts a Boolean to an Integer specifying the conversion values.
1017 *
1018 * <pre>
1019 * BooleanUtils.toIntegerObject(Boolean.TRUE, Integer.valueOf(1), Integer.valueOf(0), Integer.valueOf(2)) = Integer.valueOf(1)
1020 * BooleanUtils.toIntegerObject(Boolean.FALSE, Integer.valueOf(1), Integer.valueOf(0), Integer.valueOf(2)) = Integer.valueOf(0)
1021 * BooleanUtils.toIntegerObject(null, Integer.valueOf(1), Integer.valueOf(0), Integer.valueOf(2)) = Integer.valueOf(2)
1022 * </pre>
1023 *
1024 * @param bool The Boolean to convert
1025 * @param trueValue The value to return if {@code true}, may be {@code null}
1026 * @param falseValue The value to return if {@code false}, may be {@code null}
1027 * @param nullValue The value to return if {@code null}, may be {@code null}
1028 * @return The appropriate value
1029 */
1030 public static Integer toIntegerObject(final Boolean bool, final Integer trueValue, final Integer falseValue, final Integer nullValue) {
1031 if (bool == null) {
1032 return nullValue;
1033 }
1034 return bool.booleanValue() ? trueValue : falseValue;
1035 }
1036
1037 /**
1038 * Converts a boolean to a String returning one of the input Strings.
1039 *
1040 * <pre>
1041 * BooleanUtils.toString(true, "true", "false") = "true"
1042 * BooleanUtils.toString(false, "true", "false") = "false"
1043 * </pre>
1044 *
1045 * @param bool The Boolean to check
1046 * @param trueString The String to return if {@code true}, may be {@code null}
1047 * @param falseString The String to return if {@code false}, may be {@code null}
1048 * @return one of the two input Strings
1049 */
1050 public static String toString(final boolean bool, final String trueString, final String falseString) {
1051 return bool ? trueString : falseString;
1052 }
1053
1054 /**
1055 * Converts a Boolean to a String returning one of the input Strings.
1056 *
1057 * <pre>
1058 * BooleanUtils.toString(Boolean.TRUE, "true", "false", null) = "true"
1059 * BooleanUtils.toString(Boolean.FALSE, "true", "false", null) = "false"
1060 * BooleanUtils.toString(null, "true", "false", null) = null;
1061 * </pre>
1062 *
1063 * @param bool The Boolean to check
1064 * @param trueString The String to return if {@code true}, may be {@code null}
1065 * @param falseString The String to return if {@code false}, may be {@code null}
1066 * @param nullString The String to return if {@code null}, may be {@code null}
1067 * @return one of the three input Strings
1068 */
1069 public static String toString(final Boolean bool, final String trueString, final String falseString, final String nullString) {
1070 if (bool == null) {
1071 return nullString;
1072 }
1073 return bool.booleanValue() ? trueString : falseString;
1074 }
1075
1076 /**
1077 * Converts a boolean to a String returning {@code 'on'}
1078 * or {@code 'off'}.
1079 *
1080 * <pre>
1081 * BooleanUtils.toStringOnOff(true) = "on"
1082 * BooleanUtils.toStringOnOff(false) = "off"
1083 * </pre>
1084 *
1085 * @param bool The Boolean to check
1086 * @return {@code 'on'}, {@code 'off'}, or {@code null}
1087 */
1088 public static String toStringOnOff(final boolean bool) {
1089 return toString(bool, ON, OFF);
1090 }
1091
1092 /**
1093 * Converts a Boolean to a String returning {@code 'on'},
1094 * {@code 'off'}, or {@code null}.
1095 *
1096 * <pre>
1097 * BooleanUtils.toStringOnOff(Boolean.TRUE) = "on"
1098 * BooleanUtils.toStringOnOff(Boolean.FALSE) = "off"
1099 * BooleanUtils.toStringOnOff(null) = null;
1100 * </pre>
1101 *
1102 * @param bool The Boolean to check
1103 * @return {@code 'on'}, {@code 'off'}, or {@code null}
1104 */
1105 public static String toStringOnOff(final Boolean bool) {
1106 return toString(bool, ON, OFF, null);
1107 }
1108
1109 /**
1110 * Converts a boolean to a String returning {@code 'true'}
1111 * or {@code 'false'}.
1112 *
1113 * <pre>
1114 * BooleanUtils.toStringTrueFalse(true) = "true"
1115 * BooleanUtils.toStringTrueFalse(false) = "false"
1116 * </pre>
1117 *
1118 * @param bool The Boolean to check
1119 * @return {@code 'true'}, {@code 'false'}, or {@code null}
1120 */
1121 public static String toStringTrueFalse(final boolean bool) {
1122 return toString(bool, TRUE, FALSE);
1123 }
1124
1125 /**
1126 * Converts a Boolean to a String returning {@code 'true'},
1127 * {@code 'false'}, or {@code null}.
1128 *
1129 * <pre>
1130 * BooleanUtils.toStringTrueFalse(Boolean.TRUE) = "true"
1131 * BooleanUtils.toStringTrueFalse(Boolean.FALSE) = "false"
1132 * BooleanUtils.toStringTrueFalse(null) = null;
1133 * </pre>
1134 *
1135 * @param bool The Boolean to check
1136 * @return {@code 'true'}, {@code 'false'}, or {@code null}
1137 */
1138 public static String toStringTrueFalse(final Boolean bool) {
1139 return toString(bool, TRUE, FALSE, null);
1140 }
1141
1142 /**
1143 * Converts a boolean to a String returning {@code 'yes'}
1144 * or {@code 'no'}.
1145 *
1146 * <pre>
1147 * BooleanUtils.toStringYesNo(true) = "yes"
1148 * BooleanUtils.toStringYesNo(false) = "no"
1149 * </pre>
1150 *
1151 * @param bool The Boolean to check
1152 * @return {@code 'yes'}, {@code 'no'}, or {@code null}
1153 */
1154 public static String toStringYesNo(final boolean bool) {
1155 return toString(bool, YES, NO);
1156 }
1157
1158 /**
1159 * Converts a Boolean to a String returning {@code 'yes'},
1160 * {@code 'no'}, or {@code null}.
1161 *
1162 * <pre>
1163 * BooleanUtils.toStringYesNo(Boolean.TRUE) = "yes"
1164 * BooleanUtils.toStringYesNo(Boolean.FALSE) = "no"
1165 * BooleanUtils.toStringYesNo(null) = null;
1166 * </pre>
1167 *
1168 * @param bool The Boolean to check
1169 * @return {@code 'yes'}, {@code 'no'}, or {@code null}
1170 */
1171 public static String toStringYesNo(final Boolean bool) {
1172 return toString(bool, YES, NO, null);
1173 }
1174
1175 /**
1176 * Returns an unmodifiable list of Booleans {@code [false, true]}.
1177 *
1178 * @return An unmodifiable list of Booleans {@code [false, true]}.
1179 * @since 3.13.0
1180 */
1181 public static List<Boolean> values() {
1182 return BOOLEAN_LIST;
1183 }
1184
1185 /**
1186 * Performs an xor on a set of booleans.
1187 * <p>
1188 * This behaves like an XOR gate;
1189 * it returns true if the number of true values is odd,
1190 * and false if the number of true values is zero or even.
1191 * </p>
1192 *
1193 * <pre>
1194 * BooleanUtils.xor(true, true) = false
1195 * BooleanUtils.xor(false, false) = false
1196 * BooleanUtils.xor(true, false) = true
1197 * BooleanUtils.xor(true, false, false) = true
1198 * BooleanUtils.xor(true, true, true) = true
1199 * BooleanUtils.xor(true, true, true, true) = false
1200 * </pre>
1201 *
1202 * @param array An array of {@code boolean}s
1203 * @return true if the number of true values in the array is odd; otherwise returns false.
1204 * @throws NullPointerException Thrown if {@code array} is {@code null}.
1205 * @throws IllegalArgumentException Thrown if {@code array} is empty.
1206 */
1207 public static boolean xor(final boolean... array) {
1208 ObjectUtils.requireNonEmpty(array, "array");
1209 // false if the neutral element of the xor operator
1210 boolean result = false;
1211 for (final boolean element : array) {
1212 result ^= element;
1213 }
1214
1215 return result;
1216 }
1217
1218 /**
1219 * Performs an xor on an array of Booleans.
1220 * <pre>
1221 * BooleanUtils.xor(Boolean.TRUE, Boolean.TRUE) = Boolean.FALSE
1222 * BooleanUtils.xor(Boolean.FALSE, Boolean.FALSE) = Boolean.FALSE
1223 * BooleanUtils.xor(Boolean.TRUE, Boolean.FALSE) = Boolean.TRUE
1224 * BooleanUtils.xor(Boolean.TRUE, Boolean.FALSE, Boolean.FALSE) = Boolean.TRUE
1225 * BooleanUtils.xor(Boolean.FALSE, null) = Boolean.FALSE
1226 * BooleanUtils.xor(Boolean.TRUE, null) = Boolean.TRUE
1227 * </pre>
1228 * <p>
1229 * Null array elements map to false, like {@code Boolean.parseBoolean(null)} and its callers return false.
1230 * </p>
1231 *
1232 * @param array An array of {@link Boolean}s
1233 * @return The result of the xor operations
1234 * @throws NullPointerException Thrown if {@code array} is {@code null}.
1235 * @throws IllegalArgumentException Thrown if {@code array} is empty.
1236 */
1237 public static Boolean xor(final Boolean... array) {
1238 ObjectUtils.requireNonEmpty(array, "array");
1239 return xor(ArrayUtils.toPrimitive(array)) ? Boolean.TRUE : Boolean.FALSE;
1240 }
1241
1242 /**
1243 * {@link BooleanUtils} instances should NOT be constructed in standard programming.
1244 * Instead, the class should be used as {@code BooleanUtils.negate(true);}.
1245 *
1246 * <p>
1247 * This constructor is public to permit tools that require a JavaBean instance
1248 * to operate.
1249 * </p>
1250 *
1251 * @deprecated TODO Make private in 4.0.
1252 */
1253 @Deprecated
1254 public BooleanUtils() {
1255 // empty
1256 }
1257
1258 }