GUAVA常用方法总结整理（list map string concurrent file）

最新推荐文章于 2023-10-05 15:54:47 发布

weixin_34205076

最新推荐文章于 2023-10-05 15:54:47 发布

阅读量174

点赞数

文章标签： java python javascript ViewUI

原文链接：https://my.oschina.net/u/1024107/blog/747494

版权

2019独角兽企业重金招聘Python工程师标准>>>

1.对字符串的操作：

package com.wenniuwuren.guava;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.HashMap;
import com.google.common.base.CharMatcher;
import com.google.common.base.Charsets;
import com.google.common.base.Objects;
import com.google.common.base.Strings;
import com.google.common.collect.ComparisonChain;
import sun.org.mozilla.javascript.internal.ast.TryStatement;
/**
 * 
 * @ClassName: WorkingWithStrings 
 * @Description: 对字符串的操作
 * @author wenniuwuren 
 * @date 2015-5-20 上午11:33:59 
 *
 */
public class WorkingWithStrings {
	
	public static void main(String[] args) throws UnsupportedEncodingException {
		
	     // 问题： 1."UTF-8"必须在Java平台中被支持    2.人工敲入会有偏差
		 // byte[] bytes = "foo".getBytes("UTF-8");
		 // 解决： Charsets类提供了对Java平台支持字符集
		 byte[] bytes = "foo".getBytes(Charsets.UTF_8);
		 
		 
		 // 问题： 使用StringBuilder类连接字符串太繁琐， 代码其实都是重复的
		 // 解决： Strings类封装了连接字符串的统一代码
		 System.out.println("padEnd");
		 String stringsTest = Strings.padEnd("foo", 6, 'o');
		 System.out.println(stringsTest);
		 
		 // 在String作为参数时，将null转换成""防止空指针问题 
		 System.out.println("nullToEmpty");
		 String nullToEmptyTest1 = Strings.nullToEmpty("123");
		 String nullToEmptyTest2 = Strings.nullToEmpty(null);
		 System.out.println(nullToEmptyTest1 + "--" + nullToEmptyTest2);
		 
		 // ""转null
		 System.out.println("emptyToNull");
		 String emptyToNullTest1 = Strings.emptyToNull("123");
		 String emptyToNullTest2 = Strings.emptyToNull("");
		 System.out.println(emptyToNullTest1 + "--" + emptyToNullTest2);
		 
		 // 将字符串中的Tab和多个空格转为一个空格
		 String tabsAndSpaces = "String with   spaces	and	tabs";
		 String expected = "String with spaces and tabs";
		 String scrubbed = CharMatcher.WHITESPACE.collapseFrom(tabsAndSpaces,' ');
		 System.out.println(expected.equals(scrubbed));
		 
		 
		 
		 // Object utilities 对象工具
		 // 1. toString()实现
		 System.out.println(Objects.toStringHelper(WorkingWithStrings.class).omitNullValues()
				 .add("expected", expected).add("tabsAndSpaces", tabsAndSpaces));
		 
		 // 2. 检查如果为null值 , 填充默认值
		 System.out.println(Objects.firstNonNull(null, "default value"));
		 
		 // 3. 生成hashcode
		 System.out.println(Objects.hashCode(tabsAndSpaces, expected));
		 
		 // 4. CompareTo实现    如果都是相同的返回0，有一个不同返回-1
		 System.out.println(ComparisonChain.start().compare(tabsAndSpaces, expected).compare(expected, scrubbed).result());
	}
	
}

2.FluentIterable迭代器：

Guava提供了可以在Iterator中进行处理的功能更丰富的迭代器，其实就像是加了一个代理，增加一些功能。

package com.wenniuwuren.collections;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Lists;
/**
 * 
 * @author wenniuwuren
 *
 */
public class FluentIterableTest {
	
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		Person person1 = new Person("lilei", 50);
		Person person2 = new Person("hanmeimei", 40);
		@SuppressWarnings("rawtypes")
		ArrayList personList = Lists.newArrayList(person1, person2);
		
		//返回一个按条件过滤后的结果集
		Iterable<Person> personFilterByAge = FluentIterable.from(personList)
				  .filter(new Predicate<Person>() {
	
					@Override
					public boolean apply(Person input) {
						
						return input.getAge() > 40;
					}
					  
				  });
		Iterator<Person> i = personFilterByAge.iterator();
		while(i.hasNext()) {
			System.out.println("年龄大于40的是：" + i.next().getName());
		}
		
		System.out.println("-------------我是邪恶的分割线-------------");
		
		// 返回处理过的结果集
		List<String> transformedPersonList = FluentIterable.from(personList)
				.transform(new Function<Person, String>() {
					@Override
					public String apply(Person input) {
						return Joiner.on(':').join(input.getName(), input.getAge());
					}
					
				}).toList();
	   Iterator transformedPersonListIterator = transformedPersonList.iterator();
	   while(transformedPersonListIterator.hasNext()) {
		   System.out.println("拼接起来的结果是：" + transformedPersonListIterator.next());
	   }
	   
	 }
    
}
class Person {
	private String name;
	private int age;
	
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

3.Lists列表：

package com.wenniuwuren.collections;
import java.util.Iterator;
import java.util.List;
import com.google.common.collect.Lists;
public class ListsTest {
  
	public static void main(String[] args) {
		Person person1 = new Person("lilei", 50);
		Person person2 = new Person("hanmeimei", 40);
		Person person3 = new Person("kangkang", 20);
		Person person4 = new Person("mary", 20);
		List<Person> personList = Lists.newArrayList(person1, person2, person3, person4);
		// 拆分成[person1, person2, person3], [person4]   第二个参数为拆分长度
		List<List<Person>> subList = Lists.partition(personList, 3);
		Iterator<List<Person>> i = subList.iterator();
		while(i.hasNext()) {
			List<Person> listTemp = (List<Person>)i.next();
			Iterator<Person> iTemp = listTemp.iterator();
			while(iTemp.hasNext()) {
				System.out.println(iTemp.next().getName());
			}
		}
	}
	
	
}

Table矩阵：

使用Guava对矩阵的实现，做一些矩阵存贮等操作将大大提高效率，而不是自己用JDK的Array去实现，可能带来不少bug，而且增加代码复杂度。

package com.wenniuwuren.collections;
import java.util.Map;
import com.google.common.collect.HashBasedTable;
/**
 * Table： 矩阵的实现
 * @author wenniuwuren
 *
 */
public class TableTest {
	public static void main(String[] args) {
		HashBasedTable<Integer,Integer,String> table = HashBasedTable.create();
		table.put(1, 1, "11");
		table.put(1, 2, "12");
		table.put(1, 3, "13");
		table.put(2, 1, "21");
		table.put(2, 2, "22");
		table.put(2, 3, "23");
		
		boolean contains11 = table.contains(1,1);
		boolean containColumn2 = table.containsColumn(2);
		boolean containsRow1 = table.containsRow(1);
		boolean containsValue11 = table.containsValue("11");
		table.remove(1,3);
		table.get(3,4);
		
		Map<Integer,String> columnMap = table.column(1);
		Map<Integer,String> rowMap = table.row(2);
		
		System.out.println(table 
				+ ", contains11:" + contains11 
				+ ", containColumn2:" + containColumn2
				+ ", containsRow1:" + containsRow1
				+ ", containsValue11:" + containsValue11
				+ ", columnMap" + columnMap
				+", rowMap" + rowMap);
		
		
	}
}

4.Sets：

package com.wenniuwuren.collections;
import java.util.Iterator;
import java.util.Set;
import com.google.common.collect.Sets;
/**
 * 对Sets工具类的使用
 * @author wenniuwuren
 *
 */
public class SetsTest {
	
	public static void main(String[] args) {
		/**
		 * 返回在s1中存在， 但不再s2中存在的
		 */
		Set<String> s1 = Sets.newHashSet("1", "2", "3");
		Set<String> s2 = Sets.newHashSet("2", "3", "4");
	    System.out.println(Sets.difference(s1, s2));
	    /**
	     * 返回两个集合互斥集合
	     */
	    System.out.println(Sets.symmetricDifference(s1, s2));
	    
	    /**
	     * 返回两个集合的交集
	     */
	    System.out.println(Sets.intersection(s1, s2));
	    
	    /**
	     * 返回两个集合的并集
	     */
	    System.out.println(Sets.union(s1, s2));
	}
	
}

本文介绍了Guava集合类Maps、BiMap、ArrayListMultimap相关的使用，比如将具有唯一主键的对象快速存入Map、键值对反转等

Maps集合类扩展使用：

package com.wenniuwuren.guava;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Set;
import com.google.common.base.Function;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
/**
 * 
 * @ClassName: MapsTest 
 * @Description: Maps集合类扩展使用 
 * @author wenniuwuren 
 * @date 2015-6-1 下午5:23:22 
 *
 */
public class MapsTest {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		Person p1 = new Person("001", "zhang_san");
		Person p2 = new Person("002", "li_si");
		
		List<Person> personList = Lists.newArrayList();
		personList.add(p1);
		personList.add(p2);
		
		// 将主键当作Map的Key
		Map<String, Person> personMap = Maps.uniqueIndex(personList.iterator(), new Function<Person, String>() {
			@Override
			public String apply(Person input) {
				return input.getId();
			}
			
		});
		System.out.println("将主键当作Map的Key:" + personMap);
		
		
		// 可以说是Maps.uniqueIndex相反的作用
		Set<Person> personSet = Sets.newHashSet(p1, p2);
		@SuppressWarnings("unused")
		Map<Person, String> personAsMap= Maps.asMap(personSet, new Function() {
			@Override
			public Object apply(Object input) {
				return ((Person)input).getId();
			}
		});
		System.out.println(personAsMap);
		
		
		// 转换Map中的value值
		Map<String, String> transformValuesMap = Maps.transformValues(personMap, new Function<Person, String>() {
			@Override
			public String apply(Person input) {
				return input.getName();
			}
		});
		System.out.println("转换Map中的value值" + transformValuesMap);
		
	}
}
class Person {
	private String Id;
	private String name;
	
	public Person(String Id, String name) {
		this.Id = Id;
		this.name = name;
	}
	
	public String getId() {
		return Id;
	}
	public void setId(String id) {
		Id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
}

对ArrayListMultiMap的使用案例：

package com.wenniuwuren.guava;
import java.util.List;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Lists;
/**
 * 
 * @ClassName: ArrayListMultiMapTest 
 * @Description: 一key对应多value 
 * @author wenniuwuren 
 * @date 2015-6-1 下午6:17:00 
 *
 */
public class ArrayListMultiMapTest {
	public static void main(String[] args) {
		
		/**
		 * ArrayListMultimap  List允许重复， 所以大小为4
		 */
		ArrayListMultimap<String,String> multiMap = ArrayListMultimap.create();
		multiMap.put("Foo","1");
		multiMap.put("Foo","2");
		multiMap.put("Foo","3");
		multiMap.put("Foo","3");
		System.out.println("内容：" + multiMap + " ， 大小：" + multiMap.size());
		
		
		/**
		 * HashMultimap Hash不允许重复值， 大小为3
		 */
		HashMultimap<String,String> hashMultiMap =  HashMultimap.create();
		hashMultiMap.put("Bar","1");
		hashMultiMap.put("Bar","2");
		hashMultiMap.put("Bar","3");
		hashMultiMap.put("Bar","3");
		hashMultiMap.put("Bar","3");
		System.out.println("内容：" + hashMultiMap + " ， 大小：" + hashMultiMap.size());
		
	}
}

对BiMaps使用案例：

package com.wenniuwuren.collections;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
/**
 * 对BiMap工具类的使用： key和value都是唯一的
 * @author wenniuwuren
 *
 */
public class BiMapTest {
	public static void main(String[] args) {
		
		BiMap<String,String> biMap = HashBiMap.create();
		biMap.put("1","Tom");
		biMap.put("2","Jerry");
		
		// 放入重复值value  将会报错
		// biMap.put("2","Tom");
		
		// 相同Value覆盖前一个
		//biMap.forcePut("2","Tom");
		
		System.out.println(biMap);
		
		// key value反转 
		System.out.println(biMap.inverse());
		
		
		
	}
}

Range范围过滤：

本文介绍了Guava中Range的使用，使用Range和Guava的函数式编程可以用少量代码实现指定范围内容的过滤。

import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.Range;
/**
 * Guava Range类使用
 * Created by wenniuwuren on 2015/6/3.
 */
public class RangeTest {
	public static void main(String[] args) {
		Range<Integer> numberRange = Range.closed(1, 10);
		System.out.println("closed包含边界" + numberRange.contains(10) + " ," + numberRange.contains(1));
		Range<Integer> numberOpenRange = Range.open(1, 10);
		System.out.println("open不包含边界" + numberOpenRange.contains(1) + ", " + numberOpenRange.contains(10));
		Range<Integer> atLeast = Range.atLeast(10);
		System.out.println("大于等于边界的所有值" + atLeast);
		Range<Integer> lessThan = Range.lessThan(10);
		System.out.println("小于等于边界的所有值" + lessThan);
		/**
		 *  过滤掉不符合内容Range范围的
		 */
		Range<Integer> ageRange = Range.closed(35,50);
		Function<Person,Integer> ageFunction = new Function<Person,
				Integer>() {
			@Override
			public Integer apply(Person person) {
				return person.getAge();
			}
		};
		Person p1 = new Person("zhangsan", 50);
		Person p2 = new Person("lisi", 70);
		Predicate<Person> predicate = Predicates.compose(ageRange, ageFunction);
		System.out.println("是否包含zhangsan：" + predicate.apply(p1)
						+ ", 是否包含lisi：" + predicate.apply(p2));
	}
}
class Person {
	private String name;
	private Integer age;
	public Person(String name, Integer age) {
		this.name = name;
		this.age = age;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

输出结果：

Ordering排序工具：

import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import com.google.common.primitives.Ints;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
public class CityByPopluation implements Comparator<City> {
	@Override
	public int compare(City city1, City city2) {
		return Ints.compare(city1.getPopulation(), city2.getPopulation());
	}
	public static void main(String[] args) {
		CityByPopluation cityByPopluation = new CityByPopluation();
		CityByRainfall cityByRainfall = new CityByRainfall();
		// 根据第二个参数排序
		City city1 = new City("Beijing", 100000, 55.0);
		City city2 = new City("Shanghai", 100000, 45.0);
		City city3 = new City("ShenZhen", 100000, 33.8);
		List<City> cities = Lists.newArrayList(city1, city2, city3);
		/**
		 * 单参数排序
		 */
		// 排序反转
		Ordering<City> firstOrdering = Ordering.from(cityByRainfall).reverse();
		Collections.sort(cities, firstOrdering);
		Iterator<City> cityByRainfallIterator = cities.iterator();
		while (cityByRainfallIterator.hasNext()) {
			System.out.println(cityByRainfallIterator.next().getCityName());
		}
		System.out.println("I was evil dividing line");
		/**
		 * 多参数排序
		 */
		Ordering<City> secondaryOrdering = Ordering.
				from(cityByPopluation).compound(cityByRainfall);
		Collections.sort(cities, secondaryOrdering);
		Iterator<City> cityIterator = cities.iterator();
		while (cityIterator.hasNext()) {
			System.out.println(cityIterator.next().getCityName());
		}
		/**
		 * 取得最小最大值
		 */
		Ordering<City> ordering = Ordering.from(cityByRainfall);
		// 降雨量最高的2个城市
		List<City> topTwo = ordering.greatestOf(cities, 2);
		Iterator<City> topTwoIterator = topTwo.iterator();
		while (topTwoIterator.hasNext()) {
			System.out.println("降雨量最高城市" + topTwoIterator.next().getCityName());
		}
		// 降雨量最低的一个城市
		List<City> bottomOne = ordering.leastOf(cities, 1);
		Iterator<City> bottomOneIterator = bottomOne.iterator();
		while (bottomOneIterator.hasNext()) {
			System.out.println("降雨量最低的城市" + bottomOneIterator.next().getCityName());
		}
	}
}

City类：

/**
 * Created by wenniuwuren on 2015/6/4.
 */
public class City {
	private String cityName;
	private Integer population;
	private Double averageRainfall;
	public City(String cityName, Integer population, Double averageRainfall) {
		this.cityName = cityName;
		this.population = population;
		this.averageRainfall = averageRainfall;
	}
	public String getCityName() {
		return cityName;
	}
	public void setCityName(String cityName) {
		this.cityName = cityName;
	}
	public Integer getPopulation() {
		return population;
	}
	public void setPopulation(Integer population) {
		this.population = population;
	}
	public Double getAverageRainfall() {
		return averageRainfall;
	}
	public void setAverageRainfall(Double averageRainfall) {
		this.averageRainfall = averageRainfall;
	}
}

CityByRainfall类：

import com.google.common.primitives.Doubles;
import java.util.Comparator;
public class CityByRainfall implements Comparator<City> {
	@Override
	public int compare(City city1, City city2) {
		return Doubles.compare(city1.getAverageRainfall(), city2.getAverageRainfall());
	}
}

输出结果：

Concurrent并发：

Guava在JDK1.5的基础上，对并发包进行扩展，有一些是易用性的扩展（如Monitor），有一些是功能的完善（如ListenableFuture），再加上一些函数式编程的特性，使并发包的灵活性极大的提高...

Monitor的使用：

import com.google.common.util.concurrent.Monitor;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
/**
 * Monitor类语义和 synchronized 或者 ReentrantLocks是一样的， 只允许一个线程进入
 */
public class MonitorSample {
    private static final int MAX_SIZE = 3;
    private Monitor monitor = new Monitor();
    private List<String> list = new ArrayList<String>();
    Monitor.Guard listBelowCapacity = new
            Monitor.Guard(monitor) {
                @Override
                public boolean isSatisfied() {
                    return list.size() < MAX_SIZE;
                }
            };
    public void addToList(String item) throws InterruptedException {
        // 超过MAX_SIZE， 会锁死
        //monitor.enterWhen(listBelowCapacity);
        // 超过返回false  不会锁死
        Boolean a = monitor.tryEnterIf(listBelowCapacity);
        try {
            list.add(item);
        } finally { // 确保线程会推出Monitor锁
            monitor.leave();
        }
    }
    public static void main(String[] args) {
        MonitorSample monitorSample = new MonitorSample();
        for (int count = 0; count < 5; count++) {
            try {
                monitorSample.addToList(count + "");
            }
            catch (Exception e) {
                System.out.println(e);
            }
        }
        Iterator iteratorStringList = monitorSample.list.iterator();
        while (iteratorStringList.hasNext()) {
            System.out.println(iteratorStringList.next());
        }
    }
}

Future的扩展：可识别的返回结果，可改变的返回结果：

package com.wenniuwuren.listenablefuture;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
/**
 * 在使用ListenableFuture前， 最好看下JDK的Future使用
 * 
 * @author wenniuwuren
 *
 */
public class ListenableFutureTest {
	public static void main(String[] args) {
        
		
		// Guava封装后带有执行结束监听任务执行结束的功能
		ExecutorService executorService =
				MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
		
		ListenableFuture<String> listenableFuture = (ListenableFuture<String>) executorService
				.submit(new Callable<String>() {
					public String call() throws Exception {
						return "task success ";
					}
				});
		
		/* Futrue初始版本
		 
		// JDK 自带线程池
		//ExecutorService executor = Executors.newCachedThreadPool();
		
		// JDK Future
		Future<Integer> future = executor.submit(new Callable<Integer>() {
			public Integer call() throws Exception {
				return 1;
			}
		});
		
		// JDK Future真正获取结果的地方
		try {
			Integer count = future.get();
		} catch (Exception e) {
			e.printStackTrace();
		}*/
		
		
		/* listenableFuture 结束监听版本
		// 相比JDK的Future等待结果， Guava采用监听器在任务完成时调用
		// 但是有个缺陷， 对最后完成的结果没法对操作成功/失败进行处理， 即run方法没返回值
		listenableFuture.addListener(new Runnable() {
			@Override
			public void run() {
				System.out.println("运行完成");
			}
		}, executorService);*/
		
		// 运行成功，将会返回 "task success successfully"  解决了listenableFuture 结束监听版本不能对结果进行操作问题
		FutureCallbackImpl callback = new FutureCallbackImpl();
		// 和计算结果同步运行
		//Futures.addCallback(listenableFuture, callback);
		
		//如果计算较大， 结果的访问使用异步  将会使用executorService线程去异步执行
		Futures.addCallback(listenableFuture, callback, executorService);
		
		System.out.println(callback.getCallbackResult());
		
		
	}
}
class FutureCallbackImpl implements FutureCallback<String> {
	private StringBuilder builder = new StringBuilder();
	@Override
	public void onSuccess(String result) {
		builder.append(result).append("successfully");
	}
	@Override
	public void onFailure(Throwable t) {
		builder.append(t.toString());
	}
	public String getCallbackResult() {
		return builder.toString();
	}
}

Files文件操作：

文件的复制、重命名、内容读取等对文件的基本操作：

import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
import com.google.common.hash.HashCode;
import com.google.common.hash.Hashing;
import com.google.common.io.*;
import java.io.*;
import java.nio.charset.Charset;
import java.util.List;
/**
 * Created by wenniuwuren on 2015/6/16.
 */
public class FilesTest {
    public static void main(String[] args) {
        try {
            FilesTest filesTest = new FilesTest();
            // 一个文件内容复制到另一个文件中
            /*File original = new File("E:\\test\\original");
            File copy = new File("E:\\test\\copy");
            if (original.isFile() && copy.isFile()) {
                Files.copy(original, copy);
            }*/
            // 文件重命名
           /* File originalFile = new File("E:\\test\\1.txt");
            File newFile = new File("E:\\test\\2.txt");
            if (originalFile.isFile() && newFile.isFile()) {
                Files.move(originalFile, newFile);
            }*/
            // 将文件内容一行一行读取出来
            File file = new File("E:\\test\\1.txt");
            List<String> expectedLines = Lists.newArrayList("The quick brown", " fox jumps over", " the lazy dog");
            List<String> readLines = Files.readLines(file, Charsets.UTF_8);
            System.out.printf(readLines.toString());
            // 为文件生成一个hashcode
            HashCode hashCode = Files.hash(file, Hashing.md5());
            System.out.println(hashCode);
            // 文件 写/新增内容     完全不用去关心打开打开流/关闭流
            String hamletQuoteStart = "To be, or not to be";
            Files.write(hamletQuoteStart, file, Charsets.UTF_8);
            String hamletQuoteEnd = "that is a question";
            Files.append(hamletQuoteEnd, file, Charsets.UTF_8);
            // Sources读  Sinks写
            // Sources 和 Sinks 不是 streams', readers', 或者 writers' 对象
            // 但是提供相同功能
            File dest = new File("E:\\test\\2.txt");
            //dest.deleteOnExit();
            File source = new File("E:\\test\\1.txt");
            ByteSource byteSource = Files.asByteSource(source);
            ByteSink byteSink = Files.asByteSink(dest);
            byteSource.copyTo(byteSink);
            System.out.println(byteSink + ", " + byteSource);
            // 把几个文件内容写到同一个文件下
            File f1 = new File("E:\\test\\1.txt");
            File f2 = new File("E:\\test\\2.txt");
            File f3 = new File("E:\\test\\3.txt");
            File joinedOutput = new File("E:\\test\\4.txt");
            //joinedOutput.deleteOnExit();
            // 为每个文件生成InputSupplier(使用Closer去管理关闭底层I/O资源)
            List<InputSupplier<InputStreamReader>> inputSuppliers = filesTest.getInputSuppliers(f1, f2, f3);
            // 逻辑上合并为一个InputSupplier
            InputSupplier<Reader> joinedSupplier = CharStreams.join(inputSuppliers);
            // 建立输出
            OutputSupplier<OutputStreamWriter> outputSupplier = Files.newWriterSupplier(joinedOutput, Charsets.UTF_8);
            // 将底层InputSuppliers写到OutputSupplier
            CharStreams.copy(joinedSupplier, outputSupplier);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private String joinFiles(File... files) throws IOException {
        StringBuilder builder = new StringBuilder();
        for (File file : files) {
            builder.append(Files.toString(file, Charsets.UTF_8));
        }
        return builder.toString();
    }
    private List<InputSupplier<InputStreamReader>> getInputSuppliers(File... files) {
        List<InputSupplier<InputStreamReader>> list = Lists.newArrayList();
        for (File file : files) {
            list.add(Files.newReaderSupplier(file, Charsets.UTF_8));
        }
        return list;
    }
}

转载于:https://my.oschina.net/u/1024107/blog/747494