java聚合查询代码 java并查集

JAVA中怎么查询代码？

try{Connection con;\x0d\x0a Statement stmt;\x0d\x0a ResultSet rs;\x0d\x0a int temp;\x0d\x0a Class.forName("com.mysql.jdbc.Driver");\x0d\x0a con=DriverManager.getConnection("jdbc:mysql://localhost:3306/java","root","");//以上是数据库连接，不同的数据管理器有 //不同的驱动和链接方式，以上是mysql的连接\x0d\x0astmt=con.createStatement();\x0d\x0a rs=stmt.executeQuery("select * from student");//执行查询语句，结果赋值给结果集rs\x0d\x0a //结果集是结果于字段编号的映射，每一个字\x0d\x0a //段都有一个编号，最小为1，也就是第一个字段 \x0d\x0a while(rs.next()){\x0d\x0a String names=rs.getString("name");//查询结果转换成字符串。\x0d\x0a \x0d\x0a System.out.println(names);\x0d\x0a\x0d\x0a}rs.close();\x0d\x0a }catch(Exception e){\x0d\x0a e.printStackTrace();\x0d\x0a }

相关问答

Q1: mongondb在java里处理聚合函数？

MongoDB sum,avg等聚合函数很弱java聚合查询代码，可以用MapReduce来实现,java聚合查询代码我给java聚合查询代码你个例子

// ※※※※※※※※※※※※※※※※※※※ 数据加载 ※※※※※※※※※※※※※※※※※※※

db.proc.remove();

for(var i = 10; i 1020; i++){db.proc.insert({class:"01", val:i, name: "name" + i})};

for(var i = 10; i 1030; i++){db.proc.insert({class:"02", val:i, name: "name" + i})};

for(var i = 10; i 1040; i++){db.proc.insert({class:"03", val:i, name: "name" + i})};

for(var i = 10; i 1050; i++){db.proc.insert({class:"04", val:i, name: "name" + i})};

for(var i = 10; i 1060; i++){db.proc.insert({class:"05", val:i, name: "name" + i})};

for(var i = 10; i 1070; i++){db.proc.insert({class:"06", val:i, name: "name" + i})};

for(var i = 10; i 1080; i++){db.proc.insert({class:"07", val:i, name: "name" + i})};

for(var i = 10; i 1090; i++){db.proc.insert({class:"08", val:i, name: "name" + i})};

for(var i = 10; i 1100; i++){db.proc.insert({class:"09", val:i, name: "name" + i})};

for(var i = 10; i 1110; i++){db.proc.insert({class:"10", val:i, name: "name" + i})};

for(var i = 10; i 1120; i++){db.proc.insert({class:"11", val:i, name: "name" + i})};

// ※※※※※※※※※※※※※※※※※※※ mapReduce ※※※※※※※※※※※※※※※※※※※

m = function(){emit(this.class, {count:1, max:this.val, sum:this.val})}

r = function(key, values){

var ct = 0, sm = 0, mx = 0;

for(var i = 0; i values.length; i++){

ct += values[i].count;

sm += values[i].max;

mx = Math.max(mx, values[i].max);

}

return {count:ct, max: mx, sum:sm};

}

// ※※※※※※※※※※※※※※※※※※※ 数据处理 ※※※※※※※※※※※※※※※※※※※

res = db.runCommand({mapreduce:"proc", map:m, reduce:r, out:"proc_res"})

res = db.runCommand({mapreduce:"proc", map:m, reduce:r, out:"proc_res3", query:{"class":{$gt:"03"}}})

res = db.runCommand({mapreduce:"proc", map:m, reduce:r, out:"proc_res5", query:{"class":{$gt:"05"}}})

res = db.runCommand({mapreduce:"proc", map:m, reduce:r, out:"proc_res6", query:{"class":{$gt:"06"}}})

res = db.runCommand({mapreduce:"proc", map:m, reduce:r, out:"proc_res9", query:{"class":{$gt:"09"}}})

res = db.runCommand({mapreduce:"proc", map:m, reduce:r, out:"proc_res10",query:{"class":{$gt:"10"}}})

// ※※※※※※※※※※※※※※※※※※※ 结果查看 ※※※※※※※※※※※※※※※※※※※

db.proc_res.find()

{ "_id" : 1, "value" : { "class" : 1, "count" : 10, "sum" : 145, "max" : 19 } }

{ "_id" : 2, "value" : { "class" : 2, "count" : 20, "sum" : 390, "max" : 29 } }

{ "_id" : 3, "value" : { "class" : 3, "count" : 30, "sum" : 735, "max" : 39 } }

{ "_id" : 4, "value" : { "class" : 4, "count" : 40, "sum" : 1180, "max" : 49 } }

{ "_id" : 5, "value" : { "class" : 5, "count" : 50, "sum" : 1725, "max" : 59 } }

{ "_id" : 6, "value" : { "class" : 6, "count" : 60, "sum" : NaN, "max" : NaN } }

{ "_id" : 7, "value" : { "class" : 7, "count" : 70, "sum" : 3115, "max" : 79 } }

{ "_id" : 8, "value" : { "class" : 8, "count" : 80, "sum" : NaN, "max" : NaN } }

{ "_id" : 9, "value" : { "class" : 9, "count" : 90, "sum" : NaN, "max" : NaN } }

{ "_id" : 10, "value" : { "class" : 10, "count" : 100, "sum" : NaN, "max" : NaN } }

{ "_id" : 11, "value" : { "class" : 11, "count" : 110, "sum" : NaN, "max" : NaN } }

db.proc_res3.find()

{ "_id" : 4, "value" : { "class" : 4, "count" : 40, "sum" : 1180, "max" : 49 } }

{ "_id" : 5, "value" : { "class" : 5, "count" : 50, "sum" : 1725, "max" : 59 } }

{ "_id" : 6, "value" : { "class" : 6, "count" : 60, "sum" : NaN, "max" : NaN } }

{ "_id" : 7, "value" : { "class" : 7, "count" : 70, "sum" : NaN, "max" : NaN } }

{ "_id" : 8, "value" : { "class" : 8, "count" : 80, "sum" : 3960, "max" : 89 } }

{ "_id" : 9, "value" : { "class" : 9, "count" : 90, "sum" : 4905, "max" : 99 } }

{ "_id" : 10, "value" : { "class" : 10, "count" : 100, "sum" : NaN, "max" : NaN } }

{ "_id" : 11, "value" : { "class" : 11, "count" : 110, "sum" : NaN, "max" : NaN } }

db.proc_res5.find()

{ "_id" : 6, "value" : { "class" : 6, "count" : 60, "sum" : 2370, "max" : 69 } }

{ "_id" : 7, "value" : { "class" : 7, "count" : 70, "sum" : NaN, "max" : NaN } }

{ "_id" : 8, "value" : { "class" : 8, "count" : 80, "sum" : NaN, "max" : NaN } }

{ "_id" : 9, "value" : { "class" : 9, "count" : 90, "sum" : 4905, "max" : 99 } }

{ "_id" : 10, "value" : { "class" : 10, "count" : 100, "sum" : 5950, "max" : 109 } }

{ "_id" : 11, "value" : { "class" : 11, "count" : 110, "sum" : NaN, "max" : NaN } }

db.proc_res6.find()

{ "_id" : 7, "value" : { "class" : 7, "count" : 70, "sum" : 3115, "max" : 79 } }

{ "_id" : 8, "value" : { "class" : 8, "count" : 80, "sum" : NaN, "max" : NaN } }

{ "_id" : 9, "value" : { "class" : 9, "count" : 90, "sum" : NaN, "max" : NaN } }

{ "_id" : 10, "value" : { "class" : 10, "count" : 100, "sum" : NaN, "max" : NaN } }

{ "_id" : 11, "value" : { "class" : 11, "count" : 110, "sum" : NaN, "max" : NaN } }

db.proc_res9.find()

{ "_id" : 10, "value" : { "class" : 10, "count" : 100, "sum" : 5950, "max" : 109 } }

{ "_id" : 11, "value" : { "class" : 11, "count" : 110, "sum" : NaN, "max" : NaN } }

db.proc_res10.find()

{ "_id" : 11, "value" : { "class" : 11, "count" : 110, "sum" : NaN, "max" : NaN } }

Q2: java怎么理解组合/聚合关系给个例子最好能将细点

聚合(Aggregation) 关系是关联关系的一种，是强的关联关系。聚合是整体和个体之间的关系。例如，汽车类与引擎类、轮胎类，以及其它的零件类之间的关系便整体和个体的关系。与关联关系一样，聚合关系也是通过实例变量实现的。但是关联关系所涉及的两个类是处在同一层次上的，而在聚合关系中，两个类是处在不平等层次上的，一个代表整体，另一个代表部分。 

组合(Composition) 关系是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分对象的生命周期，组合关系是不能共享的。代表整体的对象需要负责保持部分对象和存活，在一些情况下将负责代表部分的对象湮灭掉。代表整体的对象可以将代表部分的对象传递给另一个对象，由后者负责此对象的生命周期。换言之，代表部分的对象在每一个时刻只能与一个对象发生组合关系，由后者排他地负责生命周期。部分和整体的生命周期一样。

class Driver {   

    //使用成员变量形式实现关联   

    Car mycar;   

    public void drive(){   

        mycar.run();   

    }   

    ...   

    //使用方法参数形式实现关联   

    public void drive(Car car){   

        car.run();   

    }   

}

聚合关系是是一种比较强的关联关系，java中一般使用成员变量形式实现。对象之间存在着整体与部分的关系。例如上例中

class Driver {   

    //使用成员变量形式实现聚合关系   

    Car mycar;   

    public void drive(){   

        mycar.run();   

    }   

}

假如给上面代码赋予如下语义：车是一辆私家车，是司机财产的一部分。则相同的代码即表示聚合关系了。聚合关系一般使用setter方法给成员变量赋值。 

假如赋予如下语义：车是司机的必须有的财产，要想成为一个司机必须要先有辆车，车要是没了，司机也不想活了。而且司机要是不干司机了，这个车就砸了，别人谁也别想用。那就表示组合关系了。一般来说，为了表示组合关系，常常会使用构造方法来达到初始化的目的，例如上例中，加上一个以Car为参数的构造方法 

public Driver(Car car){   

    mycar = car;   

}

所以，关联、聚合、组合只能配合语义，结合上下文才能够判断出来，而只给出一段代码让我们判断是关联，聚合，还是组合关系，则是无法判断的。

Q3: java中数据库查询问题、代码如下。用Statement可以查，用PreparedStatement中setstring查不出

System.out.println(rs.getString("UserName") + "\t" + rs.getString("PassWord"));出错java聚合查询代码了。

按java聚合查询代码你SQL看你数据库中用户名字段为LoginName,所以只要把rs.getString("UserName")改为rs.getString("LoginName")就可以java聚合查询代码了。

Q4: Java sql实现联合查询的语句

-----select语句的综合使用

select * from 系部表 ------ ‘*’代表所有内容，也就是查看‘系部表’的所有内容。

------输出部分列

select 字段，字段 from

select 系部代号,系主任 from 系部表 ------查看‘系部表’中‘系部代号’和‘系主任’两个字段。

------限制返回行数

select top 3* from

select top 2* from 系部表 ------查看‘系部表’中前二行的记录。

------定义字段名

select as from

select '明星' as 备注,* from 系部表

------加一字段，内容为‘明星’，字段名为‘备注’，查看所有字段。

-------描述例

select '描述',字段 from

select *,总价钱=价钱*数量 from 商品表

------查看所有字段并加一字段，字段名为总价钱，值为‘价钱*数量’。

----衍生列

select id,姓名=姓+名 from 身份证

select *,总价钱=价钱*数量 from 商品表

------是否显重复记录 只能用于一个字段

select distinct from

select distinct*from 系部表

------不显示重复行，如果有两行或多行在每个字段的值都一样，则只显示一行来代替这些行。

-----条件查询

select from where

select * from 系部表 where 住址 not in ('沈阳')

------显示所有字段，条件是‘住址’字段的值非‘沈阳’的。把 not 去掉就是查看‘住址’是沈阳的了。

----多个条件

select from where and

select * from 学生 where 年龄25 and 年龄20 and 住址 in ('沈阳') and 性别='女'

------多条件查看，年龄在23到30之间，住址在‘沈阳’，并且性别为‘女’。‘好友’是表名

-----空值查询

字段 is null

select * from 学生 where 学费 is null

------查看所有字段，学费字段为‘null’的行。就是没交学费的学生。

------对查询结果进行排序

order by 字段 asc升序（desc降序）

select *from 学生 order by 学号 desc ---(desc是降序，asc是升序，升序可以省略）

------查看所有字段，以‘学号’字段降序排序。

--********************************************************************************

------对数据进行统计

--记录的个数 count

--值的总和 sum

--平均值 avg

--最大值 max

--最小值 min

--count的用法

select count(*) from 学生

select count(系部代号) from 系部表

-------显示该列非空值的行数。如果是（*），就显示行数，不管空不空。如果写成count(系部代号+系主任)，那么显示的是两列都不为空的行数。

--sum的用法

select sum(学费) from 学生

select sum(价钱*数量) 总价钱 from 商品表

------显示‘价钱’字段的值乘以‘数量’字段的值，所有行的累加和。就是所以商品的总价钱。其中‘总价钱’是列名。

--avg的用法

select avg(年龄) from 学生

select avg(价钱) as 平均价 from 商品表

------显示所有价钱的平均值。as可以省略。

--max的用法

select max(价钱) as 最高价 from 商品表

------显示最高价是多少。

--****************************************************************

select * from 商品表 where 价钱 in(select max(价钱) from 商品表)

------括号语句里面返回的是‘最高价’，条件是显示‘价钱’是最高价的行。

--****************************************************************

--min的用法

select min(年龄) from 学生

select min(价钱) as 最高价 from 商品表

------显示最低价是多少。

------分组

select from group by 列名

select 商品,sum(价钱) as 总价钱 from 商品表 group by 商品

------显示‘商品’和‘总价钱’字段。

------‘总价钱’字段的值是所有同名‘商品’值的和。(因为我们用了"sum(价钱)")sum不能对varchar进行运算

------group by 是用来分组的，也就是用‘商品’字段分组。不显示重复的商品字段的行。

-----compute 汇总统计

select from compute

select from order by compute 函数 by

select * from 商品表 compute sum(价钱)

------显示两个表，把所有行和所有列都显示出来，第二个表是一个汇总表，只有一列一行，就是价钱的总合，列名为sum.

select 商品,价钱,数量 from 商品表 order by 商品 desc compute sum(价钱) by 商品

------显示表的数量为"商品"的种类乘2,一种商品一个表，还有一个sum表会对这个商品的价钱求合。

-------having 条件语句

select from group by having 条件

select 商品,sum(价钱*数量) as 总价钱 from 商品表 group by 商品 having sum(价钱*数量)20000

-----以商品分组，也就只可以查看商品字段，还有一个聚合函数字段。having是条件，是对后面的聚合函数的值的条件。

--*****************************************************************************************

create table aa(a1 int,a2 int)

create table bb(b1 int,b2 int)

insert bb values(2,2)

insert bb values(3,1)

insert bb values(7,23)

insert bb values(5,33)

insert bb values(9,53)

------子查询

----- 单列单值

where 字段 条件(必须为单值)

select * from table_a where column_a1 (select avg(column_b1) from table_b) and column_a1 100

------显示‘a1’列中的值在‘b’表中的‘b1’列中也有的行。

----- 单列多值

where 字段 in

select * from table_a where column_a1 in(select column_b1 from table_b)

where 字段all()

select * from table_a where column_a1 all(select column_b1 from table_b)

------显示‘a1'列中的值小于‘b'表中的‘b1'列中全部的值的行。

------只有小于b1列中最小值的才会被显示

where 字段any()

select * from table_a where column_a1 any(select column_b1 from table_b)

------显示‘a1'列中的值小于‘b'表中的‘b1'列中任何一行的值的行。

------只要小于b1列中最大值的就会被显示

-----多列多值

where exists(只查询)

select * from table_a where exists(select * from table_b where column_b1=101)

------exists它返回一个boolean值。真或假。条件为真则输出where前面的语句。假则反之。

------这个函数多用与if语句处。exists后面括号中的条件是如果b1列中有445这个值，就输出a表。

if exists(select * from sysobjects where name='table_b')

select * from table_a

------sysobjects包含当前数据库中所有的表。

------也就是说当前数据库中如果有table_b这个表，就为真。

if exists(select * from sysobjects where name='abc')

drop table abc

create table abc(a varchar(10),b varchar(20))

-------模糊查询

select from where like'条件'

条件 'a_'

'_a'

select * from table_a where column_a1 like '4__'

------查看a1列中三位数，并且是以4开头的行。

select * from table_a where column_a1 like '__4'

------查看a1列中三位数，并且是以4结尾的行。

select * from table_a where column_a1 like '_4_'

------查看a1列中三位数，并且是以4为中间的行。

'a%'

'%a'

'%a%'

select * from table_a where column_a1 like '4%'

-----查看a1列中以4开头的行。

select * from table_a where column_a1 like '%4'

-----查看a1列中以4结尾的行。

select * from table_a where column_a1 like '%4%'

-----查看a1列中有4的行。不管4在什么位置。

'a[a-z]'

'[a-z]a'

select * from abc where a like'a_'

select * from abc where a like'a[0-9]'

select * from table_a where column_4 like '_b_[0-9]'

-----查看第4列中第二个字符是b,第四个字符是0到9的行。

------将查询结果生成新表select.....into

select * into 王 from 学生 where 姓名 like'王__'

select * from 王

select * into 美女 from 学生 where 性别 = '女' and 年龄 like '2_'

-----查看学生表中的性别字段为女年龄十位上是2的行，再把查到的结果生成一个表，表名是into后的美女

-----它是生成一个新表的，和别的查看不一样。

select * from 美女

--停！！！

--停！！！

--停！！！

--停！！！

------合并结果集 select ...union select....

select * from table_a

select * from table_b

select * from table_a union select * from table_b

select * from table_b union select * from table_a

------查看table_a表和table_b表，两个表的连接。只是查看，并没有真正连接。要求这两个表的列数和列的数据类型完全一致。

-----------------连接查询

------内连接

--select 列名列表 from 表1 inner join 表2 on 条件

--table_a的行数乘以table_b 的行数。

select * from table_a inner join table_b on table_a.column_a1=table_b.column_b1

------内联接。显示出‘a’表的‘a1’字段和‘b’字的‘b1’字段相同的行。

--select 列名列表 from 表1,表2 where 条件

select *from table_a,table_b where table_a.column_a1=table_b.column_b1

------这是内联接的简写版。

------外联接

----左外联接

(1)select 列名列表 from 表1 left join 表2 on 条件

--以左为主，右表有则显示，无则以null补位

select * from table_a left join table_b on table_a.column_a1=table_b.column_b1

------左联接。把‘a’表中的所有行都显示出来，‘b’表中的‘b1’字段和‘a’表中的‘a1’字段

------相等的显示，但‘a’表中没有的，‘b’表没有的则显示NULL。

(1)select 列名列表 from 表1,表2 where 条件

select * from table_a,table_b where table_a.column_a1*=table_b.column_b1

------左联接的简写版。"*="是左联接的意思

----右外联接

(1)select 列名列表 from 表1 right join 表2 on 条件

select * from table_a right join table_b on table_a.column_a1=table_b.column_b1

------以右面表为准，和左联接一样。

(1)select 列名列表 from 表1,表2 where 条件

select * from table_a,table_b where table_a.column_a1=*table_b.column_b1

------右联接的简写版。

----全外联接

select 列名列表 from 表1 full join 表2 on 条件

select * from table_a full join table_b on table_a.column_a1 = table_b.column_b1

------外联接的全联接，两个表的记录都会显示，不满足条件的以null补位.

------a表15行记录,b表5行记录,满足条件的只有1行记录，查询结果有19行。

------------cross join

select 列名列表 from 表1 cross join 表2

select * from aa cross join bb

select * from 学生

create table 成绩(xid int,语文 int,数学 int,英语 int,化学 int)

insert 成绩 values(1,87,89,78,98)

insert 成绩 values(2,17,8,78,98)

insert 成绩 values(3,27,99,78,98)

insert 成绩 values(4,47,49,78,98)

insert 成绩 values(5,79,69,78,98)

insert 成绩 values(6,77,99,78,98)

insert 成绩 values(7,77,29,78,98)

select * from 成绩 cross join 学生

------成绩表的第一行记录对应一次学生表的第一行记录，总行数为两个表行数的乘积

------*************************************************

select b.姓名,a.* from 成绩 a,学生 b where a.xid *= b.xid

------左连接,"b.姓名"代表学生表的"姓名"字段

------哪个是左表哪个是右表由"a.xid *= b.xid"来定,"b.姓名,a.*"是代表显示的位置

------左连接的特性是显示左边表的所有行(成绩表的所有字段的所有行),右边表只显示满足条件的行

------*************************************************

-----------自身连接

select 员工主管.员工编号,员工主管.员工姓名,主管表.员工姓名

from 员工主管 left join 员工主管 as 主管表

on 员工主管.主管编号=主管表.员工编号

select * from 学生 a,学生 b where a.xid=b.xid

-------自联接，但要给自己起个别名。

关于java聚合查询代码和java并查集的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。