Clase Java.lang.Boolean en Java

Java proporciona una clase contenedora booleana en el paquete java.lang. La clase booleana envuelve un valor del tipo primitivo booleano en un objeto. Un objeto de tipo booleano contiene un solo campo, cuyo tipo es booleano.

Además, esta clase proporciona métodos útiles, como convertir un booleano en una string y una string en un booleano, mientras se trata de una variable booleana.

Crear un objeto booleano

La clase booleana proporciona dos constructores para crear un objeto booleano.

La siguiente declaración crea un objeto booleano que contiene el argumento de valor.
```
Boolean b = new Boolean(boolean value);
```
La siguiente declaración crea un objeto booleano que contiene el valor verdadero si el argumento de string no es nulo y es igual, ignorando mayúsculas y minúsculas, a la string «verdadero», de lo contrario, se crea un objeto booleano con valor falso.
```
Boolean b = new Boolean(String s);
```

Campos:

Booleano estático FALSO: El objeto booleano correspondiente al valor primitivo falso.
static Boolean TRUE: El objeto booleano correspondiente al valor primitivo true.
Clase estática: el objeto de clase que representa el tipo primitivo booleano.

Métodos:

static boolean parseBoolean(String s) : este método analiza el argumento de la string como un booleano. El booleano devuelto representa el valor verdadero si el argumento de string no es nulo y es igual, ignorando mayúsculas y minúsculas, a la string «verdadero», de lo contrario, devuelve falso.

Syntax : 
public static boolean parseBoolean(String s)
Parameters : 
s - the String containing the boolean representation to be parsed
Returns :
the boolean represented by the string argument

// Java program to demonstrate parseBoolean() method
public class Test
{
    public static void main(String[] args)
    {
        // parsing different Strings
        boolean b1 = Boolean.parseBoolean("True");
        boolean b2 = Boolean.parseBoolean("TruE");
        boolean b3 = Boolean.parseBoolean("False");
        boolean b4 = Boolean.parseBoolean("FALSE");
        boolean b5 = Boolean.parseBoolean("GeeksForGeeks");
          
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
          
    }
}

Producción:

true
true
false
false
false

boolean booleanValue() : este método devuelve el valor de este objeto booleano como un primitivo booleano.

Syntax : 
public boolean booleanValue()
Parameters : 
NA
Returns :
the primitive boolean value of this object.

// Java program to demonstrate booleanValue() method
public class Test
{
    public static void main(String[] args)
    {
        // creating different Boolean objects
        Boolean b1 = new Boolean("True");
        Boolean b2 = new Boolean("False");
        Boolean b3 = new Boolean("GeeksForGeeks");
          
        // getting primitive boolean value
        boolean b4 = b1.booleanValue();
        boolean b5 = b2.booleanValue();
        boolean b6 = b3.booleanValue();
          
        System.out.println(b4);
        System.out.println(b5);
        System.out.println(b6);
          
    }
}

Producción:

true
false
false

static Boolean valueOf(boolean b) : este método devuelve una instancia booleana que representa el valor booleano especificado. Si el valor booleano especificado es verdadero, devuelve Boolean.TRUE o si es falso, este método devuelve Boolean.FALSE. La otra variante de este método se discute a continuación.

Syntax : 
public static boolean valueOf(boolean b)
Parameters : 
b - a boolean value.
Returns :
a Boolean object representing b.

// Java program to demonstrate valueOf() method
public class Test
{
    public static void main(String[] args)
    {
        // creating boolean variable
        boolean b1 = true;
        boolean b2 = false;
          
        // getting Boolean objects from boolean variables
        Boolean b3 = Boolean.valueOf(b1);
        Boolean b4 = Boolean.valueOf(b2);
          
        System.out.println(b3);
        System.out.println(b4);
          
    }
}

Producción:

true
false

static Boolean valueOf(String s) : este método devuelve un booleano con un valor representado por la string especificada ‘s’. El booleano devuelto representa un valor verdadero si el argumento de string no es nulo y es igual, ignorando mayúsculas y minúsculas, a la string «verdadero».

Syntax : 
public static boolean valueOf(String s)
Parameters : 
s - a string
Returns :
a Boolean value represented by the string

// Java program to demonstrate valueOf() method
public class Test
{
    public static void main(String[] args)
    {
        // creating boolean variable using different Strings
        Boolean b1 = Boolean.valueOf("true");
        Boolean b2 = Boolean.valueOf("TRue");
        Boolean b3 = Boolean.valueOf("False");
        Boolean b4 = Boolean.valueOf("GeeksForGeeks");
        Boolean b5 = Boolean.valueOf(null);
          
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
          
    }
}

Producción:

true
true
false
false
false

static String toString(boolean b) : este método devuelve un objeto String que representa el valor booleano especificado. Si el booleano especificado es verdadero, se devolverá la string «verdadero», de lo contrario, se devolverá la string «falso». La otra variante de este método se analiza a continuación.

Syntax : 
public static String toString(boolean b)
Parameters : 
b - the boolean to be converted
Returns :
the string representation of the specified boolean

// Java program to demonstrate toString() method
public class Test
{
    public static void main(String[] args)
    {
        // creating boolean variable
        boolean b1 = true;
        boolean b2 = false;
          
        // getting String value of the primitives boolean
        String str1 = Boolean.toString(b1);
        String str2 = Boolean.toString(b2);
          
        System.out.println(str1);
        System.out.println(str2);
    }
}

Producción:

true
false

String toString() : este método devuelve un objeto String que representa el valor de este booleano. Si este objeto representa el valor verdadero, se devuelve una string igual a «verdadero». De lo contrario, se devuelve la string «falso».

Syntax : 
public String toString()
Parameters : 
NA
Returns :
a string representation of this object
Overrides :
toString in class Object

// Java program to demonstrate toString() method
public class Test
{
    public static void main(String[] args)
    {
        // creating different Boolean objects
        Boolean b1 = new Boolean("True");
        Boolean b2 = new Boolean("False");
        Boolean b3 = new Boolean("GeeksForGeeks");
        Boolean b4 = new Boolean(null);
      
          
        // getting String value of Boolean objects
        String str1 = b1.toString();
        String str2 = b2.toString();
        String str3 = b3.toString();
        String str4 = b4.toString();
          
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
    }
}

Producción:

true
false
false
false

int hashCode() : este método devuelve un código hash para este objeto booleano. Tenga en cuenta que el código hash para verdadero es 1231 y para falso es 1237. Para encontrar la razón para elegir estos números enteros como código hash, consulte aquí .

Syntax : 
public int hashCode()
Parameters : 
NA
Returns :
the integer 1231 if this object represents true;
returns the integer 1237 if this object represents false
Overrides :
hashCode in class Object

// Java program to demonstrate hashCode() method
public class Test
{
    public static void main(String[] args)
    {
        // creating different Boolean objects
        Boolean b1 = new Boolean("True");
        Boolean b2 = new Boolean("False");
        Boolean b3 = new Boolean("TRue");
        Boolean b4 = new Boolean(null);
      
        System.out.println(b1.hashCode());
        System.out.println(b2.hashCode());
        System.out.println(b3.hashCode());
        System.out.println(b4.hashCode());
    }
}

Producción:

boolean equals(Object obj) : este método devuelve verdadero si el argumento no es nulo y es un objeto booleano que representa el mismo valor booleano que este objeto.

Syntax : 
public boolean equals(Object obj)
Parameters : 
obj - the object to compare with.
Returns :
true if the Boolean objects represent the same value; 
false otherwise
Overrides :
equals in class Object

// Java program to demonstrate equals() method
public class Test
{
    public static void main(String[] args)
    {
        // creating different Boolean objects
        Boolean b1 = new Boolean("True");
        Boolean b2 = new Boolean("False");
        Boolean b3 = new Boolean("TrUe");
        Boolean b4 = new Boolean(null);
          
      
        // checking equality of Boolean objects
        System.out.println(b1.equals(b2));
        System.out.println(b2.equals(b4));
        System.out.println(b1.equals(b3));
        System.out.println(b1.equals(b4));
    }
}

Producción:

false
true
true
false

int compareTo(Boolean b) : este método “compara” esta instancia booleana con el argumento pasado ‘b’.

Syntax : 
public int compareTo(Boolean b)
Parameters : 
b - the Boolean instance to be compared
Returns :
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;
a negative value if this object represents false and the argument represents true.
Throws :
NullPointerException - if the argument is null

// Java program to demonstrate compareTo() method
public class Test
{
    public static void main(String[] args)
    {
        // creating different Boolean objects
        Boolean b1 = new Boolean("True");
        Boolean b2 = new Boolean("False");
        Boolean b3 = new Boolean("TRue");
        Boolean b4 = new Boolean(null);
      
        //comparing b1,b2,b3,b4
        System.out.println(b1.compareTo(b2));
        System.out.println(b1.compareTo(b3));
        System.out.println(b2.compareTo(b1));
        System.out.println(b1.compareTo(b4));
        System.out.println(b2.compareTo(b4));
          
        // The following statement throws NullPointerExcetion
        //  System.out.println(b1.compareTo(null));
    }
}

Producción:

int compare(boolean x, boolean y) : Este método se utiliza para “comparar” variables booleanas primitivas.

Syntax : 
public static int compare(boolean x, boolean y)
Parameters : 
x - the first boolean to compare
y - the second boolean to compare
Returns :
zero if x is same boolean value as y; 
a positive value x is true and y is false;
a negative value if x is false and y is true;
Throws :
NullPointerException - if the argument is null

// Java program to demonstrate compare() method
public class Test
{
    public static void main(String[] args)
    {
        // creating boolean variable
        boolean b1 = true;
        boolean b2 = false;
        boolean b3 = true;
        boolean b4 = false;
          
        //comparing b1,b2,b3,b4
        System.out.println(Boolean.compare(b1, b2));
        System.out.println(Boolean.compare(b1, b3));
        System.out.println(Boolean.compare(b2, b1));
        System.out.println(Boolean.compare(b2, b4));
          
        // The following statement throws NullPointerExcetion
        //  System.out.println(Boolean.compare(b1, null));
    }
}

Producción:

Este artículo es una contribución de Gaurav Miglani . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta