版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_21122243/article/details/77098034
只读设置
- Test01_ReadOnly.java
package guava.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.google.common.collect.ImmutableList;
/**
* 只读设置
* 1.原始(重新包装):将需要设置为只读的容器用Collections.unmodifiable_xxx()包装成一个新的容器;
* 2.现在(直接创建):直接用Immutable_xxx.of(元素...)创建一个新的容器
*/
public class Test01_ReadOnly {
public static void main(String[] args) {
List<String> list =new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
//对原有的list进行包装,相等于原有List的一个视图,快照,不够安全
List<String> readList =Collections.unmodifiableList(list);
readList.add("d");//java.lang.UnsupportedOperationException
list.add("d"); //改变原有List;视图也一起改变
//对比 查看 初始化List guava对只读设置 安全可靠,并且相对简单
List<String> immutableList =ImmutableList.of("a", "b", "c");
immutableList.add("d");//java.lang.UnsupportedOperationException
}
}
函数式编程(过滤|转换|组合式编程)
- Test02_Function.java
package guava.collection;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
/**
* 函数式编程 :解耦
* 1.Predicate
Predicate<T> pre=new Predicate<T>() {
@Override
public boolean apply(T input) {
return false;
}
};
* 2.Function
* Function<F, T> fun=new Function<F, T>() {
@Override
public T apply(F input) {
return null;
}
};
*
* 工具:
* Collections2.filter(容器,Predicate) 过滤器
* Collections2.transfer(容器,Function) 转换
* Function newf=Functions.compose(f1,f2...)组合式函数编程
*/
public class Test02_Function {
public static void main(String[] args) {
test1();//过滤器
test2();//转换
test3();//组合式函数编程
}
/**过滤器*/
public static void test1(){
//创建List;静态初始化
List<String> list =Lists.newArrayList("moom","son","dad","bjsxt","refer");
//找出回文 palindrome; backwords; mirror words
//匿名内部类对象: 匿名内部类,同时创建类对象
Collection<String> palindromeList =Collections2.filter(list, new Predicate<String>(){
@Override
public boolean apply(String input) {
//业务逻辑
return new StringBuilder(input).reverse().toString().equals(input);
}
});
for(String temp:palindromeList){
System.out.println(temp);
}
}
/**转换*/
public static void test2(){
//类型转换
Set<Long> timeSet =Sets.newHashSet();
timeSet.add(10000000L);
timeSet.add(99999999999999999L);
timeSet.add(2000000000L);
Collection<String> timeStrCol =Collections2.transform(timeSet, new Function<Long,String>(){
@Override
public String apply(Long input) {
return new SimpleDateFormat("yyyy-MM-dd").format(input);
}
});
for(String temp:timeStrCol){
System.out.println(temp);
}
}
/**
* 组合式函数编程
*/
public static void test3(){
//确保容器中的字符串长度不超过5,超过进行截取,后全部大写
List<String> list =Lists.newArrayList("bjsxt","good","happiness");
//确保容器中的字符串长度不超过5,超过进行截取
Function<String,String> f1 =new Function<String,String>(){
@Override
public String apply(String input) {
return input.length()>5?input.substring(0,5):input;
}
};
//转成大写
Function<String,String> f2 =new Function<String,String>(){
@Override
public String apply(String input) {
return input.toUpperCase();
}
};
//String =f2(f1(String))
Function<String,String> f =Functions.compose(f1, f2);
Collection<String> resultCol =Collections2.transform(list, f);
for(String temp:resultCol){
System.out.println(temp);
}
}
}
加入约束条件
- Test03_Constraint.java
package guava.collection;
import java.util.Set;
import com.google.common.collect.Constraint;
import com.google.common.collect.Constraints;
import com.google.common.base.Preconditions;
import com.google.common.collect.Sets;
/**
* 加入约束条件:Constraint,Preconditions,Constraints
* Constraint<E> constraint=new Constraint<E>() {
@Override
public E checkElement(E element) {
Preconditions.checkNotNull(element);//非空验证
Preconditions.checkArgument(element.length()>=5 && element.length()<=20);//长度验证
return element;
}
};
* Constraints.constrained_xxx(需要约束的容器, constraint);//返回一个容器
*/
public class Test03_Constraint {
public static void main(String[] args) {
Set<String> sets =Sets.newHashSet();
//创建约束
Constraint<String> constraint =new Constraint<String>(){
@Override
public String checkElement(String element) {
//非空验证
Preconditions.checkNotNull(element);
//长度验证 5-20为字符串
Preconditions.checkArgument(element.length()>=5 && element.length()<=20);
return element;
}
};
Set<String> cs =Constraints.constrainedSet(sets, constraint);
// cs.add(null); //java.lang.NullPointerException
// cs.add("good"); //java.lang.IllegalArgumentException
cs.add("bjsxt");
for(String str:cs){
System.out.println(str);
}
}
}
集合的操作
- Test04_GatherOperation.java
package guava.collection;
import java.util.Set;
import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;
/**
* 集合的操作:
* 1. 交集
* Sets.intersection()
* 2. 差集
* Sets.difference()
* 3. 并集
* Sets.union();
*/
public class Test04_GatherOperation {
public static void main(String[] args) {
Set<Integer> sets =Sets.newHashSet(1,2,3,4,5,6);
Set<Integer> sets2 =Sets.newHashSet(3,4,5,6,7,8,9);
//交集
System.out.println("交集为:");
SetView<Integer> intersection =Sets.intersection(sets, sets2);
for(Integer temp:intersection){
System.out.println(temp);
}
//差集
System.out.println("差集为:");
SetView<Integer> diff =Sets.difference(sets, sets2);
for(Integer temp:diff){
System.out.println(temp);
}
//并集
System.out.println("并集为:");
SetView<Integer> union =Sets.union(sets, sets2);
for(Integer temp:union){
System.out.println(temp);
}
}
}