我们现在回到函数上。记得我们用 SUM 这个指令来算出所有的 Sales (营业额)吧!如果我们的需求变成是要算出每一间店 (store_name) 的营业额 (sales),那怎么办呢?在这个情况下,我们要做到两件事:第一,我们对于 store_name 及 Sales 这两个栏位都要选出。第二,我们需要确认所有的 sales 都要依照各个 store_name 来分开算。这个语法为:
SELECT "栏位1", SUM("栏位2")
FROM "表格名"
GROUP BY "栏位1"
在我们的示范上,
Store_Information 表格
store_name |
Sales |
Date |
Los Angeles |
$1500 |
Jan-05-1999 |
San Diego |
$250 |
Jan-07-1999 |
Los Angeles |
$300 |
Jan-08-1999 |
Boston |
$700 |
Jan-08-1999 |
我们就打入,
SELECT store_name, SUM(Sales)
FROM Store_Information
GROUP BY store_name
结果:
store_name |
SUM(Sales) |
Los Angeles |
$1800 |
San Diego |
$250 |
Boston |
$700 |
当我们选不只一个栏位,且其中至少一个栏位有包含函数的运用时,我们就需要用到 GROUP BY 这个指令。在这个情况下,我们需要确定我们有 GROUP BY 所有其他的栏位。换句话说,除了有包括函数的栏位外,我 们都需要将其放在 GROUP BY 的子句中。
冒泡排序:
/*
* 冒泡排序:
*/
public static void sort(int[] data) {
for (int i = 0; i < data.length; i++) {
for (int j = data.length - 1; j > i; j--) {
if (data[j] < data[j - 1]) {
int tmp = data[j];
data[j] = data[j-1];
data[j-1] = tmp;
}
}
}
}
之前我们看到的左连接 (left join),又称内部连接 (inner join)。在这个情况下,要两个表格内都有同样的值,那一笔资料才会被选出。那如果我们想要列出一个表格中每一笔的资料,无论它的值在另一个表格中有没有出现,那该怎么办呢?在这个时候,我们就需要用到 SQL OUTER JOIN (外部连接) 的指令。
外部连接的语法是依数据库的不同而有所不同的。举例来说,在 Oracle 上,我们会在 WHERE 子句中要选出所有资料的那个表格之后加上一个 "(+)" 来代表说这个表格中的所有资料我们都要。
假设我们有以下的两个表格:
Store_Information 表格
store_name |
Sales |
Date |
Los Angeles |
$1500 |
Jan-05-1999 |
San Diego |
$250 |
Jan-07-1999 |
Los Angeles |
$300 |
Jan-08-1999 |
Boston |
$700 |
Jan-08-1999 |
|
Geography 表格
region_name |
store_name |
East |
Boston |
East |
New York |
West |
Los Angeles |
West |
San Diego |
|
我们需要知道每一间店的营业额。如果我们用一个普通的连接,我们将会漏失掉 'New York'这个店,因为它并不存在于 Store_Information 这个表格。所以,在这个情况下,我们需要用外部连接来串联这两个表格:
SELECT A1.store_name, SUM(A2.Sales) SALES
FROM Georgraphy A1, Store_Information A2
WHERE A1.store_name = A2.store_name (+)
GROUP BY A1.store_name
我们在这里是使用了 Oracle 的外部连接语法。
如果换成了Mysql:
select a1.store_name,sum(a2.sales) from geography a1 left join store_information a2
on a1.store_name=a2.store_name group by a1.store_name;
结果:
store_name |
SALES |
Boston |
$700 |
New York |
|
Los Angeles |
$1800 |
San Diego |
$250 |
请注意: 当第二个表格没有相对的资料时,SQL 会传回 NULL 值。在这一个例子中, 'New York' 并不存在于 Store_Information 表格,所以它的 "SALES" 栏位是 NULL。
在之前,我对MSSQL中的内连接和外连接所得出的数据集不是很清楚。这几天重新温习了一下SQL的书本,现在的思路应该是很清楚了,现在把自己的理解发出来给大家温习下。希望和我一样对SQL的连接语句不太理解的朋友能够有所帮助。(发这么菜的教程,各位大大们别笑话偶了,呵:D )
有两个表A和表B。
表A结构如下:
Aid:int;标识种子,主键,自增ID
Aname:varchar
数据情况,即用select * from A出来的记录情况如下图1所示:
图1:A表数据
表B结构如下:
Bid:int;标识种子,主键,自增ID
Bnameid:int
数据情况,即用select * from B出来的记录情况如下图2所示:
图2:B表数据
为了把Bid和Aid加以区分,不让大家有误解,所以把Bid的起始种子设置为100。
有SQL基本知识的人都知道,两个表要做连接,就必须有个连接字段,从上表中的数据可以看出,在A表中的Aid和B表中的Bnameid就是两个连接字段。
下图3说明了连接的所有记录集之间的关系:
图3:连接关系图
现在我们对内连接和外连接一一讲解。
1.内连接:利用内连接可获取两表的公共部分的记录,即图3的记录集C
语句如下:Select * from A JOIN B ON A.Aid=B.Bnameid
运行结果如下图4所示:
图4:内连接数据
其实select * from A,B where A.Aid=B.Bnameid与Select * from A JOIN B ON A.Aid=B.Bnameid的运行结果是一样的。
2.外连接:外连接分为两种,一种是左连接(Left JOIN)和右连接(Right JOIN)
(1)左连接(Left JOIN):即图3公共部分记录集C+表A记录集A1。
语句如下:select * from A Left JOIN B ON A.Aid=B.Bnameid
运行结果如下图5所示:
图5:左连接数据
说明:
在语句中,A在B的左边,并且是Left Join,所以其运算方式为:A左连接B的记录=图3公共部分记录集C+表A记录集A1
在图3中即记录集C中的存在的Aid为:2 3 6 7 8
图1中即表A所有记录集A中存在的Aid为:1 2 3 4 5 6 7 8 9
表A记录集A1中存在的Aid=(图1中即A表中所有Aid)-(图3中即记录集C中存在的Aid),最终得出为:1 4 5 9
由此得出图5中A左连接B的记录=图3公共部分记录集C+表A记录集A1,
最终得出的结果图5中可以看出Bnameid及Bid非NULL的记录都为图3公共部分记录集C中的记录;Bnameid及Bid为NULL的Aid为1 4 5 9的四笔记录就是表A记录集A1中存在的Aid。
(2)右连接(Right JOIN):即图3公共部分记录集C+表B记录集B1。
语句如下:select * from A Right JOIN B ON A.Aid=B.Bnameid
运行结果如下图6所示:
图6:右连接数据
说明:
在语句中,A在B的左边,并且是Right Join,所以其运算方式为:A右连接B的记录=图3公共部分记录集C+表B记录集B1
在图3中即记录集C中的存在的Aid为:2 3 6 7 8
图2中即表B所有记录集B中存在的Bnameid为:2 3 6 7 8 11
表B记录集B1中存在的Bnameid=(图2中即B表中所有Bnameid)-(图3中即记录集C中存在的Aid),最终得出为:11
由此得出图6中A右连接B的记录=图3公共部分记录集C+表B记录集B1,
最终得出的结果图6中可以看出Aid及Aname非NULL的记录都为图3公共部分记录集C中的记录;Aid及Aname为NULL的Aid为11的记录就是表B记录集B1中存在的Bnameid。
总结:
通过上面的运算解说,相信很多人已经想到,上面的情况(包括图3的关系图)说明的都只是A在B的左边的情况,
以下语句B在A的右边的又会出现什么情况呢??
select * from B Left JOIN A ON A.Aid=B.Bnameid
select * from B Right JOIN A ON A.Aid=B.Bnameid
其实对图3左右翻转一下就可以得出以下结论:
select * from B Left JOIN A ON A.Aid=B.Bnameid和select * from A Right JOIN B ON A.Aid=B.Bnameid所得出的记录集是一样的
而
select * from B Right JOIN A ON A.Aid=B.Bnameid和select * from A Left JOIN B ON A.Aid=B.Bnameid所得出的记录集也是一样的。
import java.io.*;
public class DOMTest {
private String outFile = "c:\\people.xml";
public static void main(String args[]) {
new DOMTest();
}
public DOMTest() {
try {
javax.xml.parsers.DocumentBuilder builder =
javax.xml.parsers.DocumentBuilderFactory.newInstance()
.newDocumentBuilder();
org.w3c.dom.Document doc = builder.newDocument();
org.w3c.dom.Element root = doc.createElement("老师");
org.w3c.dom.Element wang = doc.createElement("王");
wang.appendChild(doc.createTextNode("我是王老师"));
root.appendChild(wang);
doc.appendChild(root);
javax.xml.transform.Transformer transformer = javax.xml.transform.TransformerFactory
.newInstance().newTransformer();
transformer.setOutputProperty(
javax.xml.transform.OutputKeys.ENCODING, "gb2312");
transformer.setOutputProperty(
javax.xml.transform.OutputKeys.INDENT, "yes");
transformer.transform(new javax.xml.transform.dom.DOMSource(doc),
new
javax.xml.transform.stream.StreamResult(outFile));
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
public class Aqiang {
// 静态内部类
static class Test
{
private int i ;
public Test()
{
i = 2;
}
}
class TestB
{
private int i = 3;
}
private int j;
public static void main(String args[]) {
// 静态内部类(Inner Class)意味着1创建一个static内部类的对象,不需要一个外部类对象
Aqiang.Test test = new Aqiang.Test();
System.out.println("test" + test.i);
// 而非静态内部类,需要选创建一个外部类对象,然后才能创建内部内对象
Aqiang aqiang = new Aqiang();
Aqiang.TestB tb = aqiang.new TestB();
System.out.println("testb" + tb.i);
}
}
流是一个有序的字节序列,可作为一个输入源,也可作为一个输出的目的地。
字节流以字节为单位输入输出,字节流类名含有stream,字符流以字符为单位输入输出,字节流
类名含有reader或writer.为了通用性,java中字符是16位的unicode字符,所以8位的字节流必
须和16位的字符流进行转换。字节流到字符流的转换使用InputStreamReader类:
public InputStreamReader(InputStream in);
public InputStreamReader(InputStream in,String encoding);
public OuputStreamWriter(OnputStream in);
public OnputStreamWriter(OnputStream in,String encoding);
Reader和Writer类允许用户在程序中无缝的支持国际字符集,如果要读区的文件是别国语言,
要使用字符流。
JavaI/O字节流与字符流就是java 实现输入/输出 数据 字节流是一个字节一个字节的输入/输出 数据 (两个字节组成一个汉字)所以在用字节流读一串汉字时会出现乱码问题,
同样字符流是一个字符一个字符流(一个字符=两个字节)的输入/输出 数据 用字符流读一串汉字可以解决乱码问题.
有以下三个对象:
US设备对象:USDevie
US设备类型对象:USDeviceModle
US设备端口对象:USDevicePort
class USDevice
{
....
// US设备类型
USDeviceModel model;
// US设备端口对象集合
Set<USDevicePort> devicePortSet = new HashSet();
}
/**
US设备类型说明每种设备都有不同的端口数目
*/
class USDeviceModel
{
....
// 设备端口数目
int deviceport;
}
class USDevicePort
{
private int deviceId;
private int devicePort;
}
1 : 1 : n
一种US设备(device)----->设备类型(model)------>不同数目的设备端口
US设备:设备类型:设备端口数目 = 1:1:n
所以,如果新增设备的时候,要根据设备类型,得到相应的设备端口数目,
然后在USDevicePort对应的数据库表中插入记录.
编辑设备的时候,如果编辑了US设备类型,则相应的设备端口就会改变,这种
情况除了更新USDevice对应的数据表中设备类型外,因为在USDevicePort表中
存放在以前设备类型的端口记录,所以应该先删除之前的端口记录,然后再插入
现在类型所对应的端口记录.
其实只需:
//这一步根据具体设备id,从数据库中取出相应的设备对象
USDevice device = .....
// 得到US设备端口对象集合
Set devicePortSet = device.getDevicePortSet();
// 先清空以前所有的端口记录
devicePortSet.clear();
// 根据编辑后类型ID,得到设备类型对象,并可以得到此种类型上的端口数目
USDeviceModel usModle = ....
// 根据上面得到的端口数据,构造"设备端口数目"对象,并把所有的设备端口对象添加到集合中
//最后更新US设备
这样,每当编辑一个US设备的类型后,在设备端口表中,这种设备编辑之前的类型所对应的端口记录
就会被删除,而保持只有新的设备类型端口记录.
注意在配置USDevice.hbm.xml文件时,要将<set name="devicePortSet " casecade="all-orphan-delete" .../>
因为它会将和USDevice没有关联的对象从数据中删除,这也与程序中devicePortSet.clear()相对应.
看一看下面的很简单的代码,先是声明了一个Hashtable和StringBuffer对象,然后分四次把StriingBuffer对象放入到Hashtable表中,在每次放入之前都对这个StringBuffer对象append()了一些新的字符串:
package reference;
import java.util.*;
public class HashtableAdd{
public static void main(String[] args){
Hashtable ht = new Hashtable();
StringBuffer sb = new StringBuffer();
sb.append("abc,");
ht.put("1",sb);
sb.append("def,");
ht.put("2",sb);
sb.append("mno,");
ht.put("3",sb);
sb.append("xyz.");
ht.put("4",sb);
int numObj=0;
Enumeration it = ht.elements();
while(it.hasMoreElements()){
System.out.print("get StringBufffer "+(++numObj)+" from Hashtable: ");
System.out.println(it.nextElement());
}
}
}
|
如果你认为输出的结果是:
get StringBufffer 1 from Hashtable: abc,
get StringBufffer 2 from Hashtable: abc,def,
get StringBufffer 3 from Hashtable: abc,def,mno,
get StringBufffer 4 from Hashtable: abc,def,mno,xyz.
那么你就要回过头再仔细看一看上一个问题了,把对象时作为入口参数传给函数,实质上是传递了对象的引用,向Hashtable传递StringBuffer对象也是只传递了这个StringBuffer对象的引用!每一次向Hashtable表中put一次StringBuffer,并没有生成新的StringBuffer对象,只是在Hashtable表中又放入了一个指向同一StringBuffer对象的引用而已。
对Hashtable表存储的任何一个StringBuffer对象(更确切的说应该是对象的引用)的改动,实际上都是对同一个"StringBuffer"的改动。所以Hashtable并不能真正存储能对象,而只能存储对象的引用。也应该知道这条原则对与Hashtable相似的Vector, List, Map, Set等都是一样的。
上面的例程的实际输出的结果是:
/* RUN RESULT
get StringBufffer 1 from Hashtable: abc,def,mno,xyz.
get StringBufffer 2 from Hashtable: abc,def,mno,xyz.
get StringBufffer 3 from Hashtable: abc,def,mno,xyz.
get StringBufffer 4 from Hashtable: abc,def,mno,xyz.
*/
|
在做编辑功能 的时候,往往会通过一个主键ID得到相应的对象信息,然后显示到编辑页面中。如果涉及到<html:select>标签,
表示点编辑的时候,选择下拉框会显示相应的选项。
JSP页面一般这样显示:
<html:select property="busiSetId" style="width:120px;">
<option value="">请选择</option>
<logic:present name="ret">
<logic:iterate id="model" name="ret">
<option value="<bean:write name="model" property="ID"/>"><bean:write name="model" property="name"/></option>
</logic:iterate>
</logic:present>
</html:select>
但这是样子总是显示第一条数据,解决这个问题最简单的方法是在JSP页面最后添加下面语句:
<script language="javascript">
document.all("busiSetId").value="<bean:write name='CustomerSetForm' property='busiSetId'/>";
</script>
因为这段代码表示手动设置busiSetId元素,也就是<html:select>控件的值为要显示的值,而且这个代码是放到JSP最后面,
每次都会执行。
标签嵌套使用注意事项:
<logic:equal value="<bean:write name='customer' property='cusId'/>" >
注意双引号内只能使用单引号了。