Métodos de clase BitSet en Java con ejemplos | conjunto 3

                       BitSet class methods in Set 3.
               /      /      |       |     |       \      \
            and  notand    flip  isEmpty  equal   get   intersect

Métodos de clase BitSet en Java con ejemplos | conjunto 2

Los métodos de la clase BitSet se explican a continuación:

  1. y / notand : el método java.util.BitSet.and() y java.util.BitSet.notand() es un método de clase java.util.Bitset.
    El método .and() realiza una operación AND lógica del conjunto de bits (objetivo) con el conjunto de bits pasado como argumento. Esto devolverá un bit (establecido) si y solo si ambos bits que se están operando son verdaderos.
    Método .notand(): todos los bits que tienen su bit correspondiente: el conjunto se borra con este método
    Syntax:
    public void and(BitSet bitset)
               or
    public void andNot(BitSet bitste)
    Parameters:
    bitset - set to perform the operation
    
  2. equal : el método java.util.BitSet.equal() juega su papel en la comparación de dos conjuntos de bits. Lo hace comparando un objeto con otro.
    Syntax:
    public boolean equals(Object o)
    Parameters: 
    o - the object to compare with
    Overrides: equals in class Object
    Return: if object are same then true; otherwise false
    
  3. get() : el método java.util.BitSet.get() crea un nuevo BitSet con elementos del Bitset dado que tienen posiciones desde from_Index (inclusivo) hasta_Index (exclusivo).
    Syntax:
    public BitSet get(int from_Index,  int to_Index)
    Parameters:
    from_Index - index of the first bit of given BitSet to include
    to_Index - index after the last bit of the BitSet to include
    Throws:
    IndexOutOfBoundsException - if from_Index is negative, or to_Index is negative,
                                or from_Index is larger than to_Index
    
  4. Código Java que explica el uso de los métodos and(), notand(), equal(), get().

    // Java program explaining BitSet class methods
    // and(), notand(), equal(), get()
    import java.util.*;
    public class GFG
    {
        public static void main(String[] args)
        {
            BitSet bs1 = new BitSet();
            BitSet bs2 = new BitSet();
      
            // assign values to bs1 using set()
            bs1.set(7);
            bs1.set(1);
            bs1.set(2);
            bs1.set(4);
            bs1.set(3);
            bs1.set(6);
      
            // assign values to bs2
            bs2.set(4);
            bs2.set(6);
            bs2.set(3);
            bs2.set(9);
            bs2.set(2);
      
            // Printing the Bitsets
            System.out.println("bs1         : " + bs1);
            System.out.println("bs2         : " + bs2);
      
            // use of get() to get index 3 to 6 of bs1
            System.out.println("\nUse of get() on bs1 : "
                                          + bs1.get(1,4));
      
            // use of get() to get index 1 to 4 of bs2
            System.out.println("Use of get() on bs2 : "
                                        + bs2.get(1,4));
      
            // perform not operation in b/w the sets
            bs1.andNot(bs2);
            System.out.println("\nNot b/w bs1 and bs2 : " + bs1);
      
            // perform and operation between two bitsets
            bs1.and(bs2);
            System.out.println("And b/w bs1 and bs2 : "  + bs1);
      
            // equal() method to compare the bs1 and bs2
            if (bs1.equals(bs2))
                System.out.println("\nUsing equal method : Equal");
            else
                System.out.println("\nUsing equal method : Not Equal");
        }
    }

    Producción:

    bs1         : {1, 2, 3, 4, 6, 7}
    bs2         : {2, 3, 4, 6, 9}
    
    Use of get() on bs1 : {0, 1, 2}
    Use of get() on bs2 : {1, 2}
    
    Not b/w bs1 and bs2 : {1, 7}
    And b/w bs1 and bs2 : {}
    
    Using equal method : Not Equal
    
  5. flip() : el método java.util.BitSet.flip(from_Index, to_Index) establece cada bit del from_Index dado (inclusive) al to_Index especificado (exclusivo) al complemento del valor actual.
    Syntax:
    public void flip(int from_Index, int to_Index)
    Parameters:
    from_Index - index of the first bit of the given BitSet to flip
    to_Index - index after the last bit of the given BitSet to flip
    Throws:
    IndexOutOfBoundsException - if from_Index is negative, or to_Index is negative, 
                                or from_Index is larger than to_Index
    
  6. intersect() : el método java.util.BitSet.intersect() devuelve verdadero si se establecen tanto los bits en el BitSet de destino como el BitSet dado.
    Syntax:
    public boolean intersects(BitSet set)
    Parameters:
    set - BitSet to intersect with
    Returns: true if the given BitSet intersects the target BitSet
    
  7. isEmpty() : método java.util.BitSet.isEmpty() si hay algún bit, que se establece en verdadero o no en el Bitset dado.
    Syntax:
    public boolean isEmpty()
    Return: boolean indicating whether the given BitSet is empty
    
  8. Código Java que explica el uso de los métodos intersect(), isEmpty(), flip().

    // Java program explaining BitSet class methods
    // intersect(), isEmpty(), flip() methods
    import java.util.*;
    public class NewClass
    {
        public static void main(String[] args)
        {
            BitSet bs1 = new BitSet();
            BitSet bs2 = new BitSet();
      
            // assign values to bs1 using set()
            bs1.set(7);
            bs1.set(1);
            bs1.set(2);
            bs1.set(4);
            bs1.set(3);
            bs1.set(6);
      
            // assign values to bs2
            bs2.set(4);
            bs2.set(6);
            bs2.set(3);
            bs2.set(9);
            bs2.set(2);
      
            // Printing the Bitsets
            System.out.println("bs1      : " + bs1);
            System.out.println("bs2      : " + bs2);
            System.out.println("");
      
      
            // use of intersect() to check if the bitsets
            // intersects
            System.out.println("Using intersect() : "
                         + bs2.intersects(bs1));
      
            // use of flip() from_index - 1 to_index - 5
            bs1.flip(1,5);
            System.out.println("\nbs1 using flip : " + bs1);
      
            // use of flip() from_index - 2 to_index - 4
            bs2.flip(2,4);
            System.out.println("bs2 using flip : " + bs2);
            System.out.println("");
      
      
            // use of isEmpty() to check if bitsets are empty
            System.out.println("Use of isEmpty() : "
                                + bs1.isEmpty());
            System.out.println("Use of isEmpty() : "
                                 + bs2.isEmpty());
        }
    }

    Producción:

    bs1      : {1, 2, 3, 4, 6, 7}
    bs2      : {2, 3, 4, 6, 9}
    
    Using intersect() : true
    
    bs1 using flip : {6, 7}
    bs2 using flip : {4, 6, 9}
    
    Use of isEmpty() : false
    Use of isEmpty() : false
    

    Referencias:
    https://docs.oracle.com/javase/7/docs/api/java/util/BitSet.html

    Este artículo es una contribución de Mohit Gupta . 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

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *