性能上来说推荐使用： PreparedStatement批量更新
原因：

1. 在安全性上PreparedStatement会进行预处理编译，在数据的安全性上PreparedStatement是可以防止Statement的sql注入导致的漏洞问题；
2. 随着数据的不断增大，PreparedStatement的性能比Statement 的效果要好;

package com.mo.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 * @ClassName: DBUtil
 * @Description: DB测试工具类
 * @author wsq E-mail：
 * @date 2018年9月13日 上午12:47:57
public class DBUtils {
	// 定义连接所需的常量
	private static String USERNAMR = "xxx"; // Oracle数据库的用户名
	private static String PASSWORD = "xxx"; // Oracle数据库的用户密码
	private static String DRVIER = "oracle.jdbc.OracleDriver"; // 驱动
	private static String URL = "jdbc:oracle:thin:@10.1.2.24:1521:xxx";
	// 创建一个数据库连接
	Connection conn = null;
	// 创建预编译语句对象
	PreparedStatement pstm = null;
	Statement stm = null;
	// 创建一个结果集对象
	ResultSet rs = null;
	 * @Title: updateTest
	 * @Description: PreparedStatement批量更新
	 * @return void    返回类型
	public void updateTest() {
		try {
			Class.forName(DRVIER);
			// 创建数据连接
			conn = DriverManager.getConnection(URL, USERNAMR, PASSWORD);
			// 关闭自动提交，即开启事务
			conn.setAutoCommit(false);
			String sql = "update tableName set cloumn1 = ? where id = ?";
			pstm = conn.prepareStatement(sql);
			for (int i = 0; i < 10000; i++) {
				pstm.setString(1, "11");
				pstm.setInt(2, 00001);
				// 添加批处理SQL
				pstm.addBatch();
				// 每200条执行一次，避免内存不够的情况
				 * if (i > 0 && i % 200 == 0) { pstm.executeBatch(); }
			// 最后执行剩余不足200条的
			pstm.executeBatch();
			pstm.close();
			// 执行完后，手动提交事务
			conn.commit();
			// 在把自动提交打开
			conn.setAutoCommit(true);
		} catch (ClassNotFoundException e) {
			throw new RuntimeException("class not find !", e);
		} catch (SQLException e) {
			try {
				// 发生异常，事务回滚！
				if (conn != null && !conn.isClosed()) {
					conn.rollback();
					conn.setAutoCommit(true);
					System.out.println("更新失败，事务回滚！");
			} catch (Exception e2) {
				e2.printStackTrace();
			e.printStackTrace();
		} finally {
			if (rs != null) {
				try {
					rs.close();
				} catch (SQLException e) {
					e.printStackTrace();
			if (pstm != null) {
				try {
					pstm.close();
				} catch (SQLException e) {
					e.printStackTrace();
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
	 * @Title: updateTest1
	 * @Description: Statement批量更新
	 * @return void    返回类型
	public void updateTest1() {
		try {
			Class.forName(DRVIER);
			// 创建数据连接
			conn = DriverManager.getConnection(URL, USERNAMR, PASSWORD);
			stm = conn.createStatement();
			// 关闭自动提交，即开启事务
			conn.setAutoCommit(false);
			for (int i = 0; i < 10000; i++) {
				// 添加批处理SQL
				stm.addBatch("update people set firstname='John' where id=123");
				stm.addBatch("update people set firstname='Eric' where id=456");
				stm.addBatch("update people set firstname='May'  where id=789");
			// 最后执行剩余不足200条的
			stm.executeBatch();
			stm.close();
			// 执行完后，手动提交事务
			conn.commit();
			// 在把自动提交打开
			conn.setAutoCommit(true);
		} catch (ClassNotFoundException e) {
			throw new RuntimeException("class not find !", e);
		} catch (SQLException e) {
			try {
				// 发生异常，事务回滚！
				if (conn != null && !conn.isClosed()) {
					conn.rollback();
					conn.setAutoCommit(true);
					System.out.println("更新失败，事务回滚！");
			} catch (Exception e2) {
				e2.printStackTrace();
			e.printStackTrace();
		} finally {
			if (rs != null) {
				try {
					rs.close();
				} catch (SQLException e) {
					e.printStackTrace();
			if (stm != null) {
				try {
					stm.close();
				} catch (SQLException e) {
					e.printStackTrace();
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
/*	public static void main(String[] args) {
		new DBUtils().updateTest();
                    JDBC批量更新PreparedStatement和StatementPreparedStatement批量更新Statement批量更新JDBC批量更新PreparedStatement和StatementPreparedStatement批量更新Statement批量更新package com.mo.util;import java.sql.Conn...
				
        java操作数据库批量更新主要为addBatch（） 和executeBatch（）方法，一般将数据存储在ArrayList里面，一次批量更新为一个addBatch(),全部更新完后，统一执行executeBatch（）方法。一下为代码：
 public void UpdateData2(List&lt;String[]&gt; list){
        try {
				
首先注意Statement 和PreparedStatement的问题 Statement sm = cn.createStatement(); sm.addBatch(sql1); sm.addBatch(sql2); … sm.executeBatch() 用Statement的好处就是每次可以直接传一个SQL语句进去，不用管那么多。可是在数据量比较大的时候，应该会对效率有影响。不建议使用。 PreparedStatement ps = cn.preparedStatement(sql); { 　ps.setXXX(1,xxx); 　… 　ps.addBatch(); } ps.execu
				
JDBC Update操作返回值
在操作数据库时，update操作会返回数据库更新行数，但是在JDBC默认情况下则不会返回数据库更新行数，这一点有所不同，在实际操作中可能会出现意想不到的结果。在使用ORM框架时，例如Mybatis、Hibernate时由于其底层同样使用JDBC API，所以同样会出现上诉问题。
JDBC API
首先，我们看一下JDBC API中是对update操作返回值得定义，...
1） addBatch()将一组参数添加到PreparedStatement对象内部。
2） executeBatch()将一批参数提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。
Statement：
1） addBatch(String sql)方法会在批处理缓存中加入一条sql语句。
2） execute
				
文章目录class PrepareStatementInsertPrepareStatementUpdatePrepareStatementDelete
class PrepareStatementInsert
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class PrepareState
				
第5章 批量插入
5.1 批量执行SQL语句
当需要成批插入或者更新记录时，可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率
JDBC的批量处理语句包括下面三个方法：
addBatch(String)：添加需要批量处理的SQL语句或是参数；
executeBatch()：执行批量处理语句；
clearBatch():清空缓存的数据
通常我们会遇到两种批量执行SQL语句的情况：
多条SQL语句的批量处理；
一个SQL语句的批量传参；
try {
    Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
    PreparedStatement ps = conn.prepareStatement("UPDATE user SET status = ? WHERE id = ?");
    for (User u : userList) {
        ps.setString(1, u.getStatus());
        ps.setInt(2, u.getId());
        ps.addBatch();
    ps.executeBatch();
} catch (SQLException e) {
    e.printStackTrace();
				解决MySQL 5.7.9版本sql_mode=only_full_group_by问题，this is incompatible with sql_mode=only_full_group_by错误
					27701