Java基础知识01

1. Java时间类

对时间类进行转换解析

1. 将时间字符串转换为时间戳

public static void main(String[] args) {
        String time = "20190619000000";
        SimpleDateFormat ft = new SimpleDateFormat ("yyyyMMddHHmmss");
        try {
            Date tmpdate = ft.parse(time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

2.统计两个时间区间的月的个数

private List<Integer> getMonsByTimeRange(String startTime, String endTime) throws ParseException {
        List<Integer> monLit = new ArrayList<>();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");//格式化为年月
        Calendar min = Calendar.getInstance();
        Calendar max = Calendar.getInstance();
        min.setTime(sdf.parse(startTime));
        min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);
        max.setTime(sdf.parse(endTime));
        max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);
        Calendar curr = min;
        while (curr.before(max)) {
            int mon = curr.getTime().getMonth();
            monLit.add(mon);
            curr.add(Calendar.MONTH, 1);
        }
        return monLit;
    }

2.Java文件操作类

1.遍历某个路径下的文件列表

    private List<String> GetFiles(String path) {
        List<String> tmpfilelist = new ArrayList<>();
        File tmpfilehandler = new File(path);
        for( File tmpfile: tmpfilehandler.listFiles()) {
            if ( tmpfile.isFile() ) {
                tmpfilelist.add(tmpfile.toString());
            }
        }
        return tmpfilelist;
    }

2.删除某个文件或某个目录下的所有文件

public static boolean DeleteFile(String filepath) {
    if (StringUtils.isEmpty(filepath) ) {
        return false;
    }
    File tmpfilehandler = new File(filepath);
    if ( !tmpfilehandler.exists() ) {
        return false;
    }
    if ( tmpfilehandler.isFile() ) {
        return tmpfilehandler.delete();
    } else {
        String []filenames = tmpfilehandler.list();
        for(String f: filenames) {
            DeleteFile(f);
        }
        return tmpfilehandler.delete();
    }
}

3. 列出某个目录下的所有目录

public static List<String> GetDirs(String path) {
    List<String> tmpdirlist = new ArrayList<>();
    File currentdir = new File(path);
    for( File tmpfile: currentdir.listFiles()) {
        if ( tmpfile.isDirectory() ) {
            tmpdirlist.add(tmpfile.toString());
        }
    }
    return tmpdirlist;
}

3.Java数值操作类

1. 将平时用到的数值操作类，集中管理，用于以后扩展

import java.math.BigDecimal;
/**
 * description
 *
 * @author ${user}
 * @Time 2019-06-23
 */
public class DecimalUtils {
    # 01.实现对指定浮点数范围
    public static float setScale(float value, int scala) {
        BigDecimal bigDecimal = new BigDecimal((double)value);
        bigDecimal = bigDecimal.setScale(scala, 4);
        return bigDecimal.floatValue();
    }
}

4.JAVA基础-Collections工具类

1.排序操作

Collections提供以下方法对List进行排序操作
void reverse(List list)：反转
void shuffle(List list),随机排序
void sort(List list),按自然排序的升序排序
void sort(List list, Comparator c);定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j),交换两个索引位置的元素
#list--这是一个不可修改视图是要返回的列表中
public static <T> List<T> unmodifiableList(List<? extends T> list)
void rotate(List list, int distance),旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。

下面简单演示Collections操作List

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class CollectionsTest {
    public static void main(String[] args) {
        ArrayList nums =  new ArrayList();
        nums.add(8);
        nums.add(-3);
        nums.add(2);
        nums.add(9);
        nums.add(-2);
        System.out.println(nums);
        Collections.reverse(nums);
        System.out.println(nums);
        Collections.sort(nums);
        System.out.println(nums);
        Collections.shuffle(nums);
        System.out.println(nums);
        //下面只是为了演示定制排序的用法，将int类型转成string进行比较
        Collections.sort(nums, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // TODO Auto-generated method stub
                String s1 = String.valueOf(o1);
                String s2 = String.valueOf(o2);
                return s1.compareTo(s2);
            }
        });
        System.out.println(nums);
    }
}

2. 查找，替换操作

int binarySearch(List list, Object key), 对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll),根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)，根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj),用元素obj填充list中所有元素
int frequency(Collection c, Object o)，统计元素出现次数
int indexOfSubList(List list, List target), 统计targe在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素。

下面示范简单用法

package collection.collections;
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsTest {
    public static void main(String[] args) {
        ArrayList num =  new ArrayList();
        num.add(3);
        num.add(-1);
        num.add(-5);
        num.add(10);
        System.out.println(num);
        System.out.println(Collections.max(num));
        System.out.println(Collections.min(num));
        Collections.replaceAll(num, -1, -7);
        System.out.println(Collections.frequency(num, 3));
        Collections.sort(num);
        System.out.println(Collections.binarySearch(num, -5));
    }
}

3. 同步控制

Collections中几乎对每个集合都定义了同步控制方法，
例如 SynchronizedList(), SynchronizedSet()等方法，
来将集合包装成线程安全的集合。下面是Collections将普通集合包装成线程安全集合的用法，

例子：

package collection.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class SynchronizedTest {
    public static void main(String[] args) {
        Collection c = Collections.synchronizedCollection(new ArrayList());
        List list = Collections.synchronizedList(new ArrayList());
        Set s = Collections.synchronizedSet(new HashSet());
        Map m = Collections.synchronizedMap(new HashMap());
    }
}

5. 常用类库：java.lang.ThreadLocal

1.使用场景

ThreadLocal和synchronized都是为了解决多线程中相同变量的访问冲突问题。
synchronized保证同一时刻只有一个线程对共享变量进行操作，synchronized是时间换空间的体现。
ThreadLocal使变量在每个线程中都有独立拷贝的共享变量，不会出现一个线程读取变量时而被另一个线程修改的现象。
ThreadLocal是编程中空间换时间的体现

2.ThreadLocal的内部结构

1、每个Thread线程内部都有一个Map。
2、Map里面存储线程本地对象（key）和线程的变量副本（value）。
3、每个Thread线程内部都有一个Map。
4、Thread对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，
    互不干扰。

3.ThreadLocal核心方法

get()方法用于获取当前线程的副本变量值。
set()方法用于保存当前线程的副本变量值。
initialValue()为当前线程初始副本变量值。
remove()方法移除当前前程的副本变量值。

4.ThreadLocal使用实例

//包含业务唯一标识的类
public class Context {
    private String transactionId;
    public String getTransactionId() {
        return transactionId;
    }
    public void setTransactionId(String transactionId) {
        this.transactionId = transactionId;
    }
}

// 其中引用了Context类
public class MyThreadLocal {
    private static final ThreadLocal<Context> userThreadLocal = new ThreadLocal<Context>();
    public static void set(Context user){
        userThreadLocal.set(user);
    }
    public static void unset(){
        userThreadLocal.remove();
    }
    public static Context get(){
        return userThreadLocal.get();
    }
}

//ThreadLocalDemo.java。生成并将业务标识设置到ThreadLocal中然后在业务方法中调用
public class ThreadLocalDemo implements Runnable{
    private static AtomicInteger ai = new AtomicInteger(0);
    public void run() {
        Context context = new Context();
        context.setTransactionId(getName());
        //设置线程变量
        MyThreadLocal.set(context);
        System.out.println("request["+Thread.currentThread().getName()+"]:"+context.getTransactionId());
        new BusinessService().businessMethod();
        MyThreadLocal.unset();
    }
    private String getName() {
        return ai.getAndIncrement()+"";
    }
    public static void main(String[] args) {
        ThreadLocalDemo tld  = new ThreadLocalDemo();
        new Thread(tld).start();
        new Thread(tld).start();
    }
}

public class BusinessService {
    public void businessMethod() {
        Context context = MyThreadLocal.get();
        System.out.println("service["+Thread.currentThread().getName()+"]:"+context.getTransactionId());
    }
}

5.ThreadLocal使用总结

1、每个ThreadLocal只能保存一个变量副本，如果想要上线一个线程能够保存多个副本以上，就需要创建多个ThreadLocal。
2、ThreadLocal内部的ThreadLocalMap键为弱引用，会有内存泄漏的风险。
3、ThreadLocal适用于无状态，副本变量独立后不影响业务逻辑的高并发场景。如果如果业务逻辑强依赖于副本变量，则不适合用ThreadLocal解决，需要另寻解决方案。

6. java8新特性-Base64

import java.util.Base64;
import java.util.UUID;
import java.io.UnsupportedEncodingException;
public class Java8Tester {
   public static void main(String args[]){
      try {
         // 使用基本编码
         String base64encodedString = Base64.getEncoder().encodeToString("runoob?java8".getBytes("utf-8"));
         System.out.println("Base64 编码字符串 (基本) :" + base64encodedString);
         // 解码
         byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
         System.out.println("原始字符串: " + new String(base64decodedBytes, "utf-8"));
         base64encodedString = Base64.getUrlEncoder().encodeToString("TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);
         StringBuilder stringBuilder = new StringBuilder();
         for (int i = 0; i < 10; ++i) {
            stringBuilder.append(UUID.randomUUID().toString());
         }
         byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
         String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
         System.out.println("Base64 编码字符串 (MIME) :" + mimeEncodedString);
      }catch(UnsupportedEncodingException e){
         System.out.println("Error :" + e.getMessage());
      }
   }
}

7.使用Kryo将数据尽心序列化到本地磁盘，反序列使用

Kryo工具类使用

/**
     * 序列化至硬盘
     * @param filePath  序列化路径
     * @param list      带序列号列表
     * @param <T>       泛型
     */
    public static <T> void serializeObject(String filePath, List<T> list) {
        if (CollectionUtils.isEmpty(list)) {
            LOGGER.warn("没有要待序列化的东西");
        }
        Kryo kryo = new Kryo();
        kryo.setReferences(false);
        kryo.setRegistrationRequired(false);
        kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
        Output output = null;
        try {
            Path path = Paths.get(filePath);
            if (Files.notExists(path)) {
                Files.createFile(path);
            }
            output = new Output(new FileOutputStream(filePath));
            T t = list.get(0);
            kryo.register(t.getClass());
            kryo.writeObject(output, t);
            for (int i = 1; i < list.size(); i++) {
                T instance = list.get(i);
                kryo.writeObject(output, instance);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LOGGER.warn(e.getMessage(), e.fillInStackTrace());
        } finally {
            if (output != null) {
                output.close();
            }
        }
    }
    /**
     * 反序列化至类
     * @param filePath  序列化文件路径
     * @param clazz     反序列化class类名
     * @param <T>       泛型
     * @return          反序列化后的类
     */
    public static <T>List<T> deserializeObject(String filePath,Class<T> clazz) {
        Path path = Paths.get(filePath);
        if (Files.notExists(path) || Files.isDirectory(path)) {
            LOGGER.warn("反序列化文件不存在,或不是文件");
            return null;
        }
        if(clazz == null){
            LOGGER.warn("反序列化的类为null");
            return null;
        }
        List<T> list = Lists.newArrayList();
        Kryo kryo = new Kryo();
        kryo.setReferences(false);
        kryo.setRegistrationRequired(false);
        kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
        Input input = null;
        try {
            T t;
            input = new Input(new FileInputStream(filePath),10240);
            while (input.canReadInt()){
                t = kryo.readObject(input,clazz);
                list.add(t);
            }
        }catch (IOException e){
            e.printStackTrace();
            LOGGER.error(e.getMessage(),e.fillInStackTrace());
        }finally {
            if(input != null){
                input.close();
            }
        }
        return list;
    }

8.List中的sort应用

List<Map<String, Object>> list = stationDrps.get(s);
float pv = 0;
float av = 0;
if (list.size() == 1) {
    //                logger.info(s+" drp: " + list.get(0).get("PVALUE").toString());
    String pvalue = list.get(0).get("PVALUE").toString();
    String absval = list.get(0).get("ABSVAL").toString();
    pv = Float.parseFloat(pvalue);
    av = Float.parseFloat(absval);
}
list.sort(new Comparator<Map<String, Object>>() {
    @Override
    public int compare(Map<String, Object> o1, Map<String, Object> o2) {
        String s1 = o1.get("ABSVAL").toString();
        String s2 = o2.get("ABSVAL").toString();
        float f1 = Float.parseFloat(s1);
        float f2 = Float.parseFloat(s2);
        if (f1 == f2) {
            return 0;
        }
        return f1 > f2 ? 1 : -1;
    }
});

9.正则匹配

public static void Test1() {
    String filename = "Z_P_LPD_C_BABJ_20190619005201_2019_06_19.txt";
    String pattern = "Z_P_LPD_C_BABJ_\\d{14}_\\d{4}(_\\d{2}){2}(.txt|.TXT)";
    Pattern r = Pattern.compile(pattern);
    boolean flag = r.matcher(filename).matches();
    System.out.println(flag);
}

10. Java 文件监控，实时监控文件加载之Commons-io

package wy.util.filemonitor;  
import java.io.File;  
import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;  
import org.apache.commons.io.monitor.FileAlterationObserver;  
import org.apache.log4j.Logger;  
/** 
 * 文件变化监听器 
 *  
 * 在Apache的Commons-IO中有关于文件的监控功能的代码. 文件监控的原理如下： 
 * 由文件监控类FileAlterationMonitor中的线程不停的扫描文件观察器FileAlterationObserver， 
 * 如果有文件的变化，则根据相关的文件比较器，判断文件时新增，还是删除，还是更改。（默认为1000毫秒执行一次扫描） 
 *  
 * @author wy 
 *  
 */  
public class FileListener extends FileAlterationListenerAdaptor {  
    private Logger log = Logger.getLogger(FileListener.class);  
    /** 
     * 文件创建执行 
     */  
    @Override  
    public void onFileCreate(File file) {  
        log.info("[新建]:" + file.getAbsolutePath());  
    }  
    /** 
     * 文件创建修改 
     */  
    @Override  
    public void onFileChange(File file) {  
        log.info("[修改]:" + file.getAbsolutePath());  
    }  
    /** 
     * 文件删除 
     */  
    @Override  
    public void onFileDelete(File file) {  
        log.info("[删除]:" + file.getAbsolutePath());  
    }  
    /** 
     * 目录创建 
     */  
    @Override  
    public void onDirectoryCreate(File directory) {  
        log.info("[新建]:" + directory.getAbsolutePath());  
    }  
    /** 
     * 目录修改 
     */  
    @Override  
    public void onDirectoryChange(File directory) {  
        log.info("[修改]:" + directory.getAbsolutePath());  
    }  
    /** 
     * 目录删除 
     */  
    @Override  
    public void onDirectoryDelete(File directory) {  
        log.info("[删除]:" + directory.getAbsolutePath());  
    }  
    @Override  
    public void onStart(FileAlterationObserver observer) {  
        // TODO Auto-generated method stub  
        super.onStart(observer);  
    }  
    @Override  
    public void onStop(FileAlterationObserver observer) {  
        // TODO Auto-generated method stub  
        super.onStop(observer);  
    }  
}

Java

package wy.util.filemonitor;  
import java.util.concurrent.TimeUnit;  
import org.apache.commons.io.filefilter.FileFilterUtils;  
import org.apache.commons.io.monitor.FileAlterationMonitor;  
import org.apache.commons.io.monitor.FileAlterationObserver;  
/** 
 * 文件监控测试 
 *  
 * 在Apache的Commons-IO中有关于文件的监控功能的代码. 文件监控的原理如下： 
 * 由文件监控类FileAlterationMonitor中的线程不停的扫描文件观察器FileAlterationObserver， 
 * 如果有文件的变化，则根据相关的文件比较器，判断文件时新增，还是删除，还是更改。（默认为1000毫秒执行一次扫描） 
 *  
 * @author wy 
 * 
 */  
public class FileMonitorTest {  
    /** 
     * @param args 
     */  
    public static void main(String[] args) throws Exception{  
        // 监控目录    
        String rootDir = "F:\\Resume";    
        // 轮询间隔 5 秒    
        long interval = TimeUnit.SECONDS.toMillis(5);  
        // 创建一个文件观察器用于处理文件的格式    
        FileAlterationObserver _observer = new FileAlterationObserver(    
                                              rootDir,     
                                              FileFilterUtils.and(    
                                               FileFilterUtils.fileFileFilter(),    
                                               FileFilterUtils.suffixFileFilter(".txt")),  //过滤文件格式    
                                              null);    
        FileAlterationObserver observer = new FileAlterationObserver(rootDir);  
        observer.addListener(new FileListener()); //设置文件变化监听器    
        //创建文件变化监听器    
        FileAlterationMonitor monitor = new FileAlterationMonitor(interval, observer);    
        // 开始监控    
        monitor.start();    
    }  
}

11.java 读取配置文件API

读取配置文件属性类

package com.hfqx.decodelpd.utils;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;
/**
 * description
 *
 * @author ${user}
 * @Time 2019-04-04
 */
public class PropertiesUtils {
    private final static String CONFIGPATH="config\\decode.properties";
    private static Properties properties;
    {
        properties = new Properties();
        try {
//            properties.load(new InputStreamReader(PropertiesUtils.class.getClassLoader().getResourceAsStream(CONFIGPATH),
//                    "UTF-8"));
            properties.load(new InputStreamReader(new FileInputStream(CONFIGPATH),
                    "UTF-8"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public  String getProperty(String key) {
        String value = null;
        value = properties.getProperty(key);
        return value;
    }
    public static void TestGetPro(String key) {
        PropertiesUtils propertiesUtils = new PropertiesUtils();
        String value = propertiesUtils.getProperty(key);
        System.out.println(value);
    }
    public static void main(String[] args) {
        TestGetPro("DATABASE_TYPE");
    }
}

12. Java解析气象温度 -项目中的应用

按行读取文件内容

读取站点信息

package com.example.extracttemp.demo.Utils;
import java.io.*;
import java.nio.Buffer;
import java.util.ArrayList;
import java.util.List;
/**
 * description
 *
 * @author ${user}
 * @Time 2019-06-06
 */
public class StationUtils {
    private String filepath = "data/station.txt";
    public List<String> getStations() throws IOException {
        List<String> stationList = new ArrayList<>();
        File file  = new File(filepath);
        FileReader fileReader = new FileReader(file);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String tmpline = null;
        while ( (tmpline = bufferedReader.readLine()) != null ) {
            stationList.add(tmpline);
        }
        return stationList;
    }
    public static void main(String[] args) {
        StationUtils stationUtils = new StationUtils();
        try {
            List<String> stationlist = stationUtils.getStations();
            System.out.println(stationlist.size());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

解析json字符串，并保存到文件中

package com.example.extracttemp.demo.Service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Service;
import java.io.*;
import java.math.BigDecimal;
import java.util.*;
@Service
public class ParseData {
//    Map<String, List<String>> YearAvgTemp = new HashMap<>();
//    Map<String, List<String>> YearAvgLandTemp =new HashMap<>();
//
//    Map<String, List<String>> YearMinTemp = new HashMap<>();
//    Map<String, List<String>> YearMinLandTemp = new HashMap<>();
//
//    Set<String> yearSet = new TreeSet<>();
//
//    Map<String, Float> YearAvgTempResult = new HashMap<>();
//    Map<String, Float> YearAvgTempLandResult = new HashMap<>();
//
//    Map<String, Integer> DayTempLess0Result = new HashMap<>();
//    Map<String, Integer> DayTempLess2Result = new HashMap<>();
//    Map<String, Integer> DayTempLess3Result = new HashMap<>();
//
//    Map<String, Integer> LandTempLess0Result = new HashMap<>();
    StringBuffer sBuffer = new StringBuffer("");
    {
//        sBuffer.append("年份,");
//        sBuffer.append("年平均温度,");
//        sBuffer.append("年平均地表温度,");
//        sBuffer.append("日最低温度低于0℃以下日数,");
//        sBuffer.append("日最低温度低于2℃以下日数,");
//        sBuffer.append("日最低温度低于3℃以下日数,");
//        sBuffer.append("地面最低温度低于0℃以下日数");
//        sBuffer.append("\r\n");
    }
    StringBuffer sBuffer1 = new StringBuffer("");
    {
        sBuffer1.append("年份,");
        sBuffer1.append("站点,");
        sBuffer1.append("年平均温度,");
        sBuffer1.append("年平均地表温度,");
        sBuffer1.append("日最低温度低于0℃以下日数,");
        sBuffer1.append("日最低温度低于2℃以下日数,");
        sBuffer1.append("日最低温度低于3℃以下日数,");
        sBuffer1.append("地面最低温度低于0℃以下日数");
        sBuffer1.append("\r\n");
    }
    public void Parse(String path) {
        List<String> stationFileList = GetFiles(path);
        for(String filename: stationFileList) {
            Map<String, List<String>> YearAvgTemp = new HashMap<>();
            Map<String, List<String>> YearAvgLandTemp =new HashMap<>();
            Map<String, List<String>> YearMinTemp = new HashMap<>();
            Map<String, List<String>> YearMinLandTemp = new HashMap<>();
            Set<String> yearSet = new TreeSet<>();
            Map<String, Float> YearAvgTempResult = new HashMap<>();
            Map<String, Float> YearAvgTempLandResult = new HashMap<>();
            Map<String, Integer> DayTempLess0Result = new HashMap<>();
            Map<String, Integer> DayTempLess2Result = new HashMap<>();
            Map<String, Integer> DayTempLess3Result = new HashMap<>();
            Map<String, Integer> LandTempLess0Result = new HashMap<>();
            String content = getContent(filename);
            JSONObject jsonObject = JSONObject.parseObject(content);
            JSONArray jsonArray =  jsonObject.getJSONArray("DS");
            String param = jsonObject.getString("requestParams");
            String stationId = GetStationId(param);
            if ( jsonArray.size() == 0 ) {
                return;
            }
            for ( int i = 0; i < jsonArray.size(); i++ ) {
                JSONObject jsonObject1 = (JSONObject)jsonArray.get(i);
                // GST_Avg 地面平均温度
                // GST_Min 地面最低温度
                // TEM_Avg 平均温度
                // TEM_Min 最低温度
                String sta = jsonObject1.getString("Datetime");
                String Gst_avg = jsonObject1.getString("GST_Avg");
                String Gst_Min = jsonObject1.getString("GST_Min");
                String Tem_Avg = jsonObject1.getString("TEM_Avg");
                String Tem_Min = jsonObject1.getString("TEM_Min");
                if ( "999999".equals(Gst_avg) ) {
                    Gst_avg = "0.0";
                }
                if ( "999999".equals(Tem_Avg) ) {
                    Tem_Avg = "0.0";
                }
                System.out.println(sta);
                String year =  sta.split("-")[0];
                String month = sta.split("-")[1];
                yearSet.add(year);
                if ( (YearAvgTemp.keySet().contains(year)) && (year.compareTo("1960") > 0)) {
                    YearAvgTemp.get(year).add(Tem_Avg);
                } else if (year.compareTo("1960") > 0) {
                    List<String> tempList = new ArrayList<>();
                    tempList.add(Tem_Avg);
                    YearAvgTemp.put(year, tempList);
                }
                if ( ( YearAvgLandTemp.keySet().contains(year)) && (year.compareTo("1960") > 0)){
                    YearAvgLandTemp.get(year).add(Gst_avg);
                } else if (year.compareTo("1960") > 0) {
                    List<String> tempList1 = new ArrayList<>();
                    tempList1.add(Gst_avg);
                    YearAvgLandTemp.put(year, tempList1);
                }
                if( month.compareTo("07") >= 0) {
                    // 下一年
                    String tmpyear = Integer.valueOf(year) + 1 + "";
                    if ( YearMinTemp.keySet().contains(tmpyear) ) {
                        YearMinTemp.get(tmpyear).add(Tem_Min);
                    } else {
                        List<String> tmpList = new ArrayList<>();
                        tmpList.add(Tem_Min);
                        YearMinTemp.put(tmpyear, tmpList);
                    }
                    if ( YearMinLandTemp.keySet().contains(tmpyear)) {
                        YearMinLandTemp.get(tmpyear).add(Gst_Min);
                    } else {
                        List<String> tmpList = new ArrayList<>();
                        tmpList.add(Gst_Min);
                        YearMinLandTemp.put(tmpyear, tmpList);
                    }
                } else {
                    // 今天
                    if ( YearMinTemp.keySet().contains(year) ) {
                        YearMinTemp.get(year).add(Tem_Min);
                    } else {
                        List<String> tmpList = new ArrayList<>();
                        tmpList.add(Tem_Min);
                        YearMinTemp.put(year, tmpList);
                    }
                    if ( YearMinLandTemp.keySet().contains(year)) {
                        YearMinLandTemp.get(year).add(Gst_Min);
                    } else {
                        List<String> tmpList = new ArrayList<>();
                        tmpList.add(Gst_Min);
                        YearMinLandTemp.put(year, tmpList);
                    }
                }
            }
            // 求年平均温度
            for( String tempyear: YearAvgTemp.keySet() ) {
                float tempsum = 0.0f;
                int count = 0;
                for(String tempvalue: YearAvgTemp.get(tempyear) ) {
                    tempsum += Float.valueOf(tempvalue);
                    count++;
                }
                float avgtemp = tempsum / count;
                BigDecimal bigDecimal = new BigDecimal((double)avgtemp);
                bigDecimal = bigDecimal.setScale(1, 4);
                avgtemp = bigDecimal.floatValue();
                YearAvgTempResult.put(tempyear, avgtemp);
            }
            // 求年平均地面温度
            for( String tempyear: YearAvgLandTemp.keySet() ) {
                float tempsum = 0.0f;
                int count = 0;
                for(String tempvalue: YearAvgLandTemp.get(tempyear) ) {
                    tempsum += Float.valueOf(tempvalue);
                    count++;
                }
                float avglandtemp = tempsum / count;
                BigDecimal bigDecimal = new BigDecimal((double)avglandtemp);
                bigDecimal = bigDecimal.setScale(1, 4);
                avglandtemp = bigDecimal.floatValue();
                YearAvgTempLandResult.put(tempyear, avglandtemp);
            }
            // 日最低温度天数
            for( String tempyear: YearMinTemp.keySet() ) {
                int less0count = 0;
                int less2count = 0;
                int less3count = 0;
                // 0
                for ( String tempvalue: YearMinTemp.get(tempyear) ) {
                    float tempmin = Float.valueOf(tempvalue);
                    if ( tempmin < 0.0 ) {
                        less0count++;
                    }
                    if ( tempmin < 2.0 ) {
                        less2count++;
                    }
                    if ( tempmin < 3.0 ) {
                        less3count++;
                    }
                }
                DayTempLess0Result.put(tempyear, less0count);
                DayTempLess2Result.put(tempyear, less2count);
                DayTempLess3Result.put(tempyear, less3count);
            }
            // 地面最低温度天数
            for ( String tempyear: YearMinLandTemp.keySet()) {
                int less0count = 0;
                for( String tempvalue: YearMinLandTemp.get(tempyear) ) {
                    float tmpvalue = Float.valueOf(tempvalue);
                    if ( tmpvalue <= 0.0 ) {
                        less0count++;
                    }
                }
                LandTempLess0Result.put(tempyear, less0count);
            }
            FileWriter fileWriter = null;
            FileWriter fileWriter2 = null;
            try {
                fileWriter = new FileWriter("E:\\StationResult\\result\\"+stationId+".csv", true);
                fileWriter2 = new FileWriter("E:\\StationResult\\result1\\allstations.csv", true);
            } catch (IOException e) {
                e.printStackTrace();
            }
            sBuffer.append("年份,");
            sBuffer.append("年平均温度,");
            sBuffer.append("年平均地表温度,");
            sBuffer.append("日最低温度低于0℃以下日数,");
            sBuffer.append("日最低温度低于2℃以下日数,");
            sBuffer.append("日最低温度低于3℃以下日数,");
            sBuffer.append("地面最低温度低于0℃以下日数");
            sBuffer.append("\r\n");
            for( String year: yearSet) {
                if ( year.compareTo("1960") == 0 ) {
                    continue;
                }
                sBuffer.append(year);
                sBuffer.append(",");
                sBuffer.append(YearAvgTempResult.get(year));
                sBuffer.append(",");
                sBuffer.append(YearAvgTempLandResult.get(year));
                sBuffer.append(",");
                sBuffer.append(DayTempLess0Result.get(year));
                sBuffer.append(",");
                sBuffer.append(DayTempLess2Result.get(year));
                sBuffer.append(",");
                sBuffer.append(DayTempLess3Result.get(year));
                sBuffer.append(",");
                sBuffer.append(LandTempLess0Result.get(year));
                sBuffer.append("\r\n");
                sBuffer1.append(year);
                sBuffer1.append(",");
                sBuffer1.append(stationId);
                sBuffer1.append(",");
                sBuffer1.append(YearAvgTempResult.get(year));
                sBuffer1.append(",");
                sBuffer1.append(YearAvgTempLandResult.get(year));
                sBuffer1.append(",");
                sBuffer1.append(DayTempLess0Result.get(year));
                sBuffer1.append(",");
                sBuffer1.append(DayTempLess2Result.get(year));
                sBuffer1.append(",");
                sBuffer1.append(DayTempLess3Result.get(year));
                sBuffer1.append(",");
                sBuffer1.append(LandTempLess0Result.get(year));
                sBuffer1.append("\r\n");
            }
            System.out.println(sBuffer.toString());
            try {
                fileWriter.write(sBuffer.toString());
                fileWriter2.write(sBuffer1.toString());
                sBuffer.delete(0, sBuffer.length());
                sBuffer1.delete(0, sBuffer1.length());
                fileWriter2.close();
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public String GetStationId(String content) {
        int index = content.indexOf("staIds");
        int index1 = content.indexOf(",", index);
        String stationid = content.substring(index + "staIds".length()+1, index1);
        return stationid;
    }
    public String getContent(String filepath) {
        BufferedReader reader = null;
        String tempString = null;
        try {
            reader = new BufferedReader(new FileReader(filepath));
            tempString = reader.readLine();
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return tempString;
    }
    private List<String> GetFiles(String path) {
        List<String> tmpfilelist = new ArrayList<>();
        File tmpfilehandler = new File(path);
        for( File tmpfile: tmpfilehandler.listFiles()) {
            if ( tmpfile.isFile() ) {
                tmpfilelist.add(tmpfile.toString());
            }
        }
        return tmpfilelist;
    }
}