• 关于http请求、文件处理以及空间地理信息处理的工具类介绍

    一.简介

           本篇主要是搜集了日常开发中比较常用的几个工具类，他们均以Java实现，包含了比较常用的方法。比如Java实现http常见的get和post请求，Java实现文件内容读写，Java实现处理空间地理信息数据，比如合并四维空间数据的处理等。

            将这些工具类记录下来，便于以后涉及类似的场景和业务，可以直接取用和参考，也利于日后不断的改进和优化。

    二.HttpClientUtil工具类

    1. package com.sina.weibo.util;
    2.  
    3. import java.io.*;
    4. import java.net.HttpURLConnection;
    5. import java.net.URL;
    6.  
    7. /**
    8.  * @classname HttpClientUtil
    9.  * @author bingqing5
    10.  * @date 2022/08/04 17:16
    11.  * @version 2.0
    12.  */
    13.  
    14. public class HttpClientUtil {
    15.  
    16.     /**
    17.      * 以get方式发起http请求，调用接口，获取数据
    18.      *
    19.      * @param httpUrl URL参数
    20.      * @return 返回调用接口获取的字符串数据
    21.      */
    22.     public static String doGet(String httpUrl) {
    23.         // 结果字符串
    24.         String result = "";
    25.         try {
    26.             // 创建远程url连接对象
    27.             URL url = new URL(httpUrl);
    28.             StringBuilder document = new StringBuilder();
    29.             // 将远程url转换为http远程连接类
    30.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    31.             // 设置请求方式：get
    32.             conn.setRequestMethod("GET");
    33.             conn.setDoOutput(true);
    34.             conn.setDoInput(true);
    35.             // 设置URLConnection的连接参数
    36.             conn.setRequestProperty("accept", "*/*");
    37.             conn.setRequestProperty("connection", "keep-Alive");
    38.             // 设置连接主机服务器的超时时间
    39.             conn.setConnectTimeout(15000);
    40.             // 设置读取远程返回的数据时间：60000毫秒
    41.             conn.setReadTimeout(60000);
    42.             InputStream input = null;
    43.             try {
    44.                 // 建立远程连接
    45.                 conn.connect();
    46.                 input = conn.getInputStream();
    47.             } catch (Exception e) {
    48.                 e.printStackTrace();
    49.             }
    50.  
    51.             BufferedReader reader = new BufferedReader(new InputStreamReader(input,"utf-8"));
    52.             String str = "";
    53.             while ((str = reader.readLine()) != null) {
    54.                 document.append(str);
    55.             }
    56.             result = document.toString();
    57.             reader.close();
    58.             // 释放资源
    59.             input.close();
    60.             // 关闭连接
    61.             conn.disconnect();
    62.  
    63.         } catch (Exception e) {
    64.             e.printStackTrace();
    65.         }
    66.  
    67.         return result;
    68.     }
    69.  
    70.     /**
    71.      * 以post方式发起请求，调用接口，获取数据
    72.      * @param url 接口链接
    73.      * @param param 请求参数
    74.      * @return 以字符串形式返回接口获取的数据
    75.      */
    76.     public static String doPost(String url, String param) {
    77.         PrintWriter out = null;
    78.         BufferedReader in = null;
    79.         String result = "";
    80.         try {
    81.             URL realUrl = new URL(url);
    82.             // 将远程url转换为http远程连接类
    83.             HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();
    84.             // 设置请求属性
    85.             conn.setRequestProperty("accept", "*/*");
    86.             conn.setRequestProperty("connection", "keep-Alive");
    87.             conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
    88.             conn.setRequestProperty("Charset", "UTF-8");
    89.             // 设置URL请求方式
    90.             conn.setRequestMethod("POST");
    91.             // 使用URL进行输出
    92.             conn.setDoOutput(true);
    93.             // 使用URL进行输入
    94.             conn.setDoInput(true);
    95.  
    96.             // 建立输出流，并写入数据
    97.             out = new PrintWriter(conn.getOutputStream());
    98.             out.print(param);
    99.             out.flush();
    100.             in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
    101.             String line;
    102.             while ((line = in.readLine()) != null) {
    103.                 result += line;
    104.             }
    105.         } catch (Exception e) {
    106.             e.printStackTrace();
    107.         }
    108.         finally {
    109.             try {
    110.                 if (out != null) {
    111.                     out.close();
    112.                 }
    113.                 if (in != null) {
    114.                     in.close();
    115.                 }
    116.             } catch (IOException e) {
    117.                 e.printStackTrace();
    118.             }
    119.         }
    120.  
    121.         return result;
    122.     }
    123.  
    124. }

          以上HttpClientUtil类提供了两个方法：doGet()和doPost()基本满足用Java实现调用第三方提供的接口做数据处理的场景。本人在日常工作中使用这两个方法去调用PHP后台接口，获取的数据一般是JSON字符串。经历了不知道多少次的调用，这两个方法都工作的很好。

    三.FileUtils工具类

    1. package com.sina.weibo.util;
    2.  
    3. import java.io.*;
    4. import java.util.ArrayList;
    5. import java.util.List;
    6.  
    7. /**
    8.  * {@code FileUtils}是文件处理工具类。它提供了多种方法用于处理文件
    9.  * 的读取和写入。
    10.  *
    11.  * @className FileUtils
    12.  * @author bingqing5
    13.  * @date 2022/03/07 11:30
    14.  * @version 2.0
    15.  */
    16.  
    17. public class FileUtils {
    18.  
    19.     /**
    20.      * 文件内容追加，以换行符结尾
    21.      *
    22.      * @param fileName 文件名（绝对文件路径名）
    23.      * @param content 文件内容
    24.      */
    25.     public static void appendInfoToFile(String fileName, String content) {
    26.         File file = new File(fileName);
    27.         try {
    28.             // 如果文件不存在，新建一个文件
    29.             if (!file.exists()) {
    30.                 file.createNewFile();
    31.             }
    32.             OutputStreamWriter fileWriter = new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8");
    33.             content = content + "\r\n";
    34.             fileWriter.write(content);
    35.             fileWriter.flush();
    36.             fileWriter.close();
    37.         } catch (IOException e) {
    38.             e.printStackTrace();
    39.         }
    40.     }
    41.  
    42.     /**
    43.      * 文件内容读取，将内容存入集合中返回
    44.      *
    45.      * @param fileName 文件名（绝对文件路径名）
    46.      * @return 返回字符串list集合
    47.      */
    48.     public static List readInfoFromFile(String fileName) {
    49.         File file = new File(fileName);
    50.         if (!file.exists()) {
    51.             return null;
    52.         }
    53.         List list = new ArrayList();
    54.         try {
    55.             BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
    56.             String str = null;
    57.             while (null != (str = bufferedReader.readLine())) {
    58.                 list.add(str);
    59.             }
    60.             bufferedReader.close();
    61.         } catch (IOException e) {
    62.             e.printStackTrace();
    63.         }
    64.         return list;
    65.     }
    66.  
    67.  
    68. }

          以上FileUtils工具类提供了两个方法：appendInfoToFile()和readInfoFromFile()，分别用于将数据写入文件和将数据文件中读取存放到list集合中。需要注意的时，实践中，如果数据量达上亿条，1个G以上，读取时间会稍微拉长，达一分钟以上。当然，也并不一定要将数据存入list集合中再进行处理，可以读取一行数据以后及时处理，再读取下一行。但是往往在数据量很大的时候，处理数据需要关注一个问题：那就是如何防止数据重复处理，特别是在程序运行过程中被中断以后。将数据读取一遍存入list集合中个，诚然会消耗额外的内存资源，但与此同时也可以使用hashSet或LinkedHashSet存放已处理数据，在读取过程中与数据源集合中的数据对比，以便于达到避免重复处理相同的数据带来的开销。

          readInfoFromFile()方法只是针对特定文件目录下的单一文件，现实中也有很多场景需要读取文件目录下同类型的所有文件，这就需要去扫描文件目录下后缀相同的文件。以下方法，提供了实现：

    1. package siweiAutoUpdate.parse;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.FileOutputStream;
    6. import java.io.InputStream;
    7. import java.io.InputStreamReader;
    8. import java.io.Reader;
    9. import java.util.ArrayList;
    10. import java.util.HashMap;
    11. import java.util.HashSet;
    12. import java.util.List;
    13. import java.util.Map;
    14. import java.util.Set;
    15.  
    16. public class ParseSiweiBaseData {
    17.  
    18. 	private static List filePNameList = new ArrayList();
    19. 	private static List filePOIList = new ArrayList();
    20. 	private static List fileRelationList = new ArrayList();
    21.  
    22.  
    23. 	private static void scanPNameFile(File file) {
    24. 		if (file.isDirectory()) {
    25. 			File[] files = file.listFiles(new FileFilter() {
    26. 				public boolean accept(File pathname) {
    27. 					return pathname.isDirectory()
    28. 							|| (pathname.getPath().endsWith(".mid") && pathname.getName().startsWith("PName"));
    29. 				}
    30. 			});
    31. 			for (File one : files) {
    32. 				scanPNameFile(one);
    33. 			}
    34. 		} else {
    35. 			filePNameList.add(file.getAbsolutePath());
    36. 		}
    37. 	}
    38.  
    39. 	private static void scanPOIFile(File file) {
    40. 		if (file.isDirectory()) {
    41. 			File[] files = file.listFiles(new FileFilter() {
    42. 				public boolean accept(File pathname) {
    43. 					return pathname.isDirectory() || (pathname.getPath().endsWith(".mid")
    44. 							&& !pathname.getName().startsWith("POI_") && pathname.getName().startsWith("POI"));
    45. 				}
    46. 			});
    47. 			for (File one : files) {
    48. 				scanPOIFile(one);
    49. 			}
    50. 		} else {
    51. 			filePOIList.add(file.getAbsolutePath());
    52. 		}
    53. 	}
    54.  
    55. 	private static void scanRelationFile(File file) {
    56. 		if (file.isDirectory()) {
    57. 			File[] files = file.listFiles(new FileFilter() {
    58. 				public boolean accept(File pathname) {
    59. 					return pathname.isDirectory()
    60. 							|| (pathname.getPath().endsWith(".mid") && pathname.getName().startsWith("POI_Relation"));
    61. 				}
    62. 			});
    63. 			for (File one : files) {
    64. 				scanRelationFile(one);
    65. 			}
    66. 		} else {
    67. 			fileRelationList.add(file.getAbsolutePath());
    68. 		}
    69. 	}
    70.  
    71. }

    四.GeoUtils和Wkt类

          GetoUtils类相关依赖：

    1.         <dependency>
    2.             <groupId>com.vividsolutionsgroupId>
    3.             <artifactId>jtsartifactId>
    4.             <version>1.8version>
    5.         dependency>

         代码如下：

    1. package com.sina.weibo.util;
    2.  
    3. import com.vividsolutions.jts.geom.*;
    4. import com.vividsolutions.jts.io.ParseException;
    5. import com.vividsolutions.jts.io.WKTReader;
    6.  
    7. import java.io.*;
    8. import java.text.DecimalFormat;
    9. import java.util.zip.GZIPInputStream;
    10.  
    11. public class GeoUtils {
    12.  
    13.     public static final ThreadLocal FORMAT_LNGLAT = new ThreadLocal(){
    14.         @Override
    15.         protected DecimalFormat initialValue() {
    16.             // TODO Auto-generated method stub
    17.             return new DecimalFormat("###.00000");
    18.         }
    19.     };
    20.  
    21.     /**
    22.      * 创建WGS84的GeometryFactory
    23.      *
    24.      * WGS-84 地心坐标系 4326
    25.      * GCJ-02火星坐标系  3857
    26.      *
    27.      *
    28.      * 地理坐标系：GCS_WGS_1984：WKID: 4326 权限: EPSG
    30.      投影坐标系：WGS_1984_Web_Mercator_Auxiliary_Sphere：WKID: 3857 权限: EPSG
    33.      *
    34.      *
    35.      */
    36.     static final GeometryFactory geometryFactory = new GeometryFactory(
    37.             //new PrecisionModel(PrecisionModel.FLOATING), 4326);
    38.             new PrecisionModel(PrecisionModel.FLOATING), 3857);
    39.  
    40.     /**
    41.      * 获得WGS84的GeometryFactory
    42.      * @return WGS84的GeometryFactory
    43.      */
    44.     public static final GeometryFactory getGeometryFactory() {
    45.         return geometryFactory;
    46.     }
    47.  
    48.     public static double formatLngLat(double lnglat){
    49.         return Double.valueOf(FORMAT_LNGLAT.get().format(lnglat));
    50.     }
    51.  
    52.     /**
    53.      * 根据WKT生成MultiPolygon
    54.      * @param wktPolygon 多边形的WKT
    55.      * @return WKT生成MultiPolygon
    56.      * @throws ParseException 生成MultiPolygon时发生异常
    57.      */
    58.     public static final MultiPolygon getMultiPolygon(String wktPolygon) {
    59.         String wktPolygonN=null;
    60.         try{
    61.             if(wktPolygon.toUpperCase().startsWith("POLYGON")){
    62.                 wktPolygonN=wktPolygon.replace("POLYGON", "MULTIPOLYGON").replace("((", "(((").replace("))", ")))");
    63.             }else{
    64.                 wktPolygonN=wktPolygon;
    65.             }
    66.             WKTReader reader = new WKTReader(geometryFactory);
    67.             return (MultiPolygon) reader.read(wktPolygonN);
    68.         }catch(Exception e){
    69.             e.printStackTrace();
    70.         }
    71.         return null;
    72.     }
    73.  
    74.     /**
    75.      * 通过经纬度点生成多边形对象
    76.      * @param ordinates 经纬度点，格式:经度,纬度,经度,纬度...
    77.      * @return 生成的多边形对象
    78.      */
    79.     public static final Polygon getPolygon(double[] ordinates) {
    80.         if (ordinates.length % 2 == 1)
    81.             throw new RuntimeException("ordinates.length = " + ordinates.length + " error!");
    82.  
    83.         int lnglatLength = ordinates.length / 2;
    84.  
    85.         // 保证首位经纬度相同
    86.         Coordinate[] coordinates = null;
    87.         if (ordinates[0] == ordinates[ordinates.length - 2] && ordinates[1] == ordinates[ordinates.length -1]) {
    88.             coordinates = new Coordinate[lnglatLength];
    89.         } else {
    90.             coordinates = new Coordinate[lnglatLength + 1];
    91.             coordinates[coordinates.length - 1] = new Coordinate(ordinates[0], ordinates[1]);
    92.         }
    93.  
    94.         for (int i = 0; i < lnglatLength; i++) {
    95.             coordinates[i] = new Coordinate(ordinates[i*2],ordinates[i*2+1]);
    96.         }
    97.         LinearRing lr = geometryFactory.createLinearRing(coordinates);
    98.         return geometryFactory.createPolygon(lr, null);
    99.     }
    100.  
    101.     /**
    102.      * 通过经纬度点生成路线
    103.      * @param ordinates 经纬度点，格式:经度,纬度,经度,纬度...
    104.      * @return 生成的路线
    105.      */
    106.     public static final LineString getLineString(double[] ordinates) {
    107.         if (ordinates.length % 2 == 1)
    108.             throw new RuntimeException("ordinates.length = " + ordinates.length + " error!");
    109.  
    110.         Coordinate[] coordinates = new Coordinate[ordinates.length / 2];
    111.         for (int i = 0; i < coordinates.length; i++) {
    112.             coordinates[i] = new Coordinate(ordinates[i*2],ordinates[i*2+1]);
    113.         }
    114.  
    115.         return geometryFactory.createLineString(coordinates);
    116.     }
    117.  
    118.     /**
    119.      * 通过经纬度点生成多边形对象
    120.      * @param coordinates 经纬度点
    121.      * @return 生成的多边形对象
    122.      */
    123.     public static final Polygon getPolygon(Coordinate[] coordinates) {
    124.  
    125.         // 保证首位经纬度相同
    126.         Coordinate[] lrCoordinates = null;
    127.         if (coordinates[0].x == coordinates[coordinates.length -1].x && coordinates[0].y == coordinates[coordinates.length -1].y) {
    128.             lrCoordinates = coordinates;
    129.         } else {
    130.             lrCoordinates = new Coordinate[coordinates.length + 1];
    131.             for (int i = 0; i < coordinates.length; i++) {
    132.                 lrCoordinates[i] = coordinates[i];
    133.             }
    134.             lrCoordinates[lrCoordinates.length - 1] = coordinates[0];
    135.         }
    136.  
    137.         LinearRing lr = geometryFactory.createLinearRing(lrCoordinates);
    138.         return geometryFactory.createPolygon(lr, null);
    139.     }
    140.  
    141.     /**
    142.      * 根据WKT生成空间对象
    143.      * @param  空间对象的类
    144.      * @param wkt WKT
    145.      * @param t 空间对象的实例
    146.      * @return WKT生成空间对象
    147.      * @throws ParseException 生成MultiPolygon时发生异常
    148.      */
    149.     public static final  T getGeometry(final String wkt, final Class t) throws ParseException {
    150.         WKTReader reader = new WKTReader(geometryFactory);
    151.         return (T) reader.read(wkt);
    152.     }
    153.  
    154.     /**
    155.      * 根据WKT生成MultiLineString
    156.      * @param wktLineString WKT
    157.      * @return 生成的MultiLineString
    158.      * @throws ParseException 生成MultiLineString时发生异常
    159.      */
    160.     public static final MultiLineString getMultiLineString(String wktLineString) throws ParseException {
    161.         WKTReader reader = new WKTReader(geometryFactory);
    162.         return (MultiLineString) reader.read(wktLineString);
    163.     }
    164.  
    165.     /**
    166.      * 地球赤道半径，单位米
    167.      */
    168.     public static final double EARTH_RADIUS = 6378137;
    169.  
    170.     /**
    171.      * 面积(平方米)
    172.      *
    173.      */
    174.     public static double getArea(Geometry wktGeo){
    175.         double km=wktGeo.getArea()*10000;//平方公里
    176.         return km*1000000;
    177.     }
    178.  
    179.     /**
    180.      * 距离(米)
    181.      *
    182.      */
    183.     public static long getDistance(Geometry geometry1,Geometry geometry2){
    184.         long distance=(long)(geometry1.distance(geometry2)*100000);
    185.         return distance;
    186.     }
    187.  
    188.  
    189.     /**
    190.      * 角度转弧度
    191.      *
    192.      * */
    193.     public static double angleToRad(double angle) {
    194.         return angle * Math.PI / 180.0;
    195.     }
    196.  
    197.     /**
    198.      * 弧度转角度
    199.      *
    200.      * */
    201.     public static double radToAngle(double rad) {
    202.         return 180.0/Math.PI * rad;
    203.     }
    204.  
    205.     /**
    206.      * 计算两个空间坐标点之间的距离，单位米
    207.      * @param lng1 空间坐标点1的经度，单位度
    208.      * @param lat1 空间坐标点1的纬度，单位度
    209.      * @param lng2 空间坐标点2的经度，单位度
    210.      * @param lat2 空间坐标点2的纬度，单位度
    211.      * @return 两个空间坐标点之间的距离，单位米
    212.      */
    213.     public static double computeDistance(double lng1, double lat1, double lng2, double lat2) {
    214.         final double radLat1 = angleToRad(lat1);
    215.         final double radLat2 = angleToRad(lat2);
    216.         final double a = radLat1 - radLat2;
    217.         final double b = angleToRad(lng1) - angleToRad(lng2);
    218.         double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) +
    219.                 Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
    220.         s = s * EARTH_RADIUS;
    221.         //s = Math.round(s * 10000) / 10000;
    222.         return s;
    223.     }
    224.  
    225.     /**
    226.      * 获得p2点相对于p1点的极坐标方向，方向范围[0,360)
    227.      * @param lng1 p1点的经度，单位度
    228.      * @param lat1 p1点的纬度，单位度
    229.      * @param lng2 p2点的经度，单位度
    230.      * @param lat2 p2点的纬度，单位度
    231.      * @return 获得p2点相对于p1点的极坐标方向，方向范围[0,360)
    232.      */
    233.     public static double getDirection(double lng1, double lat1, double lng2, double lat2) {
    234.         double a = (Math.atan2(lng2 - lng1, lat2 - lat1) * 180d / Math.PI);
    235.         if (a < 0) {
    236.             a += 360;
    237.         }
    238.         return a;
    239.     }
    240.  
    241.     public static final double R=22.5;
    242.     public static final double R_3=R*3;
    243.     public static final double R_5=R*5;
    244.     public static final double R_7=R*7;
    245.     public static final double R_9=R*9;
    246.     public static final double R_11=R*11;
    247.     public static final double R_13=R*13;
    248.     public static final double R_15=R*15;
    249.  
    250.     /**
    251.      * 获得角度方向的空间描
    252.      * 每个象限分为4部分(22.5)
    253.      * @param dirValue 角度方向值
    254.      * @param isFuzzy 是否为模糊描述，当为true时描述信息只表示北、东北、东、东南等八个方向；当
    255.      *                为false时返回以南北为参考的具体角度信息（非西方的以东西为参考），如正北，
    256.      *                北偏东30度等。
    257.      * @return 获得角度方向的空间描述
    258.      */
    259.     public static String getDirectionDesc(int dirValue, boolean isFuzzy) {
    260.         String str1 = "";
    261.         dirValue %= 360;
    262.         if (dirValue < 0) dirValue += 360;
    263.         if (isFuzzy) {
    264.             if (dirValue <= R || dirValue >= R_15) str1 = "北";
    265.             else if (dirValue < R_3) str1 = "东北";
    266.             else if (dirValue <= R_5) str1 = "东";
    267.             else if (dirValue < R_7) str1 = "东南";
    268.             else if (dirValue <= R_9) str1 = "南";
    269.             else if (dirValue < R_11) str1 = "西南";
    270.             else if (dirValue <= R_13) str1 = "西";
    271.             else if (dirValue < R_15) str1 = "西北";
    272.  
    273.         } else {
    274.  
    275.             if(dirValue==0)str1="正北";
    276.             else if(dirValue<90)str1="北偏东";
    277.             else if(dirValue==90) str1="正东";
    278.             else if(dirValue<180 && dirValue>90) str1="南偏东";
    279.             else if(dirValue==180) str1="正南";
    280.             else if(dirValue<270 && dirValue>180) str1="南偏西";
    281.             else if(dirValue==270) str1="正西";
    282.             else if(dirValue<360 && dirValue>270) str1="北偏西";
    283.  
    284.         }
    285.  
    286.  
    287.         return str1;
    288.     }
    289.  
    290.     /**
    291.      * 将double型的数四舍五入成多少位的数，当length大于0时，表示四舍五入小数点后length位；当length等于0时，表示四舍五入
    292.      * 到整数；当length小于0时，表示四舍五入到整数部分前-length位。
    293.      * @param value 待转换的数值
    294.      * @param length 截取长度
    295.      * @return 四舍五入后的数值
    296.      */
    297.     public static String roundTo(double value, int length) {
    298.         value *= Math.pow(10, length);
    299.         long result = Math.round(value);
    300.  
    301.         double newValue = result * Math.pow(10, -length);
    302.         if (length <= 0) {
    303.             return String.valueOf((long) newValue);
    304.         } else {
    305.             String resultStr = String.valueOf(newValue);
    306.             int pos = resultStr.indexOf(".");
    307.             int newLength = resultStr.length() - pos - 1;
    308.             for (int i = newLength; i < length; i++) {
    309.                 resultStr += "0";
    310.             }
    311.             return resultStr.substring(0, pos + 1 + length);
    312.         }
    313.     }
    314.  
    315.     public static String readGeoloc(byte[] columnBlob) throws IOException {
    316.         ByteArrayInputStream bais=new ByteArrayInputStream(columnBlob);
    317.         BufferedInputStream b=new BufferedInputStream(new GZIPInputStream(bais));
    318.         BufferedReader br=new BufferedReader(new InputStreamReader(b));
    319.         StringBuffer sb=new StringBuffer();
    320.         String p=br.readLine();
    321.         while(p!=null){
    322.             sb.append(p);
    323.             p=br.readLine();
    324.         }
    325.         
    326.         br.close();
    327.         b.close();
    328.         bais.close();
    329.         p=sb.toString();
    330.         sb.delete(0, p.length());
    331.         return p;
    332.     }
    333.  
    334.  
    335. }

         Wkt类提供了合并wkt数据的方法，代码如下：

    1. package com.sina.weibo.process;
    2.  
    3. import com.sina.weibo.entity.WktObject;
    4. import com.sina.weibo.util.FileUtils;
    5. import com.sina.weibo.util.GeoUtils;
    6. import com.vividsolutions.jts.geom.Geometry;
    7. import com.vividsolutions.jts.geom.MultiPolygon;
    8.  
    9. import java.util.ArrayList;
    10. import java.util.HashMap;
    11. import java.util.List;
    12. import java.util.Map;
    13. import java.util.stream.Collectors;
    14.  
    15. /**
    16.  * @author bingqing5
    17.  * @date 2022/08/03
    18.  * @version 1.0
    19.  */
    20.  
    21. public class Wkt {
    22.  
    23.  
    24.     /**
    25.      * 合并wkt数据
    26.      *
    27.      * @param list wkt列表
    28.      * @return wkt文本
    29.      */
    30.     public static String mergeWkt(List list) {
    31.         Geometry multiPolygon = null;
    32.         int mc = 0;
    33.         for (int i = 0; i < list.size(); i++) {
    34.             String w = list.get(i).toUpperCase();
    35.             if (w.startsWith("POLYGON") || w.startsWith("MULTIPOLYGON")) {
    36.                 MultiPolygon multiPolygonTmp = GeoUtils.getMultiPolygon(w);
    37.                 mc++;
    38.                 if (multiPolygon == null) {
    39.                     multiPolygon = (Geometry) multiPolygonTmp;
    40.                 } else {
    41.                     multiPolygon = multiPolygon.union(multiPolygonTmp);
    42.                 }
    43.             }
    44.         }
    45.  
    46.         return multiPolygon.toText();
    47.     }
    48. }

          该方法在运行时会消耗大量的内存资源，而且数据处理时间较长。这是需要注意的点。

  • 相关阅读:
    Fama-French三因子和五因子模型和Stata代码（内附原始数据）
    Windows 安装TVM 及各种报错解决！无GPU版本
    声明式HTTP客户端-Feign 使用入门详解
    线性代数学习笔记7-2：矩阵对角化、求矩阵的幂、求一阶差分方程和Fibonacci数列（特征值的应用）
    Go开源世界主流成熟ORM框架gorm实践分享
    C语言变量定义选择题
    Spring Bean 的一生
    GBASE 8A v953报错集锦51--非空列的数据加载
    Springboot毕设项目老来福平台682f5（java+VUE+Mybatis+Maven+Mysql）
    分析入门 Python 股票量化交易的原因
  • 原文地址：https://blog.csdn.net/lbq15735104044/article/details/126580198