说说preparedstatement和statement的区别

1.PreparedStatement：PreparedStatement是java.sql包下面的一个接口，用来执行SQL语句查询，通过调用connection.preparedStatement(sql)方法可以获得PreparedStatment对象。数据库系统会对sql语句进行预编译处理（如果JDBC驱动支持的话），预处理语句将被预先编译好，这条预编译的sql查询语句能在将来的查询中重用，这样一来，它比Statement对象生成的查询速度更快。2.Statement使用 Statement 对象。在对数据库只执行一次性存取的时侯，用 Statement 对象进行处理。PreparedStatement 对象的开销比Statement大，对于一次性操作并不会带来额外的好处。

PreparedStatements是预编译的，因此，性能会更好。同时，不同的查询参数值，PreparedStatement可以重用。

来自javaapi用于执行静态SQL语句并返回它所生成结果的对象。在默认情况下，同一时间每个Statement对象在只能打开一个ResultSet对象。因此，如果读取一个ResultSet对象与读取另一个交叉，则这两个对象必须是由不同的Statement对象生成的。如果存在某个语句的打开的当前ResultSet对象，则Statement接口中的所有执行方法都会隐式关闭它

Prepared 是表示要预编译 SQL （请求服务器去先编译），之后可以跑循环之类的而省掉编译过程。同时使用 PreparedStatement 时用参数的办法能避免 SQL 注入漏洞，推荐任何时间都使用 PreparedStatement （特别需要用到参数的时候）。SQL 注入是这样的：select 1 from users where username="" + name + "" and passwd="" + password + """;那么入侵者可以在网页上填 上用户名和密码凑出：name= " " or 1 = 1" "password = " " or 1 = 1 " "这样你把这两个变量替换到字符串之后完整的 SQL 变成了：select 1 from users where username = "" or 1 = 1 and password = "" or 1 =1;这里面应该最后 一个 1 = 1 是成立的，所以入侵者不知道用户名和密码也成功登录到网站了。

1.这三个都是接口。statement继承wrappe，prepastatement继承statement，callablestatement继承preparedstatement 2.statement接口提供了执行语句和获取结果的基本方法； preparstatement接口增加了处理IN参数的方法； callablestatement接口增加了处理OUT参数的方法 3.statement：普通的不带参的查询sql，支持批量更新，批量删除； preparedstatement：可变参数的sql，预编译一次，执行多次，可以防止sql注入，支持批量更新，批量删除； callablestatement：继承自preparedstatement，支持带参的sql操作，支持调用存储过程，提供了对输出和输入/输出参数(INOUT)的支持;

你的关键字会被转义

PreparedStatement 预编译,一次编译,到处执行,效率高,并且参数可以使用占位符如(?,:test),安全些.

有的小伙伴用中琅条码打印软件制作条形码时，条形码数据没有保存在TXT或者Excel表中，而是保存在数据库中，那就无法选择TXT或者Excel数据源导入条形码数据了，这样的话，在条码打印软件可以选择连接相应的数据库来获取条码数据。以SQL Server数据库为例。运行条码打印软件，新建标签，设置标签尺寸，行列等信息。完成之后点数据库工具，选择SQL Server数据源。然后配置SQL Server数据库连接信息，输入服务器名称（直接输入服务器名称或者输入localhost）、端口、数据库名称，以及SQL Server数据库的账号密码，测试连接。接下来就可以在条码打印软件中绘制一个条形码，在条形码的属性中修改条形码数据，条码数据选择数据库导入，然后选择对应的数据库连接和字段即可接下来打印预览查看就可以到连接的SQL Server数据库“yu”表中的数据都批量生成条形码了。

批量数据进入数据库使用addBatch()和executeBatch()方法PreparedStatement.addBatch(); ...... PreparedStatement.executeBatch();需要注意的是一次最多不要超过50条:1.因为插入的时候数据库已经锁定，然而若是一次性插入太多会造成其他业务的等待。2.会造成内存的溢出举例：PreparedStatement pst = (PreparedStatement) con.prepareStatement("insert into ***** values (?,"***")"); for (int i = 0; i < 10000; i++) { pst.setInt(1, i); // 把一个SQL命令加入命令列表 pst.addBatch(); } // 执行批量更新 pst.executeBatch(); // 语句执行完毕，提交本事务 con.commit();

使用ps的set方法首先要构造带有占位符的sql。例：ps = con.prepareStatement("SELECT * FROM fnbl_user WHERE username =?");ps.setString(1, "admin");result = ps.executeQuery(preSql);不同的参数使用不同的set，也可以setString等。望采纳

preparedstatement怎么查看sql推荐使用以下方法：Connection con = DriverManager.getConnection(url);DebugLevel debug = DebugLevel.ON;String sql = "SELECT name,rate FROM EmployeeTable WHERE rate > ?";//Use a factory instead of Connection to get a PreparedStatement.//PreparedStatement ps = con.prepareStatement(sql);

当你向数据库提交SQL语句后，数据库要对这条语句进行编译，例如语法分析、优化路径选择、分配资源等一系列操作，这是需要时间的。当你向数据库插入10条记录时，如果使用常规做法，数据库需要编译10次。而使用PreparedStatement接口，数据库只需要编译一次，其他只是更改参数就可以了。所以，当你向数据库中进行批量操作的时候，预编译效率比较高。

setstring是给你的sql中的一个参数赋值，使用preparedstatement你的sql一般应该是这样的，包含一个?的占位符，用于设置参数：stringsql="select*fromuseruwhereu.name=?";setstring的作用就是给?赋值，第一个参数是?的位置，从1开始；第二个参数就是值了

拼接 like %%

常常有人问及如何得到PreparedStatement最终执行的SQL语句;或者如何在控制台输出占位符的真实值.....http://www.blogjava.net/crazycy/archive/2015/02/03/59581.html详细可以参考这个，有图解教程，希望可以帮到你

这不就是1条数据提交一次么，只填一个值就提交肯定出错，因为参数数量不够。如果不提交，后来的数据就覆盖了之前的。

ps = ct.prepareStatement("select username,nserPasswd from users where users.username=? and users.userPasswd=?");//执行rs = ps.executeQuery();你创建的PreparedStatement对象，然后呢SQL语句中的2个?的值你还没注入进去呢就去数据库执行了所以报错了

问的不规范，应该问 同一个connection可以构造一个statement和一个preparedStatement对象吗？可以的

我就佩服你们编程序的。

execute()返回boolean值，如果是查询返回true，如果是更新false如果你执行update/delete/insert，需要执行executeUpdate(),返回值为收到影响的行数执行select则使用executeQuery()返回ResultSet

重新安装java或者重新配置一下jdk的路径

import scala.collection.mutable.ArrayBufferimport scala.io.Sourceimport java.io.PrintWriterimport util.control.Breaks._import org.apache.spark.SparkContextimport org.apache.spark.sql.SQLContextimport java.sql.DriverManagerimport java.sql.PreparedStatementimport java.sql.Connectionimport org.apache.spark.sql.types.IntegerTypeimport org.apache.spark.sql.types.StructTypeimport org.apache.spark.sql.types.StructFieldimport org.apache.spark.sql.types.StringTypeimport org.apache.spark.sql.Rowimport java.util.Propertiesimport org.apache.spark.sql.SaveModeobject SimpleDemo extends App { val sc = new SparkContext("local[*]", "test") val sqlc = new SQLContext(sc) val driverUrl = "jdbc:mysql://ip:3306/ding?user=root&password=root&zeroDateTimeBehavior=convertToNull&characterEncoding=utf-8" val tableName = "tbaclusterresult" //把数据转化为DataFrame,并注册为一个表 val df = sqlc.read.json("G:/data/json.txt") df.registerTempTable("user") val res = sqlc.sql("select * from user") println(res.count() + "---------------------------") res.collect().map { row => { println(row.toString()) } } //从MYSQL读取数据 val jdbcDF = sqlc.read .options(Map("url" -> driverUrl, // "user" -> "root", // "password" -> "root", "dbtable" -> tableName)) .format("jdbc") .load() println(jdbcDF.count() + "---------------------------") jdbcDF.collect().map { row => { println(row.toString()) } } //插入数据至MYSQL val schema = StructType( StructField("name", StringType) :: StructField("age", IntegerType) :: Nil) val data1 = sc.parallelize(List(("blog1", 301), ("iteblog", 29), ("com", 40), ("bt", 33), ("www", 23))). map(item => Row.apply(item._1, item._2)) import sqlc.implicits._ val df1 = sqlc.createDataFrame(data1, schema) // df1.write.jdbc(driverUrl, "sparktomysql", new Properties) df1.write.mode(SaveMode.Overwrite).jdbc(driverUrl, "testtable", new Properties) //DataFrame类中还有insertIntoJDBC方法，调用该函数必须保证表事先存在，它只用于插入数据，函数原型如下： //def insertIntoJDBC(url: String, table: String, overwrite: Boolean): Unit //插入数据到MYSQL val data = sc.parallelize(List(("www", 10), ("iteblog", 20), ("com", 30))) data.foreachPartition(myFun) case class Blog(name: String, count: Int) def myFun(iterator: Iterator[(String, Int)]): Unit = { var conn: Connection = null var ps: PreparedStatement = null val sql = "insert into blog(name, count) values (?, ?)" try { conn = DriverManager.getConnection(driverUrl, "root", "root") iterator.foreach(data => { ps = conn.prepareStatement(sql) ps.setString(1, data._1) ps.setInt(2, data._2) ps.executeUpdate() }) } catch { case e: Exception => e.printStackTrace() } finally { if (ps != null) { ps.close() } if (conn != null) { conn.close() } } }}

Connection con = null; PreparedStatement pstmt = null;在实例化这两个对象后不要再调用其他含有这两个参数的方法,如果需要调用另一个数据查询的方法,那就放到实例化前调用,不知是不是有这个情况

靠谱，推荐大家使用。 C onnection con = D riverM anager.getC onnection(url); D ebugLevel debug = D ebugLevel.O N ; String sql = "SELEC T nam e,rate FRO M Em ployeeTable W H ERE rate > ?"; //U se a factory instead of C onnection to get a PreparedStatem ent. //PreparedStatem ent ps = con.prepareStatem ent(sql); PreparedStatem ent ps = Statem entFactory.getStatem ent(con,sql,debug); ps.setInt(1,25); //If ps is a D ebuggableStatem ent, you see the statem ent, //otherw ise, an object identifier is displayed System .out.println(" debuggable statem ent= " + ps.toString()); 附件是这段代码中用到的类。

这个基本上是不可以的。能作为参数的都是变量，而目前的标准SQL和各厂商的扩展中(不管SQL Server, Oracle, PostgreSQL)，都支持变量作为表名。故这是不可以的。一个变通的方法是使用动态SQL, 但是那已经失去PrepareStatement的意义了。

statement已经被淘汰了,建议使用PreparedStatement.更安全,能防止sql注入

在CSDN的JAVA基础版,常常有人问及如何得到PreparedStatement最终执行的SQL语句;或者如何在控制台输出占位符的真实值.....原因就是PreparedStatement执行的sql语句有大量的占位符?....问题诸如JDBC中:如何得到 conn.prepareStatement 最终执行的sql语句。sql="update table1 set a=?,b=?"stmt = con.prepareStatement(sql);stmt.setObjec t(1,"a");stmt.setObjec t(2,"b");希望可以通过stmt或者conn 得到：update table1 set a="a",b="b"亦或Hibernate中如我执行：find("select * from t_table where id = ?",new Integer(5));在控制台显示SQL时只显示：select * from t_table where id = ?如何才能做到将控制台显示的占位符用其真实的值来替换？即控制台输出时显示：select * from t_table where id = 5共享我在工程中的使用方法：插入操作：/** * 执行插入数据库的语句public int executeInsert(String sql, Object[] params) { Connection conn = null; PreparedStatement pstmt = null; ResultSet rs = null; try { //1 获得连接 conn = MyDBConnection.getInstance().getConnection(); //2 设置提交方式为程序控制 conn.setAutoCommit(false); //3 获得语句对象 pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS); //4 设置SQL语句的参数 if (null != params && 0 < params.length) { setParams(pstmt, params); } //5 打印SQL语句 if (MyDBConstants.showSQL) {getPreparedSQL(sql, params); } //6 执行语句 pstmt.executeUpdate(); //7 程序提交 conn.commit(); //8 返回生成的主键 rs = pstmt.getGeneratedKeys(); int generatedKey = 0; if (rs.next()) { generatedKey = rs.getInt(1); } if (0 < generatedKey) throw new MySQLException("插入记录时出错"); return generatedKey; } catch (SQLException e) { //回滚 MyDBUtil.rollBack(conn); throw new MySQLException(e); } finally { //关闭打开的操作 MyDBUtil.close(conn, pstmt, rs); }}

使用JDBC进行数据库的增删改查操作1.下载Microsoft SQL Server 2005 JDBC 驱动包jar文件 将jar文件引入工程中2.封装数据库链接的获取和关闭操作import java.sql.*;public class BaseDao { /** * 数据库驱动类的字符串,完整的包名加类名 在工程中查看添加的jar文件 能看到这个类 */ private static final String DRIVE = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; /** * 数据库连接地址 * * DataBaseName=数据库名称 其它固定 */ private static final String URL = "jdbc:sqlserver://localhost:1433;DataBaseName=bbs"; /** * 连接数据库的用户名 */ private static final String USER = "sa"; /** * 用户密码 */ private static final String PASSWORD = ""; /** * 获取连接 异常直接抛出 或者捕获后自定义异常信息再抛出 */ public static Connection getConnection() throws Exception { Class.forName(DRIVE); return DriverManager.getConnection(URL, USER, PASSWORD); } /** * 关闭与数据库的连接 释放资源 */ public static void closeAll(ResultSet resultSet, PreparedStatement pst, Connection connection) throws Exception { if (resultSet != null) resultSet.close(); if (pst != null) pst.close(); if (connection != null) connection.close(); }}3.创建图书的实体类public class Book { /** * 数据库主键 */ private Long id; /** * 作者 */ private String author; /** * 书名 */ private String name; /** * 默认构造 * */ public Book() { } /** * 全字段构造 * @param id * @param author * @param name */ public Book(Long id, String author, String name) { this.id = id; this.author = author; this.name = name; } /** * 以下为读写属性的方法 * @return */ public String getAuthor() { return author; } public void setAuthor(String author) { this.author = author; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; }}4.创建与图书表交互的工具类import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.util.ArrayList;import java.util.List;public class BookDao { /** * 添加新书 * * @param book 要添加入数据库的图书 作者 书名 必须给定 */ public void addBook(Book book) throws Exception { // 连接 Connection connection = null; // 执行语句 PreparedStatement pst = null; try { connection = BaseDao.getConnection(); // 构造执行语句 String sql = "insert into book values(" + book.getAuthor() + "," + book.getName() + ")"; pst = connection.prepareStatement(sql); pst.executeUpdate(); } catch (Exception e) { // 抛出异常 throw e; } finally { // 无论是否异常 均关闭数据库 BaseDao.closeAll(null, pst, connection); } } /** * 查询所有书籍列表 */ public List<Book> getBooks() throws Exception { // 用于存放查寻结果的集合 List<Book> books = new ArrayList<Book>(); // 连接 Connection connection = null; // 执行语句 PreparedStatement pst = null; // 查询结果 ResultSet resultSet = null; try { connection = BaseDao.getConnection(); // 构造查询语句 String sql = "select * from book"; pst = connection.prepareStatement(sql); resultSet = pst.executeQuery(); // 循环读取查询结果行 while (resultSet.next()) { // getXXX的参数为数据表列名 Book book = new Book(resultSet.getLong("id"), resultSet .getString("author"), resultSet.getString("name")); // 将封装好的图书对象存入集合 books.add(book); } } catch (Exception e) { // 抛出异常 throw e; } finally { // 无论是否异常 均关闭数据库 BaseDao.closeAll(resultSet, pst, connection); } // 返回查询结果 return books; }/***其它方法类似上面 只是语句不同*/}当然 以上只是简单的封装 初学者可以在理解以上代码的基础上 进行更高级的封装5.使用BookDao添加书籍和获取所有书籍列表import java.util.List;/** * 测试类 * @author Administrator * */public class Test { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { //创建工具类对象 BookDao dao = new BookDao(); //创建一本图书 Book book = new Book(null,"QQ:495691293","编程菜鸟"); //添加书籍到数据库 dao.addBook(book); //获取所有图书列表 List<Book> books = dao.getBooks(); //输出结果 for (Book b : books) { System.out.println(b.getId()+" "+b.getAuthor()+" "+b.getName()); } }}

prepared statement准备语句; 准备好的报告拼音双语对照双语例句1Asked about the legality of the killing, Carney read from a prepared statement.问道射杀的合法性，Carney读起了已经准备好的报告。2Senator Donahue welcomed the witness cordially, after which Dr. Stavely read a prepared statement.参议员唐纳休和颜悦色地对证人表示欢迎，随后，斯塔弗利医生念了一份事先准备好的声明。

晕，改成con.prepareStatement("select stuName,stuPay,stuJob from member); 这样不就没有参数了吗？？汗！插入会，查询就不会了，真是不知道举一反三，程序员之路很漫长！慢慢熬吧

在某个时候会被jdk 清理

是的，注入漏洞是由于在参数值改变了sql的执行逻辑，例如//username正常情况下应该是一个用户名只包含数字或者英文字母，//但是当用户填写的是下面的串的时候，注入漏洞就发生了String username=" a" or 1=1 ";String pssword="xxx";String sql="select * from users where password=""+password+"" and user_name = " "+username;此时不管密码的什么都能查询到数据。相当于绕过验证了。PreparedStatement的参数注入功能会把参数里的特殊字符进入转义，单引号这样的是会被转义的，所以sql的逻辑不会因为参数值发生改变，注入漏洞就不可能发生了

conn为空引起的错误public static Connection getConnection() 去掉static 修饰符

Connection用到的PreparedStatements不缓存到池中。

你好，关于PreparedStatement真的比Statement快吗从开始写程序就一直被灌输着一种思想，如果使用jdbc一定要使用PreparedStatement，而不要使用Statement对象。 其中的原因有好多，比如可以防止数据库缓冲池溢出，代码的可读性，可维护性。这些都很正确。 但是还有一点人们经常提的就是PreparedStatement能够显著的提高执行效率。但PreparedStatement并不一定比Statement快：Statement 在select语句的时候比PreparedStatement效率高. 其他的就不一定了.希望对你有帮助

直接excute 删除语句 不行么

　　Java中PreparedStatement和Statement的用法区别　　1、 PreparedStatement接口继承Statement， PreparedStatement 实例包含已编译的 SQL 语句，所以其执行速度要快于 Statement 对象。　　2、作为 Statement 的子类，PreparedStatement 继承了 Statement 的所有功能。三种方法execute、 executeQuery 和 executeUpdate 已被更改以使之不再需要参数。　　3、在JDBC应用中，如果已经是稍有水平开发者，就应该始终以PreparedStatement代替Statement。也就是说，在任何时候都不要使用Statement。基于以下的原因:　　一、代码的可读性和可维护性。　　虽然用PreparedStatement来代替Statement会使代码多出几行，但这样的代码无论从可读性还是可维护性上来说，都比直接用Statement的代码高很多档次：　　stmt.executeUpdate("insert into tb_name (col1,col2,col2,col4) values (""+var1+"",""+var2+"","+var3+",""+var4+"")");//stmt是Statement对象实例　　perstmt = con.prepareStatement("insert into tb_name (col1,col2,col2,col4) values (?,?,?,?)");　　perstmt.setString(1,var1);　　perstmt.setString(2,var2);　　perstmt.setString(3,var3);　　perstmt.setString(4,var4);　　perstmt.executeUpdate(); //prestmt是 PreparedStatement 对象实例　　二、PreparedStatement尽最大可能提高性能。　　语句在被DB的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中(相当于一个涵数)就会得到执行。这并不是说只有一个Connection中多次执行的预编译语句被缓存，而是对于整个DB中，只要预编译的语句语法和缓存中匹配。那么在任何时候就可以不需要再次编译而可以直接执行。而statement的语句中，即使是相同一操作，而由于每次操作的数据不同所以使整个语句相匹配的机会极小，几乎不太可能匹配。比如:　　insert into tb_name (col1,col2) values ("11","22");　　insert into tb_name (col1,col2) values ("11","23");　　即使是相同操作但因为数据内容不一样，所以整个个语句本身不能匹配，没有缓存语句的意义。事实是没有数据库会对普通语句编译后的执行代码缓存。　　当然并不是所以预编译语句都一定会被缓存，数据库本身会用一种策略，比如使用频度等因素来决定什么时候不再缓存已有的预编译结果。以保存有更多的空间存储新的预编译语句。　　三、最重要的一点是极大地提高了安全性。　　即使到目前为止，仍有一些人连基本的恶义SQL语法都不知道。　　String sql = "select * from tb_name where name= ""+varname+"" and passwd=""+varpasswd+""";　　如果我们把[" or "1" = "1]作为varpasswd传入进来，用户名随意，看看会成为什么?　　select * from tb_name = "随意" and passwd = "" or "1" = "1";　　因为"1"="1"肯定成立,所以可以任何通过验证.更有甚者:　　把[";drop table tb_name;]作为varpasswd传入进来,则:　　select * from tb_name = "随意" and passwd = "";drop table tb_name;有些数据库是不会让你成功的，但也有很多数据库就可以使这些语句得到执行。　　而如果你使用预编译语句，传入的任何内容就不会和原来的语句发生任何匹配的关系，只要全使用预编译语句，就用不着对传入的数据做任何过虑。而如果使用普通的statement，有可能要对drop等做费尽心机的判断和过虑。

用ps的set方法首先要构造带有占位符的sql。例：ps = con.prepareStatement("SELECT * FROM fnbl_user WHERE username =?");ps.setString(1, "admin");result = ps.executeQuery(preSql);不同的参数使用不同的set，也可以setString等。java中的PreparedStatement 接口继承了Statement，并与之在两方面有所不同：有人主张，在JDBC应用中，如果你已经是稍有水平开发者，你就应该始终以PreparedStatement代替Statement.也就是说，在任何时候都不要使用Statement。

自己看吧。public void update(User u) {Connection conn = null;PreparedStatement stmt = null;String sql = "update t_user set uname=?,upwd=?,addNum=? where id = ?";try {conn = ConnectionUtils.getConnection();stmt = conn.prepareStatement(sql);stmt.setString(1, u.getUname());stmt.setString(2, u.getUpwd());stmt.setInt(3, u.getAddNum());stmt.setInt(4, u.getId());stmt.executeUpdate();} catch (SQLException e) {e.printStackTrace();} finally{ConnectionUtils.close(stmt);ConnectionUtils.close(conn);}}

String sql="select * from article where title like " %？%" ";

一次编译，多次执行

其实是预编译功能，用preparedstatement就会把sql的结构给数据库预编译。SQL注入 攻 击 是利用是指利用 设计 上的漏洞，在目 标 服 务 器上运行 Sql语 句以及 进 行其他方式的 攻 击 ， 动态 生成 Sql语 句 时 没有 对 用 户输 入的数据 进 行 验证 是 Sql注入 攻 击 得逞的主要原因。 对 于 JDBC而言， SQL注入 攻 击 只 对 Statement有效， 对 PreparedStatement 是无效的， 这 是因 为 PreparedStatement 不允 许 在不同的插入 时间 改 变查询 的 逻辑结 构。 如 验证 用 户 是否存在的 SQL语 句 为 ： select count(*) from usertable where name="用 户 名 " and pswd="密 码 "如果在 用 户 名字段 中 输 入 " or "1"="1" or "1"="1或是在 密 码 字段 中 输 入 1" or "1"="1将 绕过验证 ，但 这种 手段只 对 只 对 Statement有效， 对 PreparedStatement 无效。 PreparedStatement 相 对 Statement有以下 优 点： 1.防注入攻击 2.多次运行速度快 3.防止数据库缓冲区溢出 4.代 码 的可读性可维护性好

prepareStatement.setInt(1,值).setString(2,值)

executeUPdate()；是执行sql语句执行的类型为 UPDATE 或者DELETE类型的

setstring是给你的sql中的一个参数赋值，使用preparedstatement你的sql一般应该是这样的，包含一个?的占位符，用于设置参数：stringsql="select*fromuseruwhereu.name=?";setstring的作用就是给?赋值，第一个参数是?的位置，从1开始；第二个参数就是值了

显示真实的执行计划有助于更好的分析SQL语句的全过程，尤其是运行此SQL语句实时的I/O开销。通过对比预估的I/O与真实的I/O开销来判断SQL语句所存在问题，如缺少统计信息，SQL语句执行的次数，根据实际中间结果集的大小来选择合适的连接方式等。本文仅仅讲述display_cursor函数的使用。一、display_cursor函数用法1、display_cursor函数语法DBMS_XPLAN.DISPLAY_CURSOR(sql_id IN VARCHAR2 DEFAULT NULL,cursor_child_no IN NUMBER DEFAULT NULL,format IN VARCHAR2 DEFAULT "TYPICAL"); 2、display_cursor函数参数描述sql_id指定位于库缓存执行计划中SQL语句的父游标。默认值为null。当使用默认值时当前会话的最后一条SQL语句的执行计划将被返回可以通过查询V$SQL 或V$SQLAREA的SQL_ID列来获得SQL语句的SQL_ID。cursor_child_no指定父游标下子游标的序号。即指定被返回执行计划的SQL语句的子游标。默认值为0。如果为null，则sql_id所指父游标下所有子游标的执行计划都将被返回。format控制SQL语句执行计划的输出部分，即哪些可以显示哪些不显示。使用与display函数的format参数与修饰符在这里同样适用。除此之外当在开启statistics_level=all时或使用gather_plan_statistics提示可以获得执行计划中实时的统计信息有关详细的format格式描述请参考：dbms_xplan之display函数的使用 中format参数的描述

JAVA的数据库用的database与表所在的database是否一致？

好像是这个方法.getParameterMetaDataParameterMetaData getParameterMetaData()throws SQLException检索此 PreparedStatement 对象的参数的编号、类型和属性。返回：一个 ParameterMetaData 对象，它包含有关此 PreparedStatement 对象的参数的编号、类型和属性的信息抛出：SQLException - 如果发生数据库访问错误不过还是不明白,"select * from table where field=? and field=?"我想设置的参数应该是通过函数参数传递过来，

当然可以了，PreparedStatement是Statement的子接口，这不就是多态么

1. 执行效率：Statement 采取直接编译 SQL 语句的方式，扔给数据库去执行，而 PreparedStatement 则先将 SQL 语句预编译一遍，再填充参数，这样效率会高一些。JDK 文档说：SQL 语句被预编译并且存储在 PreparedStatement 对象中，其后可以使用该对象高效地多次执行该语句。2. 代码可读性：Statement 中 SQL 语句中需要 Java 中的变量，加就得进行字符串的运算，还需要考虑一些引号、单引号的问题，参数变量越多，代码就越难看；而 PreparedStatement，则不需要这样，参数可以采用“?”代替，接下来再进行参数的填充，这样利于代码的可读性，并且符合面向对象的思想。3. 安全性：Statement 由于可能需要采取字符串与变量的拼接，很容易进行 SQL 注入攻击，而 PreparedStatement 由于是预编译，再填充参数的，不存在 SQL 注入问题。