BooleanUtils Commons Lang

La classe org.apache.commons.lang3.BooleanUtils permet de faciliter la manipulation de la primitive boolean ou de la classe Boolean. Cet article présente certaines fonctions uniquement à l'aide de tests unitaires, dans la classe fr.ejn.tutorial.apache.commons.lang3.BooleanUtilsTest.

Votre avis

Nobody voted on this yet  You need to enable JavaScript to vote

Tweet

Conversion en boolean

Il est courant d'effectuer des conversions de chaînes de caractères en boolean dans les projets. Le plus courant est de transformer la chaîne true en boolean true, et de même false en false. Cependant, ces chaînes peuvent être Y / N par exemple. La classe BooleanUtils propose des fonctions toBoolean qui vont permettre de faire des conversions vers la primitives boolean.

Le test unitaire fr.ejn.tutorial.apache.commons.lang3.BooleanUtilsTest donne de nombreux exemples de ces conversions. Pour les chaînes de caractères, des valeurs courantes sont disponibles en standard. Les chaînes de caractères true, y, on ou yes sont convertibles en true, et sans tenir compte de la casse. De la même façon, les chaînes false, n, off ou no sont convertisen false. De la même façon, le nombre 1 produit un true et 0 en false.

  @Test
  public void testToBoolean() {
    Assert.assertTrue(BooleanUtils.toBoolean("true"));
    Assert.assertTrue(BooleanUtils.toBoolean("TRUE"));
    Assert.assertTrue(BooleanUtils.toBoolean("tRuE"));
    Assert.assertTrue(BooleanUtils.toBoolean("y"));
    Assert.assertTrue(BooleanUtils.toBoolean("Y"));
    Assert.assertTrue(BooleanUtils.toBoolean("t"));
    Assert.assertTrue(BooleanUtils.toBoolean("T"));
    Assert.assertTrue(BooleanUtils.toBoolean("on"));
    Assert.assertTrue(BooleanUtils.toBoolean("ON"));
    Assert.assertTrue(BooleanUtils.toBoolean("oN"));
    Assert.assertTrue(BooleanUtils.toBoolean("yes"));
    Assert.assertTrue(BooleanUtils.toBoolean("YES"));
    Assert.assertTrue(BooleanUtils.toBoolean("YeS"));
    Assert.assertTrue(BooleanUtils.toBoolean(1));
    Assert.assertTrue(BooleanUtils.toBoolean(3, 3, 4));
    Assert.assertTrue(BooleanUtils.toBoolean("oui", "oui", "non"));

    Assert.assertFalse(BooleanUtils.toBoolean("false"));
    Assert.assertFalse(BooleanUtils.toBoolean("FALSE"));
    Assert.assertFalse(BooleanUtils.toBoolean("fAlSe"));
    Assert.assertFalse(BooleanUtils.toBoolean("n"));
    Assert.assertFalse(BooleanUtils.toBoolean("N"));
    Assert.assertFalse(BooleanUtils.toBoolean("f"));
    Assert.assertFalse(BooleanUtils.toBoolean("F"));
    Assert.assertFalse(BooleanUtils.toBoolean("off"));
    Assert.assertFalse(BooleanUtils.toBoolean("OFF"));
    Assert.assertFalse(BooleanUtils.toBoolean("oFf"));
    Assert.assertFalse(BooleanUtils.toBoolean("no"));
    Assert.assertFalse(BooleanUtils.toBoolean("NO"));
    Assert.assertFalse(BooleanUtils.toBoolean("nO"));
    Assert.assertFalse(BooleanUtils.toBoolean(0));
    Assert.assertFalse(BooleanUtils.toBoolean(4, 3, 4));
    Assert.assertFalse(BooleanUtils.toBoolean("non", "oui", "non"));
  }

Dans cet exemple, il y a qutre instructions où sont fournies les valeurs pour produire la valeur true et false. Ainsi, il est possible d'utiliser des valeurs personnalisées comme oui / non, ou des nombres spécifiques.

Dans ce cas, la valeur produite est du type de la primitive <ode>boolean</code>. Le même type de fonctions est disponible pour produire une instance de l'objet Boolean, comme présenté dans le même test unitaire.

  @Test
  public void testToBooleanObject() {
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("true"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("TRUE"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("tRuE"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("y"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("Y"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("t"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("T"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("on"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("ON"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("oN"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("yes"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("YES"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("YeS"));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(1));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils
        .toBooleanObject(new Integer(3), new Integer(3), new Integer(4), null));
    Assert.assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("oui", "oui", "non", "null"));

    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("false"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("FALSE"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("fAlSe"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("n"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("N"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("f"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("F"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("off"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("OFF"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("oFf"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("no"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("NO"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("nO"));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(0));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils
        .toBooleanObject(new Integer(4), new Integer(3), new Integer(4), null));
    Assert.assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("non", "oui", "non", "null"));

    Assert.assertNull(BooleanUtils.toBooleanObject("dummy"));
    Assert.assertNull(BooleanUtils.toBooleanObject(null, new Integer(3), new Integer(4), null));
    Assert.assertNull(BooleanUtils.toBooleanObject("null", "oui", "non", "null"));
  }

Dans ce cas, il est possible de produire des objet null.

Conversion en chaîne de caractères

A l'instar de la conversion en boolean, il est possible de convertir un boolean en chaîne de caractères à l'aide de fonctions de type toString. Il existe plusieurs fonctions qui vont retourner des chaînes courantes.

• toStringTrueFalse retourne true ou false;
• toStringOnOff retourne on ou off;
• toStringYesNo retourne yes ou no.

La fonction toString permet de spécifier des chaînes de caractères spécifiques. Les mêmes fonctions sont disponibles avec un instance de la classe Boolean, qui peuvent produire une instance null.

Ces utilisations sont illustrées dans le test unitaire fr.ejn.tutorial.apache.commons.lang3.BooleanUtilsTest.

  @Test
  public void testToString() {
    Assert.assertEquals("Y", BooleanUtils.toString(true, "Y", "N"));
    Assert.assertEquals("N", BooleanUtils.toString(false, "Y", "N"));

    Assert.assertEquals("true", BooleanUtils.toStringTrueFalse(true));
    Assert.assertEquals("false", BooleanUtils.toStringTrueFalse(false));

    Assert.assertEquals("on", BooleanUtils.toStringOnOff(true));
    Assert.assertEquals("off", BooleanUtils.toStringOnOff(false));

    Assert.assertEquals("yes", BooleanUtils.toStringYesNo(true));
    Assert.assertEquals("no", BooleanUtils.toStringYesNo(false));

    Assert.assertEquals("Y", BooleanUtils.toString(Boolean.TRUE, "Y", "N", "null value"));
    Assert.assertEquals("N", BooleanUtils.toString(Boolean.FALSE, "Y", "N", "null value"));
    Assert.assertEquals("null value", BooleanUtils.toString(null, "Y", "N", "null value"));

    Assert.assertEquals("true", BooleanUtils.toStringTrueFalse(Boolean.TRUE));
    Assert.assertEquals("false", BooleanUtils.toStringTrueFalse(Boolean.FALSE));
    Assert.assertNull(BooleanUtils.toStringTrueFalse(null));

    Assert.assertEquals("on", BooleanUtils.toStringOnOff(Boolean.TRUE));
    Assert.assertEquals("off", BooleanUtils.toStringOnOff(Boolean.FALSE));
    Assert.assertNull(BooleanUtils.toStringOnOff(null));

    Assert.assertEquals("yes", BooleanUtils.toStringYesNo(Boolean.TRUE));
    Assert.assertEquals("no", BooleanUtils.toStringYesNo(Boolean.FALSE));
    Assert.assertNull(BooleanUtils.toStringYesNo(null));
  }

Validation boolean

Afin de limiter la note de compléxité d'une classe / fonction, la classe BooleanUtils propose des fonctions pour valider si une condition est vrai ou fausse.

• isFalse valide que l'argument passé est un boolean false;
• isTrue valide que l'argument passé est un boolean true;
• isNotFalse valide que l'argument passé n'est pas un boolean false. Elle est similaire à isTrue;
• isNotTrue valide que l'argument passé n'est pas un boolean true. Elle est similaire à isFalse.

Les deux dernières fonctions listées sont écrites dans le but d'avoir des noms explicites.

Les tests suivants illustrent l'utilisation des fonctions.

  @Test
  public void testIsFalse() {
    int first = 1;
    int second = 0;
    Assert.assertTrue(BooleanUtils.isFalse(first == second));

    first = 1;
    second = 1;
    Assert.assertFalse(BooleanUtils.isFalse(first == second));
  }

  @Test
  public void testIsNotFalse() {
    int first = 1;
    int second = 0;
    Assert.assertFalse(BooleanUtils.isNotFalse(first == second));

    first = 1;
    second = 1;
    Assert.assertTrue(BooleanUtils.isNotFalse(first == second));
  }

  @Test
  public void testIsNotTrue() {
    int first = 1;
    int second = 0;
    Assert.assertTrue(BooleanUtils.isNotTrue(first == second));

    first = 1;
    second = 1;
    Assert.assertFalse(BooleanUtils.isNotTrue(first == second));
  }

  @Test
  public void testIsTrue() {
    int first = 1;
    int second = 0;
    Assert.assertFalse(BooleanUtils.isTrue(first == second));

    first = 1;
    second = 1;
    Assert.assertTrue(BooleanUtils.isTrue(first == second));
  }