知识回顾：

1. 值过滤器（ValueFilter）

Filter filter= new ValueFilter (CompareFilter.CompareOp.EQUAL, new SubstringComparator(“wang”));
解释：用ValueFilter类实例化了一个filter对象，并将wang这个参数传入到了filter对象中

2. 单列值过滤器（SingleColumnValueFilter）

Filter filter= new SingleColumnValueFilter( Bytes.toBytes(“info”), Bytes.toBytes(“name”), CompareFilter.CompareOp.EQUAL, new SubstringComparator(“wang”));
解释：用SingleColumnValueFilter类实例化一个filter对象， 将info族name列字符串转换成了字节流并封装起来，将wang这个参数传入到filter对象中

3. 列键过滤器（KeyOnlyFilter）

列键过滤器的作用就是在遍历过程中不获取值只获取列名。
KeyOnlyFilter filter = new KeyOnlyFilter();
解释：

4. 首次列键过滤器（FirstKeyOnlyFilter）

解释：首次列键过滤器是在列键过滤器的基础上更进一步，他在遍历到行的第1个列的时候就立即放弃了往下遍历该行的其他列，转而便立下一个列，由于总是获取第1个列键，所以叫首次列键过滤器。使用这种过滤器时，如果扫描到列，那么证明该行必然存在，所以在做行数统计的时候速度非常快。

5. 行过滤器（ROWFilter）

行过滤器的作用是针对rowkey进行过滤。
RowFilter filter = new RowFilter(CompareFilter.CompareOp.GREATER,new SubstringComparator(“1001”));
解释：用RowFilter类实例化一个filter对象，并将1001这个参数传入到这个对象中

6. 前缀过滤器（PrefixFilter）

前缀过滤器是一种行健过滤器，可以根据行健的前缀，来匹配行健包含指定前缀的数据。
PrefixFilter filter= new PrefixFilter(Bytes.toBytes(“row”));

7. 随机行过滤器（RandomRowFilter）

当你想随机抽取系统的一部分数据的时候，可以使用随机行过滤器，这种过滤器适用于数据分析时，对系统数据进行采样的场景，通过随机行过滤器，让你可以随机的选择系统中的一部分数据
随机行过滤器的构造函数是： RandomRowFilter(float chance)chance是一个用来比较的数值，它的取值范围从0~1.0。当扫描器遍历数据的时候，每遍历到一行数据，Hbase就会调用Random来得出一个随机数，并用这个随机数跟你提供的chance值进行比较，如果比较的结果是随机数比chance小，该条记录就会被选择出来。

8. 列族过滤器（FamilyFilter）

针对列族来进行过滤。
FamilyFilter filter= new FamilyFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator(“info”));

上代码：

  1. public class HBaseFilter {
  3.     public static void main(String[] args) {
  4.         // TODO Auto-generated method stub
  5.         //获取配置文件
  6.         Configuration config = HBaseConfiguration.create();
  7.         config.set("hbase.zookeeper.quorum", "192.168.141.30");
  8.         config.set("hbase.master","localhost:16010");
  9.         config.set("hbase.zookeeper.property.clientPort", "2181");
  10.         try {
  11.             //创建链接
  12.             Connection connection = ConnectionFactory.createConnection(config);
  13.             Admin admin = connection.getAdmin();
  14.             //链接Table接口
  15.             Table table = connection.getTable(TableName.valueOf("test"));
  16.             Scan scan = new Scan();
  18.             //值过滤器
  19.             ValueFilter filter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("wang"));
  20.             scan.setFilter(filter);
  21.             ResultScanner rs = table.getScanner(scan);
  22.             for(Result result : rs) {
  23.                 Cell[] cells = result.rawCells();
  24.                 for(Cell cell : cells) {
  25.                     System.out.println("Value=" + Bytes.toString(CellUtil.cloneValue(cell)));
  26.                 }
  27.             }
  28.             rs.close();
  29.             table.close();
  30.             connection.close();
  32. /*            //单列值过滤器
  33.             SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes("info1"), Bytes.toBytes("name"), CompareFilter.CompareOp.EQUAL, new SubstringComparator("wang"));
  34.             scan.setFilter(filter);
  35.             ResultScanner rs = table.getScanner(scan);
  36.             for(Result result : rs) {
  37.                 String name = Bytes.toString(result.getValue(Bytes.toBytes("info1"), Bytes.toBytes("name")));
  38.                 System.out.println("Value=" + name);
  39.             }
  40.             rs.close();
  41.             table.close();
  42.             connection.close();
  43. */            
  44. /*            //列键过滤器
  45.             KeyOnlyFilter filter = new KeyOnlyFilter();
  46.             scan.setFilter(filter);
  47.             ResultScanner rs = table.getScanner(scan);
  48.             for(Result result : rs) {
  49.                 String rowkey = Bytes.toString(result.getRow());
  50.                 System.out.println("Rowkey=" + rowkey);
  51.                 Cell[] cells = result.rawCells();
  52.                 for(Cell cell : cells) {
  53.                     System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
  54.                 }
  55.             }
  56.             rs.close();
  57.             table.close();
  58.             connection.close();
  59. */
  60. /*            //首次列键过滤器
  61.             FirstKeyOnlyFilter filter = new FirstKeyOnlyFilter();
  62.             scan.setFilter(filter);
  63.             ResultScanner rs = table.getScanner(scan);
  64.             int count = 0;
  65.             for(Result result : rs) {
  66.                 count ++;
  67.             }
  68.             System.out.println("该表共有：" + count + "行");
  69.             rs.close();
  70.             table.close();
  71.             connection.close();
  72. */            
  73. /*            //行过滤器
  74.             RowFilter filter = new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("1002")));
  75.             scan.setFilter(filter);
  76.             ResultScanner rs = table.getScanner(scan);
  77.             for(Result result : rs) {
  78.                 Cell[] cells = result.rawCells();
  79.                 for(Cell cell : cells) {
  80.                     System.out.println("行键:" + Bytes.toString(CellUtil.cloneRow(cell)));
  81.                     System.out.println("列族:" + Bytes.toString(CellUtil.cloneFamily(cell)));
  82.                     System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
  83.                     System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
  84.                 }
  85.             }
  86.             rs.close();
  87.             table.close();
  88.             connection.close();
  89. */            
  90. /*            //前缀过滤器
  91.             PrefixFilter filter = new PrefixFilter(Bytes.toBytes("100"));
  92.             scan.setFilter(filter);
  93.             ResultScanner rs = table.getScanner(scan);
  94.             for(Result result : rs) {
  95.                 Cell[] cells = result.rawCells();
  96.                 for(Cell cell : cells) {
  97.                     System.out.println("行键:" + Bytes.toString(CellUtil.cloneRow(cell)));
  98.                     System.out.println("列族:" + Bytes.toString(CellUtil.cloneFamily(cell)));
  99.                     System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
  100.                     System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
  101.                 }
  102.             }
  103.             rs.close();
  104.             table.close();
  105.             connection.close();
  106. */            
  107. /*            //随机行过滤器
  108.             RandomRowFilter filter = new RandomRowFilter(new Float(0.8));
  109.             scan.setFilter(filter);
  110.             ResultScanner rs = table.getScanner(scan);
  111.             for(Result result : rs) {
  112.                 String rowkey = Bytes.toString(result.getRow());
  113.                 System.out.println("Rowkey=" + rowkey);
  114.             }
  115.             rs.close();
  116.             table.close();
  117.             connection.close();
  118. */            
  119. /*            //列族过滤器
  120.             FamilyFilter filter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("info2")));
  121.             scan.setFilter(filter);
  122.             ResultScanner rs = table.getScanner(scan);
  123.             for(Result result : rs) {
  124.                 Cell[] cells = result.rawCells();
  125.                 for(Cell cell : cells) {
  126.                     System.out.println("行键:" + Bytes.toString(CellUtil.cloneRow(cell)));
  127.                     System.out.println("列族:" + Bytes.toString(CellUtil.cloneFamily(cell)));
  128.                     System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
  129.                     System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
  130.                 }
  131.             }
  132.             rs.close();
  133.             table.close();
  134.             connection.close();
  135. */            
  136. /*            //列过滤器
  137.             QualifierFilter filter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("tname")));
  138.             scan.setFilter(filter);
  139.             ResultScanner rs = table.getScanner(scan);
  140.             for(Result result : rs) {
  141.                 Cell[] cells = result.rawCells();
  142.                 for(Cell cell : cells) {
  143.                     System.out.println("行键:" + Bytes.toString(CellUtil.cloneRow(cell)));
  144.                     System.out.println("列族:" + Bytes.toString(CellUtil.cloneFamily(cell)));
  145.                     System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
  146.                     System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
  147.                 }
  148.             }
  149.             rs.close();
  150.             table.close();
  151.             connection.close();
  152. */            
  153.         }catch(IOException e) {
  154.             e.printStackTrace();
  155.             }
  156.     }
  158. }

1. 值过滤器

代码：
该过滤器使用单元格的值来过滤数据，只有满足条件、指定值的单元格才会被返回

//值过滤器
ValueFilter filter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("wang"));
scan.setFilter(filter);
ResultScanner rs = table.getScanner(scan);
for(Result result : rs) {
    Cell[] cells = result.rawCells();
    for(Cell cell : cells) {
        System.out.println("Value=" + Bytes.toString(CellUtil.cloneValue(cell)));
    }
}

实验结果：
_%TFTUV[~NVCSNL_]WVMZIU.png

2.单列值过滤器

该过滤器类似于关系型数据库where条件语句，通过判断数据行指定的列限定符对应的值是否匹配指定的条件（如:等于1000）来决定是否将改数据行返回
代码：

SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes("info1"), Bytes.toBytes("name"), CompareFilter.CompareOp.EQUAL, new SubstringComparator("wang"));
scan.setFilter(filter);
ResultScanner rs = table.getScanner(scan);
for(Result result : rs) {
    String name = Bytes.toString(result.getValue(Bytes.toBytes("info1"), Bytes.toBytes("name")));
    System.out.println("Value=" + name);
}

实验结果
GE$8T}6%61CH1KN4USM@(~4.png

3.列键过滤器

该过滤器使得查询结果只返回行键

KeyOnlyFilter filter = new KeyOnlyFilter();
scan.setFilter(filter);
ResultScanner rs = table.getScanner(scan);
for(Result result : rs) {
    String rowkey = Bytes.toString(result.getRow());
    System.out.println("Rowkey=" + rowkey);
    Cell[] cells = result.rawCells();
    for(Cell cell : cells) {
        System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
    }
}
rs.close();
table.close();
connection.close();

![TRRDGZ1@A~L5107$V9FM94.png

4. 首次列键过滤器

FirstKeyOnlyFilter filter = new FirstKeyOnlyFilter();
scan.setFilter(filter);
ResultScanner rs = table.getScanner(scan);
int count = 0;
for(Result result : rs) {
    count ++;
}
System.out.println("该表共有：" + count + "行");
rs.close();
table.close();
connection.close();

image.png

5TWA}%5$1_@HOBB(1CDGKXM.png
3IB9DZ~LL1JG1CYC$_V}XVX.png
Z3FB89IX5F{FC%7C)HEE`82.png
$P{426OATW@H(PSOH`B}XYS.png
E$))JSW@WDA87O210}94N(T.png