- 浏览: 2467413 次
- 性别:
- 来自: 杭州
文章分类
- 全部博客 (574)
- Book (62)
- Architecture (6)
- Java (39)
- Taobao (41)
- Distributed (4)
- Life (72)
- Database (7)
- Spring (16)
- Photography (15)
- Bicycle (41)
- Test (20)
- jBPM (8)
- Business (12)
- Movie (3)
- Ajax (15)
- Code (7)
- Eclipse (96)
- VIM (2)
- Music (6)
- Groovy (10)
- AutoHotKey (3)
- Dorado (10)
- Maven (7)
- Scrum (5)
- English (20)
- Financial (12)
- OSGi (3)
- Other (4)
- Tool (6)
- Browser (1)
- PPT (1)
- Project Management (4)
- Agile (6)
- Nosql (1)
- Search engine (6)
- Shell (2)
- Open Source (4)
- Storm (10)
- Guava (3)
- Baby (1)
- netty (1)
- Algorithm (1)
- Linux (1)
- Python (2)
最新评论
-
roy2011a:
https://github.com/ebottabi/sto ...
storm的序列化问题及与spring的结合方式 -
roy2011a:
能抗能打 写道哥们儿,你好!能共享下那个storm与sprin ...
storm的序列化问题及与spring的结合方式 -
Alick1:
兄弟,你之前是不是在深圳的正阳公司呆过啊?
storm的ack和fail -
liuleixwd:
先点个赞,写的非常好!有个问题请教下,如果我再bolt里不用e ...
storm的ack和fail -
yao-dd:
solr的facet查询
参考:
http://codemunchies.com/2009/10/beautiful-code-with-google-collections-guava-and-static-imports-part-1/ (2,3,4)
http://blog.publicobject.com
更多用法参考http://ajoo.iteye.com/category/119082
以前这么用:
现在这么用(JDK7将实现该功能):
针对不可变集合:
以前这么用:
现在Guava这么用:
文本文件读取现在Guava这么用
基本类型比较, 现在Guava这么用:
Guava中CharMatcher的用法:
Guava中Joiner的用法:
另一种写法:
Guava中Splitter的用法:
对于这样的字符串进行切分:
Ints中一些用法:
集合
set的交集, 并集, 差集的用法(http://publicobject.com/2008/08/coding-in-small-with-google-collections.html)
针对Map的用法:
验证与条件检查
原来的写法:
Guava的写法(Jakarta Commons中有类似的方法):
一个更酷的用法:
如果一个key对应多个value的Map, 你会怎么处理? 如果还在使用Map<K, List<V>>的话, 你就out了
使用MultiMap吧:
Multimap的另一个使用场景:
比如有一个文章数据的map:
如果要按照type分组生成一个List
针对集合中只有一个元素的情况:
Iterables.getOnlyElement();
这个主要是用来替换Set.iterator.next()或 List.get(0), 而且在测试中使用非常方便, 如果出现0个或者2+则直接抛出异常
比较的最大最小值:
Comparators.max
Comparators.min
equals和hashcode的用法:
ImmutableList.copyOf的用法:
以前这么用:
现在这么用:
Iterables.concat()的用法:
以前这么用:
现在这么用:
Constraints.constrainedList: 给List操作注入约束逻辑, 比如添加不合法元素直接报错.
以前这么写:
不允许插入空值的Set(Constraints的用法):
Multimap的用法(允许多值的map):
以前这么写:
现在这么写:
以前这么写:
现在这么写(需要将map转换成multimap):
Joiner的用法:
以前这样写:
现在这样写:
Comparators.fromFunction的用法:
以前这样写:
现在这样写(感觉也没省多少):
BiMap(双向map)的用法:
以前的用法:
现在的用法:
换一种写法:
关于Strings的一些用法(http://blog.ralscha.ch/?p=888):
Throwables的用法(将检查异常转换成未检查异常):
Multimap用法整理(http://jnb.ociweb.com/jnb/jnbApr2008.html):
用来统计多值出现的频率:
输出结果:
Functions(闭包功能)
不过这种转换是在访问元素的时候才进行, 下面的例子可以说明:
http://codemunchies.com/2009/10/beautiful-code-with-google-collections-guava-and-static-imports-part-1/ (2,3,4)
http://blog.publicobject.com
更多用法参考http://ajoo.iteye.com/category/119082
以前这么用:
Map<String, Map<Long, List<String>>> map = new HashMap<String, Map<Long,List<String>>>();
现在这么用(JDK7将实现该功能):
Map<String, Map<Long, List<String>>> map = Maps.newHashMap();
针对不可变集合:
以前这么用:
List<String> list = new ArrayList<String>(); list.add("a"); list.add("b"); list.add("c"); list.add("d");
现在Guava这么用:
ImmutableList<String> of = ImmutableList.of("a", "b", "c", "d"); ImmutableMap<String,String> map = ImmutableMap.of("key1", "value1", "key2", "value2");
文本文件读取现在Guava这么用
File file = new File(getClass().getResource("/test.txt").getFile()); List<String> lines = null; try { lines = Files.readLines(file, Charsets.UTF_8); } catch (IOException e) { e.printStackTrace(); }
基本类型比较, 现在Guava这么用:
int compare = Ints.compare(a, b);
Guava中CharMatcher的用法:
assertEquals("89983", CharMatcher.DIGIT.retainFrom("some text 89983 and more")) assertEquals("some text and more", CharMatcher.DIGIT.removeFrom("some text 89983 and more"))
Guava中Joiner的用法:
int[] numbers = { 1, 2, 3, 4, 5 }; String numbersAsString = Joiner.on(";").join(Ints.asList(numbers));
另一种写法:
String numbersAsStringDirectly = Ints.join(";", numbers);
Guava中Splitter的用法:
Iterable split = Splitter.on(",").split(numbsAsString);
对于这样的字符串进行切分:
String testString = "foo , what,,,more,"; Iterable<String> split = Splitter.on(",").omitEmptyStrings().trimResults().split(testString);
Ints中一些用法:
int[] array = { 1, 2, 3, 4, 5 }; int a = 4; boolean contains = Ints.contains(array, a); int indexOf = Ints.indexOf(array, a); int max = Ints.max(array); int min = Ints.min(array); int[] concat = Ints.concat(array, array2);
集合
set的交集, 并集, 差集的用法(http://publicobject.com/2008/08/coding-in-small-with-google-collections.html)
HashSet setA = newHashSet(1, 2, 3, 4, 5); HashSet setB = newHashSet(4, 5, 6, 7, 8); SetView union = Sets.union(setA, setB); System.out.println("union:"); for (Integer integer : union) System.out.println(integer); SetView difference = Sets.difference(setA, setB); System.out.println("difference:"); for (Integer integer : difference) System.out.println(integer); SetView intersection = Sets.intersection(setA, setB); System.out.println("intersection:"); for (Integer integer : intersection) System.out.println(integer);
针对Map的用法:
MapDifference differenceMap = Maps.difference(mapA, mapB); differenceMap.areEqual(); Map entriesDiffering = differenceMap.entriesDiffering(); Map entriesOnlyOnLeft = differenceMap.entriesOnlyOnLeft(); Map entriesOnlyOnRight = differenceMap.entriesOnlyOnRight(); Map entriesInCommon = differenceMap.entriesInCommon();
验证与条件检查
原来的写法:
if (count <= 0) { throw new IllegalArgumentException("must be positive: " + count); }
Guava的写法(Jakarta Commons中有类似的方法):
Preconditions.checkArgument(count > 0, "must be positive: %s", count);
一个更酷的用法:
public PostExample(final String title, final Date date, final String author) { this.title = checkNotNull(title); this.date = checkNotNull(date); this.author = checkNotNull(author); }
如果一个key对应多个value的Map, 你会怎么处理? 如果还在使用Map<K, List<V>>的话, 你就out了
使用MultiMap吧:
Multimap<Person, BlogPost> multimap = ArrayListMultimap.create();
Multimap的另一个使用场景:
比如有一个文章数据的map:
List<Map<String, String>> listOfMaps = mapOf("type", "blog", "id", "292", "author", "john");
如果要按照type分组生成一个List
Multimap<String, Map<String, String>> partitionedMap = Multimaps.index( listOfMaps, new Function<Map<String, String>, String>() { public String apply(final Map<String, String> from) { return from.get("type"); } });
针对集合中只有一个元素的情况:
Iterables.getOnlyElement();
这个主要是用来替换Set.iterator.next()或 List.get(0), 而且在测试中使用非常方便, 如果出现0个或者2+则直接抛出异常
比较的最大最小值:
Comparators.max
Comparators.min
equals和hashcode的用法:
public boolean equals(Object o) { if (o instanceof Order) { Order that = (Order)o; return Objects.equal(address, that.address) && Objects.equal(targetArrivalDate, that.targetArrivalDate) && Objects.equal(lineItems, that.lineItems); } else { return false; } } public int hashCode() { return Objects.hashCode(address, targetArrivalDate, lineItems); }
ImmutableList.copyOf的用法:
以前这么用:
public Directions(Address from, Address to, List<Step> steps) { this.from = from; this.to = to; this.steps = Collections.unmodifiableList(new ArrayList<Step>(steps)); }
现在这么用:
public Directions(Address from, Address to, List<Step> steps) { this.from = from; this.to = to; this.steps = ImmutableList.of(steps); }
Iterables.concat()的用法:
以前这么用:
public boolean orderContains(Product product) { List<LineItem> allLineItems = new ArrayList<LineItem>(); allLineItems.addAll(getPurchasedItems()); allLineItems.addAll(getFreeItems()); for (LineItem lineItem : allLineItems) { if (lineItem.getProduct() == product) { return true; } } return false; }
现在这么用:
public boolean orderContains(Product product) { for (LineItem lineItem : Iterables.concat(getPurchasedItems(), getFreeItems())) { if (lineItem.getProduct() == product) { return true; } } return false; }
Constraints.constrainedList: 给List操作注入约束逻辑, 比如添加不合法元素直接报错.
以前这么写:
private final List<LineItem> purchases = new ArrayList<LineItem>(); /** * Don't modify this! Instead, call {@link #addPurchase(LineItem)} to add * new purchases to this order. */ public List<LineItem> getPurchases() { return Collections.unmodifiableList(purchases); } public void addPurchase(LineItem purchase) { Preconditions.checkState(catalog.isOffered(getAddress(), purchase.getProduct())); Preconditions.checkState(purchase.getCharge().getUnits() > 0); purchases.add(purchase); } 现在这么写: private final List<LineItem> purchases = Constraints.constrainedList( new ArrayList<LineItem>(), new Constraint<LineItem>() { public void checkElement(LineItem element) { Preconditions.checkState(catalog.isOffered(getAddress(), element.getProduct())); Preconditions.checkState(element.getCharge().getUnits() > 0); } }); /** * Returns the modifiable list of purchases in this order. */ public List<LineItem> getPurchases() { return purchases; }
不允许插入空值的Set(Constraints的用法):
Set<String> set = Sets.newHashSet(); Set<String> constrainedSet = Constraints.constrainedSet(set, Constraints.notNull()); constrainedSet.add("A"); constrainedSet.add(null); // NullPointerException here
Multimap的用法(允许多值的map):
以前这么写:
Map<Salesperson, List<Sale>> map = new Hashmap<SalesPerson, List<Sale>>(); public void makeSale(Salesperson salesPerson, Sale sale) { List<Sale> sales = map.get(salesPerson); if (sales == null) { sales = new ArrayList<Sale>(); map.put(salesPerson, sales); } sales.add(sale); }
现在这么写:
Multimap<Salesperson, Sale> multimap = new ArrayListMultimap<Salesperson,Sale>(); public void makeSale(Salesperson salesPerson, Sale sale) { multimap.put(salesperson, sale); }
以前这么写:
public Sale getBiggestSale() { Sale biggestSale = null; for (List<Sale> sales : map.values()) { Sale biggestSaleForSalesman = Collections.max(sales, SALE_COST_COMPARATOR); if (biggestSale == null || biggestSaleForSalesman.getCharge() > biggestSale().getCharge()) { biggestSale = biggestSaleForSalesman; } } return biggestSale; }
现在这么写(需要将map转换成multimap):
public Sale getBiggestSale() { return Collections.max(multimap.values(), SALE_COST_COMPARATOR); }
Joiner的用法:
以前这样写:
public class ShoppingList { private List<Item> items = ...; ... public String toString() { StringBuilder stringBuilder = new StringBuilder(); for (Iterator<Item> s = items.iterator(); s.hasNext(); ) { stringBuilder.append(s.next()); if (s.hasNext()) { stringBuilder.append(" and "); } } return stringBuilder.toString(); } }
现在这样写:
public class ShoppingList { private List<Item> items = ...; ... public String toString() { return Join.join(" and ", items); } }
Comparators.fromFunction的用法:
以前这样写:
public Comparator<Product> createRetailPriceComparator( final CurrencyConverter currencyConverter) { return new Comparator<Product>() { public int compare(Product a, Product b) { return getRetailPriceInUsd(a).compareTo(getRetailPriceInUsd(b)); } public Money getRetailPriceInUsd(Product product) { Money retailPrice = product.getRetailPrice(); return retailPrice.getCurrency() == CurrencyCode.USD ? retailPrice : currencyConverter.convert(retailPrice, CurrencyCode.USD); } }; }
现在这样写(感觉也没省多少):
public Comparator<Product> createRetailPriceComparator( final CurrencyConverter currencyConverter) { return Comparators.fromFunction(new Function<Product,Money>() { /** returns the retail price in USD */ public Money apply(Product product) { Money retailPrice = product.getRetailPrice(); return retailPrice.getCurrency() == CurrencyCode.USD ? retailPrice : currencyConverter.convert(retailPrice, CurrencyCode.USD); } }); }
BiMap(双向map)的用法:
以前的用法:
private static final Map<Integer, String> NUMBER_TO_NAME; private static final Map<String, Integer> NAME_TO_NUMBER; static { NUMBER_TO_NAME = Maps.newHashMap(); NUMBER_TO_NAME.put(1, "Hydrogen"); NUMBER_TO_NAME.put(2, "Helium"); NUMBER_TO_NAME.put(3, "Lithium"); /* reverse the map programatically so the actual mapping is not repeated */ NAME_TO_NUMBER = Maps.newHashMap(); for (Integer number : NUMBER_TO_NAME.keySet()) { NAME_TO_NUMBER.put(NUMBER_TO_NAME.get(number), number); } } public static int getElementNumber(String elementName) { return NUMBER_TO_NAME.get(elementName); } public static string getElementName(int elementNumber) { return NAME_TO_NUMBER.get(elementNumber); }
现在的用法:
private static final BiMap<Integer,String> NUMBER_TO_NAME_BIMAP; static { NUMBER_TO_NAME_BIMAP = Maps.newHashBiMap(); NUMBER_TO_NAME_BIMAP.put(1, "Hydrogen"); NUMBER_TO_NAME_BIMAP.put(2, "Helium"); NUMBER_TO_NAME_BIMAP.put(3, "Lithium"); } public static int getElementNumber(String elementName) { return NUMBER_TO_NAME_BIMAP.inverse().get(elementName); } public static string getElementName(int elementNumber) { return NUMBER_TO_NAME_BIMAP.get(elementNumber); }
换一种写法:
private static final BiMap<Integer,String> NUMBER_TO_NAME_BIMAP = new ImmutableBiMapBuilder<Integer,String>() .put(1, "Hydrogen") .put(2, "Helium") .put(3, "Lithium") .getBiMap();
关于Strings的一些用法(http://blog.ralscha.ch/?p=888):
assertEquals("test", Strings.emptyToNull("test")); assertEquals(" ", Strings.emptyToNull(" ")); assertNull(Strings.emptyToNull("")); assertNull(Strings.emptyToNull(null)); assertFalse(Strings.isNullOrEmpty("test")); assertFalse(Strings.isNullOrEmpty(" ")); assertTrue(Strings.isNullOrEmpty("")); assertTrue(Strings.isNullOrEmpty(null)); assertEquals("test", Strings.nullToEmpty("test")); assertEquals(" ", Strings.nullToEmpty(" ")); assertEquals("", Strings.nullToEmpty("")); assertEquals("", Strings.nullToEmpty(null)); assertEquals("Ralph_____", Strings.padEnd("Ralph", 10, '_')); assertEquals("Bob_______", Strings.padEnd("Bob", 10, '_')); assertEquals("_____Ralph", Strings.padStart("Ralph", 10, '_')); assertEquals("_______Bob", Strings.padStart("Bob", 10, '_')); assertEquals("xyxyxyxyxy", Strings.repeat("xy", 5));
Throwables的用法(将检查异常转换成未检查异常):
package com.ociweb.jnb.apr2010; import com.google.common.base.Throwables; import java.io.InputStream; import java.net.URL; public class ExerciseThrowables { public static void main(String[] args) { try { URL url = new URL("http://ociweb.com"); final InputStream in = url.openStream(); // read from the input stream in.close(); } catch (Throwable t) { throw Throwables.propagate(t); } } }
Multimap用法整理(http://jnb.ociweb.com/jnb/jnbApr2008.html):
用来统计多值出现的频率:
Multimap<Integer, String> siblings = Multimaps.newHashMultimap(); siblings.put(0, "Kenneth"); siblings.put(1, "Joe"); siblings.put(2, "John"); siblings.put(3, "Jerry"); siblings.put(3, "Jay"); siblings.put(5, "Janet"); for (int i = 0; i < 6; i++) { int freq = siblings.get(i).size(); System.out.printf("%d siblings frequency %d\n", i, freq); }
输出结果:
引用
0 siblings frequency 1
1 siblings frequency 1
2 siblings frequency 1
3 siblings frequency 2
4 siblings frequency 0
5 siblings frequency 1
1 siblings frequency 1
2 siblings frequency 1
3 siblings frequency 2
4 siblings frequency 0
5 siblings frequency 1
Functions(闭包功能)
Function<String, Integer> strlen = new Function<String, Integer>() { public Integer apply(String from) { Preconditions.checkNotNull(from); return from.length(); } }; List<String> from = Lists.newArrayList("abc", "defg", "hijkl"); List<Integer> to = Lists.transform(from, strlen); for (int i = 0; i < from.size(); i++) { System.out.printf("%s has length %d\n", from.get(i), to.get(i)); } }
不过这种转换是在访问元素的时候才进行, 下面的例子可以说明:
Function<String, Boolean> isPalindrome = new Function<String, Boolean>() { public Boolean apply(String from) { Preconditions.checkNotNull(from); return new StringBuilder(from).reverse().toString().equals(from); } }; List<String> from = Lists.newArrayList("rotor", "radar", "hannah", "level", "botox"); List<Boolean> to = Lists.transform(from, isPalindrome); for (int i = 0; i < from.size(); i++) { System.out.printf("%s is%sa palindrome\n", from.get(i), to.get(i) ? " " : " NOT "); } // changes in the "from" list are reflected in the "to" list System.out.printf("\nnow replace hannah with megan...\n\n"); from.set(2, "megan"); for (int i = 0; i < from.size(); i++) { System.out.printf("%s is%sa palindrome\n", from.get(i), to.get(i) ? " " : " NOT "); } }
评论
9 楼
guwan
2016-04-29
现在这么用(JDK7将实现该功能):
这个说法是错误的,JDK7和8并没有实现。
这个说法是错误的,JDK7和8并没有实现。
8 楼
glamey
2015-08-27
其实比较推荐guava里边关于Listen Future,这个挺好使的。
7 楼
xiangping
2014-09-10
不少错误,垃圾
6 楼
zhglhy
2014-07-17
很多新的用法
5 楼
focus2008
2014-05-01
学习了。。。
4 楼
peak
2013-12-13
感觉最有用的是创建对象,Multimap,Joiner了,其他的很多习惯用commons的包
3 楼
heyonga
2013-10-16
内容不少,不错,值得收藏
2 楼
s21109
2012-06-15
很详细 感谢哟
1 楼
kinsou
2011-08-12
这帖子我喜欢!
相关推荐
12. **Java库与框架**:可能包含使用Apache Commons、Google Guava等常用库,以及Spring、Hibernate等框架的示例,帮助开发者更好地理解和应用这些工具。 13. **异常处理**:Java异常处理是程序错误处理的关键,...
2. Guava:Google推出的高效库,包含集合、缓存、并发、I/O等多方面工具,尤其在处理并发和数据结构方面有显著优势。 3. Lombok:一个可以通过注解自动为类生成getter、setter、构造函数等元数据的库,减少了样板...
Java常用工具类整理 本文将详细介绍 Spring 及 Guava 相关工具类的使用说明和代码 demo。这些工具类都是 Java 开发中常用的实用工具,可以帮助开发者快速高效地完成各种任务。 一、Spring 工具类 1. org.spring...
OTTO是Google Guava团队开发的一个轻量级事件总线框架,它主要用于Android应用程序中的组件解耦。在“OTTO官方demo整理工程”中,我们可以深入理解如何在实际项目中运用OTTO框架来提高代码的可维护性和灵活性。 ...
11. **Guava**: Guava 是Google提供的一个Java库,包含了大量的系统级别的实用工具类,如集合、并发、缓存、I/O等。 12. **JUnit.jupiter**: 这是JUnit 5的新测试引擎,提供了更现代的测试API和更灵活的测试配置。 ...
此外,可能还包括Spring Framework、Hibernate ORM等框架的官方文档,以及Apache Commons、Guava等常用库的API。 2. **在线编译器与运行平台**:例如CodePen、Repl.it或Jsfiddle,这些平台可以让开发者在浏览器中...
13. **Java API和库**:介绍常用API,如Math、Date、Calendar,以及第三方库如Apache Commons或Google Guava的使用。 14. **设计模式**:可能涵盖了单例、工厂、观察者、装饰器等常见设计模式的概念和应用场景。 ...
- **Guava**:Google提供的Java库,包含大量常用的工具类和数据结构。 9. **面试准备** - **集合框架**:深入理解集合类的特性,如ArrayList与LinkedList的性能差异,以及在多线程环境下的选择。 - **IO框架**:...
9. **Google Guava**:guava.jar,提供了许多Java核心库的高级功能,如集合操作、并发工具、I/O操作等。 10. **Jackson或Gson**:如jackson-databind.jar,用于JSON对象与Java对象之间的相互转换。 以上只是列举了...
2. Guava:Google的工具库,包含丰富的数据结构、并发工具、缓存机制等。 以上只是Java编程的一部分知识点,实际开发中还需要理解设计模式、数据库操作、框架应用、测试技巧等多个方面。不断学习和实践,才能真正...
例如,`log4j.jar`用于日志记录,`slf4j-api.jar`和相应的实现库用于更高级的日志抽象,`commons-lang3.jar`提供了很多实用的工具类,`guava.jar`是Google提供的大量常用工具类库。 在实际开发中,根据项目需求,...
- **Glide**:Google推荐的图片加载库,特别适合于处理大量的图片加载,支持多种资源格式和高效的内存管理。 3. **图片处理** - **Picasso-transformations**:为Picasso提供了一系列的图片变换效果,如圆形、...
- **Google Guava**:`com.google.common.io.BaseEncoding.base64()` - **net.iharder.Base64** - **MigBase64**:据称是编码速度最快的实现 为了评估不同实现的性能,可以通过编写性能测试代码,对比它们在大量...