java解析shp文件

已于 2024-04-10 19:27:15 修改
阅读量742 收藏 15
点赞数 11
文章标签： java 前端 服务器
于 2024-04-10 19:26:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javaMyGod/article/details/137607681
版权 
    工作之余记录，没有美化好：
POM引入：


<!-- for geotools begin -->
    <!--处理空间数据-->
    <!-- geotools主要依赖 -->
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-metadata</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-referencing</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-epsg-wkt</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-shapefile</artifactId>
        <version>27.2</version>
    </dependency>

    <!--<dependency>-->
    <!--<groupId>org.geotools</groupId>-->
    <!--<artifactId>gt-data</artifactId>-->
    <!--<version>27.2</version>-->
    <!--</dependency>-->

    <!--<dependency>-->
    <!--<groupId>org.geotools</groupId>-->
    <!--<artifactId>gt-api</artifactId>-->
    <!--<version>27.2</version>-->
    <!--</dependency>-->
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-main</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-swing</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-jdbc</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools.jdbc</groupId>
        <artifactId>gt-jdbc-postgis</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-opengis</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-epsg-hsql</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-geojson</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.geotools</groupId>
        <artifactId>gt-process-feature</artifactId>
        <version>27.2</version>
    </dependency>
    <dependency>
        <groupId>org.locationtech.jts</groupId>
        <artifactId>jts-core</artifactId>
        <version>1.18.2</version>
    </dependency>
    <!--for geotools end-->

    <!--读取geojson文件-->
    <dependency>
        <groupId>com.googlecode.json-simple</groupId>
        <artifactId>json-simple</artifactId>
        <version>1.1.1</version>
    </dependency>
    <dependency>
        <groupId>org.wowtools</groupId>
        <artifactId>giscat-vector-pojo</artifactId>
        <version>1.1.1-STABLE</version>
    </dependency>
    <!--读取geojson文件end-->


</dependencies>

<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
    <repository>
        <id>spring-snapshots</id>
        <name>Spring Snapshots</name>
        <url>https://repo.spring.io/snapshot</url>
        <releases>
            <enabled>false</enabled>
        </releases>
    </repository>

    <!-- geotools的远程库 -->
    <repository>
        <id>osgeo</id>
        <name>OSGeo Release Repository</name>
        <url>https://repo.osgeo.org/repository/release/</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
        <releases>
            <enabled>true</enabled>
        </releases>
    </repository>
    <repository>
        <id>osgeo-snapshot</id>
        <name>OSGeo Snapshot Repository</name>
        <url>https://repo.osgeo.org/repository/snapshot/</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
        <releases>
            <enabled>false</enabled>
        </releases>
    </repository>
    <!-- geotools的远程库end -->
import org.geotools.data.DefaultTransaction;
import org.geotools.data.FeatureSource;
import org.geotools.data.Transaction;
import org.geotools.data.shapefile.ShapefileDataStore;
import org.geotools.data.shapefile.ShapefileDataStoreFactory;
import org.geotools.data.simple.SimpleFeatureCollection;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.geotools.data.simple.SimpleFeatureSource;
import org.geotools.data.simple.SimpleFeatureStore;
import org.geotools.factory.CommonFactoryFinder;
import org.geotools.feature.FeatureCollection;
import org.geotools.feature.FeatureIterator;
import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
import org.geotools.filter.text.cql2.CQL;
import org.geotools.geojson.GeoJSON;
import org.geotools.geojson.feature.FeatureJSON;
import org.geotools.geojson.geom.GeometryJSON;
import org.geotools.referencing.crs.DefaultGeographicCRS;
import org.geotools.util.factory.GeoTools;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.locationtech.jts.geom.LineString;
import org.locationtech.jts.geom.MultiPolygon;
import org.locationtech.jts.geom.Point;
import org.locationtech.jts.geom.Polygon;
import org.opengis.feature.Property;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.feature.type.AttributeDescriptor;
import org.opengis.filter.Filter;
import org.opengis.filter.FilterFactory2;
import org.springframework.stereotype.Component;

import java.io.*;
import java.net.MalformedURLException;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.*;
@Component
public class GeoToolsMethod {
    //使用openGIS FilterFactory2
    private static org.opengis.filter.FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(GeoTools.getDefaultHints());
    //读取shp
    public FeatureSource<SimpleFeatureType, SimpleFeature> ReadShpFile(String filePath) throws Exception{
        File dir = new File(filePath);
        File[] subFiles = dir.listFiles();
        if (null!=subFiles){
            for (File subFile : subFiles) {
                if (subFile.getName().endsWith(".shp")) {
                    filePath = subFile.getPath();break;
                }
            }
        }
        File shpFile = new File(filePath);
        //源shape文件
        //ShapefileDataStore shpDataStore = (ShapefileDataStore) new ShapefileDataStoreFactory().createDataStore(subFile.toURI().toURL());
        ShapefileDataStore shpDataStore = new ShapefileDataStore(shpFile.toURI().toURL());
        shpDataStore.setCharset(Charset.forName("UTF-8"));
        FeatureSource<SimpleFeatureType, SimpleFeature> featureSource = shpDataStore.getFeatureSource();
        return featureSource;
    }
    //读取geojson
    public FeatureCollection ReadGeojsonFile(String pathfile) throws Exception{
        FeatureCollection featureCollection = null;
                //创建一个JSONParser对象
        JSONParser jsonParser = new JSONParser();
        //解析JSON文件的内容
        try {
            //String pathfile = getClass().getClassLoader().getResource("csdata").getPath()+"/csfeature.geojson";
            //先用json.simple读取geojson文件
//            org.json.simple.JSONObject obj = (org.json.simple.JSONObject) jsonParser.parse(new FileReader("D:/hjyTest/JAVA/demo_gdal2/target/classes/csdata/csfeature.geojson"));
            JSONObject obj = (JSONObject) jsonParser.parse(new FileReader(pathfile));
            //JSONObject obj = (JSONObject) jsonParser.parse(new FileReader("E:\\河南省乡镇点\\FieldPolygon.geojson"));
            //删除除features以外其它对象，方便下面所需的geojson字符串
//            obj.remove("type");
//            obj.remove("name");
//            obj.remove("crs");
            //获取features对象json字符串
            String strGeoJson =obj.toString();
            System.out.println(strGeoJson);


            // 指定GeometryJSON构造器，15位小数
            FeatureJSON fjson_15 = new FeatureJSON(new GeometryJSON(15));
            // fjson_15已经保留15位
            fjson_15.setEncodeFeatureCollectionCRS(true);
            fjson_15.setEncodeNullValues(true);

            featureCollection = fjson_15.readFeatureCollection(strGeoJson);
            fjson_15.writeFeatureCollection(featureCollection,System.out);  // 控制台输出和原始geojson一致



//            OutputStream ostream = new ByteArrayOutputStream();
//            GeoJSON.write(featureCollection, ostream);
//            // 输出：{"type":"FeatureCollection","features":[{"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[116.1983,39.7832],[116.0445,39.2323],[116.8959,39.3831],[116.8698,39.9182],[116.1983,39.7832]]]},"properties":{"area":3865207830},"id":"polygon.1"}]}
//            System.out.println(ostream);

//            //获取数据
//            FeatureIterator<SimpleFeature> iterator = featureCollection.features();
//            while(iterator.hasNext()) {
//                SimpleFeature feature = iterator.next();
//                try{
//                    org.locationtech.jts.geom.Geometry geom1 = (org.locationtech.jts.geom.Geometry) feature.getDefaultGeometry();
//                    System.out.println(geom1.getCoordinate());
//                }catch (Exception e){
//
//                }
//
//
//                feature.getName();
//                Iterator<Property> it = feature.getProperties().iterator();
//                LinkedHashMap<String, Object> data = new LinkedHashMap<>();
//                String geometry = "";
//                while (it.hasNext()) {
//                    Property pro = it.next();
//                    if (pro.getValue() instanceof  org.locationtech.jts.geom.Point) {//点
//                        geometry = "'" + ((org.locationtech.jts.geom.Point) pro.getValue()).toString() + "'";
//                        data.put("geom", geometry);
//                    } else if (pro.getValue() instanceof org.locationtech.jts.geom.Polygon) {//面
//                        geometry = "'" + ((org.locationtech.jts.geom.Polygon) pro.getValue()).toString() + "'";
//                        data.put("geom", geometry);
//                    } else if (pro.getValue() instanceof org.locationtech.jts.geom.MultiPolygon) {//多面
//                        geometry = "'" + ((org.locationtech.jts.geom.MultiPolygon) pro.getValue()).toString() + "'";
//                        data.put("geom", geometry);
//                    } else if (pro.getValue() instanceof org.locationtech.jts.geom.LineString) {//线
//                        geometry = "'" + ((org.locationtech.jts.geom.LineString) pro.getValue()).toString() + "'";
//                        data.put("geom", geometry);
//                    } else {
//                        data.put(pro.getName().toString(), pro.getValue());
//                    }
//                }
//                System.out.println(data);
//            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        return featureCollection;
    }
    //方法一：
    //返回其属性值
    public List<LinkedHashMap<String,Object>> getAttirbutes(String srs, FeatureCollection col){
        //srs="EPSG:4326"
        List<LinkedHashMap<String,Object>> listMap = new ArrayList<>();
        FeatureIterator<SimpleFeature> iterator = col.features();
            while(iterator.hasNext()) {
                SimpleFeature feature = iterator.next();
                //获取属性
                Iterator<Property> it = feature.getProperties().iterator();
                LinkedHashMap<String, Object> data = new LinkedHashMap<>();
                String geometry = "";
                while (it.hasNext()) {
                    Property pro = it.next();
                    if (pro.getValue() instanceof Point) {//点
                        geometry = "'"  +((Point) pro.getValue()).toString()+ "'"+","+srs.substring(srs.indexOf(":")+1);
                        data.put("geom",geometry);
                    } else if (pro.getValue() instanceof Polygon) {//面
                        geometry = "'"+((Polygon) pro.getValue()).toString()+ "'"+","+srs.substring(srs.indexOf(":")+1);
                        data.put("geom",geometry);
                    } else if (pro.getValue() instanceof MultiPolygon) {//多面
                        geometry = "'"+((MultiPolygon) pro.getValue()).toString()+ "'"+","+srs.substring(srs.indexOf(":")+1);
                        data.put("geom",geometry);
                    } else if (pro.getValue() instanceof LineString) {//线
                        geometry = "'" +((LineString) pro.getValue()).toString()+ "'"+","+srs.substring(srs.indexOf(":")+1);
                        data.put("geom",geometry);
                    } else {
                        if(pro.getValue() instanceof Date){
                            Date myDate = (Date)pro.getValue();
                            SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            String strDate3 = sdf3.format(myDate);
                            data.put(pro.getName().toString(),strDate3);
                        }else{
                            data.put(pro.getName().toString(),pro.getValue());
                        }
                    }
                }
                //System.out.println(data);
                listMap.add(data);
            }
            return listMap;
    }
    //方法二：
    //返回属性值
    public List<LinkedHashMap<String,Object>> getAttirbutes2(String srs, FeatureCollection col){
        //srs="EPSG:4326"
        List<LinkedHashMap<String,Object>> listMap = new ArrayList<>();
        //另外一种循环start
        SimpleFeatureCollection sfc = (SimpleFeatureCollection)col;
        // 获取当前矢量数据有哪些属性字段值
        List<AttributeDescriptor> attributes = sfc.getSchema().getAttributeDescriptors();
        // 拿到迭代器
        SimpleFeatureIterator simpleFeatureIterator = sfc.features();
        // 遍历每一个要素
        while(simpleFeatureIterator.hasNext()) {
            SimpleFeature simpleFeature = simpleFeatureIterator.next();
            LinkedHashMap<String, Object> data = new LinkedHashMap<>();
            // java8新特性流api
            attributes.stream().forEach((a) -> {
                Object tempobj = simpleFeature.getAttribute(a.getLocalName());
                // 依次读取这个shape中每一个属性值，当然这个属性值，可以处理其它业务
                if(a.getLocalName().indexOf("geom")>=0){
                    String geometry = "";
                    if (tempobj instanceof Point) {//点
                        geometry = "'"  +((Point) tempobj).toString()+ "'"+","+srs.substring(srs.indexOf(":")+1);
                        data.put("geom",geometry);
                    } else if (tempobj instanceof Polygon) {//面
                        geometry = "'"+((Polygon) tempobj).toString()+ "'"+","+srs.substring(srs.indexOf(":")+1);
                        data.put("geom",geometry);
                    } else if (tempobj instanceof MultiPolygon) {//多面
                        geometry = "'"+((MultiPolygon) tempobj).toString()+ "'"+","+srs.substring(srs.indexOf(":")+1);
                        data.put("geom",geometry);
                    } else if (tempobj instanceof LineString) {//线
                        geometry = "'" +((LineString) tempobj).toString()+ "'"+","+srs.substring(srs.indexOf(":")+1);
                        data.put("geom",geometry);
                    }
                }else{
                    if(tempobj instanceof Date){
                        Date myDate = (Date)tempobj;
                        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        String strDate3 = sdf3.format(myDate);
                        data.put(a.getLocalName(),strDate3);
                    }else{
                        data.put(a.getLocalName(),tempobj);
                    }
//                    System.out.println(a.getLocalName() + ":" + simpleFeature.getAttribute(a.getLocalName()));
                }
            });
            listMap.add(data);
        }
        return listMap;
    }
    //查询 CQL
    public Filter ReturnFilter(String sql)throws Exception{
        String wkt = "POLYGON ((113.17574362102584 23.135924459989738, 113.07445367113468 22.981863911800943, 113.3121749821035 22.932375044753726, 113.3907263718155 23.073180341529934, 113.17574362102584 23.135924459989738))";
        Filter filter = null;
        // 相交
        filter =  CQL.toFilter( "OBJECTID = 5 or INTERSECTS(the_geom," + wkt + ")");
        if(sql!=null || sql!=""){
            filter = CQL.toFilter(sql);
        }
        // 在10公里以内
        //  Filter filter =  CQL.toFilter( "DWITHIN(the_geom," + wkt + ", 10, kilometers)");
        return filter;
    }
    //查询 使用openGIS FilterFactory2
    public Filter ReturnFilter2(){
        Filter filter = ff.greaterOrEqual(ff.property("OBJECTID"), ff.literal(5));
        return filter;
    }

    public static SimpleFeatureType createType(Class<?> c, String layerName) {
        SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
        builder.setCRS(DefaultGeographicCRS.WGS84);
        builder.add("FID",String.class);
        builder.add("the_geom", c);
        // 设置了图层的名字
        builder.setName(layerName);
        SimpleFeatureType simpleFeatureType = builder.buildFeatureType();
        return simpleFeatureType;
    }
　　//生成shp
    public static void createShp(String shpPath, SimpleFeatureCollection collection) throws IOException {
        File shpFile = new File(shpPath);
        ShapefileDataStoreFactory dataStoreFactory = new ShapefileDataStoreFactory();
        SimpleFeatureType simpleFeatureType = collection.getSchema();
        // 创造shpstore需要的参数
        Map<String, Serializable> params = new HashMap<>();
        params.put("url", shpFile.toURI().toURL());
        params.put("create spatial index", Boolean.TRUE);
        ShapefileDataStore newDataStore =
                (ShapefileDataStore) dataStoreFactory.createNewDataStore(params);
        newDataStore.createSchema(simpleFeatureType);
        Transaction transaction = new DefaultTransaction("create");
        String typeName = newDataStore.getTypeNames()[0];
        SimpleFeatureSource featureSource = newDataStore.getFeatureSource(typeName);
        SimpleFeatureStore featureStore = (SimpleFeatureStore) featureSource;
        featureStore.setTransaction(transaction);
        featureStore.addFeatures(collection);
        featureStore.setTransaction(transaction);
        transaction.commit();
        transaction.close();
    }
/　　//这里也是读取shp
    public static SimpleFeatureCollection readFeatureCollection(String shpPath) {
        SimpleFeatureCollection featureCollection = null;
        File shpFile = new File(shpPath);
        try {
            ShapefileDataStore shapefileDataStore = new ShapefileDataStore(shpFile.toURI().toURL());
            // 设置编码,防止属性的中文字符出现乱码
            shapefileDataStore.setCharset(Charset.forName("UTF-8"));
            // 这个typeNamae不传递，默认是文件名称
            FeatureSource featuresource = shapefileDataStore.getFeatureSource(shapefileDataStore.getTypeNames()[0]);
            featureCollection = (SimpleFeatureCollection) featuresource.getFeatures();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return featureCollection;
    }

}

@Autowired
    GeoToolsMethod geoToolsMethod;

//测试geoTools封装好的方法
    @Test
    public void Test_geoToolsMethod() throws Exception{
        //测试读取shp
        FeatureSource<SimpleFeatureType, SimpleFeature> featureSource=geoToolsMethod.ReadShpFile("D:\\ceshi\\dwq0606");
        String srs = CRS.lookupIdentifier(featureSource.getSchema().getCoordinateReferenceSystem(),true);  // 获取EPSG
        System.out.println(srs);
        FeatureCollection collection = featureSource.getFeatures();
        long startTime = System.currentTimeMillis();
        //测试获取getAttributes
        List<LinkedHashMap<String,Object>> listAttr = geoToolsMethod.getAttirbutes(srs,collection);
        long endTime = System.currentTimeMillis();
        System.out.println("运行时长："+(endTime-startTime)+"ms"); //1128ms
        startTime = System.currentTimeMillis();
        //测试获取getAttributes2
        List<LinkedHashMap<String,Object>> listAttr2 = geoToolsMethod.getAttirbutes2(srs,collection);
        endTime = System.currentTimeMillis();
        System.out.println("运行时长："+(endTime-startTime)+"ms"); //980ms 1015
        //System.out.println(listAttr);
    }

//做geometry 的计算距离，取交集、合并几何、difference
    @Test
    public void GeometryOperate() throws Exception{
        GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory( null );
        //创建一条线
        List<Coordinate> points1 = new ArrayList<Coordinate>();
        points1.add(new Coordinate(0,0));
        points1.add(new Coordinate(1,3));
        points1.add(new Coordinate(2,3));
        Coordinate[] coords  = (Coordinate[]) points1.toArray(new Coordinate[points1.size()]);
        LineString line1 = geometryFactory.createLineString(coords);
        //创建第二条线
        List<Coordinate> points2 = new ArrayList<Coordinate>();
        points2.add(new Coordinate(3,0));
        points2.add(new Coordinate(3,3));
        points2.add(new Coordinate(5,6));
        Coordinate[] coords2  = (Coordinate[]) points2.toArray(new Coordinate[points2.size()]);
        LineString line2 = geometryFactory.createLineString(coords2);
//        返回(A)与(B)中距离最近的两个点的距离
        System.out.println(line1.distance(line2));//out 1.0
//        两个几何对象的交集
        System.out.println(line1.intersection(line2));//out GEOMETRYCOLLECTION EMPTY
//        几何对象合并
        Geometry lineunion = line1.union(line2);
        System.out.println(lineunion); //out MULTILINESTRING ((0 0, 1 3, 2 3), (3 0, 3 3, 5 6))
        //在A几何对象中有的，但是B几何对象中没有
        System.out.println(line1.difference(line2));//out LINESTRING (0 0, 1 3, 2 3)
        System.out.println(lineunion.difference(line2));//out LINESTRING (0 0, 1 3, 2 3)
        //交集
        System.out.println(lineunion.intersection(line2));//out MULTILINESTRING ((3 0, 3 3), (3 3, 5 6))

        WKTReader reader = new WKTReader(geometryFactory);
        Polygon geometry1 = (Polygon) reader.read("POLYGON((0 0, 2 0 ,2 2, 0 2,0 0))");
        Polygon geometry2 = (Polygon) reader.read("POLYGON((0 0, 4 0 , 4 1, 0 1, 0 0))");
        OverlayOp op = new OverlayOp(geometry1,geometry2);
        Geometry g =op.getResultGeometry(OverlayOp.INTERSECTION);//POLYGON ((2 0, 0 0, 0 1, 2 1, 2 0))
        //Geometry g2 = op.getResultGeometry(OverlayOp.UNION);
        //Geometry g3 = op.getResultGeometry(OverlayOp.DIFFERENCE);
        //Geometry g4 = op.getResultGeometry(OverlayOp.SYMDIFFERENCE);
        //PlanarGraph p = op.getGraph(); //图<v,e

        //LineMerger 线路合并，线路之间不能有交点，并且只在线路末尾有公共交点
        // lineMerger 和union区别，union可以在两条相交的线中生成交点(noded)
        WKTReader wktReader = new WKTReader();
        LineMerger lineMerger = new LineMerger();
        List<Geometry> list = new ArrayList<Geometry>();
        list.add(wktReader.read("LINESTRING (3 3,2 2,0 0)"));
        list.add(wktReader.read("LINESTRING (3 3,6 6,0 10)"));
        list.add(wktReader.read("LINESTRING (0 10,3 1,10 1)"));
        lineMerger.add(list);
        Collection<Geometry> mergerLineStrings = lineMerger.getMergedLineStrings();
        for (Geometry tempg : mergerLineStrings) {
            System.out.println(tempg.toText()); //LINESTRING (0 0, 2 2, 3 3, 6 6, 0 10, 3 1, 10 1)
        }

    }

javaMyGod
关注
  • 11
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java解析上传的shp文件，包含jar，方法，shp文件
07-21
java使用geotools解析shp文件，内容包含 解析方法，使用的各种jar包，以及单区域shp和多区域shp文件
JAVA解析shp文件
Edgar_LQS的博客
12-24 2461
时间：2019.12.24.20.37 之前写过JAVA实现shp文件转wkb文件 现在做一个补充，实现获取shp文件的属性信息 java代码如下 package com.atlchain.bcgis.data; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import org.ge...
java解析shp文件以及坐标转换（工具类）
許先生的博客
04-09 5208
百度找了很多大部分都是pom的，maven项目中的，但是用maven下载不了，只能一个jar一个jar下载了，中间也遇到了很多坑，都是pom中没有提到的架包 直接上代码，最后我会解析shp文件所用到的所有jar截图粘上 package com.common.utils; import java.io.File; import java.io.IOException; import j...
java 解析shp文件（转GeoJSON\esrijson、生成图片）
weixin_41963652的博客
03-16 6763
1.下载jar包 2.根目录下新建lib文件夹，将jar包放入 3.配置maven pom文件 <!-- shp解析--> <dependency> <groupId>org.geotools</groupId> <artifactId>gt-shapefile</artifactId> <version>19.2</version> <scop.
Java解析shp文件（ZIP压缩包）获取坐标集
weixin_50074995的博客
07-09 1650
在Java后台解析前台上传的shp文件，因为shp文件一般不会是单独出现包括了索引文件等，所以一般都是以压缩包的形式出现，因此如果要获取其中的坐标集，则必须先解压压缩包 解压压缩包的链接 解压压缩包 解析shp需要下载jar包，无法使用依赖直接下载 解析shp所需的jar包 <!--解析shp文件--> <dependency> <groupId>gt.api</groupId> <ar
shp文件解析java实现
09-03
提供通过meteoInfo+geotools解析shp文件，提取出shp文件中的数据，javaj技术实现，获取边界线数据、中心点坐标、最大、最小经纬度值等
java中读取shp文件数据存入数据库
06-29
shp文件：地理信息系统，也被称作GIS，它主要的扩展类型是SHAPEFILE (.SHP)，一个包含了矢量地理空间数据的流行文件格式，描述了几何形态，点，线和多边形...该方法通过java代码实现将shp文件的数据读取以及存入数据库
ShpAnalysis.zip（包含Java方式解析shp文件的IDEA工程和ShapeExplorer.exe）
06-18
包含Java方式解析shp文件的IDEA工程和ShapeExplorer.exe。arcmap工具(2G)过大，ShapeExplorer能打开shp文件，但有时获取信息出差，Java方式解析shp文件提供了另一种解决方式，之间运行即可，但解析也有一定局限性。...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 931
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 880
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 279
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Lambda表达式特点
weixin_57763462的博客
04-24 799
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 408
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 880
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
qq_43209531的博客
04-30 152
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 715
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
Java设计模式_概述（设计模式类型和基本原则）
weisian的博客
04-25 862
通过合成，可以将已有的类组合成新的类，达到复用的目的，同时保持类的简单和清晰。设计模式（Design pattern）代表了最佳的实践，是软件开发人员在软件开发过程中面临一般问题的解决方案，是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。但不推荐刚入门的开发者学习，哪怕把代码搞的一塌糊涂，也要先将功能完成，初学者，迈过坑是必然的，只有对自己编写的代码不满意，你才会体会到设计模式的重要性，也才能更加理解。也就是说，一个类应该尽量减少与其他类的耦合度，只与它直接相关的类进行交互。
埃氏筛选-判断素数
qq_45706306的博客
04-27 197
筛选：从最小的质数2开始，将它的所有倍数标记为合数（非质数），即把 isshushu 数组中对应索引位置的值设置为 true。计数：在筛选过程中，每当遇到一个未被标记为合数的数（即 isshushu 数组中对应值为 false 的数），则它就是一个质数，增加质数计数器 count 的值。返回结果：当所有小于 n 的数都经过筛选后，返回质数计数器 count 的值，即小于 n 的质数数量。通过这种方式，代码能够高效地找出并计算给定范围内质数的数量，避免了逐一检查每个数是否为质数的低效方法。
java 解析 shp格式文件
05-26
要解析 shp 格式文件，可以使用 Java 开源库 GeoTools。GeoTools 提供了一套 Java API，用于加载、操作和存储空间数据，包括 shp 文件。 以下是一个简单的示例代码，演示如何使用 GeoTools 解析 shp 文件： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值