逍遥谷

String a = String.valueOf(2);//integer to numeric string
int i = Integer.parseInt(a);//numeric string to an int

BufferedWriter out = null;
try {
	out = new BufferedWriter(new FileWriter(”filename”, true));
	out.write(”aString”);
} catch (IOException e) {
	// error processing code
} finally {
	if (out != null) {
		out.close();
	}
}

String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();

SimpleDateFormat format = new SimpleDateFormat( "dd.MM.yyyy" );
Date date = format.parse( myString );

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

/**
 * <p></p>
 * @author z```s
 * @version 1.0.0
 * @since java8
 * 2023-11-22 14:23
 */
public class OracleJdbcTest {
    
    String driverClass = "oracle.jdbc.driver.OracleDriver";
    
    Connection connection;
    
    public void init(FileInputStream fs) throws ClassNotFoundException, SQLException, IOException {
        Properties props = new Properties();
        props.load(fs);
        String url = props.getProperty("db.url");
        String userName = props.getProperty("db.user");
        String password = props.getProperty("db.password");
        Class.forName(driverClass);
        connection = DriverManager.getConnection(url, userName, password);
    }
    
    public void fetch() throws SQLException {
        PreparedStatement ps = connection.prepareStatement("select SYSDATE from dual");
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            // do the thing you do  
        }
        rs.close();
        ps.close();
    }
    
    public static void main(String[] args) throws SQLException, IOException, ClassNotFoundException {
        OracleJdbcTest test = new OracleJdbcTest();
        test.init(null);
        test.fetch();
    }
    
}

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * <p></p>
 * @author z```s
 * @version 1.0.0
 * @since java8
 * 2020/5/11 10:45
 */
public class JSON {
    
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
    
    public static final String DATE_TIME_FORMAT_01 = "yyyy-MM-dd HH:mm:ss";
    
    public static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat(DATE_TIME_FORMAT_01);
    
    static {
        OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //OBJECT_MAPPER.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
        simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
        simpleModule.addSerializer(Double.class, ToStringSerializer.instance);
        simpleModule.addSerializer(Double.TYPE, ToStringSerializer.instance);
        simpleModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT_01)));
        simpleModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT_01)));
        OBJECT_MAPPER.registerModule(simpleModule);
    }
    
    private JSON() {
    }

    /**
     * 将json文件转换为JSON对象
     * @param filePath
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T jsonFileParseObject(String filePath, Class<T> clazz) {
        try {
            return OBJECT_MAPPER.readValue(new File(filePath), clazz);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 对象转换JSON字符串
     * @param object
     * @return
     */
    public static String toJSONString(Object object) {
        try {
            return OBJECT_MAPPER.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * JSON字符串转换对象
     * @param text
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T parseObject(String text, Class<T> clazz) {
        try {
            return OBJECT_MAPPER.readValue(text, clazz);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * JSON字符串转换为List
     * @param text
     * @param <T>
     * @return
     */
    public static <T> List<T> parseArray(String text) {
        TypeReference<ArrayList<T>> typeReference = new TypeReference<ArrayList<T>>() {};
        try {
            return OBJECT_MAPPER.readValue(text, typeReference);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * JSON字符串转换为Map
     * @param text
     * @return
     */
    public static <T> LinkedHashMap<String, T> parseMap(String text) {
        TypeReference<LinkedHashMap<String, T>> typeReference = new TypeReference<LinkedHashMap<String, T>>() {};
        try {
            return OBJECT_MAPPER.readValue(text, typeReference);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }
    
}