Java中的BitSet nextSetBit（）方法-yiteyi-C++库

BitSet是java中定义的一个类。util包。它创建一个由布尔值表示的位数组。

null

nextSetBit（）方法： BitSet类中的此方法用于返回在指定起始索引时或之后设置为true的第一位的索引。如果不存在这样的位，则返回-1。

语法：

public int nextSetBit(int fromIndex)

参数： 此方法采用强制参数 fromIndex 这是开始检查下一个真位的索引（包括）。

返回值： 此方法返回下一个设置位的索引，如果没有这样的位，则返回-1

例外情况： 这个方法抛出 IndexOutOfBoundsException 如果指定的索引为负。

注：要迭代位集中的真位，请使用以下循环：

for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
     // operate on index i here
 }

例1： 要显示nextSetBit（）函数的实现：

                     // Java program illustrating Bitset                   
                     // nextSetBit() function.                   
                             
                     import                               java.util.*;                   
                     public                               class                               GFG {                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Constructors of BitSet class                   
                                         BitSet bs1 =                               new                               BitSet();                   
                                         BitSet bs2 =                               new                               BitSet();                   
                                         BitSet bs3 =                               new                               BitSet();                   
                             
                                         /* assigning values to set1*/                   
                                         bs1.set(                               0                               );                   
                                         bs1.set(                               1                               );                   
                                         bs1.set(                               2                               );                   
                                         bs1.set(                               4                               );                   
                             
                                         // assign values to bs2                   
                                         bs2.set(                               4                               );                   
                                         bs2.set(                               6                               );                   
                                         bs2.set(                               5                               );                   
                                         bs2.set(                               1                               );                   
                                         bs2.set(                               2                               );                   
                                         bs2.set(                               3                               );                   
                                         bs2.set(                               12                               );                   
                             
                                         // Printing the 2 Bitsets                   
                                         System.out.println(                               "bs1 : "                               + bs1);                   
                                         System.out.println(                               "bs2 : "                               + bs2);                   
                                         System.out.println(                               "bs3 : "                               + bs3);                   
                             
                                         // Performing nextSetBit() on bitsets                   
                                         System.out.println(bs1.nextSetBit(                               2                               ));                   
                                         System.out.println(bs2.nextSetBit(                               0                               ));                   
                                         System.out.println(bs3.nextSetBit(                               3                               ));                   
                                         }                   
                     }                   

输出：

bs1 : {0, 1, 2, 4}
bs2 : {1, 2, 3, 4, 5, 6, 12}
bs3 : {}
2
1
-1

例2： 要显示IndexOutOfBoundException，请执行以下操作：

                     // Java program illustrating Bitset                   
                     // nextSetBit() function.                   
                             
                     import                               java.util.*;                   
                     public                               class                               GFG {                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Constructors of BitSet class                   
                                         BitSet bs1 =                               new                               BitSet();                   
                                         BitSet bs2 =                               new                               BitSet();                   
                             
                                         /* assigning values to set1*/                   
                                         bs1.set(                               0                               );                   
                                         bs1.set(                               1                               );                   
                                         bs1.set(                               2                               );                   
                                         bs1.set(                               4                               );                   
                             
                                         // assign values to bs2                   
                                         bs2.set(                               4                               );                   
                                         bs2.set(                               6                               );                   
                                         bs2.set(                               5                               );                   
                                         bs2.set(                               1                               );                   
                                         bs2.set(                               2                               );                   
                                         bs2.set(                               3                               );                   
                                         bs2.set(                               12                               );                   
                             
                                         // Printing the 2 Bitsets                   
                                         System.out.println(                               "bs1 : "                               + bs1);                   
                                         System.out.println(                               "bs2 : "                               + bs2);                   
                             
                                         try                               {                   
                                         // Passing -1 as parameter                   
                                         System.out.println(bs1.nextSetBit(-                               1                               ));                   
                                         }                   
                                         catch                               (Exception e) {                   
                                         System.out.println(                               "Exception when "                   
                                         +                               "negative index is passed "                   
                                         +                               "as parameter : "                               + e);                   
                                         }                   
                                         }                   
                     }                   

输出：

bs1 : {0, 1, 2, 4}
bs2 : {1, 2, 3, 4, 5, 6, 12}
Exception when negative index is passed as parameter : java.lang.IndexOutOfBoundsException: fromIndex < 0: -1

文章版权归作者所有，未经允许请勿转载。

THE END

Java