Java Boolean From toBoolean(Integer value, Integer trueValue, Integer falseValue)

Here you can find the source of toBoolean(Integer value, Integer trueValue, Integer falseValue)

  1. HOME
  2. Java
  3. B
  4. Boolean From
  5. toBoolean(Integer value, Integer trueValue, Integer falseValue)

Description

Converts an Integer to a boolean specifying the conversion values.

 BooleanUtils.toBoolean(new Integer(0), new Integer(1), new Integer(0)) = false BooleanUtils.toBoolean(new Integer(1), new Integer(1), new Integer(0)) = true BooleanUtils.toBoolean(new Integer(2), new Integer(1), new Integer(2)) = false BooleanUtils.toBoolean(new Integer(2), new Integer(2), new Integer(0)) = true BooleanUtils.toBoolean(null, null, new Integer(0))                     = true

License

Apache License

Parameter

Parameter Description
value the Integer to convert
trueValue the value to match for <code>true</code>, may be <code>null</code>
falseValue the value to match for <code>false</code>, may be <code>null</code>

Exception

Parameter Description
IllegalArgumentException if no match

Return

true or false

Declaration 

public static boolean toBoolean(Integer value, Integer trueValue, Integer falseValue)

Method Source Code

//package com.java2s;
/*/*from w  w  w .  jav a  2  s . c  o  m*/
   $Id: BooleanUtils.java,v 1.3 2004-01-28 15:10:40 mvdb Exp $
       
   Copyright 2002-2004 The Xulux Project
    
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
    
   http://www.apache.org/licenses/LICENSE-2.0
    
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

public class Main {
    /**
     * <p>Converts a Boolean to a boolean handling <code>null</code>
     * by returning <code>false</code>.</p>
     *
     * <pre>
     *   BooleanUtils.toBoolean(Boolean.TRUE)  = true
     *   BooleanUtils.toBoolean(Boolean.FALSE) = false
     *   BooleanUtils.toBoolean(null)          = false
     * </pre>
     *
     * @param bool  the boolean to convert
     * @return <code>true</code> or <code>false</code>,
     *  <code>null</code> returns <code>false</code>
     */
    public static boolean toBoolean(Boolean bool) {
        if (bool == null) {
            return false;
        }
        return (bool.booleanValue() ? true : false);
    }

    /**
     * <p>Converts an int to a boolean using the convention that <code>zero</code>
     * is <code>false</code>.</p>
     *
     * <pre>
     *   BooleanUtils.toBoolean(0) = false
     *   BooleanUtils.toBoolean(1) = true
     *   BooleanUtils.toBoolean(2) = true
     * </pre>
     *
     * @param value  the int to convert
     * @return <code>true</code> if non-zero, <code>false</code>
     *  if zero
     */
    public static boolean toBoolean(int value) {
        return (value == 0 ? false : true);
    }

    /**
     * <p>Converts an int to a boolean specifying the conversion values.</p>
     *
     * <pre>
     *   BooleanUtils.toBoolean(0, 1, 0) = false
     *   BooleanUtils.toBoolean(1, 1, 0) = true
     *   BooleanUtils.toBoolean(2, 1, 2) = false
     *   BooleanUtils.toBoolean(2, 2, 0) = true
     * </pre>
     *
     * @param value  the Integer to convert
     * @param trueValue  the value to match for <code>true</code>
     * @param falseValue  the value to match for <code>false</code>
     * @return <code>true</code> or <code>false</code>
     * @throws IllegalArgumentException if no match
     */
    public static boolean toBoolean(int value, int trueValue, int falseValue) {
        if (value == trueValue) {
            return true;
        } else if (value == falseValue) {
            return false;
        }
        // no match
        throw new IllegalArgumentException("The Integer did not match either specified value");
    }

    /**
     * <p>Converts an Integer to a boolean specifying the conversion values.</p>
     *
     * <pre>
     *   BooleanUtils.toBoolean(new Integer(0), new Integer(1), new Integer(0)) = false
     *   BooleanUtils.toBoolean(new Integer(1), new Integer(1), new Integer(0)) = true
     *   BooleanUtils.toBoolean(new Integer(2), new Integer(1), new Integer(2)) = false
     *   BooleanUtils.toBoolean(new Integer(2), new Integer(2), new Integer(0)) = true
     *   BooleanUtils.toBoolean(null, null, new Integer(0))                     = true
     * </pre>
     *
     * @param value  the Integer to convert
     * @param trueValue  the value to match for <code>true</code>,
     *  may be <code>null</code>
     * @param falseValue  the value to match for <code>false</code>,
     *  may be <code>null</code>
     * @return <code>true</code> or <code>false</code>
     * @throws IllegalArgumentException if no match
     */
    public static boolean toBoolean(Integer value, Integer trueValue, Integer falseValue) {
        if (value == null) {
            if (trueValue == null) {
                return true;
            } else if (falseValue == null) {
                return false;
            }
        } else if (value.equals(trueValue)) {
            return true;
        } else if (value.equals(falseValue)) {
            return false;
        }
        // no match
        throw new IllegalArgumentException("The Integer did not match either specified value");
    }

    /**
     * <p>Converts a String to a boolean (optimised for performance).</p>
     *
     * <p><code>'true'</code>, <code>'on'</code> or <code>'yes'</code>
     * (case insensitive) will return <code>true</code>. Otherwise,
     * <code>false</code> is returned.</p>
     *
     * <p>This method performs 4 times faster (JDK1.4) than
     * <code>Boolean.valueOf(String)</code>. However, this method accepts
     * 'on' and 'yes' as true values.
     *
     * <pre>
     *   BooleanUtils.toBoolean(null)    = false
     *   BooleanUtils.toBoolean("true")  = true
     *   BooleanUtils.toBoolean("TRUE")  = true
     *   BooleanUtils.toBoolean("tRUe")  = true
     *   BooleanUtils.toBoolean("on")    = true
     *   BooleanUtils.toBoolean("yes")   = true
     *   BooleanUtils.toBoolean("false") = false
     *   BooleanUtils.toBoolean("x gti") = false
     * </pre>
     *
     * @param str  the String to check
     * @return the boolean value of the string, <code>false</code> if no match
     */
    public static boolean toBoolean(String str) {
        // Previously used equalsIgnoreCase, which was fast for interned 'true'.
        // Non interned 'true' matched 15 times slower.
        //
        // Optimisation provides same performance as before for interned 'true'.
        // Similar performance for null, 'false', and other strings not length 2/3/4.
        // 'true'/'TRUE' match 4 times slower, 'tRUE'/'True' 7 times slower.
        if (str == "true") {
            return true;
        }
        if (str == null) {
            return false;
        }
        switch (str.length()) {
        case 2: {
            char ch0 = str.charAt(0);
            char ch1 = str.charAt(1);
            return (ch0 == 'o' || ch0 == 'O') && (ch1 == 'n' || ch1 == 'N');
        }
        case 3: {
            char ch = str.charAt(0);
            if (ch == 'y') {
                return (str.charAt(1) == 'e' || str.charAt(1) == 'E')
                        && (str.charAt(2) == 's' || str.charAt(2) == 'S');
            }
            if (ch == 'Y') {
                return (str.charAt(1) == 'E' || str.charAt(1) == 'e')
                        && (str.charAt(2) == 'S' || str.charAt(2) == 's');
            }
        }
        case 4: {
            char ch = str.charAt(0);
            if (ch == 't') {
                return (str.charAt(1) == 'r' || str.charAt(1) == 'R')
                        && (str.charAt(2) == 'u' || str.charAt(2) == 'U')
                        && (str.charAt(3) == 'e' || str.charAt(3) == 'E');
            }
            if (ch == 'T') {
                return (str.charAt(1) == 'R' || str.charAt(1) == 'r')
                        && (str.charAt(2) == 'U' || str.charAt(2) == 'u')
                        && (str.charAt(3) == 'E' || str.charAt(3) == 'e');
            }
        }
        }
        return false;
    }

    /**
     * Since xulux works with objects and we don't want to figure
     * out the type beforehand, we have a stub that is calling
     * the string and boolean toBoolean methods.
     *
     * @param object - if it is null it will return false by default.
     * @return the restult of the conversion.
     * @throws IllegalArgumentException - when the type has no booleanconverter.
     */
    public static boolean toBoolean(Object object) {
        if (object == null) {
            return false;
        }
        if (object instanceof String) {
            return toBoolean((String) object);
        } else if (object instanceof Boolean) {
            return toBoolean((Boolean) object);
        } else {
            throw new IllegalArgumentException("Cannot convert to boolean");
        }
    }

    /**
     * <p>Converts a String to a Boolean throwing an exception if no match found.</p>
     *
     * <p>null is returned if there is no match.</p>
     *
     * <pre>
     *   BooleanUtils.toBoolean("true", "true", "false")  = true
     *   BooleanUtils.toBoolean("false", "true", "false") = false
     * </pre>
     *
     * @param str  the String to check
     * @param trueString  the String to match for <code>true</code>
     *  (case sensitive), may be <code>null</code>
     * @param falseString  the String to match for <code>false</code>
     *  (case sensitive), may be <code>null</code>
     * @return the boolean value of the string
     * @throws IllegalArgumentException if the String doesn't match
     */
    public static boolean toBoolean(String str, String trueString, String falseString) {
        if (str == null) {
            if (trueString == null) {
                return true;
            } else if (falseString == null) {
                return false;
            }
        } else if (str.equals(trueString)) {
            return true;
        } else if (str.equals(falseString)) {
            return false;
        }
        // no match
        throw new IllegalArgumentException("The String did not match either specified value");
    }
}

Related

  1. toBoolean(final String value)
  2. toBoolean(final String value)
  3. toBoolean(final String value, final boolean def)
  4. toBoolean(int i)
  5. toBoolean(int value)
  6. toBoolean(Number value)
  7. toBoolean(Object anObj)
  8. toBoolean(Object bool)
  9. toBoolean(Object o)