A. java后台根据条件查询怎么写呀
如果是动态查询，也就是上面的条件个数不确定时，你在后台先做判断哪个条件是需要用的，然后先定义一个String类型的参数，把你需要的条件拼接出来。sql的话就这样写select * from 表明 where 1=1 后面拼接你的条件
B. Java里通用的查询方法怎么写
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.PreparedStatement;
public class JDBC {
private Connection con = null;
private Statement stmt = null;
private ResultSet rs = null;
private String driver = "com.mysql.jdbc.Driver";
private String url="jdbc:mysql://localhost:3306/dataname
?characterEncoding=GBK";
private String user = "root";
private String password = "mysql";
/**
* 准备连接
*/
public void startConnection() throws ClassNotFoundException, SQLException {
Class.forName(driver); //注册数据库驱动
con = DriverManager.getConnection(url, user, password); //获得数据库连接
}
/**
* 执行select 并返回结果集 throws SQLException
*/
public ResultSet query(String sql) throws SQLException {
stmt = con.createStatement(); //创建Statement
rs = stmt.executeQuery(sql); //执行查询
return rs;
}
/**
* 执行insert update delete
*/
public int update(String sql) throws SQLException {
stmt = con.createStatement();
int r = stmt.executeUpdate(sql);
return r;
}
/**
* 释放资源（连接）
*/
public void releaseConnection() {
try {
if (rs != null)
rs.close();
stmt.close();
if (con != null)
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
C. java中怎么写一个公共的查询数据库方法
package cn.db;//这个是自己建的包，这样子方便用的时候就可以通过包名来确定路径了
import java.sql.*;
import java.util.ArrayList;
public class DbDao {
Connection con=null;//连接
Statement stm=null;//执行SQL语句
ResultSet rs=null;//保存查询结果
public void connectDb(){
try {
Class.forName("com.mysql.jdbc.Driver");//这句固定的
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb","root","root");//其中的mydb是数据库名，后面两个root分别是数据库用户名和密码（我用的是MySQL数据库）
stm = con.createStatement();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public ArrayList executeQuery(String sql){//这个方法是用来查询数据库的，并且将查询的数据放到链表中
ArrayList list = new ArrayList();
try {
rs = stm.executeQuery(sql);
while(rs.next()){
//这里写入你要查询的数据，得由你自己写了。
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return list;
}
public void closeDb(){//关闭数据库
try {
if(rs!=null) rs.close();
if(stm!=null) stm.close();
if(con!=null) con.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
D. JAVA连接数据库，查询功能怎么写
public class JdbcNoarg {
//查询一行数据
public void getQueryNoargOne(){
JdbcMysqlPool jdbc = new JdbcMysqlPool();
Connection con=null;
Statement st = null;
String sql;
ResultSet rst = null;
try {
//获取数据库连接
con = jdbc.getConnection();
//在连接里打开一条通道createStatement，返回Statement对象
st = con.createStatement();
sql = "select *from student";
//把我们想要结果sql语句发送给数据库，数据库返回的数据用java ResultSet来接收
rst= st.executeQuery(sql);
//获取结果集的第一行数据9
rst.first();
//获取结果集指定列的数据
String name = rst.getString("name");
String interest = rst.getString("interest");
System.out.println("name:"+name+";interest:"+interest);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(rst!=null)
rst.close();
if(st!=null)
st.close();
if(con!=null)
con.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
E. JAVA中怎么实现查询 代码
try{Connection con;
Statement stmt;
ResultSet rs;
int temp;
Class.forName("com.mysql.jdbc.Driver");
con=DriverManager.getConnection("jdbc:mysql://localhost:3306/java","root","");//以上是数据库连接，不同的数据管理器有 //不同的驱动和链接方式，以上是mysql的连接
stmt=con.createStatement();
rs=stmt.executeQuery("select * from student");//执行查询语句，结果赋值给结果集rs
//结果集是结果于字段编号的映射，每一个字
//段都有一个编号，最小为1，也就是第一个字段
while(rs.next()){
String names=rs.getString("name");//查询结果转换成字符串。
System.out.println(names);
}rs.close();
}catch(Exception e){
e.printStackTrace();
}
F. java中的条件查询怎么写
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.PreparedStatement;
public class JDBC {
private Connection con = null;
private Statement stmt = null;
private ResultSet rs = null;
private String driver = "com.mysql.jdbc.Driver";
private String url="jdbc:mysql://localhost:3306/dataname
?characterEncoding=GBK";
private String user = "root";
private String password = "mysql";
/**
* 准备连接
*/
public void startConnection() throws ClassNotFoundException, SQLException {
Class.forName(driver); //注册数据库驱动
con = DriverManager.getConnection(url, user, password); //获得数据库连接
}
/**
* 执行select 并返回结果集 throws SQLException
*/
public ResultSet query(String sql) throws SQLException {
stmt = con.createStatement(); //创建Statement
rs = stmt.executeQuery(sql); //执行查询
return rs;
}
/**
* 执行insert update delete
*/
public int update(String sql) throws SQLException {
stmt = con.createStatement();
int r = stmt.executeUpdate(sql);
return r;
}
/**
* 释放资源（连接）
*/
public void releaseConnection() {
try {
if (rs != null)
rs.close();
stmt.close();
if (con != null)
con.close();
} catch (SQLException e) {
e.printStackTrace(); }
} }
G. java查询类怎么写
写一个方法,多一个参数,表示参数类型,根据参数类型,改变查询SQL语句
如:
public
ResultSet
query(参数1,参数2....
类型参数1){
if
类型参数1=1
{
sql=按第一种方式查询的sqlstring
}
if...........
if...........
xxx.executequery(sql)
return
...
}
H. Java实现查询的功能
查询部分代码如下：
StringstrSQL;
strSQL="select*fromtb_managerwheremanager='"+jTextField1.getText().trim()+"'";
rs=db.getResult(strSQL);
try
{
if(rs.first())
{
jTextField1.setText(rs.getString("manager"));
jTextField2.setText(rs.getString("den"));
jTextField3.setText(rs.getString("ID"));
jTextField4.setText(rs.getString("remark"));
jTextField5.setText(rs.getString("sex"));
}
else
{
JOptionPane.showMessageDialog(null,"无此信息");
}
}catch(SQLExceptione)
{JOptionPane.showMessageDialog(null,"查询信息失败!");}
}
I. java的递归查询怎么写
原文在这里，写得不错，楼主可参考下，具体链接如下，我只是搬运工！
http://blog.csdn.net/u011627980/article/details/51454323
/**
*说明方法描述：将list转为树tree结构
*
*@paramallRrecords
*@return
*@time2016年5月10日下午6:00:35
*@authoryangdong
*/
publicList<Record>useListRecordToTree(List<Record>allRrecords){
List<Record>listParentRecord=newArrayList<Record>();
List<Record>listNotParentRecord=newArrayList<Record>();
//第一步：遍历allRrecords保存所有数据的uuid用于判断是不是根节点
Map<String,String>mapAllUuid=newHashMap<String,String>();
Map<String,Record>allRecordMap=newHashMap<String,Record>();
for(Recordrecord:allRrecords){
mapAllUuid.put(record.getStr("uuid"),record.getStr("uuid"));
allRecordMap.put(record.getStr("uuid"),record);
}
//第二步：遍历allRrecords找出所有的根节点和非根节点
if(allRrecords!=null&&allRrecords.size()>0){
for(Recordrecord:allRrecords){
if(StringUtil.isBlank(record.getStr("parent_uuid"))
||!mapAllUuid.containsKey(record.getStr("parent_uuid"))){
listParentRecord.add(record);
}else{
listNotParentRecord.add(record);
}
}
}
//第三步：递归获取所有子节点
if(listParentRecord.size()>0){
for(Recordrecord:listParentRecord){
//添加所有子级
record.set("childs",this.getTreeChildRecord(listNotParentRecord,record.getStr("uuid")));
}
}
returnlistParentRecord;
}
/**
*说明方法描述：使list转换为树并根据关键字和节点名称过滤
*
*@paramallRecords所有节点
*@paramkeywords要过滤的关键字
*@paramfilterFields要过滤的字段
*@return
*@time2016年5月19日下午3:27:32
*@authoryangdong
*/
publicList<Record>useListRecordToTreeByKeywords(List<Record>allRecords,Stringkeywords,String...filterFields){
List<Record>listRecord=newArrayList<Record>();
Map<String,Record>allRecordMap=newHashMap<String,Record>();
for(Recordrecord:allRecords){
allRecordMap.put(record.getStr("uuid"),record);
}
//遍历allRrecords找出所有的nodeName和关键字keywords相关的数据
if(allRecords!=null&&allRecords.size()>0){
if(filterFields.length>1){
for(Recordrecord:allRecords){
for(Stringfield:filterFields){
//比较
if(record.getStr(field).toLowerCase().indexOf(keywords.toLowerCase())!=-1){
listRecord.add(record);
}
}
}
}else{
for(Recordrecord:allRecords){
//比较
if(record.getStr(filterFields[0]).toLowerCase().indexOf(keywords.toLowerCase())!=-1){
listRecord.add(record);
}
}
}
}
//查找过滤出来的节点和他们的父节点
listRecord=this.getSelfAndTheirParentRecord(listRecord,newArrayList<Record>(),
newHashMap<String,Record>(),allRecordMap);
//将过滤出来的数据变成树tree结构
listRecord=this.useListRecordToTree(listRecord);
returnlistRecord;
}
/**
*说明方法描述：递归查询子节点
*
*@paramchildList子节点
*@paramparentUuid父节点id
*@return
*@time2016年5月10日下午3:29:35
*@authoryangdong
*/
privateList<Record>getTreeChildRecord(List<Record>childList,StringparentUuid){
List<Record>listParentRecord=newArrayList<Record>();
List<Record>listNotParentRecord=newArrayList<Record>();
//遍历tmpList，找出所有的根节点和非根节点
if(childList!=null&&childList.size()>0){
for(Recordrecord:childList){
//对比找出父节点
if(StringUtil.equals(record.getStr("parent_uuid"),parentUuid)){
listParentRecord.add(record);
}else{
listNotParentRecord.add(record);
}
}
}
//查询子节点
if(listParentRecord.size()>0){
for(Recordrecord:listParentRecord){
//递归查询子节点
record.set("childs",getTreeChildRecord(listNotParentRecord,record.getStr("uuid")));
}
}
returnlistParentRecord;
}
/**
*说明方法描述：递归找出本节点和他们的父节点
*
*@paramparentList根据关键字过滤出来的相关节点的父节点
*@paramresultList返回的过滤出来的节点
*@paramfilterRecordMap已经过滤出来的节点
*@paramallRecordMap所有节点
*@return
*@time2016年5月19日上午9:53:56
*@authoryangdong
*/
privateList<Record>getSelfAndTheirParentRecord(List<Record>parentList,List<Record>resultList,
Map<String,Record>filterRecordMap,
Map<String,Record>allRecordMap){
//当父节点为null或者节点数量为0时返回结果，退出递归
if(parentList==null||parentList.size()==0){
returnresultList;
}
//重新创建父节点集合
List<Record>listParentRecord=newArrayList<Record>();
//遍历已经过滤出来的节点
for(Recordrecord:parentList){
Stringuuid=record.getStr("uuid");
Stringparent_uuid=record.getStr("parent_uuid");
//如果已经过滤出来的节点不存在则添加到list中
if(!filterRecordMap.containsKey(uuid)){
listParentRecord.add(record);//添加到父节点中
filterRecordMap.put(uuid,record);//添加到已过滤的map中
allRecordMap.remove(uuid);//移除集合中相应的元素
resultList.add(record);//添加到结果集中
}
//找出本节点的父节点并添加到listParentRecord父节点集合中，并移除集合中相应的元素
if(StringUtil.isNotBlank(parent_uuid)){
RecordparentRecord=allRecordMap.get(parent_uuid);
if(parentRecord!=null){
listParentRecord.add(parentRecord);
allRecordMap.remove(parent_uuid);
}
}
}
//递归调用
getSelfAndTheirParentRecord(listParentRecord,resultList,filterRecordMap,allRecordMap);
returnresultList;
}
[java]viewplain
//示例
[java]viewplain
/**
*说明方法描述：递归查询所有权限
*
*@paramkeyword
*@paramis_deleted
*@return
*@time2016年5月10日下午3:47:50
*@authoryangdong
*/
publicList<Record>getRecordByKeywordRecursive(Stringkeyword,Stringis_deleted){
//第一步：查询所有的数据
StringBuffersql=newStringBuffer(
"selectpa.uuid,pa.parent_uuid,pa.author_code,pa.author_name,pa.is_menu,pa.sort_number,pa.is_enable,pa.menu_icon");
sql.append("froms_authorpa");
List<Object>params=newArrayList<Object>();
sql.append("wherepa.is_deleted=?");
params.add(is_deleted);
sql.append("orderbypa.sort_numberasc");
List<Record>allRrecords=Db.use(AppConst.DB_DATASOURCE_MAIN).find(sql.toString(),ParamUtil.listToArray(params));
[java]viewplain
//第二步：将list变为树tree结构
if(StringUtil.isNotBlank(keyword)){
returnsuper.useListRecordToTreeByKeywords(allRrecords,keyword,"author_name");
}else{
returnsuper.useListRecordToTree(allRrecords);
}
}
J. 在java中如何使用一个方法实现两种不同的查询
楼主能否说的详细点，我这里认为的是一个方法实现两种不同形式的查询(此处举例：模糊查询、精准查询)
定义vo类A
public
class
A{
private
String
name;
private
String
addr;
......
//
get\set方法
}
定义方法B
public
list
A(A
vo){
//
vo:包含name、addr
String
sql
=
"Select
*
from
表名
where
1=1";
1、精准查询
if(vo.getName()!=null&&vo.getName().trim()>0){
sql
+=
"and
字段
=
'"+vo.getName()+"'";
}
2、模糊查询
if(vo.getAddr()!=null&&vo.getAddr().trim()>0){
sql
+=
"and
字段
like
'"+vo.getAddr()+"'";
}
return
list结果集;
}
注：不建议使用sql拼接方法进行查询，容易sql注入，此处为了方便才这样编写，希望回答对你有点启发。