1：The food is delicious!  好吃
2：your son/daughter is so cute 你的孩子很可爱
3：your chinese is really surprising  你的中文令人惊讶
4：can you speak slowly? 请您说得慢些好吗？
5：come with me. 跟我来
6： congratulations. 恭喜恭喜
7： After you
8：Slow down! 慢点
9：Watch out! 当心
10：I beg your pardon？
11： I am a football fan

SELECT UPPER(F.TABLESPACE_NAME) "表空间名",
D.TOT_GROOTTE_MB "表空间大小(M)",
D.TOT_GROOTTE_MB - F.TOTAL_BYTES "已使用空间(M)",
TO_CHAR(ROUND((D.TOT_GROOTTE_MB - F.TOTAL_BYTES) / D.TOT_GROOTTE_MB * 100,
2),
'990.99') "使用比",
F.TOTAL_BYTES "空闲空间(M)",
F.MAX_BYTES "最大块(M)"
FROM (SELECT TABLESPACE_NAME,
ROUND(SUM(BYTES) / (1024 * 1024), 2) TOTAL_BYTES,
ROUND(MAX(BYTES) / (1024 * 1024), 2) MAX_BYTES
FROM SYS.DBA_FREE_SPACE
GROUP BY TABLESPACE_NAME) F,
(SELECT DD.TABLESPACE_NAME,
ROUND(SUM(DD.BYTES) / (1024 * 1024), 2) TOT_GROOTTE_MB
FROM SYS.DBA_DATA_FILES DD
GROUP BY DD.TABLESPACE_NAME) D
WHERE D.TABLESPACE_NAME = F.TABLESPACE_NAME
ORDER BY 4 DESC
--order by F.TABLESPACE_NAME


select OSUSER,PROGRAM,USERNAME,SCHEMANAME,B.Cpu_Time,STATUS,B.SQL_TEXT
from V$SESSION A LEFT JOIN V$SQL B ON A.SQL_ADDRESS=B.ADDRESS AND A.SQL_HASH_VALUE=B.HASH_VALUE order by b.cpu_time desc

1 08/06  A组 瑞士 00:00 捷克 巴塞尔               0:1
2 08/06  A组 葡萄牙 02:45 土耳其 日内瓦           2:0
3 09/06  B组 奥地利 00:00 克罗地亚 维也纳         0:1
4 09/06  B组 德国 02:45 波兰 克拉根佛特           2:0
5 10/06  C组 罗马尼亚 00:00 法国 苏黎世           0:0
6 10/06  C组 荷兰 02:45 意大利 伯尔尼             3:0
7 11/06  D组 西班牙 00:00 俄罗斯 因斯布鲁克       4:1
8 11/06  D组 希腊 02:45 瑞典 萨尔茨堡             0:2
9 12/06  A组 捷克 00:00 葡萄牙 日内瓦     3:1
10 12/06 A组 瑞士 02:45 土耳其 巴塞尔
11 13/06 B组 克罗地亚 00:00 德国 克拉根佛特
12 13/06 B组 奥地利 02:45 波兰 维也纳
13 14/06 C组 意大利 00:00 罗马尼亚 苏黎世
14 14/06 C组 荷兰 02:45 法国 伯尔尼
15 15/06 D组 瑞典 00:00 西班牙 因斯布鲁克
16 15/06 D组 希腊 02:45 俄罗斯 萨尔茨堡
17 16/06 A组 瑞士 02:45 葡萄牙 巴塞尔
18 16/06 A组 土耳其 02:45 捷克 日内瓦
19 17/06 B组 奥地利 02:45 德国 维也纳
20 17/06 B组 波兰 02:45 克罗地亚 克拉根佛特
21 18/06 C组 荷兰 02:45 罗马尼亚 伯尔尼
22 18/06 C组 法国 02:45 意大利 苏黎世
23 19/06 D组 希腊 02:45 西班牙 萨尔茨堡
24 19/06 D组 俄罗斯 02:45 瑞典 因斯布鲁克
25 20/06 1/4决赛 A组第1 02:45 B组第2 巴塞尔
26 21/06 1/4决赛 B组第1 02:45 A组第2 维也纳
27 22/06 1/4决赛 C组第1 02:45 D组第2 巴塞尔
28 23/06 1/4决赛 D组第1 02:45 C组第2 维也纳
29 26/06 半决赛 第25场胜者 02:45 第26场胜者 巴塞尔
30 27/06 半决赛 第27场胜者 02:45 第28场胜者 维也纳
31 30/06 决赛 第29场胜者 02:45 第30场胜者 维也纳

本人比较看好西班牙

 

 

    在开发过程中遇到这样一个问题：
    2008-06-02 16:29:23,262 WARN [org.hibernate.util.JDBCExceptionReporter] SQL Error: 30036, SQLState: 99999
2008-06-02 16:29:23,263 ERROR [org.hibernate.util.JDBCExceptionReporter] ORA-30036: unable to extend segment by 1024 in undo tablespace 'UNDOTBS2'
后来查资料才发现是Undo表空间的问题。查看了一下Undo表空间剩的空间已经很少了。这种问题解决方法如下：

    

UNDO表空间用于存放UNDO数据,当执行DML操作(INSERT,UPDATE和DELETE)时,oracle会将这些操作执行前的旧数据写入到UNDO段,在oracle9i之前,管理UNDO数据时使用(Rollback Segment)完成的.从oracle9i开始,管理UNDO数据不仅可以使用回滚段,还可以使用UNDO表空间.因为规划和管理回滚段比较复杂,所有oracle database 10g已经完全丢弃用回滚段.并且使用UNDO表空间来管理UNDO数据.

1:查看所有的Undo表空间

SELECT * FROM dba_tablespaces where contents='UNDO'

2:Undo大小计算公式：

SELECT ((UR * (UPS * DBS)) + (DBS * 24))/1048576 AS "MB"
FROM (SELECT value AS UR
FROM v$parameter
WHERE name = 'undo_retention'),
(SELECT (SUM(undoblks)/SUM
(((end_time-begin_time)*86400))) AS UPS
FROM v$undostat),
(SELECT value AS DBS
FROM v$parameter
WHERE name = 'db_block_size');
3：修改Undo表空间大小

 先删除原来的表空间：
 drop tablespace UNDOTBS2 including contents and datafiles
 再建立一个和原来名称一样的表空间
 create undo tablespace UNDOTBS2 datafile '/home/oracle/oradata/depsight/undotbs2.dbf' size 50m

    想象一下，把所有的失望和希望都强加在一个人身上，留下的是什么那，那得把大地压得颤抖。 

    沿着鸽子的哨音，我寻找着你，高高的森林挡住了天空，小路上一颗迷途的蒲公英，把我引向蓝灰色的湖泊，在微微摇晃的倒影中。我找到了你。

    这诗歌怎么样啊，《迷途》。猜猜谁写的。

    如果说弗罗斯特的选择是无法改变而且使它变得伟大，那么普通人的选择又能算什么那。

    我静静回想你的眼神，但我永远无法读懂那里含有什么，是期盼还是讨厌。

    高考。意味着什么那，解脱、或是一段历史的结束，都一样吧。

    还记得史铁生说得好啊：女人对于你才是一个必然，而我对于你只是一个偶然。改编一下：

    高考对于我们来说是一个必然，考上了才是一个偶然。

    你对于我来说就跟其他的一样，其他的也跟你一样。当我看到他们我就想起你，而我看到你是就会忘记他们。

    多么美好的生活，就这样过去啦，不会回来了，在这里消逝，溶释在不知道的地方。

距离高考就剩下四十天了，从来没有象现在这样的考虑过一些事情。

每当我想到在这儿度过的一天，就想起一句话: 复课一年的生活将是你一生的财富--纯属放屁的一句话不知道害了多少像我一样的学生，如果将来的一天再有人跟我说这句话，我会吃了他。

在这儿受尽了窝囊气，老师不象老师象畜生，女生比男人还男人，男生比女人还女人。这些可以忍受而且必须忍受。

在这儿不知为什么从没想起过以前的跟高中同学在一起的岁月，就像一个世外的人，跟着果子每天吃饭睡觉上课跑操，突然间变得淡然了，一切都不重要了。

从没想过自己有一天会考上家人期望的大学，只是自己一个人在这儿思考一些问题，有时候去喝点酒或者打打台球什么的。

苍凉的生活再有四十天就要结束了--彻底的结束。在这儿得一切都将成为过去，可能存在我的记忆中，也可能被我遗忘生活跟我开了一个玩笑，呵呵，勇气，责任，挫折，汗水，成绩，理想，情感，忧郁，都他妈的将要去啦。

曾想过写一篇长一点得东西记录这一年的心路历程，后来放弃了，自己根本就不会写什么东西，经历就像一杯水你喝了它，它就消失，你倒了它它也是没有了，结果都一样，被子终将空的。留下的只是一些零碎的片段，希望它是完整的，但它永远不会。

在正确的时间遇上错误的人，注定是一声叹息；在错误的时间遇到对的人，注定是一场悲伤。这话说的太好了，每听一遍都是眼泪模糊。

幻想，是美好的，生活在自己想象的世界里是完美的。憧憬，怅惘，期待，虚伪，流氓，拳击，读书，音乐，电影，每天充斥着我，生活就是这个样子的吗？幸福在哪里？

天空，晴朗，云彩，时光，流水，尘土，星空，黎明，这是幸福。

孤独，寂寞，惆怅，失落，灿烂，忧伤，浮躁，平淡，这也是幸福。

理想，信念，执着，信仰，支撑，拼搏，努力，坚持，就像平凡的伟大的土地在我们心里生长，这同样是幸福。

萎靡，沉醉，疯狂，堕落，枯萎，这不是幸福，这是什么那？

生活是肥皂，生活是牙膏，生活是大宝，人生必落俗。

平静，烦恼，压力，浪潮，激动，愤怒，没什么可以阻挡的。真的吗？

白云苍狗，过眼云烟，花开花落，云卷云舒。

就像阿Q一样有时候也想一下这个东西，就是“女......”我们要继续想下去的。

现在老觉得女孩魅惑迷离的眼神是那么的可爱，值得留恋。那就是烙印打在心上了。

男人在夜深人静的时候才会留下眼泪抚摸自己的伤口，生活跟我们开了一个玩笑，希望这一切能让我在以后想起来的时候会有多点的释然，少一点的无奈，少一点伤感。

可能所有的人都能理解我的心情。看过这篇日志的人啊，愿上帝保佑你们，愿我的忠诚助你们一臂之力。

HashMap输出排序，以前写的接口没有考虑这个问题，现在输出要求排序，可以在得到Map结果后进行如下操作对数据进行排序：

Object[] key =   map.keySet().toArray();
//升序排序
        Arrays.sort(key);
       
        for(int i=0;i<key.length;++i)
        {
         System.out.println("Key_Id=="+key[i]+"Key_Value===="+map.get(key[i]));;
        }

我对以前对汉龙集团根本不了解，可今天看了一个贴子说是汉龙集团捐助的5所希望小学在地震中屹立不倒，
师生的生命得以挽救，心里特别震撼，当时的集团一个主任负责监管建设这五所希望小学，非常严格，
10年之前，10年之后，想起这，人的感动不由心生，好人有好报！但是就是这样严格按照工程质量建造的学校，因为在地震中没有倒，而被人称做“奇迹”，为何？我不说大家也明白。其它的建设的都是垃圾工程。
好人有好报，良心被狼吃了的人也必遭天遣！

距高考80天的感想

1.每天生活都是一个样子,教室-厕所-食堂-宿舍,看见的人也是一样,男生-女生-老师-还有畜生,这样的生活太他妈的爽了.

2.每天有固定的时间看书\睡觉\吃饭\跑操.连上个厕所的时间每天都是一样的,这样的生活其实一天就可以了,没有必要每天都这样.

3.每当我看都畜生的时候我就想自己真是个幸运的孩子啊,在这个时候才遇见他,而不是整个高中,真他吗的是幸福啊.

4.并不是每天都能看到的人,但为什么总是在尴尬的时候出现了,就象是一个雷锋在发扬钉子般的钻的精神,突然就钻出来拉.

5.我要在地上画满窗子,让所有习惯黑暗的眼睛都习惯光明,高三的学子们,掰着你们的爪子算一算你们就剩下几十天了,我在这里给你们祝福了.

6.我们不要嫉恨畜生,他们也是很好的呀,他们吃饭睡觉喝水撒尿跟我们一样,不过他们的思想跟我们不大一样,他们是牲畜的思想--仅此而已.

7.这里上学的有十种人.1.上学迟到的,2.上课睡觉的,3.上课看课外书的,4.上课说话的,5.老师不讲课睡不着觉的,6.吃饭把漱口水吐你鞋上的,7.再你吃饭的时候突然把你的馒头撞掉的而且还很横的,8.你在睡觉的时候突然闯入什么都不说的,9.半夜三更在楼道唱歌的,10没有女朋友跟你说他有的.

8.要原谅他们啊,并且要为他们祈祷啊----滚你娘的吧.老子不在乎.

同志们,革命尚未成功同志仍需努力,我们要好好学习天天向上啊,为什么那?

转自别处：
    1：抽象类：
                    有时候，我们可能想要构造一个很抽象的父类对象，它可能仅仅代表一个分类或抽象概念，它的实例没有任何意义，因此不希望它能被实例化。例如：有一个父类“水果（Fruit）”，它有几个子类“苹果（Apple）”、“橘子（Orange）”、“香蕉（Banana）”等。水果在这里仅仅只是作为一个分类，显然水果的实例没有什么意义（就好像一个人如果告诉你他买了一些水果但是却不告诉你是苹果还是橘子，你很难想象他到底买的是什么。） 。而水果类又要能被子类化，这就要求我们使用抽象类（abstract class）来解决这个问题。
在java中，通过在class关键字前增加abstract修饰符，就可以将一个类定义成抽象类。抽象类不能被实例化。例如：
          定义抽象类水果（Fruit）
          public abstract class Fruit {
                  ……
          }
           如果我们试图用以下语句来获得一个实例，将无法编译成功。
           Fruit fruit = new Fruit();
而我们仍然可以构造水果类的子类，如：
          子类“苹果（Apple）”
           public class Apple extends Fruit {
                   ……
           }
          子类“橘子（Orange）”
           public class Orange extends Fruit {
                   ……
           }
这样就达到我们的目的了。
抽象类除了能象普通类一样可以拥有一般的属性和方法，也可以拥有抽象方法（abstract method）。例如：
           抽象类“形状（Shape）”拥有抽象方法draw()。
           public abstract class Shape {
                  ……
                  public abstract void draw();
                  ……
           }
抽象方法与抽象的行为相对应，通常是这个行为对父对象没有意义，而子对象有具体动作。例如方法draw()对于类Shape没有意义，而类Shape的子类矩形（Rectangle）的方法draw()可以有实际的动作（根据矩形的四个顶点画出矩形的四个边），子类圆（Circle）的方法draw()也可以有实际的动作（根据圆心和半径画出圆周）。
抽象类可以有抽象方法也可以没有抽象方法；但是如果一个类有抽象方法，那这个类只能定义为抽象类。
           如果按照以下代码类“形状（Shape）”仍然拥有抽象方法draw()，但没有定义为抽象类，将会编译失败。
           public class Shape {
                  ……
                  public abstract void draw();
                  ……
           }
抽象方法还有一个特点是，它强迫子类要么仍然保持抽象性（即不具体实现该方法并仍然定义为抽象类），要么具体表现出这个方法的行为（实现具体的动作或者通过抛出UnsupportedOperationException异常来表明不支持该行为）。这样也可以强化多态性。

2：接口（interface）
java语言使用关键字interface定义一个接口。接口也是抽象对象，它甚至比抽象类更抽象。接口中的方法都是抽象方法。
    一个接口可以继承其他接口；一个类通过关键字implements声明要实现一个接口，并具体实现接口的方法。
           例如：有一个接口InterfaceA，
           public interface InterfaceA {
                   void methodA();
           }
           类ClassA实现接口InterfaceA。
           public class ClassA {
                   public void methodA() {
                           System.out.println("methodA of ClassA implements InterfaceA");
                   }
           }
如果是抽象类实现一个接口，那么抽象类中可以不具体实现接口的方法（保持其抽象性），而由其子类去实现。
           抽象类ClassB实现接口InterfaceA，但是没有具体实现方法methodA()，
           public abstract class ClassB {
           }
           子类ClassBSub实现接口InterfaceA，但是没有具体实现方法methodA()，
           public class ClassBSub {
                   public void methodA() {
                           System.out.println("methodA of ClassBSub the subclass of ClassB");
                   }
           }
接口和抽象类显著的共同点是接口和抽象类都可以有抽象方法。
接口和抽象类的不同点有：
           (1)抽象类可以有实例变量，而接口不能拥有实例变量，接口中的变量都是静态（static）的常量（final）。
           (2)抽象类可以有非抽象方法，而接口只能有抽象方法。
java中，类与类之间是不能多继承的。java之所以禁止类与类之间的多继承是因为多继承有很大的缺点。
多继承虽然能使子类同时拥有多个父类的特征，但是其缺点也是很显著的，主要有两方面：
(1)如果在一个子类继承的多个父类中拥有相同名字的实例变量，子类在引用该变量时将产生歧义，无法判断应该使用哪个父类的变量。例如：
           类ClassA：
           public class ClassA {
                   protected int varSame = 0;
           }
           类ClassB：
           public class ClassB {
                   protected int varSame = 1;
           }
           子类ClassC：（假设允许类与类之间多继承）
           public class ClassC extends ClassA, ClassB {
                   public void printOut() {
                           System.out.println(super.varSame);
                   }
                   public static void main(String[] args) {
                           ClassC classC = new ClassC();
                           classC.printOut();
                   }
           }
           上面程序的运行结果会是什么呢？输出0还是1？
(2)如果在一个子类继承的多个父类中拥有相同方法，子类中有没有覆盖该方法，那么调用该方法时将产生歧义，无法判断应该调用哪个父类的方法。例如：
           类ClassA：
           public class ClassA {
                   public void printOut() {
                           System.out.println(0);
                   }
           }
           类ClassB：
           public class ClassB {
                   public void printOut() {
                           System.out.println(1);
                   }
           }
           子类ClassC：（假设允许类与类之间多继承）
           public class ClassC extends ClassA, ClassB {
                   public static void main(String[] args) {
                           ClassA classA = new ClassC();
                           classA.printOut();       -------------------------  A行
                           ClassB classB = new ClassC();
                           classB.printOut();       -------------------------  B行
                           ClassC classC = new ClassC();
                           classC.printOut();       -------------------------  C行
                   }
           }
           上面程序的运行结果会是什么呢？A、B、C三行的输出是0还是1？
正因为有以上的致命缺点，所以java中禁止一个类继承多个父类；但是幸运的是java提供了接口，并能通过接口的功能获得多继承的许多优点而又摒弃了类与类多继承的缺点。
java允许一个接口继承多个父接口，也允许一个类实现多个接口，而这样的多继承有上面提到的缺点马？
答案是没有，这是由接口的抽象性决定的。
正如前面介绍的，在接口中不能有实例变量，只能有静态的常量，不能有具体的方法（包含方法体），只能有抽象方法，因此也就摒弃了多继承的缺点。
对于一个类实现多个接口的情况，因为接口只有抽象方法，具体方法只能由实现接口的类实现，在调用的时候始终只会调用实现类的方法（不存在歧义），因此不存在多继承的第二个缺点；而又因为接口只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。
对于一个接口继承多个父接口的情况也一样不存在这些缺点。
请看以下示例。
            接口A：
            public interface InterfaceA {
                    int len = 1;
                    void output();
            }
            接口B：
            public interface InterfaceB {
                    int len = 2;
                    void output();
            }
            接口Sub继承接口A和接口B：
            public interface InterfaceSub extends InterfaceA, interfaceB {
            }
            类Xyz实现接口Sub：
            public class Xyz implements InterfaceSub {
                    public void output() {
                            System.out.println("output in class Xyz.");
                    }
                     public void outputLen(int type) {
                             switch(type) {
                                     case InterfaceA.len:
                                             System.out.println("len of InterfaceA=."+type);
                                             break;
                                     case InterfaceB.len:
                                             System.out.println("len of InterfaceB=."+type);
                                             break;
                             }
                    }
                   public static void main(String[] args) {
                           Xyz xyz= new Xyz ();
                           xyz .output();
                           xyz .outputLen();
                   }
           }
           以上代码不存在什么问题，但是如果试图编写以下存在冲突的代码，则会编译失败。
           Xyz xyz = new Xyz();
           int len = xyz.len;
           System.out.println(len);
由于引入了接口，java显得非常灵活，也使得java中的多态性更加富有魔力。