直接上代码
 
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Date;


public class sqlExecute {

    public void executeBatch() throws Exception {

        DbUtil dbUtil = new DbUtil();
        Connection con = dbUtil.getCon();
        String sql = "insert into pousheng_member_channel_rels (member_id,type,register_at) select id,\"YY\" as TYPE,register_at from mc_profiles limit 100000 offset ";


        Statement st = null;
        int j=0;
        try {
            long start = System.currentTimeMillis();
            st = con.createStatement();
            con.setAutoCommit(false);
            j=4000000;
            for (int i=0;i<20;i++,j+=100000){
                String s=sql+j;
                System.out.println(s);
                st.addBatch(s);
            }
            st.executeBatch();
            st.clearBatch();
            con.commit();
            long end = System.currentTimeMillis();
            System.out.println("200万数据插入耗时："+(end-start)/1000+"s");
        } catch (Exception e) {
            System.out.println("起点"+j+"错误请重新执行脚本");
            e.printStackTrace();
        } finally {
            dbUtil.closeCon(con);
        }
    }
}
 
 
 
单条sql执行每执行一条会有io的开销，导致耗时长，这里使用的是批处理提交事务的方式，一次提交20条sql，每次执行插入10万条数据，这样减少了io的开销，速度也会快很多
 

原文转载自：http://blog.csdn.net/wang379275614/article/details/26294569
 
一、使用批处理
 
批处理，可以大幅度提升大量增、删、改的速度，就是对大数据操作有很大的效率提升。 
 　　与上篇文章中提到的“连接池”相似。其实就是先将多次操作（增删改）打包，然后再一次发送执行 
 　　主要用到两个方法： 
 　　　Ø 打包：PreparedStatement.addBatch(); 
 　　　Ø 发送、执行：PreparedStatement.executeBatch(); 
 　　　Ø 关闭自动提交、提交：conn.setAutoCommit(false)、conn.commit();
 
二、正确关闭JDBC连接的顺序
 
直接关闭Connection 
 在一般的处理中，直接关闭connection没有问题，但必须保证是这里的关闭是真正的《关闭》
 
但在使用连接池运用中，关闭connection并不意味着真正的关闭了connection，而是将connection返回到池中，并没有关闭。在这种情况下，你的prepsttment和resulset都没有被关闭。
 
这样就不行了。 
 正确顺序是：
 
打开时：Connection -> PreparedStatement -> ResultSet
关闭时：ResultSet-> PreparedStatement -> Connection
 
三、代码
 
package com;

import java.sql.Connection;  
import java.sql.DriverManager;
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.SQLException;  
import java.sql.Statement;  
/** 
 * @author-zhipeng 
 * 
 * 对比批处理与非批处理的差别（本例的循环所在位置） 
 */  
public class BatchTest {  

    /** 
     * 对比“批处理”与“非批处理”的执行效率 
     */  
    public static void main(String[] args) throws SQLException {  
        //非批处理，插入100条数据所花费的时间  
        long start = System.currentTimeMillis();  
       for (int i = 0; i < 100; i++)  
            create(i);  
        long end = System.currentTimeMillis();  
        System.out.println("create:" + (end - start));  
        //批处理，插入100条数据所花费的时间  
       start = System.currentTimeMillis();  
        createBatch();  
        end = System.currentTimeMillis();  
        System.out.println("createBatch:" + (end - start)); 
    }  
    /** 
     * 非批处理-插入1条数据 
     */  
    static void create(int i) throws SQLException {  
        Connection conn = null;  
        PreparedStatement ps = null;  
        ResultSet rs = null;  

        try {  
            //JdbcUtils为自定义的操作类，这里不多介绍  
            String a = "jdbc:sqlite://e:/work/soft/sqlite-dll-win64-x64-3200100/test.db";
            conn = DriverManager.getConnection(a);  
            String sql = "insert into person values("+i+", 'leo')";  
            ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);  
            //执行插入  
            ps.executeUpdate();  
        } finally {  
            //释放资源  
            conn.close();

        }  
    }  
    /** 
     * 批处理-插入100条数据 
     */  
    static void createBatch() throws SQLException { 
        Connection conn = null;  
        PreparedStatement ps = null;  
        ResultSet rs = null;  
        try {  
            String a = "jdbc:sqlite://e:/work/soft/sqlite-dll-win64-x64-3200100/test.db";
            conn = DriverManager.getConnection(a);    
            conn.setAutoCommit(false);  
            String sql = "insert into person values(?, ?)";  
            ps = conn.prepareStatement(sql);  
            //注意批处理与“非批处理”循环放的位置  
            for (int i = 0; i < 100; i++) {  

                ps.setInt(1, i);
                ps.setString(2, "meimei");  
                //关键方法1：打包  
                ps.addBatch();  
            }  
            int[] is = ps.executeBatch();  
            ps.close();
            conn.commit();
            //关键方法2：执行  

        } finally {  
            conn.close();
        }  
    }  
}  
 
另外还有第二种方法，据说效率更高 
 地址：http://blog.csdn.net/fengkaungdewoniu/article/details/52740113

注意： 有一个很奇葩的错误， 如果SQL语句的末尾含有分号（;） 会出现ORA-00933: SQL 命令未正确结束 
 
 
 
参考：SQL语句要不要加分号？ ，在程序里面编译器会把分号（;）当做SQL本身的一部分，所以会报错。
 
 
Oracle数据源配置
 
driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@//192.168.1.15:1521/orcl
username=test
password=test
 
jdbc数据库链接工具类
 
import java.io.InputStream;
import java.sql.*;
import java.util.List;
import java.util.Properties;
import java.util.logging.Logger;

/**
 * @Description TODO 连接Oracle
 */
public class JdbcUtil {
    private static Logger logger = Logger.getLogger("JdbcUtil");

    private static String driver;
    private static String url;
    private static String username;
    private static String password;

    static {
        // 创建 properties 对象获取文件
        Properties ps = new Properties();
        // 获取流对象
        InputStream is = JdbcUtil.class.getResourceAsStream("/driver.properties");
        try {
            // 加载文件
            ps.load(is);
            driver = ps.getProperty("driver");
            url = ps.getProperty("url");
            username = ps.getProperty("username");
            password = ps.getProperty("password");
            // 加载驱动
            Class.forName(driver);
        } catch (Exception e) {
            logger.warning("Load OracleDriver Exception：>> " + e.getMessage());
        }
    }

    /**
     * 获取链接对象
     *
     * @return conn
     */
    public static Connection getConnection() {
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            logger.warning("Connection Oracle Exception：>> " + e.getMessage());
        }
        return conn;
    }

    /**
     * 创建链接对象 (因只进行增删改操作，所以采用把数据拼接到SQL语句的方式)
     *
     * @param conn
     * @return ps
     */
    public static Statement getStatement(Connection conn) {
        Statement statement = null;
        try {
            statement = conn.createStatement();
        } catch (SQLException e) {
            logger.warning("Create Statement Exception：>> " + e.getMessage());
        }
        return statement;

    }

    /**
     * 增刪改通用语句
     *
     * @param dataList
     * @return i
     */
    public static int executeDML(List<String> dataList) {
        if (dataList.size() == 0 || dataList == null) {
            return -1;
        }
        Connection conn = getConnection();
        Statement statement = getStatement(conn);
        try {
            // 关闭事务自动提交
            conn.setAutoCommit(false);
            // 计数器
            int i = 0;
            for (int j = 0; j < dataList.size(); j++) {
                statement.addBatch(dataList.get(j));
                //  每 10000 条，向数据库发送一次执行请求
                if (++i % 10000 == 0) {
                    statement.executeBatch();
                }
            }
            // 执行批量处理语句
            statement.executeBatch();
            // 提交事务
            conn.commit();
            return i;
        } catch (SQLException e) {
            try {
                conn.rollback();
            } catch (SQLException e1) {
                logger.warning("Rollback Exception：>> " + e.getMessage());
            }
            logger.warning("ExecuteUpdate Exception：>> " + e.getMessage());
        } finally {
            allClose(statement, conn);
        }
        return -1;
    }

    public static void allClose(Statement statement, Connection conn) {
        try {
            if (statement != null) {
                statement.close();
            }
        } catch (SQLException e) {
            logger.warning("Statement Closed Exception：>> " + e.getMessage());
        }
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            logger.warning("Connection Closed Exception：>> " + e.getMessage());
        }
    }
}

 
执行主方法的类
 
import com.tengxt.db.JdbcUtil;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

public class Main {
    private static Logger logger = Logger.getLogger("Main");

    public static void main(String[] args) {
        // 从项目根路径获取SQL指定文件，打成jar包后可以获取到外部的SQL文件
        String confPath = System.getProperty("user.dir") + File.separator + "point.txt";
        File loadFile = new File(confPath);
        sqlToDb(loadFile);
    }

    /**
     * 把 SQL 语句插入数据库中
     *
     * @param file
     */
    public static void sqlToDb(File file) {
        if (!file.exists()) {
            logger.info("File is Not Found");
        } else {
            InputStreamReader inputStreamReader = null;
            BufferedReader bufferedReader = null;
            int i = 0;
            String read = null;
            List<String> dataList = null;
            try {
                // 
                inputStreamReader = new InputStreamReader(new FileInputStream(file), "UTF-8");
                bufferedReader = new BufferedReader(inputStreamReader);
                dataList = new ArrayList<>();
                while ((read = bufferedReader.readLine()) != null) {
                    i = i + read.split("/").length;
                    logger.info("Execute Data: " + read);
                    dataList.add(read);
                }
                // 执行数据库操作
                int dml = JdbcUtil.executeDML(dataList);
                if (dml > 0) {
                    System.out.println("执行成功，受影响条数: " + dml);
                }
            } catch (Exception e) {
                logger.warning(i + "行 >> 执行失败！：" + read + "Exception: " + e.getMessage());
            } finally {
                try {
                    if (bufferedReader != null) {
                        bufferedReader.close();
                    }
                } catch (IOException e) {
                    logger.warning("bufferedReader Closed Exception：>> " + e.getMessage());
                }
                try {
                    if (inputStreamReader != null) {
                        inputStreamReader.close();
                    }
                } catch (IOException e) {
                    logger.warning("InputStreamReader Closed Exception：>> " + e.getMessage());
                }
            }
        }
    }
}

                 
 
/**
   * 执行多条更新的Sql语句
   */
  public boolean UpdataSql(String sql[]){
    TestConnect.Connect();    
      try {
          sta = TestConnect.connection.createStatement();
          for(int i=0;i            sta.addBatch(sql[i]);            
            System.out.println("输出SQL语句："+sql[i]);                 
          }     
          sta.executeBatch();//执行
          return(true);
      }
      catch (Exception ex) {
          System.out.println("Error : " + ex.toString());
          return(false);
        }
      finally{
        try{
          TestConnect.connection.commit();
          sta.close();
          TestConnect.connection.close();
          
        }catch(Exception e){
          e.printStackTrace();
        }        
      }    
  }
            

再分享一下我老师大神的人工智能教程吧。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！https://blog.csdn.net/jiangjunshow