java使用GeoTools读取shp文件并画图的操作代码

GeoTools是ArcGis地图与java对象的桥梁，恰如jdbc之于oracle与java。
shp文件本身是存有地理对象边界坐标、对象中心城市及城市编号的多多边形字符串。
需要使用的依赖如下

 
        
            org.geotools
            gt-shapefile
            ${geotools.version}
        

        
            org.geotools
            gt-swing
            ${geotools.version}
        
        
        
            dom4j
            dom4j
            1.6.1
        
        
            com.alibaba
            fastjson
            1.2.47
        

对象：

public class CutProperty {

    private String province;
    private int x;
    private int y;

    /**
     * 图片宽
     * */
    private int width;

    /**
     * 图片高
     * */
    private int height;

    /**
     * 画图时线条粗细
     * */
    private float weight;

    /**
     * 地图坐标右边界
     * */
    private int rightborder;

    /**
     * 地图坐标放大倍数
     * */
    private int bei;

    /**
     * 文字大小
     * */
    private int stringsize;

来自@author [email protected]的工具类，读取shp文件：

package com.gwhn.geotools;

import org.geotools.data.FeatureWriter;
import org.geotools.data.FileDataStoreFactorySpi;
import org.geotools.data.Transaction;
import org.geotools.data.shapefile.ShapefileDataStore;
import org.geotools.data.shapefile.ShapefileDataStoreFactory;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.geotools.data.simple.SimpleFeatureSource;
import org.geotools.feature.FeatureCollection;
import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
import org.geotools.referencing.crs.DefaultGeographicCRS;
import org.junit.Test;
import org.locationtech.jts.geom.*;
import org.opengis.feature.Property;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;

import java.io.File;
import java.io.Serializable;
import java.nio.charset.Charset;
import java.util.*;

public class ShapeUtil {

    //读shp文件【几何信息+属性信息】
    public List SHPRead(String path) throws Exception {
        List propertyList = new ArrayList<>();
        //基于上面新建的shapfile文件，进行读取

        //构建shapefile数据存储的实例
        ShapefileDataStoreFactory dataStoreFactory = new ShapefileDataStoreFactory();

        //基于路径构建文件对象
        File file = new File(path);

        //构建一个已存在的shapfile数据源
        //ShapefileDataStore:数据存储实现，允许从Shapefiles读取和写入
        ShapefileDataStore ds = (ShapefileDataStore) dataStoreFactory.createDataStore(file.toURI().toURL());

        //设置编码，防止中文读取乱码
        ds.setCharset(Charset.forName("UTF-8"));

        //getFeatureSource():ContentFeatureSource
        //这个特性是由 FeatureCollection提供的操作完成的。单独的特征记忆实现由子类提供:
        //SimpleFeatureSource特征资源明确地使用FeatureCollection【集合】，可迭代
        SimpleFeatureSource featureSource = ds.getFeatureSource();

        //getFeatures():以FeatureCollection的形式检索所有特性。
        //一个用于处理FeatureCollection的实用工具类。提供一个获取FeatureCollection实例的机制
        FeatureCollection result = featureSource.getFeatures();

        System.out.println("几何对象总共有：" + result.size());
        //features():返回一个FeatureIterator迭代器
        SimpleFeatureIterator it = (SimpleFeatureIterator) result.features();

        while (it.hasNext()) {
            SimpleFeature feature = it.next();
            //迭代属性【属性我们可以理解为一个几何对象的属性节点，也就是对一个几何图形的描述字段】
            Iterator ip = feature.getProperties().iterator();
//            System.out.println("========================");
            //再来个while
            while (ip.hasNext()) {
                Property pro = ip.next();
//                System.out.println(pro.getName()+" = "+pro.getValue());
                propertyList.add(pro);
            }//end 属性迭代
        }
        it.close();
        return propertyList;
    }
   
}

来自@author [email protected]的工具类，此处用来将shp中获取的字符串转化为多多边形对象MultiPolygon

package com.gwhn.geotools;


import org.locationtech.jts.geom.*;
import org.locationtech.jts.io.ParseException;
import org.locationtech.jts.io.WKTReader;

import java.util.List;

/**
 * 几何对象构建器
 *
 * @author [email protected]
 * @version V1.0.1
 * @blob http://blog.csdn.net/appleyk
 * @date 2017年12月8日10:38:49
 */

//单例模式
public class GeometryCreator {

    public static GeometryCreator geometryCreator = null;

    private GeometryFactory geometryFactory = new GeometryFactory();

    public GeometryCreator() {
    }

    /**
     * 返回本类的唯一实例
     *
     * @return
     */
    public static GeometryCreator getInstance() {
        if (geometryCreator == null) {
            return new GeometryCreator();
        }
        return geometryCreator;
    }


    /**
     * 1.构建点
     */

    /**
     * 1.1根据X，Y坐标构建一个几何对象： 点 【Point】
     *
     * @param x
     * @param y
     * @return
     */
    public Point createPoint(double x, double y) {
        Coordinate coord = new Coordinate(x, y);
        Point point = geometryFactory.createPoint(coord);
        return point;
    }

    /**
     * 1.2根据几何对象的WKT描述【String】创建几何对象： 点 【Point】
     *
     * @return
     * @throws ParseException
     */
    public Point createPointByWKT(String PointWKT) throws ParseException {
        WKTReader reader = new WKTReader(geometryFactory);
        Point point = (Point) reader.read(PointWKT);
        return point;
    }

    /**
     * 1.3根据几何对象的WKT描述【String】创建几何对象：多点 【MultiPoint】
     *
     * @return
     * @throws ParseException
     */
    public MultiPoint createMulPointByWKT(String MPointWKT) throws ParseException {
        WKTReader reader = new WKTReader(geometryFactory);
        MultiPoint mpoint = (MultiPoint) reader.read(MPointWKT);
        return mpoint;
    }


    /**
     * 2.构建线
     */


    /**
     * 2.1根据两点 创建几何对象：线 【LineString】
     *
     * @param ax
     * @param ay
     * @param bx
     * @param by
     * @return
     */
    public LineString createLine(double ax, double ay, double bx, double by) {
        Coordinate[] coords = new Coordinate[]{new Coordinate(ax, ay), new Coordinate(bx, by)};
        LineString line = geometryFactory.createLineString(coords);
        return line;
    }

    /**
     * 2.2根据线的WKT描述创建几何对象：线 【LineString】
     *
     * @param LineStringWKT
     * @return
     * @throws ParseException
     */
    public LineString createLineByWKT(String LineStringWKT) throws ParseException {
        WKTReader reader = new WKTReader(geometryFactory);
        LineString line = (LineString) reader.read("LINESTRING(0 0, 2 0)");
        return line;
    }

    /**
     * 2.3根据点组合的线数组，创建几何对象：多线 【MultiLineString】
     *
     * @param list
     * @return
     */
    public MultiLineString createMLine(List list) {

        MultiLineString ms = null;


        if (list == null) {
            return ms;
        }

        LineString[] lineStrings = new LineString[list.size()];


//      Coordinate[] coords1  = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)};    
//      LineString line1 = geometryFactory.createLineString(coords1);    
//       
//      Coordinate[] coords2  = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)};    
//      LineString line2 = geometryFactory.createLineString(coords2);    

        int i = 0;
        for (Coordinate[] coordinates : list) {
            lineStrings[i] = geometryFactory.createLineString(coordinates);
        }

        ms = geometryFactory.createMultiLineString(lineStrings);

        return ms;
    }


    /**
     * 2.4根据几何对象的WKT描述【String】创建几何对象 ： 多线【MultiLineString】
     *
     * @param MLineStringWKT
     * @return
     * @throws ParseException
     */
    public MultiLineString createMLineByWKT(String MLineStringWKT) throws ParseException {
        WKTReader reader = new WKTReader(geometryFactory);
        MultiLineString line = (MultiLineString) reader.read(MLineStringWKT);
        return line;
    }


    /**
     * 3.构建多边形
     */


    /**
     * 3.1 根据几何对象的WKT描述【String】创建几何对象：多边形 【Polygon】
     *
     * @param PolygonWKT
     * @return
     * @throws ParseException
     */
    public Polygon createPolygonByWKT(String PolygonWKT) throws ParseException {
        WKTReader reader = new WKTReader(geometryFactory);
        Polygon polygon = (Polygon) reader.read(PolygonWKT);
        return polygon;
    }

    /**
     * 3.2 根据几何对象的WKT描述【String】创建几何对象： 多多边形 【MultiPolygon】
     *
     * @param MPolygonWKT
     * @return
     * @throws ParseException
     */
    public MultiPolygon createMulPolygonByWKT(String MPolygonWKT) throws ParseException {
        WKTReader reader = new WKTReader(geometryFactory);
        MultiPolygon mpolygon = (MultiPolygon) reader.read(MPolygonWKT);
        return mpolygon;
    }

    /**
     * 根据多边形数组 进行多多边形的创建
     *
     * @param polygons
     * @return
     * @throws ParseException
     */
    public MultiPolygon createMulPolygonByPolygon(Polygon[] polygons) throws ParseException {

        return geometryFactory.createMultiPolygon(polygons);
    }

    /**
     * 4.构建几何对象集合
     */


    /**
     * 4.1 根据几何对象数组，创建几何对象集合：【GeometryCollection】
     *
     * @return
     * @throws ParseException
     */
    public GeometryCollection createGeoCollect(Geometry[] geoArray) throws ParseException {
//            LineString line = createLine(125.12,25.4,85.63,99.99);    
//            Polygon poly    =  createPolygonByWKT("POLYGON((20 10, 30 0, 40 10, 30 20, 20 10))");    
//            Geometry g1     = geometryFactory.createGeometry(line);    
//            Geometry g2     = geometryFactory.createGeometry(poly);    
//            Geometry[] geoArray = new Geometry[]{g1,g2};    
        GeometryCollection gc = geometryFactory.createGeometryCollection(geoArray);
        return gc;
    }


    /**
     * 5.构建圆
     */

    /**
     * 5.1 根据圆点以及半径创建几何对象：特殊的多边形--圆 【Polygon】
     *
     * @param x
     * @param y
     * @param RADIUS
     * @return
     */
    public Polygon createCircle(double x, double y, final double RADIUS) {

        final int SIDES = 32;//圆上面的点个数

        Coordinate coords[] = new Coordinate[SIDES + 1];
        for (int i = 0; i < SIDES; i++) {
            double angle = ((double) i / (double) SIDES) * Math.PI * 2.0;
            double dx = Math.cos(angle) * RADIUS;
            double dy = Math.sin(angle) * RADIUS;
            coords[i] = new Coordinate((double) x + dx, (double) y + dy);
        }
        coords[SIDES] = coords[0];
        //线性环
        LinearRing ring = geometryFactory.createLinearRing(coords);
        Polygon polygon = geometryFactory.createPolygon(ring, null);
        return polygon;
    }


    /**
     *  6.构建环
     */

    /**
     * 6.1 根据WKT创建环
     *
     * @param ringWKT
     * @return
     * @throws ParseException
     */
    public LinearRing createLinearRingByWKT(String ringWKT) throws ParseException {
        WKTReader reader = new WKTReader(geometryFactory);
        LinearRing ring = (LinearRing) reader.read(ringWKT);
        return ring;
    }

}

有xml如下：

    
    

        
            D:/testspace/spd/rain/
            D:/testspace/spd/Provinces_shp/
            D:\testspace\spd\output\
            D:\testspace\spd\Export\
            D:\testspace\spd\Export\
        
        
    

xml读取以获取shp文件位置和图片输出位置：

package com.gwhn.Util;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Text;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.Iterator;

/**
 * @author banxian
 * @date 2021/1/21 15:56
 */
public class YereeXmlContext {

    /**
     * 根据一二三级字节点的key，迭代到第三级节点根据三级key获取值
     * 
     * 
     *    
     *        D:\\temp\\upload\\
     *    
     * 
     *
     * @param key1
     * @param key2
     * @param key3
     * @return
     * @author banxian
     * @date: 2021/1/21 19:51
     */
    public String getXmlValue(String key1, String key2, String key3) {
        try {
            //1.创建Reader对象
            SAXReader reader = new SAXReader();
            //2.加载xml
            String directoryPath = Thread.currentThread().getContextClassLoader().getResource("config.xml").getPath();//获取项目根目录
            Document document = reader.read(new File(directoryPath));
            //3.获取根节点
            Element rootElement = document.getRootElement();
            Element moduleElement = getTargetElement(key1, rootElement);
            Element groupElement = getTargetElement(key2, moduleElement);
            Element configElement = getTargetElement(key3, groupElement);
            Attribute attribute = (Attribute) configElement.attributes().get(0);
            String key = attribute.getValue();
            Text text3 = (Text) configElement.content().get(0);
            String value = text3.getText();
            return value;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取和targetKey匹配的一个子节点
     *
     * @param targetKey
     * @param parentElement
     * @return
     * @author banxian
     * @date: 2021/1/21 19:53
     */
    public Element getTargetElement(String targetKey, Element parentElement) {
        Iterator iterator = parentElement.elementIterator();
        Element childElement = null;
        while (iterator.hasNext()) {
            Element element = (Element) iterator.next();
            Attribute attribute = (Attribute) element.attributes().get(0);
            String key = attribute.getValue();
            if (key.equals(targetKey) || key == targetKey) {
                childElement = element;
                break;
            }
        }
        return childElement;
    }
}

核心类：用多边形绘图

package com.gwhn.Util;

import com.gwhn.entity.CutProperty;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.MultiPolygon;

import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.List;

/**
 * @author banxian
 * @date 2021/6/28 12:37
 */
public class PolygonUtil {

    ImageUtils imageUtils = new ImageUtils();
    TxtUtil txtUtil = new TxtUtil();

    /**
     * 根据多多边形画图
     * @param path
     * @param cutProperty
     * @param multiPolygonList
     * @return
     * @author banxian
     * @date: 2021/6/30 15:31
     */
    public void graphicsByMultiPolygon(String path, List multiPolygonList, CutProperty cutProperty) {
        try {
            int imageWidth = cutProperty.getWidth();// 图片的宽度
            int imageHeight = cutProperty.getHeight();// 图片的高度
            BufferedImage image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB);
            Graphics2D graphics = (Graphics2D) image.getGraphics();
            graphics.setColor(Color.white);
            graphics.fillRect(0, 0, imageWidth, imageHeight);
            graphics.setColor(Color.black);
            int m = cutProperty.getBei() / 100;
            graphics.setStroke(new BasicStroke(cutProperty.getWeight() * m));//线条粗细
            Font font = new Font("宋体", Font.BOLD, 1200);
            graphics.setFont(font);
            graphics.drawString(cutProperty.getProvince(),  12500, 1500);
            for (MultiPolygon multiPolygon : multiPolygonList) {
                int num = multiPolygon.getNumGeometries();
                for (int i = 0; i < num; i++) {
                    Geometry geometry = multiPolygon.getGeometryN(i);
                    drawPolygon(geometry, cutProperty, graphics);
                }
            }
            imageUtils.createImage(path, image);
            System.out.println(path + ":" + font.getSize());
        } catch (
                Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 画出一个多边形
     * @param geometry
     * @param cutProperty
     * @param graphics2D
     * @return
     * @author banxian
     * @date: 2021/6/28 12:37
     */
    public void drawPolygon(Geometry geometry, CutProperty cutProperty, Graphics2D graphics2D) {
        int m = cutProperty.getBei() / 100;
        Double xtemp = Double.valueOf(cutProperty.getX() * m);
        Double ytemp = Double.valueOf(cutProperty.getY() * m);

        //处理飞地
        if (geometry.toString().contains("),")) {
            String geoStr = geometry.toString();
            String tempStr = geoStr.substring(9, geoStr.length() - 1) + ",";
            while (tempStr.contains("),")) {
                String temp = tempStr.substring(0, tempStr.indexOf("),") + 2);
                tempStr = tempStr.substring(temp.length()).trim();
                Polygon polygon = txtUtil.getPolygonByStr(temp,cutProperty);
                graphics2D.drawPolygon(polygon);
            }
        } else {
            Coordinate[] coordinates = geometry.getCoordinates();
            Polygon polygon = new Polygon();
            Double x, y;
            for (int j = 0; j < coordinates.length; j++) {
                Coordinate coordinate = coordinates[j];
                x = coordinate.getX() * cutProperty.getBei() - xtemp;
                y = cutProperty.getRightborder() * m - coordinate.getY() * cutProperty.getBei() - ytemp;
                polygon.addPoint(x.intValue(), y.intValue());
            }
            graphics2D.drawPolygon(polygon);
        }
    }
}

工具类：处理特殊的边界，一般由飞地、岛屿组成

package com.gwhn.Util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.gwhn.entity.CutProperty;

import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author banxian
 * @date 2021/5/10 15:57
 */
public class TxtUtil {

    public Polygon getPolygonByStr(String polygonStr,CutProperty cutProperty) {
        polygonStr = polygonStr.substring(1, polygonStr.length() - 2) + ",";
        List polygonStrList = new ArrayList<>();
        while (polygonStr.contains(",")) {
            String pointStr = polygonStr.substring(0, polygonStr.indexOf(",")).trim();
            polygonStrList.add(pointStr);
            polygonStr = polygonStr.substring(polygonStr.indexOf(",") + 1);
        }
        return transPointStrToPolygon(polygonStrList, cutProperty);
    }

    public Polygon transPointStrToPolygon(List polygonStrList,CutProperty cutProperty) {
        int m = cutProperty.getBei() / 100;
        Double xtemp = Double.valueOf(cutProperty.getX() * m);
        Double ytemp = Double.valueOf(cutProperty.getY() * m);
        Polygon polygon = new Polygon();
        for (String pointStr : polygonStrList) {
            Double x = Double.parseDouble(pointStr.substring(0, pointStr.indexOf(" ")));
            Double y = Double.parseDouble(pointStr.substring(pointStr.indexOf(" ")).trim());
            x = x * cutProperty.getBei() - xtemp;
            y = cutProperty.getRightborder()*m - y * cutProperty.getBei()-ytemp;
            polygon.addPoint(x.intValue(), y.intValue());
        }
        return polygon;
    }

    //读取json文件
    public String readJsonFile(String fileName) {
        String jsonStr = "";
        try {
            File jsonFile = new File(fileName);
            FileReader fileReader = new FileReader(jsonFile);
            Reader reader = new InputStreamReader(new FileInputStream(jsonFile), "utf-8");
            int ch = 0;
            StringBuffer sb = new StringBuffer();
            while ((ch = reader.read()) != -1) {
                sb.append((char) ch);
            }
            fileReader.close();
            reader.close();
            jsonStr = sb.toString();
            return jsonStr;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 读取json获取图片剪切参数
     *
     * @param
     * @return
     * @author banxian
     * @date: 2021/6/25 8:16
     */
    public Map getCutPropertyMap() {
        String path = Thread.currentThread().getContextClassLoader().getResource("property.json").getPath();//获取项目根目录
        String s = readJsonFile(path);
        JSONObject jsonObject = JSON.parseObject(s);
        JSONArray jsonArray = jsonObject.getJSONArray("properties");//构建JSONArray数组
        List cutPropertyList = jsonArray.toJavaList(CutProperty.class);
        Map cutPropertyMap = new HashMap();
        for (CutProperty cutProperty : cutPropertyList) {
            cutPropertyMap.put(cutProperty.getProvince(), cutProperty);
        }
        return cutPropertyMap;
    }
    
}

核心类：从读到的shp文件数据中提取字符串转化为多多边形，绘图

package com.gwhn.controller;

import com.gwhn.Util.PolygonUtil;
import com.gwhn.Util.TxtUtil;
import com.gwhn.Util.YereeXmlContext;
import com.gwhn.entity.CutProperty;
import com.gwhn.geotools.GeometryCreator;
import com.gwhn.geotools.ShapeUtil;
import org.locationtech.jts.geom.MultiPolygon;
import org.opengis.feature.Property;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author banxian
 * @date 2021/6/1 8:12
 */
public class ShpPictureController {
    PolygonUtil polygonUtil = new PolygonUtil();
    TxtUtil txtUtil = new TxtUtil();
    Map cutPropertyMap = txtUtil.getCutPropertyMap();

    /**
     * 根据国家shp文件画出中国地图
     * @param
     * @return
     * @author banxian
     * @date: 2021/6/28 12:35
     */
    public void doNation() {
        YereeXmlContext yereeXmlContext = new YereeXmlContext();
        GeometryCreator geometryCreator = new GeometryCreator();
        String shapePath = yereeXmlContext.getXmlValue("Http", "FileExport", "ProvincePath") + "province.shp";
        ShapeUtil shapeUtil = new ShapeUtil();
        try {
            List propertyList = shapeUtil.SHPRead(shapePath);
            List multiPolygonList = new ArrayList<>();
            for (int i = 0; i * 8 < propertyList.size(); i++) {
                Property property = propertyList.get(i * 8);
                String valueStr = property.getValue().toString();
                MultiPolygon multiPolygon = geometryCreator.createMulPolygonByWKT(valueStr);
                multiPolygonList.add(multiPolygon);
            }
            String path = yereeXmlContext.getXmlValue("Http", "FileExport", "ExportPath");
            File newFileDir = new File(path);
            //如果不存在 则创建
            if (!newFileDir.exists()) {
                newFileDir.mkdirs();
            }
//            String picturName = imageUtils.genImageName() + ".jpg";
            String picturName = "中国.jpg";
            CutProperty cutProperty = cutPropertyMap.get("中国");
            polygonUtil.graphicsByMultiPolygon(path + picturName, multiPolygonList, cutProperty);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("完成");
    }

    /**
     * 根据分省shp文件画出地图
     * @param
     * @return
     * @author banxian
     * @date: 2021/6/28 12:35
     */
    public void doProvince() {
        YereeXmlContext yereeXmlContext = new YereeXmlContext();
        GeometryCreator geometryCreator = new GeometryCreator();
        ShapeUtil shapeUtil = new ShapeUtil();
        String shapeDirPath = yereeXmlContext.getXmlValue("Http", "FileExport", "ProvinceShapePath");

        List fileList = new ArrayList<>();
        fileList = getFileList(shapeDirPath, fileList);
        for (int j = 0; j < fileList.size(); j++) {
            File file = fileList.get(j);
            if (file.getName().contains(".shp")) {
                File parentFile = file.getParentFile();
                String province = parentFile.getName();
                System.out.println(province);
                int size = 7;
                if (province.equals("湖北") || province == "湖北" || province.equals("安徽") || province == "安徽") {
                    size = 10;
                }
                CutProperty cutProperty = cutPropertyMap.get(province);
                try {
                    List propertyList = shapeUtil.SHPRead(file.getPath());
                    List multiPolygonList = new ArrayList<>();
                    for (int i = 0; i * size < propertyList.size(); i++) {
                        String valueStr = propertyList.get(i * size).getValue().toString();
                        MultiPolygon multiPolygon = geometryCreator.createMulPolygonByWKT(valueStr);
                        multiPolygonList.add(multiPolygon);
                    }
                    String path = yereeXmlContext.getXmlValue("Http", "FileExport", "ExportPath");
                    ;
                    File newFileDir = new File(path);
                    //如果不存在 则创建
                    if (!newFileDir.exists()) {
                        newFileDir.mkdirs();
                    }
                    String picturName = province + ".jpg";
                    polygonUtil.graphicsByMultiPolygon(path + picturName, multiPolygonList, cutProperty);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("完成");
    }

    /**
     * 获取shp文件集合
     * @param dirPath
     * @param fileList
     * @return
     * @author banxian
     * @date: 2021/6/28 12:36
     */
    public List getFileList(String dirPath, List fileList) {
        File dir = new File(dirPath);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        for (File file : dir.listFiles()) {
            if (!file.isDirectory()) {
                fileList.add(file);
            } else {
                getFileList(file.getPath(), fileList);
            }
        }
        return fileList;
    }

}

地图坐标截取参数

{
  "properties": [
    {
      "province": "中国",
      "x": 8000,
      "y": 18600,
      "width": 25000,
      "height": 15000,
      "weight": 5.0,
      "bei":350,
      "rightborder": 25000,
      "stringsize": 500
    },
    {
      "province": "上海",
      "x": 12050,
      "y": 21800,
      "width": 23000,
      "height": 16000,
      "weight": 0.8,
      "bei": 10000,
      "rightborder": 25000,
      "stringsize": 500
    },
    {
      "province": "云南",
      "x": 9700,
      "y": 22000,
      "width": 25000,
      "height": 25000,
      "weight": 2.0,
      "bei": 2500,
      "rightborder": 25000,
      "stringsize": 50
    },
    {
      "province": "内蒙古",
      "x": 9000,
      "y": 19000,
      "width": 25000,
      "height": 15000,
      "weight": 3.0,
      "bei": 600,
      "rightborder": 25000,
      "stringsize": 180
    },
    {
      "province": "北京",
      "x": 11515,
      "y": 20830,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 10000,
      "rightborder": 25000,
      "stringsize": 600
    },
    {
      "province": "吉林",
      "x": 12100,
      "y": 20200,
      "width": 25000,
      "height": 17000,
      "weight": 2.0,
      "bei": 2100,
      "rightborder": 25000,
      "stringsize": 40
    },
    {
      "province": "四川",
      "x": 9600,
      "y": 21500,
      "width": 25000,
      "height": 20000,
      "weight": 2.0,
      "bei": 1900,
      "rightborder": 25000,
      "stringsize": 40
    },
    {
      "province": "天津",
      "x": 11600,
      "y": 20920,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 10000,
      "rightborder": 25000,
      "stringsize": 600
    },
    {
      "province": "宁夏",
      "x": 10400,
      "y": 20960,
      "width": 20000,
      "height": 25000,
      "weight": 1.0,
      "bei": 4210,
      "rightborder": 25000,
      "stringsize": 40
    },
    {
      "province": "安徽",
      "x": 11350,
      "y": 21500,
      "width": 25000,
      "height": 22000,
      "weight": 1.0,
      "bei": 3300,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "山东",
      "x": 11430,
      "y": 21050,
      "width": 25000,
      "height": 20000,
      "weight": 1.0,
      "bei": 2900,
      "rightborder": 25000,
      "stringsize": 35
    },
    {
      "province": "山西",
      "x": 10900,
      "y": 20850,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 3500,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "广东",
      "x": 10750,
      "y": 22400,
      "width": 25000,
      "height": 15000,
      "weight": 1.0,
      "bei": 2200,
      "rightborder": 25000,
      "stringsize": 40
    },
    {
      "province": "广西",
      "x": 10400,
      "y": 22200,
      "width": 25000,
      "height": 18000,
      "weight": 1.0,
      "bei": 2600,
      "rightborder": 25000,
      "stringsize": 35
    },
    {
      "province": "新疆",
      "x": 7200,
      "y": 19800,
      "width": 25000,
      "height": 20000,
      "weight": 2.0,
      "bei": 900,
      "rightborder": 25000,
      "stringsize": 150
    },
    {
      "province": "江苏",
      "x": 11550,
      "y": 21400,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 4000,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "江西",
      "x": 11250,
      "y": 21950,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 4000,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "河北",
      "x": 11250,
      "y": 20600,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 3000,
      "rightborder": 25000,
      "stringsize": 40
    },
    {
      "province": "河南",
      "x": 10900,
      "y": 21200,
      "width": 25000,
      "height": 23000,
      "weight": 1.0,
      "bei": 2700,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "浙江",
      "x": 11800,
      "y": 21800,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 5000,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "湖北",
      "x": 10800,
      "y": 21500,
      "width": 25000,
      "height": 20000,
      "weight": 1.0,
      "bei": 3000,
      "rightborder": 25000,
      "stringsize": 30
    },
    {
      "province": "湖南",
      "x": 10800,
      "y": 21900,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 3500,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "甘肃",
      "x": 9000,
      "y": 20300,
      "width": 25000,
      "height": 25000,
      "weight": 2.0,
      "bei": 1200,
      "rightborder": 25000,
      "stringsize": 70
    },
    {
      "province": "福建",
      "x": 11550,
      "y": 22050,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 4000,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "西藏",
      "x": 7500,
      "y": 21000,
      "width": 25000,
      "height": 15000,
      "weight": 1.5,
      "bei": 1000,
      "rightborder": 25000,
      "stringsize": 100
    },
    {
      "province": "贵州",
      "x": 10350,
      "y": 21900,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 3200,
      "rightborder": 25000,
      "stringsize": 35
    },
    {
      "province": "辽宁",
      "x": 11850,
      "y": 20500,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 3300,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "重庆",
      "x": 10500,
      "y": 21700,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 4700,
      "rightborder": 25000,
      "stringsize": 20
    },
    {
      "province": "陕西",
      "x": 10450,
      "y": 21000,
      "width": 25000,
      "height": 25000,
      "weight": 1.0,
      "bei": 2900,
      "rightborder": 25000,
      "stringsize": 25
    },
    {
      "province": "青海",
      "x": 8700,
      "y": 20900,
      "width": 25000,
      "height": 15000,
      "weight": 2.0,
      "bei": 1500,
      "rightborder": 25000,
      "stringsize": 70
    },
    {
      "province": "黑龙江",
      "x": 12000,
      "y": 19500,
      "width": 25000,
      "height": 18000,
      "weight": 1.0,
      "bei": 1500,
      "rightborder": 25000,
      "stringsize": 60
    }
  ]
}

测试类

public static void main(String[] args) {
        try {
            ShpPictureController shpPictureController = new ShpPictureController();
//            shpPictureController.doProvince();
            shpPictureController.doNation();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

最终画出的图片效果如下:

到此这篇关于java使用GeoTools读取shp文件并画图的操作代码的文章就介绍到这了,更多相关java读取shp文件并画图内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！