Guava翻译之Small Function

  1. 云栖社区>
  2. 博客>
  3. 正文

Guava翻译之Small Function

normanli 2017-02-27 17:35:40 浏览1940
展开阅读全文

Guava 的一些小功能点

我们已经到了书的最后一章,但是任然感觉还有很多东西没有覆盖到。虽然在这么短的篇幅里我们不可能覆盖到guava的多有功能,但是我们已经尽力了。 这一章我们将介绍一些没有必要单独一章介绍的一些小的工具类,虽然他们不是天天不用到,但是一旦用到,你就会发现真的非常方便. 这一章我们将学习一下的几个知识点:

  1. Hashing 类: 通过Hashing类的静态工具方法我们可以获取HashFunction 实例
  2. 布隆过滤: Bloom 过滤这样的数据结构,可以明确返回一个数据不存在,但是不能确保一个元素肯定存在.当存在Hash碰撞时有可能误判。
  3. Optional类: Optional 类可以让我们选择使用 null 的引用
  4. Throwables类: Throwables 类中有静态工具方法可以与Throwable协作

创建合适的Hash函数

Hash函数是确定对象身份标识和确定是否重复的基础,同时它也是合理使用java结合的必备条件。 Hash函数的基本工作方式: 将对象数据映射为数字。 因此我们希望避免将不同的数据生成相同的数字,毋庸置疑,写一个优秀的Hash函数的工作就留给那些专家吧, 但是幸运的是,在Guava的帮助下我们不需要自己去写Hash函数, Hashing类提供了一些静态方法可以创建HashFunction的实例。

校验总和哈希函数

Guava 提供了两种实现了checksum算法的HashFunction,分别是Adler-32 和 CRC-32,创建这两个HashFunction 可以按照如下的方法:

HashFunction adler32 = Hashing.adler32();
HashFunction crc32 = Hashing.crc32();

这里我们可以简单的使用Hashing函数的静态方法去获取想要的实例.

一般哈希函数

下面我们将看一下一般的hash函数,一般的hash函数是不带加密语义,非常适合基于Hash的查找类任务。 第一个要介绍的就是 murmur Hash,这是一个在2008年由Austin发现的。 其他的一般性hash算法叫做GooFastHash。 下面让我们看下怎样创建这些一般性Hash函数:

HashFunction gfh = Hashing.goodFastHash(128);
HashFunction murmur3_32 = Hashing.murmur3_32();
HashFunction murmur3_128 = Hashing.murmur3_128();

上面的例子中我们使用GoodFastHash算法返回一个最小包含128长度bit位,一个字节包含8个bit位,因此调用GoodFastHash至少返回16个字节(128/8).接下来我们创建了两个murmur实例的Hash. 第一个是实现了32-bit的murmur3_32算法,第二个murmur Hash实例实现了128bit murmur3_128算法。

密码哈希函数

虽然完整的讨论密码哈希函数超出了本书的返回,但是简单的说密码哈希函数就是为了保证数据的安全。 一般来说,密码哈希函数有一些如下的属性:
-- 一点小的数据改变,就会导致HashCode发生很大的变化
-- 在理论上,通过hash code 反推出原始数据是什么是不可能的。

下面Guava提供了创建密码哈希函数的变体:

HashFunction sha1 = Hashing.sha1();
HashFunction sha256 = Hashing.sha256();
HashFunction sha512 = Hashing.sha512();

上面的三种Hash算法实现了sha1,sha256,sha512三种加密算法。

Bloom Filter

Bloom 过滤器是一个独特的数据结构,它可以用来确定一个元素是否存在于一个set中, 但是让Bloom过滤更有意思的是,它能准确的判断一个元素不存在,但是不能准确的判断出一个元素存在于set中。这样的特性可以用在比较耗时的数据查找中.

BloomFilter 简述

BloomFilter实际是一个bit的集合,按照以下方式工作:

  1. 增加一个元素到filter中。
  2. 将这个元素进行多次Hash,将的到的hash值的bit位设置为1。

当判断一个元素是否存在在set中时,按照同样的方法进行多次hash,如果对应的位上有一个不为1,那么就可以说明这个元素在set中不存在,但是即使每个元素位都是为1,也不能表明这个元素就存在,因为可能会发生Hash碰撞。

Funnels and PrimitiveSinks

Funnels 接口接受一个对象,并将对象数据发送给PrimitveSink接口, PrimitiveSink对象接受原始类型的数据,PrimitiveSink接口抽取参加Hash的数据,下面我们看一下具体的例子:

public enum BookFunnel implements Funnel<Book> {
//This is the single enum value
FUNNEL;
public void funnel(Book from, PrimitiveSink into) {
into.putBytes(from.getIsbn().getBytes(Charsets.UTF_8))
.putDouble(from.getPrice());
}
}

上面的例子中我们创建一个Funnel实例接受一个Book的实例。 注意我们这里通过枚举实现Funnel接口, ISBN和Price被放入到PrimitiveSink实例作为Hash函数的入参。

创建 BloomFilter 实例

上面我们学了怎样去创建一个Funnel实例,现在我们可以去创建BloomFilter实例:

BloomFilter<Book> bloomFilter = BloomFilter.create(new
BookFunnel(), 5);

上面这个例子中,我们通过调用BloomFilter的静态create方法传入一个Funnel实例和一个整数,这个整数其实就是使用的Hash函数个数,比如上面的5,我们其实是使用5个hash函数生成5个对应的Hashcode值。将这5个对应的hashcode值对应的bit位修改为1. 接下来我们来看一个具体的例子:

public class BloomFilterExample {
public static void main(String[] args) throws Exception {
File booksPipeDelimited = new
File("src/main/resources/books.data");
List<Book> books = Files.readLines(booksPipeDelimited,
Charsets.UTF_8, new LineProcessor<List<Book>>() {
Splitter splitter = Splitter.on('|');
List<Book> books = Lists.newArrayList();
Book.Builder builder = new Book.Builder();
public boolean processLine(String line) throws
IOException {
List<String> parts =
Lists.newArrayList(splitter.split(line));
builder.author(parts.get(0))
.title(parts.get(1))
.publisher(parts.get(2))
.isbn(parts.get(3))
.price(Double.parseDouble(parts.get(4)));
books.add(builder.build());
return true;
}
@Override
public List<Book> getResult() {
return books;
}
});
BloomFilter<Book> bloomFilter = BloomFilter.create(new
BookFunnel(), 5);
for (Book book : books) {
bloomFilter.put(book);
}
Book newBook = new Book.Builder().title("Mountain
Climbing").build();
Book book1 = books.get(0);
System.out.println("book "+book1.getTitle()+" contained
"+bloomFilter.mightContain(book1));
System.out.println("book "+newBook.getTitle()+" contained
"+bloomFilter.mightContain(newBook));
}

下面是执行结果:
Book [Being A Great Cook] contained true
Book [Mountain Climbing] contained false

上面的例子比较简单,就不多做介绍了。

虽然我们不会经常用到BloomFilter,但是我们还是应该将它放到我们常用java工具库中。

Optional

null objects是比较棘手的一个问题,有很大一部分问题,都是由于我们认为一个方法返回的值可能不是null,但是我们经常惊讶的发现她居然是是null,为了解决这个问题,Guava中有这样的一个类,叫Optional, Optional是一个不可变对象,可能会包含一个对象引用,也可能不包含对象引用, 一个好的使用Optional类的方式是让方法的返回值为Optional,通过这种方式,我们可以强制调用方认为方法的返回值可能是不存在的。必须采取措施防止这种情况。

创建 Optioanal实例

Optional类是一个抽象类,我们可以直接继承,也有一些静态方法我们可以使用去创建Optional实例。

  1. Optional.absent()返回一个空的Optional实例
  2. Optional.of(T ref) 返回一个包含Type ref的Optioanal实例
  3. OPtioanal.fromNullable(T ref) 如果 ref不为null,那么返回一个包含 Type t的Optional实例,否则返回一个空的Optional实例

让我们来看一些简单的例子:

@Test
public void testOptionalOfInstance(){
TradeAccount tradeAccount = new
TradeAccount.Builder().build();
Optional<TradeAccount> tradeAccountOptional =
Optional.of(tradeAccount);
assertThat(tradeAccountOptional.isPresent(),is(true));
}

在这个例子中,我们使用Optional.of方法,返回一个包含给定对象的Optional实例,我们通过调用isPresent方法来确认包含的对象是否存在。
更有趣的Optional.fromNullable例子如下:

@Test(expected = IllegalStateException.class)
public void testOptionalNull(){
Optional<TradeAccount> tradeAccountOptional =
Optional.fromNullable(null);
assertThat(tradeAccountOptional.isPresent(),is(false));
tradeAccountOptional.get();
}

在上面的单元测试的例子中,我们使用Optional.fromNullable()静态方法,这个例子中,我们也返回了一个Optional实例,这次我们调用isPresent方法,期望得到的结果为false,调用get方法会抛出IllegalStateException.
总的来说,使用Optional类似的我们必须处理Null值的情况

Throwables

Throwables类包含了很多静态方法区处理在java中必然会遇到的 java.lang.Throwable,Errors和Exceptions错误。有的时候有这样的一个工具类去处理异常堆栈是什么方便的。 而Throwables类刚好提供了这样的工具。 下面我们将去看下面两个比较特别的方法:

获取异常链

Throwables.getCausalChain 方法返回一个Throwable对象集合。从堆栈的最顶层依次到最底层,下面是一个比较好的例子:

@Test
public void testGetCausalChain() {
ExecutorService executor =
Executors.newSingleThreadExecutor();
List<Throwable> throwables = null;
Callable<FileInputStream> fileCallable = new
Callable<FileInputStream>() {
@Override
public FileInputStream call() throws Exception {
return new FileInputStream("Bogus file");
}
};
Future<FileInputStream> fisFuture =
executor.submit(fileCallable);
try {
fisFuture.get();
} catch (Exception e) {
throwables = Throwables.getCausalChain(e);
}
assertThat(throwables.get(0).getClass().
isAssignableFrom(Execution
Exception.class),is(true));
assertThat(throwables.get(1).getClass().
isAssignableFrom(FileNotFo
undException.class),is(true));
executor.shutdownNow();
}

上面的这个例子中,我们创建了一个Callable实例期望返回一个FileInputStream对象,但是我们故意写了一个文件不存在的地址,这样就会出现FileNotFoundException。 当我们调用get方法时,出现了异常,我们调用Throwables.getCausalChain方法获取具体的异常,首先第一个是ExecutionException,第二个是FileNotFoundException.类似这样我们就得到所有的异常类型,这样我们就可以处理感兴趣的异常。

获取根异常

Throwables.getRootCause方法接受一个Throwable实例,返回异常对象的Root Cause. 下面是具体的例子:

@Test
public void testGetRootCause() throws Exception {
ExecutorService executor =
Executors.newSingleThreadExecutor();
Throwable cause = null;
final String nullString = null;
Callable<String> stringCallable = new Callable<String>() {
@Override
public String call() throws Exception {
return nullString.substring(0,2);
}
};
Future<String> stringFuture=
executor.submit(stringCallable);
try {
stringFuture.get();
} catch (Exception e) {
cause = Throwables.getRootCause(e);
}
assertThat(cause.getClass().isAssignableFrom(NullPointerExcep
tion.
class),is(true));
executor.shutdownNow();
}

上面的这个例子中我们通过getRootCause() 获取到了根异常

总结

在这一章中我们覆盖到了一些非常有用的类,虽然它们不是经常的使用到,但是一旦需要,就会感觉非常的方便,首先我们学了Hash函数,和Hashing类提供的一个有用的工具, 接着我们学习了利用Hash函数构造的一个比较好用的数据结构BloomFilter. 我们还学习了Optional类,使用这样的类可以使我们的代码更加强壮,避免出现Null值引起的异常,最后我们学习了Throwables类,Throwables类包含了一些有用的静态方法,可以方便的处理代码抛出的异常。

网友评论

登录后评论
0/500
评论
normanli
+ 关注