java工作中的一些技巧

----------------------------------------------------------------------
> 遍历list 移除当前的某个
private void removeNoRelProd(List<EventMergeDto> data) {
    if (data != null) {
        for (Iterator<EventMergeDto> it = data.iterator(); it.hasNext(); ) {
            EventMergeDto dto = it.next();
            if (dto.getProds() == null || dto.getProds().isEmpty()) {
                it.remove();
            }
        }
    }
}

----------------------------------------------------------------------
> 遍历Map
private String appendParam(String url, Map<String, Object> params) {
        StringBuilder sbuilder = new StringBuilder(url);
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            sbuilder.append(entry.getKey());
            sbuilder.append("=");
            sbuilder.append(entry.getValue());
            sbuilder.append("&");
        }
    }
----------------------------------------------------------------------
> 属性复制  spring-beans包
org.springframework.beans.BeanUtils  
BeanUtils.copyProperties(nt, ntd);
----------------------------------------------------------------------
> 利用cache做搜索  guava包
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

public static Cache<String, List<BaseStock>> cache = CacheBuilder.newBuilder().expireAfterAccess(24, TimeUnit.HOURS).build();
List<BaseStock> data = null; 
    try {
        data = cache.get("", () -> loadBaseStock());
    }catch(Exception e) {
        data = baseStockDao.findAll();
    }    
data = data.stream().filter(v -> v.getAbbr_szh().contains(name) || v.getCode().contains(name)).collect(Collectors.toList());

----------------------------------------------------------------------
> 取list集合对象中的某一个属性的最大值最小值
List<RelationStock> result = CollectionUtils.isNotEmpty(data) ? data.subList(0,Math.min(5, data.size())): Lists.newArrayList();
// 最大年份
Integer maxyear = Collections.max(result, new Comparator<RelationStock>() {
    @Override
    public int compare(RelationStock o1, RelationStock o2) {
        return (o1.getYear() < o2.getYear() ? -1 : (o1.getYear() == o2.getYear() ? 0 : 1));
    }
}).getYear();
logger.info("最大年份：" + maxyear);
// 最小年份
Integer minyear = Collections.max(result, new Comparator<RelationStock>() {
    @Override
    public int compare(RelationStock o1, RelationStock o2) {
        return (o1.getYear() > o2.getYear() ? -1 : (o1.getYear() == o2.getYear() ? 0 : 1));
    }
}).getYear();
logger.info("最小年份：" + minyear);
----------------------------------------------------------------------
System.out.println(Pattern.matches("(.*?)\\.(\\w+)", ".雷.A"));
     
java.util
Map<String, Object> params = Collections.singletonMap("code", cepCode);

List<Object> objects = Collections.emptyList();
List emptyList = Collections.EMPTY_LIST;

----------------------------------------------------------------------
> list 排序
public static void main(String[] args) {
        String sort = "1";
        List<EventMergeDto> resultList1 = Lists.newArrayList();
         
        // 排序方式一
        resultList1.sort(new Comparator<EventMergeDto>(){
            @Override
            public int compare(EventMergeDto o1, EventMergeDto o2) {
                if((sort).equals("1")){
                    return o2.getWeight().compareTo(o1.getWeight());
                }else if((sort).equals("2")){
                    return o2.getHeat().compareTo(o1.getHeat());
                }else if((sort).equals("3")){
                    return o2.getTread().compareTo(o1.getTread());
                }
                return o2.getWeight().compareTo(o1.getWeight());
            }
        });
         
        // 排序方式二
        resultList1.sort((o1,o2)->o2.getWeight().compareTo(o1.getWeight()));
         
         
        // 排序方式三
        resultList1 = resultList1.stream().sorted((o1,o2)->o2.getWeight().compareTo(o1.getWeight())).collect(Collectors.toList());
         
        // 排序方式四
        Collections.sort(resultList1, new Comparator<EventMergeDto>(){
            @Override
            public int compare(EventMergeDto o1, EventMergeDto o2) {
                // 权重倒倒叙排序
                int compare = o2.getWeight().compareTo(o1.getWeight());
                if(compare == 0){
                    // 热度倒叙排序
                    return o2.getHeat().compareTo(o1.getHeat());
                }
                return compare;
            }
        });    

         // 排序
        Collections.sort(data, new Comparator<RelationStock>() {
            @Override
            public int compare(RelationStock o1, RelationStock o2) {
                // 年份降序排序
                int compare = o2.getFp().compareTo(o1.getFp()); // 正数是正序 负数是倒叙  因为是o2写在前面 所以是返回倒叙的
                if(compare == 0){
                    // 收入降序排序
                    if("NA".equals(o2.getValue())){
                        o2.setValue("0");
                    }if("NA".equals(o1.getValue())){
                        o1.setValue("0");
                    }
                    return new BigDecimal(o2.getValue()).subtract( new BigDecimal(o1.getValue())).intValue();
                }

                return compare;
            }
        });
    }
----------------------------------------------------------------------
> List.stream().filter
 filter: 对于Stream中包含的元素使用给定的过滤函数进行过滤操作，新生成的Stream只包含符合条件的元素；

// tream当成一个高级版本的Iterator。  
public static void main(String[] args){
     // 获取一个List中，元素大于2017-11-05数
     List<String> list = Arrays.asList("2017-11-05,2017-11-08,2017-11-01,2017-11-26".split(","));
     String from  = "2017-11-05";
     List<String> dataList = list.stream().filter((o) -> {return o.compareTo(from)>0;}).collect(Collectors.toList());
     System.out.println(dataList);
     
     // 获取一个List中，元素不为null的个数
     List<Integer> nums = Lists.newArrayList(1,null,3,4,null,6);
     long count = nums.stream().filter(num -> num != null).count();
     System.out.println(count);

     List<Person> result = list.stream().filter(Person::isStudent).collect(toList());
}
----------------------------------------------------------------------
> Objects用法
java.utiil.Objects

List<ProductRs.Ind> waitInd = productRs.getInd();
ProductRs.Ind csf = waitInd.stream().filter(v -> Objects.equals(v.getT(), "csf")).findFirst().orElse(null);

import java.util.Objects;

corpus.setCrt(Objects.isNull(exist) ? new Date() : exist.getCrt());
if (Objects.nonNull(corpus.getType())) {}
----------------------------------------------------------------------
> 随机数
System.out.println((int)((Math.random()*9+1)*100000));// 随机6位数
System.out.println((int)((Math.random()*9+1)*1000000));// 随机7位数
System.out.println((int)((Math.random()*9+1)*10000000));// 随机8位数
----------------------------------------------------------------------
> double 数字标准化 逗号分隔
// import java.math.BigDecimal;
// import java.text.DecimalFormat;
Double val = 11789.30;
DecimalFormat decimalformat = new DecimalFormat("###,###.##");
System.out.println(decimalformat.format(val));// 11,789.3
----------------------------------------------------------------------
> list :: 用法

List<String> eventIdSet = new ArrayList<String>();
List<String> newArrayList = Lists.newArrayList("2015","2014","2013","2018");
System.out.println(eventIdSet); // []
newArrayList.stream().forEach(eventIdSet::add);
System.out.println(eventIdSet); // [2015, 2014, 2013, 2018]
----------------------------------------------------------------------
StringUtils.equals(DatashiftConstants.TYPE_UPDATE, jobParameter.getType())
Strings.isNullOrEmpty(lv)
----------------------------------------------------------------------
> 判断map是否为空
import org.apache.commons.collections.MapUtils;
Map<FinDataKey, VDataMapValue> quarterCacheMap = null;
MapUtils.isNotEmpty(quarterCacheMap)
----------------------------------------------------------------------
> sql in  拼写
// import org.apache.commons.lang.StringUtils;
public static void main(String[] args) {
    List<String> conceptIds = Arrays.asList("1212,69437hfuit,32ui,iu3i".split(","));
    System.out.println(String.join(",", conceptIds));// 1212,69437hfuit,32ui,iu3i
    // 或 StringUtils.join(conceptIds,",")
    
    List<String> sids = Arrays.asList("1212,69437hfuit,32ui,iu3i".split(","));
    String sql  = "select * from nlp_en where textid in" + "('"+StringUtils.join(sids,"','")+"')";
    System.out.println(sql);//  select * from nlp_en where textid in('1212','69437hfuit','32ui','iu3i')
}
----------------------------------------------------------------------
>List转map
map方法  用于需要对一个流中的值进行某种形式的转换

List<News> newsLists = newsDao.findAll(newsids);
Map<String,News> newMaps = newsLists.stream().map((one)->{return one;}).collect(Collectors.toMap(k->k.get_id().toString(), v->v));
或
Map<String,News> newMaps = newsLists.stream().collect(Collectors.toMap(k->k.get_id().toString(), v->v));
或
Map<String,News> newMaps = newsLists.stream().map(one->one).collect(Collectors.toMap(k->k.get_id().toString(), v->v));

> toList
List<EventList> newMaps = newsLists.stream().map(one->one).collect(Collectors.toList());

> toSet
Set<String> newMaps = newsLists.stream().map(one->one).collect(Collectors.toSet());

----------------------------------------------------------------------
>List 去重
//方式一
List<String> list = Arrays.asList("admin,test,passwd,passwd,test".split(","));
System.out.println(list);
list =  list.stream().distinct().collect(Collectors.toList());
System.out.println(list);

//方式二
List<News> news = newsDao.findNewsByComsOrInds(query,offset,limit);
// 根据title去重
Set<News> newSet = new TreeSet<>((o1, o2) -> o1.getTitle().compareTo(o2.getTitle()));
newSet.addAll(news);
news = new ArrayList<>(newSet);

//方式三
List<Person> persons = new ArrayList<Person>();
Set<String> listTemp = new HashSet<String>();
for(Iterator<Person> it = persons.iterator(); it.hasNext();){
    Person a = it.next();
    if (listTemp.contains(a.getName())) {
        it.remove();
    } else {
        listTemp.add(a.getName());
    }
}

//方式四
List<Person> persons = new ArrayList<Person>();
Set<String> set = new HashSet<String>();
persons.forEach((one)->{
    String title = one.getName().trim();
    if(!set.contains(title)){
        set.add(title);
        disPer.add(one);
    }
});
persons = disPer;

----------------------------------------------------------------------
> Optional介绍
Optional是Java8新加入的一个容器，这个容器只存1个或0个元素，它用于防止出现NullpointException，它提供如下方法：
isPresent() 
判断容器中是否有值。
ifPresent(Consume lambda) 
容器若不为空则执行括号中的Lambda表达式。
T get() 
获取容器中的元素，若容器为空则抛出NoSuchElement异常。
T orElse(T other) 
获取容器中的元素，若容器为空则返回括号中的默认值。

BasicDBList items = Optional.ofNullable((BasicDBList) dbObject.get("items")).orElse(new BasicDBList());

----------------------------------------------------------------------
>时间
/**
     * import java.time.LocalTime;
     * import java.time.format.DateTimeFormatter;
     */
    public static void main(String[] args) throws ParseException {
        DateTimeFormatter CLNHHMM = DateTimeFormatter.ofPattern("HH:mm");
        LocalTime time = LocalTime.parse("16:25", CLNHHMM);
        System.out.println(time);

        System.out.println(Optional.ofNullable(time)); // 16:25

        List<String> crons = new ArrayList<>();
        // time不为空的话,放入   java.util.Optional;
        Optional.ofNullable(time).ifPresent(t -> {
            crons.add(String.format("0 %d %d * * ?", t.getHour(), t.getMinute()));
        });

        System.out.println(crons);

        LocalDateTime ldt_current= LocalDateTime.now();
        System.out.println(ldt_current); // 2017-11-27T11:27:51.702
         
        LocalDateTime ldt_before = ldt_current.plusHours(-24);
        System.out.println(ldt_before); //  2017-11-26T11:27:51.702
         
        String curr_format = ldt_current.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));
        String before_format = ldt_before.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));        
        System.out.println(curr_format);  // 2017-11-27 11:27:51.702
        System.out.println(before_format); // 2017-11-26 11:27:51.702
    }

>时间
import java.time.LocalDate; // jdk

LocalDate 只有年月日
LocalTime 精准的时分秒
LocalDateTime 年月日时分秒都有

LocalDate today = LocalDate.now();  // 2017-10-25
LocalDate tomorrow = today.plusDays(1); // 2017-10-26
String st = String.join(" ",today.toString(),"00:00:00"); // 2017-10-25 00:00:00
String et=String.join(" ",tomorrow.toString(),"00:00:00"); // 2017-10-26 00:00:00
----------------------------------------------------------------------
public static Date getDate(Integer interval) {
    if (interval != null) {
        LocalDateTime n = LocalDateTime.of(LocalDate.now(), LocalTime.of(0, 0));
        if (interval.equals(RECENTWEEK.interval)) {
            n = n.minusWeeks(1);
        }
        if (interval.equals(RECENTMONTH.interval)) {
            n = n.minusWeeks(1);
        }
        return Date.from(n.atZone(ZoneId.systemDefault()).toInstant());
    }
    return null;
}
----------------------------------------------------------------------
> 当前时间往前退一个月的时间

Date trdt = new Date();
String startDt = DateUtil.formatDate(DateUtils.addMonths(trdt, -1), "yyyyMMdd");

----------------------------------------------------------------------
>BigDecimal 保留小数位数 四舍五入

/**
 * 保留小数位数  四舍五入
 * @param val 值    scale 保留几位
 */
public static Double scale(Double val, int scale){
    if(val == null || val.isInfinite() || val.isNaN()) {
        return 0d;
    }
    BigDecimal bg = new BigDecimal(val);
    //进行四舍五入 然后保留多少位
    return bg.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
----------------------------------------------------------------------
> bigDecimal 相加
BigDecimal g = new BigDecimal(1.236d);
g = g.add(new BigDecimal(0.5d));
g = g.add(new BigDecimal(0.5d));
System.out.println(g.doubleValue());    
----------------------------------------------------------------------
>利用正则表达式校验

private static boolean filterSecu(String cd) {
    String regex = "^(6.*SH_EQ)|((0|3).*SZ_EQ)$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(cd);
    boolean find = matcher.find();
    return find;
}

String time = "20160406150519";
Pattern    pattern = Pattern.compile("^[0-9]{8}15[0-9]{4}");
if(pattern.matcher(time).matches()) {
    return time.substring(0, 8) + "150000";
    System.out.println("当前匹配");
}else{
    System.out.println("当前不匹配");
}

//验证是否为空
StringUtils.isNotBlank("");
----------------------------------------------------------------------
>判断集合是否为空
//<dependency>
//    <groupId>commons-collections</groupId>
//    <artifactId>commons-collections</artifactId>
//    <version>3.2.1</version>
//</dependency>

import org.apache.commons.collections.CollectionUtils;
List<S> datas = 。。。。。。;
if(CollectionUtils.isEmpty(datas)) {
        continue;
}
//判断集合不为空
if(CollectionUtils.isNotEmpty(updateEntities)) {
        updateData(updateEntities);
        entities = removeAll(entities, updateEntities);
}
----------------------------------------------------------------------
> 将逗号分隔的String 装换成list
private List<String> asList(String keys){
    List<String> list = null;
    if(StringUtils.isBland(keys)){
        list = Arrays.asList(keys.split(","));
    }
}
----------------------------------------------------------------------
>清除Map中的数据

public static Map<String, Integer> syncHqIndex = new HashMap<String, Integer>();    
syncHqIndex.remove("");

>清除List中的数据
public static List<String> clearSecus = new ArrayList<String>();
clearSecus.clear();
----------------------------------------------------------------------
数组实现
Arrays.asList("1001","1002","1003","1008","1005","1054","1055","1012")
List<String> dataTypeFi = Arrays.asList("11", "21", "31");

import com.google.common.collect.Lists;
Lists.newArrayList("1001,1002,1003,1012".split(","))
----------------------------------------------------------------------
private String getKey(String... args) {
        StringBuilder sb = new StringBuilder();
        for (String s : args) {
            sb.append(s);
        }
        return sb.toString();
    }
----------------------------------------------------------------------

>校验集合是否为空
import org.apache.commons.collections.CollectionUtils;

BasicDBList orList = new BasicDBList();
CollectionUtils.isEmpty(orList)
----------------------------------------------------------------------
>校验数数据是否为空

import org.apache.commons.lang3.StringUtils;
StringUtils.isBlank("")
校验数据不为空
StringUtils.isNotBlank("");       

String[] arr = str.split(splitor);
List<String> list = new ArrayList<String>(arr.length);
for(String s : arr){
    if(StringUtils.isNotEmpty(s)){
        list.add(s);
    }
}

----------------------------------------------------------------------
>switch  case 用法    
    
 // 根据股票类型取相应记录
public Set<String> getSecusByMarketType(int secuType) {
    Set<String> secus = null;
    switch (secuType) {
    case Constants.SECU_A:
        secus = baseProfileBiz.getSecusByMarket(BaseConstants.MARKET_A, null, null);
        break;
    case Constants.SECU_ABROAD:
        secus = baseProfileBiz.getSecusByMarket("H,US", null, null);
        break;
    default:
        break;
    }
    return secus;
}    
----------------------------------------------------------------------
> 枚举
package com.csf.tag.common.enums;

public enum StateEnum {
     // 删除状态
    DELETE(0),
     // 系统生成
    ADD_BY_SYSTEM(1),
     // 人工维护
    ADD_BY_HAND(2);

    private int value;
    StateEnum(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}
----------------------------------------------------------------------
->枚举 switch case 用法
public enum DictDownloadType {    
    ENTITY(1,"实体"), INDUSTRY(9,"行业");
    
    public Integer key;
    public String  dsc;    
    private DictDownloadType(Integer key, String dsc){
        this.key = key;
        this.dsc = dsc;
    }    
    public static DictDownloadType get(Integer key){
        DictDownloadType[] values = DictDownloadType.values();
        for(DictDownloadType object : values){
            if(object.key == key){
                return object;
            }
        }
        return null;
    }
}    

public void txtMessasge(Integer number)  throws Exception{            
    DictDownloadType downtype = DictDownloadType.get(number);
    switch(downtype){
        case ENTITY:txtWriteEntity(out, query, number, cacheKey, speed);break;//实体
        case INDUSTRY:txtWriteIndustry(out, query, number, cacheKey, speed);break;//行业
    }
}

----------------------------------------------------------------------
验证数据
 public static boolean isAEquity(String code) {
        if (StringUtils.isBlank(code)) return false;
        boolean flag = false;
        Pattern p = Pattern.compile("^(6.*SH_EQ|(0|3).*SZ_EQ)$");
        Matcher m = p.matcher(code);
        if (m.matches())
            flag = true;
        return flag;
    }
----------------------------------------------------------------------

>使用System.arraycopy()实现数组之间的复制  

System提供了一个静态方法arraycopy(),我们可以使用它来实现数组之间的复制。其函数原型是：
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
src:源数组； srcPos:源数组要复制的起始位置； dest:目的数组； destPos:目的数组放置的起始位
置； length:复制的长度。 注意：src and dest都必须是同类型或者可以进行转换类型的数组． 有趣
的是这个函数可以实现自己到自己复制，比如： int[] fun ={0,1,2,3,4,5,6}; 
System.arraycopy(fun,0,fun,3,3); 则结果为：{0,1,2,0,1,2,6}; 实现过程是这样的，先生成一个长
度为length的临时数组,将fun数组中srcPos 到srcPos+length-1之间的数据拷贝到临时数组中，再执行
System.arraycopy(临时数组,0,fun,3,3)
如：
// remove one item from array
private static String[] removeItemFromArray(String[] array, int index) {
    int length = array.length;
    Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
    System.arraycopy(array, 0, result, 0, index);
    if (index < length - 1) {
        System.arraycopy(array, index + 1, result, index, length - index - 1);
    }
    return (String[]) result;
}
----------------------------------------------------------------------
//验证
import org.springframework.util.Assert;
Assert.notNull(rse, "ResultSetExtractor must not be null");
----------------------------------------------------------------------
Map<String ,Object> map = new HashMap<String,Object>();
Collection c = map.values();

----------------------------------------------------------------------
>Map遍历

Map<String, DBObject> secuInfoMap = new HashMap<String, DBObject>();
// 遍历 secuIdMap, 用orgId 作为中介， 从 orgInfoMap 中取机构名称等
for (Map.Entry<String, String> entry : secuOrgIdMap.entrySet()) {
    String secu = entry.getKey();
    String orgId = entry.getValue();

    secuInfoMap.put(secu, orgInfoMap.get(orgId));
}

private static BasicDBObject prepareDBObject(LinkedHashMap<String, Object> map) {
        BasicDBObject dbObj = new BasicDBObject();

        Set<String> s = map.keySet();
        for (String key : s) {
            dbObj.put(key, map.get(key));
        }

        return dbObj;
    }
----------------------------------------------------------------------
> map 分组

public static void main(String[] args) {
        List<EventNewsCon> list = Lists.newArrayList();
        list.add(new EventNewsCon("1", "698", new Date(),new Date()));
        list.add(new EventNewsCon("1", "25478", new Date(),new Date()));
        list.add(new EventNewsCon("1", "25478", new Date(),new Date()));
        list.add(new EventNewsCon("21", "698", new Date(),new Date()));
        list.add(new EventNewsCon("21", "12014", new Date(),new Date()));
        
        // 分组  方式一
        Map<String, List<EventNewsCon>> collect0 = Maps.newConcurrentMap();
        list.forEach((one)->{
            List<EventNewsCon> va = collect0.get(one.getEvent_id());
            if(CollectionUtils.isEmpty(va)){
                va = Lists.newArrayList();
                collect0.put(one.getEvent_id(), va);
            }
            va.add(one);
        });
        System.out.println(collect0);
        
        // 分组 方式二
        Map<String, List<EventNewsCon>> collect = list.stream().collect(Collectors.groupingBy(k->k.getEvent_id()));
        System.out.println(collect);
        
        Map<String, List<RelationStock>> collect = data.stream().collect(Collectors.groupingBy(k -> k.getFp(), Collectors.toList()));

        // 分组 方式三
        Map<String, List<EventNewsCon>> collect1 = list.stream()
                .collect(Collectors.groupingBy(k->k.getEvent_id(),Collectors.mapping(v->v,Collectors.toList())));
        System.out.println(collect1);
        
        // 分组  {1=[698, 25478, 25478], 21=[698, 12014]}
        Map<String, List<String>> collect2 = list.stream()
                .collect(Collectors.groupingBy(k->k.getEvent_id(),Collectors.mapping(v->v.getNews_id(),Collectors.toList())));
        System.out.println(collect2);
        
        // 分组 value进行去重  {1=[698, 25478], 21=[698, 12014]}
        Map<String, Set<String>> collect3 = list.stream()
                .collect(Collectors.groupingBy(k->k.getEvent_id(),Collectors.mapping(v->v.getNews_id(),Collectors.toSet())));
        System.out.println(collect3);
}
----------------------------------------------------------------------
> map分组 对每组求和

// Stream的map和flatMap的区别:  map会将一个元素变成一个新的Stream   但是flatMap会将结果打平，得到一个单个元素
// 分组 ，对每组求和 
ReportAnalyseDetail t = new ReportAnalyseDetail();
List<String> auths = t.getAuths();

Map<String, Integer> map = data.stream().flatMap(e -> e.getAuths().stream()).collect(Collectors.groupingBy(k -> k, Collectors.summingInt(v -> 1)));

Map<String, Set<String>> newsEventIdMap = eventNewsConDao.fetchByNewsIds(newsIdList);
Set<Set<String>> collect = newsEventIdMap.entrySet().stream().map(k -> k.getValue()).collect(Collectors.toSet());
Set<String> eventIds = newsEventIdMap.entrySet().stream().flatMap(k -> k.getValue().stream()).collect(Collectors.toSet());

// 按照eq_feed_id分组并统计其数量
Map<String, Long> collect = equalsList.stream().collect(Collectors.groupingBy(k->k.getEq_feed_id(),Collectors.counting()));

----------------------------------------------------------------------
>list遍历
@SuppressWarnings("unchecked")
    private static List<String> delDuplicated(List<String> oldList) {
        Set<Object> set = new HashSet<Object>();
        List<String> newList = new ArrayList<String>();
        for (Iterator iter = oldList.iterator(); iter.hasNext();) {
            Object element = iter.next();
            if (set.add(element)) newList.add((String) element);
        }
        return newList;
    }

Map<K, V> map = ；
List<Map.Entry<K, V>> entrys = new ArrayList<>(map.entrySet());
Map<K, V> result = Maps.newLinkedHashMap();
entrys.stream().forEach((entry) -> result.put(entry.getKey(), entry.getValue()));

----------------------------------------------------------------------    
>利用StringUtils.join()方法拼接字符串
import org.apache.commons.lang.StringUtils;

List<String> results = new ArrayList<String>();
results.add(buildResultString("secu", "rpt", "item_cd", "current period", "current value", "unit",
   "previous period", "previous value", "unit", "ratio"));
   
 public static String buildResultString(String... fields){
    return StringUtils.join(fields, ",");
}

StringUtils.join(strings, separator);
      
----------------------------------------------------------------------
> 字符串时间比较大小

String dt = "";
String oneDt = "";
if(oneDt.compareTo(dt)<0){
    System.out.println("说明oneDt < dt");
}
----------------------------------------------------------------------
> map 初始化

/**
 *  HashMap 是没有顺序的；LinkedHashMap 是有顺序的
 */
public static final Map<String, String> MARKETMAP = new HashMap<String, String>() {
    private static final long serialVersionUID = -1454726433772295097L;
    {
        put("新加坡证券交易所第一股东", "新加坡证券交易所");
        put("深圳证券交易所主板A股", "深交所主板");
        put("纳斯达克证券交易所全球精选市场", "美国NASDAQ证券交易所");
        put("上海证券交易所A股", "上交所");
        put("深圳证券交易所中小企业板", "深交所中小板");
    }
};

public static void main(String[] args) {        
    for(String s : MARKETMAP.keySet()){
        System.out.println(s+"="+MARKETMAP.get(s));
    }
    
    System.out.println("*******************************************************");
    Map<String, String> map = new LinkedHashMap<String, String>();
    map.put("新加坡证券交易所第一股东", "新加坡证券交易所");
    map.put("深圳证券交易所主板A股", "深交所主板");
    map.put("纳斯达克证券交易所全球精选市场", "美国NASDAQ证券交易所");
    map.put("上海证券交易所A股", "上交所");
    map.put("深圳证券交易所中小企业板", "深交所中小板");
    
    for(String s : map.keySet()){
        System.out.println(s+"="+map.get(s)+"  ");
    }
}
----------------------------------------------------------------------
> List 进行截取多少个

public static void main(String[] args) {
    // 方式一
    List<Object> list = new ArrayList<Object>();
    list.add("a");list.add("b");list.add("c");
    list.add("d");list.add("e");list.add("f");
    list.add("g");list.add("h");
    // [a, b, c] [d, e] [f, g]  list 的subList默认有一个规则，接取是 包含头，不包含尾部， 最有要加上最后的
    System.out.println(list.subList(0, 3) + " "+ list.subList(3, 5) + " " + list.subList(5, list.size()-1));
    String idx50Code = list.subList(0, 3).toString();
    System.out.println(idx50Code);
    System.out.println(idx50Code.substring(1,idx50Code.length()-1));
    
    // 方式二
    List<EventTimelineDto> result = new ArrayList<EventTimelineDto>();
    int offset = 25;
    int limit = 20;
    result.subList(offset, Math.min(offset+=limit, result.size()))
    
    
    // 方式三
    List<String> list = Arrays.asList("1,2".split(","));
    System.out.println(list);
    list = list.stream().limit(3).collect(Collectors.toList());
    System.out.println(list);

    list = list.stream.skip(3)limit(6).collect(Collectors.toList());

    List<NewsFeed> list = dao.find(query, offset, limit);
    int total = list.size();
    int pos = 0;
    while (pos < total) 
        List<NewsFeed> subList = list.subList(pos, Math.min(pos+=1000, total));
    }    
}
----------------------------------------------------------------------
> 数据拼接
String header = String.format("%s,%s,%s,%s,%s,%s", 
    new Object[]{"时间","tick","主力流入","主力流出","小单流入","小单流出"});
System.out.println(header);
//输出结果为 ：  时间,tick,主力流入,主力流出,小单流入,小单流出

String.format("0 %d %d * * ?", "16", "25")
//输出结果为： 0 16 25 * * ?

----------------------------------------------------------------------