import org.geotools.factory.FactoryRegistryException; //导入依赖的package包/类
public static void main(String [] args) throws NoSuchAuthorityCodeException, FactoryRegistryException, FactoryException, MismatchedDimensionException, TransformException{

		
		String zone = "52";
		double easting =596450.153;
		double northing = 6680793.777;
		System.out.print(SpatialUtilities.convertUTM_MGA942Geographic_EPSG4326(easting, northing, zone));
		
//		String zone = "53";
//		double easting =616450.153;
//		double northing = 6680793.777;
//		System.out.print(SpatialUtilities.convertUTM_MGA942Geographic_EPSG4326(easting, northing, zone));
		
	}
 

import org.geotools.factory.FactoryRegistryException; //导入依赖的package包/类
/**
 * @param oldFeatureType the {@link FeatureType} of the existing features.
 * @param fieldArray the list of the names of new fields. 
 * @param classesArray the list of classes of the new fields.
 * @throws FactoryRegistryException 
 * @throws SchemaException
 */
public FeatureExtender( SimpleFeatureType oldFeatureType, String[] fieldArray,
        Class<?>[] classesArray ) throws FactoryRegistryException, SchemaException {

    List<AttributeDescriptor> oldAttributeDescriptors = oldFeatureType
            .getAttributeDescriptors();
    List<AttributeDescriptor> addedAttributeDescriptors = new ArrayList<AttributeDescriptor>();
    for( int i = 0; i < fieldArray.length; i++ ) {
        AttributeTypeBuilder build = new AttributeTypeBuilder();
        build.setNillable(true);
        build.setBinding(classesArray[i]);
        AttributeDescriptor descriptor = build.buildDescriptor(fieldArray[i]);
        addedAttributeDescriptors.add(descriptor);
    }

    List<AttributeDescriptor> newAttributesTypesList = new ArrayList<AttributeDescriptor>();
    for( AttributeDescriptor attributeDescriptor : oldAttributeDescriptors ) {
        newAttributesTypesList.add(attributeDescriptor);
    }
    newAttributesTypesList.addAll(addedAttributeDescriptors);

    // create the feature type
    SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
    b.setName(oldFeatureType.getName());
    b.setCRS(oldFeatureType.getCoordinateReferenceSystem());
    b.addAll(newAttributesTypesList);
    newFeatureType = b.buildFeatureType();
}
 

import org.geotools.factory.FactoryRegistryException; //导入依赖的package包/类
/**
 * The most specific way to create a new FeatureType.
 * 
 * @param types
 *            The AttributeTypes to create the FeatureType with.
 * @param name
 *            The typeName of the FeatureType. Required, may not be null.
 * @param ns
 *            The namespace of the FeatureType. Optional, may be null.
 * @param isAbstract
 *            True if this created type should be abstract.
 * @param superTypes
 *            A Collection of types the FeatureType will inherit from.
 *            Currently, all types inherit from feature in the opengis
 *            namespace.
 * 
 * @return A new FeatureType created from the given arguments.
 * 
 * @throws FactoryRegistryException
 *             If there are problems creating a factory.
 * @throws SchemaException
 *             If the AttributeTypes provided are invalid in some way.
 */
public static FeatureType newFeatureType(final AttributeType[] types,
		final String name, final URI ns, final boolean isAbstract,
		final FeatureType[] superTypes, final AttributeType defaultGeometry)
		throws FactoryRegistryException, SchemaException {
	final FeatureTypeFactory factory = newInstance(name);
	factory.addTypes(types);
	factory.setNamespace(ns);
	factory.setAbstract(isAbstract);
	if (defaultGeometry != null) {
		factory.setDefaultGeometry((GeometryAttributeType) defaultGeometry);
	}

	if (superTypes != null) {
		factory.setSuperTypes(Arrays.asList(superTypes));
	}

	return factory.getFeatureType();
}
 

import org.geotools.factory.FactoryRegistryException; //导入依赖的package包/类
/**
 * Create a FeatureTypeFactory which contains all of the AttributeTypes from
 * the given FeatureType. This is simply a convenience method for<br>
 * <code><pre>
 * FeatureTypeFactory factory = FeatureTypeFactory.newInstace();
 * factory.importType(yourTypeHere);
 * factory.setName(original.getName());
 * factory.setNamespace(original.getNamespace());
 * factory.setNillable(original.isNillable());
 * factory.setDefaultGeometry(original.getDefaultGeometry());
 * </pre></code>
 * 
 * @param original
 *            The FeatureType to obtain information from.
 * 
 * @return A new FeatureTypeFactory which is initialized with the state of
 *         the original FeatureType.
 * 
 * @throws FactoryRegistryException
 *             If a FeatureTypeFactory cannot be found.
 */
public static FeatureTypeFactory createTemplate(final FeatureType original)
		throws FactoryRegistryException {

	final FeatureTypeFactory builder = FeatureTypeFactory
			.newInstance(original.getTypeName());
	builder.importType(original);
	builder.setNamespace(original.getNamespace());
	builder.setDefaultGeometry(original.getDefaultGeometry());

	final FeatureType[] ancestors = original.getAncestors();

	if (ancestors != null) {
		builder.setSuperTypes(Arrays.asList(ancestors));
	}

	return builder;
}