HBase的简单学习三

一 过滤器

1.1相关概念

1.过滤器可以根据列族、列、版本等更多的条件来对数据进行过滤,

基于 HBase 本身提供的三维有序(行键,列,版本有序),这些过滤器可以高效地完成查询过滤的任务,带有过滤器条件的 RPC 查询请求会把过滤器分发到各个 RegionServer(这是一个服务端过滤器),这样也可以降低网络传输的压力。

2.使用过滤器至少需要两类参数:

一类是抽象的操作符,另一类是比较器

3.过滤器的作用是在服务端判断数据是否满足条件,然后只将满足条件的数据返回给客户端

4.过滤器的类型很多,但是可以分为三大类:

  • 比较过滤器:可应用于rowkey、列簇、列、列值过滤器

  • 专用过滤器:只能适用于特定的过滤器

  • 包装过滤器:包装过滤器就是通过包装其他过滤器以实现某些拓展的功能

1.2  CompareOperator 比较运算符

比较运算符

  • LESS <

  • LESS_OR_EQUAL <=

  • EQUAL =

  • NOT_EQUAL <>

  • GREATER_OR_EQUAL >=

  • GREATER >

  • NO_OP 排除所有

1.3  常见的六大比较器

BinaryComparator

按字节索引顺序比较指定字节数组,采用Bytes.compareTo(byte[])

BinaryPrefixComparator

通BinaryComparator,只是比较左端前缀的数据是否相同

NullComparator

判断给定的是否为空

BitComparator

按位比较

RegexStringComparator

提供一个正则的比较器,仅支持 EQUAL 和非EQUAL

SubstringComparator

判断提供的子串是否出现在中

 二 常用的过滤器

2.1 行键过滤器

1.先将表名封装成一个TableName的对象

TableName tn = TableName.valueOf("表名");

2.获取表对象  使用数据库连接对象conn中的getTable获取表对象,参数是TableName的对象

Table table = conn.getTable(tn);

3.创建sacn对象

Scan scan = new Scan();

4.创建什么比较器,传入的值是不同的

这里是行键比较器,比较的是在这个行键的大小,所以用BinaryComparator,传入的是行键

BinaryComparator binaryComparator = new BinaryComparator(Bytes.toBytes("行键"));

5.创建一个行键过滤器对象

里面传入的是操作符,跟比较器对象

RowFilter rowFilter = new RowFilter(CompareOperator.LESS, binaryComparator);

6.设置过滤器

使用的是scan里面的setFilter方法,里面传入的是过滤器对象

scan.setFilter(rowFilter);

7.创建结果对象

使用的是表对象中的getScanner方法,传入的是scan对象

ResultScanner resultScanner = table.getScanner(scan);

8.遍历结果对象

    /**
     * 需求:通过RowFilter与BinaryComparator过滤比rowKey 1500100010小的所有值出来
     * 配合等值比较器BinaryComparator
     */
    @Test
    public void scanDataWithRowFilterAndBinaryComparator() throws Exception{
        try {
            //先将表名封装成一个TableName的对象
            TableName st = TableName.valueOf("students");
            //获取表对象
            Table table = conn.getTable(st);
            //scan
            Scan scan = new Scan();
            //创建一个BinaryComparator比较器对象,里面传入的是行键
            BinaryComparator binaryComparator = new BinaryComparator(Bytes.toBytes("1500100010"));
            //创建一个行键过滤器对象
            RowFilter rowFilter = new RowFilter(CompareOperator.LESS, binaryComparator);

            //设置过滤器
            //public Scan setFilter(Filter filter)
            scan.setFilter(rowFilter);
            //创建结果对象
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                HBaseUtils.printResult(result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }

2.2 列簇过滤器

1.先将表名封装成一个TableName的对象

TableName tn = TableName.valueOf("表名");

2.获取表对象  使用数据库连接对象conn中的getTable获取表对象,参数是TableName的对象

Table table = conn.getTable(tn);

3.创建sacn对象

Scan scan = new Scan();

4.创建什么比较器,传入的值是不同的

这里是列簇比较器,比较的是列簇是是否包含,所以使用SubstringComparator比较器,传入的是字符串

5.创建一个什么的过滤器对象

这里是列簇过滤器 FamilyFilter

里面传入的是操作符,跟比较器对象

FamilyFilter familyFilter = new FamilyFilter(CompareOperator.EQUAL, substringComparator);

6.设置过滤器

使用的是scan里面的setFilter方法,里面传入的是过滤器对象

scan.setFilter(rowFilter);

7.创建结果对象

使用的是表对象中的getScanner方法,传入的是scan对象

ResultScanner resultScanner = table.getScanner(scan);

8.遍历结果对象

    /**
     * 列簇过滤器:FamilyFilter
     * 需求:过滤出列簇名中包含“a”的列簇中所有数据配合包含比较器SubstringComparator
     */
    @Test
    public void scanDataWithFamilyFilterAndSubstringComparator() {
        try {
            //先将表名封装成一个TableName的对象
            TableName st = TableName.valueOf("users");
            //获取表对象
            Table table = conn.getTable(st);
            //scan
            Scan scan = new Scan();
            //创建一个SubstringComparator包含比较器对象,里面传入是字符
            SubstringComparator substringComparator = new SubstringComparator("f");
            //创建一个列簇过滤器对象
            FamilyFilter familyFilter = new FamilyFilter(CompareOperator.EQUAL, substringComparator);
            //设置过滤器
            //public Scan setFilter(Filter filter)
            scan.setFilter(familyFilter);
            //创建结果对象
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                HBaseUtils.printResult(result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

 2.3 列名过滤器

1.先将表名封装成一个TableName的对象

TableName tn = TableName.valueOf("表名");

2.获取表对象  使用数据库连接对象conn中的getTable获取表对象,参数是TableName的对象

Table table = conn.getTable(tn);

3.创建sacn对象

Scan scan = new Scan();

4.创建什么比较器,传入的值是不同的

这里是列名比较器,比较的是列簇是是否包含,所以使用SubstringComparator比较器,传入的是字符串

5.创建一个什么的过滤器对象

这里是列簇过滤器QualifierFilter

里面传入的是操作符,跟比较器对象

QualifierFilter qualifierFilter = new QualifierFilter(CompareOperator.EQUAL, substringComparator);

6.设置过滤器

使用的是scan里面的setFilter方法,里面传入的是过滤器对象

scan.setFilter(rowFilter);

7.创建结果对象

使用的是表对象中的getScanner方法,传入的是scan对象

ResultScanner resultScanner = table.getScanner(scan);

8.遍历结果对象

    /**
     * 列名过滤器:QualifierFilter
     * 通过QualifierFilter与SubstringComparator查询列名包含 m 的列的值
     */
    @Test
    public void scanDataWithQualifierFilterAndSubstringComparator() {

        try {
            //先将表名封装成一个TableName的对象
            TableName st = TableName.valueOf("users");
            //获取表对象
            Table table = conn.getTable(st);
            //scan
            Scan scan = new Scan();
            //创建一个SubstringComparator包含比较器对象,里面传入是字符
            SubstringComparator substringComparator = new SubstringComparator("m");
            //创建一个列名过滤器对象
            QualifierFilter qualifierFilter = new QualifierFilter(CompareOperator.EQUAL, substringComparator);
            //设置过滤器
            //public Scan setFilter(Filter filter)
            scan.setFilter(qualifierFilter);
            //创建结果对象
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                HBaseUtils.printResult(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }}

2.4 列值过滤器

列值过滤器只能过滤出当前符合条件的列,至于与该列属于同一行的其他列并不会返回

1.先将表名封装成一个TableName的对象

TableName tn = TableName.valueOf("表名");

2.获取表对象  使用数据库连接对象conn中的getTable获取表对象,参数是TableName的对象

Table table = conn.getTable(tn);

3.创建sacn对象

Scan scan = new Scan();

4.创建什么比较器,传入的值是不同的

这里是列值比较器,比较的是列值前面是否以啥开头,所以使用BinaryPrefixComparator比较器,传入的是字符串

BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator(Bytes.toBytes("从"));

5.创建一个什么的过滤器对象

这里是列值过滤器valueFilter

里面传入的是操作符,跟比较器对象

ValueFilter valueFilter = new ValueFilter(CompareOperator.EQUAL, binaryPrefixComparator);

6.设置过滤器

使用的是scan里面的setFilter方法,里面传入的是过滤器对象

scan.setFilter(valueFilter );

7.创建结果对象

使用的是表对象中的getScanner方法,传入的是scan对象

ResultScanner resultScanner = table.getScanner(scan);

8.遍历结果对象

    /**
     * 列值过滤器(属于比较过滤器)
     * 通过ValueFilter与BinaryPrefixComparator过滤出所有的cell中值以 "从" 开头的学生
     * 注意:列值过滤器只能过滤出当前符合条件的列,至于与该列属于同一行的其他列并不会返回
     */
    @Test
    public void scanDataWithValueFilterAndBinaryPrefixComparator(){
        try {
            //先将表名封装成一个TableName的对象
            TableName st = TableName.valueOf("students");
            //获取表对象
            Table table = conn.getTable(st);
            //scan
            Scan scan = new Scan();
            //创建一个BinaryPrefixComparator只是比较左端前缀的数据是否相同比较器对象,里面传入是字节数组
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator(Bytes.toBytes("从"));
            //创建一个列值过滤器对象
            ValueFilter valueFilter = new ValueFilter(CompareOperator.EQUAL, binaryPrefixComparator);
            //设置过滤器
            //public Scan setFilter(Filter filter)
            scan.setFilter(valueFilter);
            //创建结果对象
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                HBaseUtils.printResult(result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

2.5 专用过滤器

2.5.1单列值过滤器

SingleColumnValueFilter会返回满足条件的cell所在行的所有cell的值(即会返回一行数据)

1.创建过滤器不一样

//创建单列值过滤器

//public SingleColumnValueFilter(final byte [] family, final byte [] qualifier,

// final CompareOperator op,

// final org.apache.hadoop.hbase.filter.ByteArrayComparable comparator)

传入的是行键,列名(全是字节数组形式),操作符,比较器对象

    /**
     * 单列值过滤器(专用过滤器)
     * 需求:通过SingleColumnValueFilter与BinaryPrefixComparator过滤出所有的cell中值以 "从" 开头的学生
     */
    @Test
    public void scanDataWithSingleColumnValueFilterAndBinaryPrefixComparator(){
        try {
            //先将表名封装成一个TableName的对象
            TableName tn = TableName.valueOf("students");
            //获取表对象
            Table table = conn.getTable(tn);
            //scan
            Scan scan = new Scan();
            //创建一个BinaryPrefixComparator只是比较左端前缀的数据是否相同比较器对象,里面传入是字节数组
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator(Bytes.toBytes("从"));
            //创建一个单列值过滤器对象
            //public SingleColumnValueFilter(byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator)
            SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes("info"), Bytes.toBytes("name"), CompareOperator.EQUAL, binaryPrefixComparator);
            //设置过滤器
            //public Scan setFilter(Filter filter)
            scan.setFilter(singleColumnValueFilter);
            //创建结果对象
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                HBaseUtils.printResult(result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

2.得到的结果跟列值比较器有所不同,它可以把这行所有数据全都展示出来

2.5.2列值排除过滤器

SingleColumnValueExcludeFilter 会返回满足条件的cell所在行的所有cell的值(即会返回一行数据)

1.创建过滤器不一样

//创建列值排除过滤器

//public SingleColumnValueExcludeFilter(byte[] family, byte[] qualifier,

// CompareOperator op, ByteArrayComparable comparator)

 传入的是行键,列名(全是字节数组形式),操作符,比较器对象

/**
     * 列值排除过滤器
     * SingleColumnValueExcludeFilter
     * 通过SingleColumnValueExcludeFilter与BinaryComparator查询文科一班所有学生信息,最终不返回clazz列
     */
    @Test
    public void scanDataWithSingleColumnValueExcludeFilterAndBinaryComparator(){
        try {
            //先将表名封装成一个TableName的对象
            TableName tn = TableName.valueOf("students");
            //获取表对象
            Table table = conn.getTable(tn);
            //scan
            Scan scan = new Scan();
            //创建一个BinaryPrefixComparator只是比较左端前缀的数据是否相同比较器对象,里面传入是字节数组
            BinaryComparator binaryComparator = new BinaryComparator(Bytes.toBytes("文科一班"));
            //创建一个列值排除过滤器对象
            //public SingleColumnValueExcludeFilter(byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator)
            SingleColumnValueExcludeFilter singleColumnValueExcludeFilter = new SingleColumnValueExcludeFilter(Bytes.toBytes("info"), Bytes.toBytes("clazz"), CompareOperator.EQUAL, binaryComparator);
            //设置过滤器
            //public Scan setFilter(Filter filter)
            scan.setFilter(singleColumnValueExcludeFilter);
            //创建结果对象
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                HBaseUtils.printResult(result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

2.结果是 除了我们输入的列,其他全部输出

 2.5.3 rowkey前缀过滤器:

PrefixFilter

1.不需要设置比较器

2.设置的过滤器不同

//PrefixFilter(final byte [] prefix)

里面直接传入行键的字节数组

  /**
     * 行键前缀过滤器  PrefixFilter
     * 通过PrefixFilter查询以15001001开头的所有前缀的rowkey
     */
    @Test
    public void scanDataWithPrefixFilter(){
        try {
            //先将表名封装成一个TableName的对象
            TableName tn = TableName.valueOf("students");
            //获取表对象
            Table table = conn.getTable(tn);
            //scan
            Scan scan = new Scan();
            //创建一个行键前缀过滤器对象
            //public PrefixFilter(byte[] prefix)
            PrefixFilter prefixFilter = new PrefixFilter(Bytes.toBytes("15001001"));
            //设置过滤器
            //public Scan setFilter(Filter filter)
            scan.setFilter(prefixFilter);
            //创建结果对象
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                HBaseUtils.printResult(result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

2.结果

2.5.4 分页过滤器

PageFilter

1.需要设置分页的张数,查询的数量,起始行

2.设置过滤器

PageFilter pageFilter = new PageFilter(pageNumData);

3.遍历要for 循环遍历,因为设置了页数

4.前一页的末尾是下页的起始行

    /**
     * 分页过滤器
     * PageFilter
     * 通过PageFilter查询三页的数据,每页10条
     */
    @Test
    public void scanDataWithPageFilter() {
        try {
            //先将表名封装成一个TableName的对象
            TableName tn = TableName.valueOf("students");
            //获取表对象
            Table table = conn.getTable(tn);
            //设置要查询的页数
            int pageNum=3;
            //设置每一行查询的数量
            int pageNumData=10;
            //设置起始行
            String statKey="";
            //创建分页对象
            PageFilter pageFilter = new PageFilter(pageNumData);
            //创建scan对象
            Scan scan = new Scan();
            //设置scan对象
            scan.setFilter(pageFilter);
            for (int i=1;i<=pageNum;i++){
                System.out.println("======================="+i+"页=========");
                ResultScanner resultScanner = table.getScanner(scan);
                for (Result result : resultScanner) {
                    statKey = Bytes.toString(result.getRow()) + 0;
                    //设置下一行的开始
                    scan.withStartRow(Bytes.toBytes(statKey));
                    HBaseUtils.printResult(result);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

2.6 包装过滤器

2.6.1 跳过过滤器

SkipFilter

1.//创建跳过过滤器

SkipFilter skipFilter = new SkipFilter(valueFilter);

里面传入的是过滤器

2.他只能跳过列值,不能跳过行键

3.看看区别

a.这里设置过滤器用的是列值过滤器

 结果只是将含有理科的没有查询,但是其他的都查询了

 b.设置的是跳过过滤器

结果是将所有含理科的全部不查询

 2.6.2 停止过滤器

WhileMatchFilter

1.设置过滤器

WhileMatchFilter whileMatchFilter = new WhileMatchFilter(valueFilter);

传入的是过滤器对象

2.只能跳过列值

3.区别

 a.这里设置过滤器用的是列值过滤器

 结果只是将含有理科的没有查询,但是其他的都查询了

b.停止过滤器

他是查到有理科出现,立马停止

 

 2.7 多过滤器

1.过滤条件可以设置多个比较器与过滤器

2.创建过滤器集合

将过滤器添加到集合中

3.创建FilterList对象

FilterList filterList = new FilterList();

//public void addFilter(List<Filter> filters)

filterList.addFilter(filters);

  /**
     * 组合过滤器
     * 需求:通过运用4种比较器过滤出姓于,年纪大于22岁,性别为女,且是理科的学生。
     */

    @Test
    public void scanDataWithGroupFilter(){
        try {
            //先将表名封装成一个TableName的对象
            TableName tn = TableName.valueOf("students");
            //获取表对象
            Table table = conn.getTable(tn);
            //scan
            Scan scan = new Scan();
            //创建比较器,判断姓名是否以于开头
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator(Bytes.toBytes("于"));
            //创建比较器 判断年龄是否大于22
            BinaryComparator binaryComparator = new BinaryComparator(Bytes.toBytes("22"));
            //创建比较器 判断性别是否为女
            BinaryComparator binaryComparator1 = new BinaryComparator(Bytes.toBytes("女"));
            //创建比较器 判断班级是否为理科
            SubstringComparator substringComparator = new SubstringComparator("理科");

            //创建单列值过滤器,判断姓名是否以于开头
            SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes("info"),Bytes.toBytes("name"), CompareOperator.EQUAL, binaryPrefixComparator);
            //创建单列值过滤器,判断年龄是否大于22
            SingleColumnValueFilter singleColumnValueFilter1 = new SingleColumnValueFilter(Bytes.toBytes("info"), Bytes.toBytes("age"), CompareOperator.GREATER, binaryComparator);
            //创建单列值过滤器,判断年龄是否大于22
            SingleColumnValueFilter singleColumnValueFilter2 = new SingleColumnValueFilter(Bytes.toBytes("info"), Bytes.toBytes("gender"), CompareOperator.EQUAL, binaryComparator1);
            //创建单列值过滤器,判断班级是否含有理科
            SingleColumnValueFilter singleColumnValueFilter3 = new SingleColumnValueFilter(Bytes.toBytes("info"), Bytes.toBytes("clazz"), CompareOperator.EQUAL, substringComparator);
            //创建过滤器集合
            ArrayList<Filter> filters = new ArrayList<>();
            filters.add(singleColumnValueFilter);
            filters.add(singleColumnValueFilter1);
            filters.add(singleColumnValueFilter2);
            filters.add(singleColumnValueFilter3);
            //创建创建FilterList对象对象
            FilterList filterList = new FilterList();
            filterList.addFilter(filters);

            //设置过滤器
            //public Scan setFilter(Filter filter)
            scan.setFilter(filterList);
            //创建结果对象
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                HBaseUtils.printResult(result);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

综合案例

查询文科一班学生总分排名前10的学生(输出:学号,姓名,班级,总分)结果写到hbase

1、先将成绩表创建出来

2.将成绩表与学生表关联起来

3.设置合适的rowKey

4.重新创建一张表,设置合适的rowKey

package com.shujia.base;

import com.shujia.utils.HBaseUtils;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.PrefixFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Arrays;
import java.util.HashMap;

public class HBasePractice {
    public static void main(String[] args) throws Exception {
        //获取数据库连接对象
        Connection conn = HBaseUtils.CONNECTION;
        Admin admin = HBaseUtils.ADMIN;
        //创建一张表
//        HBaseUtils.createOneTable("scores","info");
        /**
         * 1500100001,1000001,98
         * 1500100001,1000002,5
         * 1500100001,1000003,137
         * 1500100001,1000004,29
         * 1500100001,1000005,85
         * 1500100001,1000006,52
         * 1500100002,1000001,139
         *
         *
         * 所以我们这样设置rowkey
         *1500100001-1000001,98
         *1500100001-1000002,5
         *1500100001-1000003,137
         *1500100001-1000004,29
         *1500100001-1000005,85
         *1500100001-1000006,52
         *1500100002-1000001,139
         * 查询文科一班学生总分排名前10的学生(输出:学号,姓名,班级,总分)结果写到hbase
         */
        //读文件
//        BufferedReader br = new BufferedReader(new FileReader("hbase/data/score.txt"));
//        String line = null;
//        while ((line=br.readLine())!=null){
//            String[] split = line.split(",");
//            String id = split[0];
//            String sid = split[1];
//            String sc = split[2];
//            HBaseUtils.putOneDataToTable("scores",id+"-"+sid,"info","score",sc);
//        }
        //先将表名封装成一个TableName的对象
        TableName tn = TableName.valueOf("students");
        TableName tn1 = TableName.valueOf("scores");
        //获取表对象
        Table students = conn.getTable(tn);
        Table scores = conn.getTable(tn1);
        //scan
        Scan scan = new Scan();
        //设置比较器
        BinaryComparator binaryComparator = new BinaryComparator(Bytes.toBytes("文科一班"));
        //设置过滤器
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes("info"), Bytes.toBytes("clazz"), CompareOperator.EQUAL, binaryComparator);
        //设置过滤器
        scan.setFilter(singleColumnValueFilter);
        //创建结果对象
        ResultScanner resultScanner = students.getScanner(scan);
        //创建map集合
        HashMap<String, Integer> yiBanWenKe = new HashMap<>();
        for (Result result : resultScanner) {
            String id = Bytes.toString(result.getRow());
            //创建rowkey前缀过滤器
            PrefixFilter prefixFilter = new PrefixFilter(Bytes.toBytes(id));
            //scan
            Scan scan1 = new Scan();
            //设置过滤器
            scan1.setFilter(prefixFilter);
            //创建结果对象
            ResultScanner resultScanner1 = scores.getScanner(scan1);
            int sumScore=0;
            for (Result result1 : resultScanner1) {
                int score = Integer.parseInt(Bytes.toString(result1.getValue(Bytes.toBytes("info"), Bytes.toBytes("score"))));
                sumScore+=score;
            }
            String name = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("name")));
            String clazz = Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("clazz")));
            yiBanWenKe.put(id+"-"+name+"-"+clazz,sumScore);
        }
//        yiBanWenKe.forEach((k,v)->{
//            String[] split = k.split("-");
//            System.out.println("学号:"+split[0]+"\t姓名:"+split[1]+"\t班级:"+split[2]+"\t总分:"+v);
//        });

        /**
         * 因为要降序排序,而hbase中,使用limit不能做到,这个时候只能重新设置rowKey
         * 1500100946 秋海白 文科一班 353
         * 1500100308 黄初夏 文科一班 628
         *
         * 353-1500100946 秋海白 文科一班
         * 628-1500100308 黄初夏 文科一班
         * 再使用比较大的数减去分数,这样比较高的分数就就可以再上面
         * (1000-353)-1500100946 秋海白 文科一班
         * (1000-628)-1500100308 黄初夏 文科一班
         */
        //创建结果表
//        HBaseUtils.dropOneTable("clazzWenOne");
//        HBaseUtils.createOneTable("clazzWenOne","info");
        yiBanWenKe.forEach((k,v)->{
            String[] split = k.split("-");
            String id = split[0];
            String name = split[1];
            String clazz = split[2];
            int new_score=1000-v;
            System.out.println("学号:"+split[0]+"\t姓名:"+split[1]+"\t班级:"+split[2]+"\t总分:"+v);
//            System.out.println("键:"+new_score+"-"+id+"\t姓名:"+name+"\t班级:"+clazz+"\t总分:"+v);
            HBaseUtils.putOneDataToTable("clazzWenOne",new_score+"-"+id,"info","name",name);
            HBaseUtils.putOneDataToTable("clazzWenOne",new_score+"-"+id,"info","clazz",clazz);
        });
//        HBaseUtils.scanData("clazzWenOne",10);
        
        //释放资源
        HBaseUtils.closeSource();

    }
}

2.8 布隆过滤器

1.本质上布隆过滤器是一种数据结构,比较巧妙的概率型数据结构,特点是高效地插入和查询,可以用来告诉你 “某样东西一定不存在或者可能存在”。

2.在HBase中,布隆过滤器(Bloom Filter)的主要作用是提高随机读(get)的性能。HBase通过布隆过滤器来避免大量的读文件操作,特别是在过滤指定的rowkey是否在目标文件时,有助于减少不必要的扫描多个文件。

3.创建表的时候,可以在设置列簇描述器对象时候设置

使用的是ColumnFamilyDescriptorBuilder里面的newBuilder方法,传入的是列簇的字节数组

然后继续使用设置布隆过滤器的方法setBloomFilterType,里面传入的是设置的控制行还是列

ColumnFamilyDescriptor columnFamilyDescriptor = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(columnFamily))

.setBloomFilterType(BloomType.ROW).build();

    public static void createOneTable(String tableName, String columnFamily) {
        try {
            //先将表名封装成一个TableName的对象
            TableName tn = TableName.valueOf(tableName);
            if (!ADMIN.tableExists(tn)){
                TableDescriptorBuilder table = TableDescriptorBuilder.newBuilder(tn);
                //创建列簇描述器对象
//                ColumnFamilyDescriptor info = ColumnFamilyDescriptorBuilder.of("info");
                //使用另一种方法创建列簇描述器对象,并设置布隆过滤器
                ColumnFamilyDescriptor info = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(columnFamily))
                        .setBloomFilterType(BloomType.ROW).build();

                //将列簇与表进行关联
                table.setColumnFamily(info);
                //调用方法,创建表
                ADMIN.createTable(table.build());
                System.out.println(tn + "表创建成功!!!");
            }else {
                System.out.println(tn + "表已经存在!");
            }

        } catch (Exception e) {
            System.out.println("表创建失败!!");
            e.printStackTrace();
        }
    }

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/567631.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Redis中的缓存击穿、缓存穿透、缓存雪崩问题

1.什么是缓存击穿&#xff1f; 客户端恶意访问一个不存在的数据&#xff0c;从而造成穿透缓存&#xff0c;请求直接到达数据库&#xff0c;频繁的发送这一类的请求&#xff0c;直接查询数据库&#xff0c;数据库的压力变大。 1.1如何解决缓存击穿呢&#xff1f; 1&#xff0…

基于harris角点和RANSAC算法的图像拼接matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程 1.算法运行效果图预览 2.算法运行软件版本 MATLAB2022a 3.部分核心程序 ....................................................................... I1_harris fu…

【MySQL]】数据库操作指南之数据库的基础操作

&#x1f331;博客主页&#xff1a;青竹雾色间 &#x1f331;系列专栏&#xff1a;MySQL探险日记 &#x1f618;博客制作不易欢迎各位&#x1f44d;点赞⭐收藏➕关注 ✨人生如寄&#xff0c;多忧何为 ✨ 文章目录 1. 创建数据库2.数据库的编码集与校验集2.1 编码集 (Character…

嵌入式Python基础1-2

嵌入式Python基础1-2 条件语句 if elif else 随机数random eval while循环 for循环 水仙花数 循环else list 列表常用方法 增删改查 加排序 append remove pop index() 升序sort(&#xff09;降序 sort(reverseTrue) 反转 reverse&#xff08;&#xff09;…

ESP32开发

1、简介 1.1 种类 WIFI模块在PC上做为客户端、服务器&#xff0c;在STM32上做服务器的通讯。在物联网应用开发有重要作用&#xff0c;种类居多&#xff0c;如下图 红色方框的esp8266-01s型号的无限wifi模块就是本章学习的主要对象。 1.2 特点 小巧的尺寸&#xff1a;ESP-01…

SpanBert学习

SpanBERT: Improving Pre-training by Representing and Predicting Spans 核心点 提出了更好的 Span Mask 方案&#xff0c;也再次展示了随机遮盖连续一段字要比随机遮盖掉分散字好&#xff1b;通过加入 Span Boundary Objective (SBO) 训练目标&#xff0c;增强了 BERT 的性…

python自动生成SQL语句自动化

&#x1f47d;发现宝藏 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。【点击进入巨牛的人工智能学习网站】。 Python自动生成SQL语句自动化 在数据处理和管理中&#xff0c;SQL&#xff08;Structured …

WAF防范原理

目录 一、什么是WAF 二、纵深安全防御 WAF的组网模式 WAF配置全景 WAF端 服务器 攻击端 拦截SQL注入&#xff0c;XSS攻击&#xff0c;木马文件上传 要求&#xff1a; 使用WAF&#xff0c;通过配置策略要求能防御常见的web漏洞攻击&#xff08;要求至少能够防御SQL、XSS、文…

毕业设计注意事项

1.开题 根据学院发的开题报告模板完成&#xff0c;其中大纲部分可参考资料 2.毕设 根据资料中的毕设评价标准&#xff0c;对照工作量 3.论文 3.1 格式问题 非常重要&#xff0c;认真对比资料中我发的模板&#xff0c;格式有问题&#xff0c;答辩输一半&#xff01; 以word…

wireshark RTP分析参数

主要看丢弃和Delta&#xff0c; 丢弃就是丢掉的udp包&#xff0c;所占的比率 Delta是当前udp包接收到的时间减去上一个udp包接收到的时间 根据载荷可以知道正确的delta应该是多少&#xff0c;比如G711A&#xff0c;ptime20&#xff0c;那么delta理论上应该趋近于20. 这里的de…

C++面向对象程序设计 - 运算符重载

函数重载就是对一个已有的函数赋予新的含义&#xff0c;使之实现新的功能。因此一个函数名就可以用来代表不同功能的函数&#xff0c;也就是一名多用。运算符也可以重载&#xff0c;即运算符重载&#xff08;operator overloading&#xff09;。 一、运算符重载的方法 运算符重…

# IDEA2019 如何打开 Run Dashboard 运行仪表面板

IDEA2019 如何打开 Run Dashboard 运行仪表面板 段子手168 1、依次点击 IDEA 上面工具栏 —> 【View】 视图。 —> 【Tool Windows】 工具。 —> 【Run Dashboard】 运行仪表面板。 2、如果 【Tool Windows 】工具包 没有 【Run Dashboard】 运行仪表面板 项 依次…

【好书推荐7】《机器学习平台架构实战》

【好书推荐7】《机器学习平台架构实战》 写在最前面《机器学习平台架构实战》编辑推荐内容简介作者简介目  录前  言本书读者内容介绍充分利用本书下载示例代码文件下载彩色图像本书约定 &#x1f308;你好呀&#xff01;我是 是Yu欸 &#x1f30c; 2024每日百字篆刻时光&…

STM32系统参数和结构

系列文章目录 STM32单片机系列专栏 C语言术语和结构总结专栏 文章目录 1. 基本参数 2. 片上资源&#xff08;外设&#xff09; 3. STM32系列命名规则 4. 系统结构 5. 引脚定义 6. 启动配置 7. 最小系统电路 8. 型号分类和缩写 1. 基本参数 STM32F103C8T6 系列&#…

达梦(DM)数据库表索引

达梦DM数据库表索引 表索引索引准则其他准则 创建索引显式地创建索引其他创建索引语句 使用索引重建索引删除索引 表索引 达梦数据库表索引相关内容比较多&#xff0c;常用的可能也就固定的一些&#xff0c;这里主要说一下常用的索引&#xff0c;从物理存储角度进行分类&#…

B008-方法参数传递可变参数工具类

目录 方法参数传递可变参数冒泡排序Arrays工具类Arrays工具类常用方法 方法参数传递 /*** java中只有值传递* 基本数据类型 传递的是具体的值* 引用数据类型 传递的是地址值*/ public class _01_ParamPass {public static void main(String[] args) {// 调用方法 getSumge…

网络变压器在网络分析仪上能通过测试,装上设备后网速达不到呢?

Hqst华轩盛(石门盈盛)电子导读&#xff1a;今天和大家一起探讨网络变压器在网络分析仪上能通过测试&#xff0c;装上设备后网通设备网速达不到的可能原因及其处理方式 一、出现这种情况可能有以下原因&#xff1a; 1.1. 设备兼容性问题&#xff1a;设备其它元器件与 网络…

Docker容器化技术:概述与安装

目录 一、云基础知识 1、常见的云服务厂商 2、云计算服务模式三种层次 3、什么是虚拟化 4、什么是虚拟机 5、虚拟化产品 5.1 仿真虚拟化产品 5.2 半虚拟化产品 5.3 全虚拟化产品 6、虚拟机架构 6.1 寄居架构 6.2 源生架构 二、认识容器 1、容器的概述 2、容器的…

【Netty】ByteBuf与拆包粘包

ByteBuf 在介绍ByteBuf之前先来一套基础的代码来演示ByteBuf的使用。 package blossom.project.netty;import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled;import java.nio.charset.StandardCharsets;/*** author: ZhangBlossom* date: 2023/12/14 13:37* con…

web学习

day02-01 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>js快速引入</title> <!-- 内部脚本--> <!-- <script>--> <!-- alert(Hello JS)--> <!-- <…