随笔:93 文章:11 评论:22 引用:0
首页 发新随笔
发新文章 联系 聚合管理

java截取字符串,截串,substring和split,分割字母和数字,正则缝隙

关键字: java截取字符串 截串 substring

需求,把"01:大汽车",分成01和大汽车

有两种做法:一是substring

Java代码
  1. package test;  
  2.   
  3. public class substringTest  
  4. {  
  5.  public static void main(String args[])   
  6.  {   
  7.   String N = "01:大汽车";   
  8.   String L="";   
  9.   String R="";   
  10.   int k= N.length();   
  11.   for (int i = 0; i < N.length(); i++)   
  12.   {   
  13.    if (N.substring(i, i + 1).equals("|"))   
  14.    {     
  15.     L=N.substring(0,i).trim();   
  16.     R=N.substring(i+1,k).trim();   
  17.    }   
  18.    else   
  19.    {   
  20.                 
  21.    }   
  22.    System.out.println(L);   
  23.    System.out.println(R);   
  24.   }  
  25.  }  
  26. }   

 另外一种方法是CSDN上一位叫老六的人给我写的

package Test

Java代码
  1. public class splitTest  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         String s = new String("01:大汽车");   
  6.         String a[] = s.split(":");  
  7.       
  8.         System.out.println(a[0]);  
  9.         System.out.println(a[1]);  
  10.     }  
  11. }  

 split分割字母和数字,简单正则缝隙

Java代码
  1. public class Test01 {  
  2.     public static void main(String[] args) {  
  3.         String str = "one123";  
  4.         String regex = "(?<=one)(?=123)";  
  5.         String[] strs = str.split(regex);  
  6.         for(int i = 0; i < strs.length; i++) {  
  7.             System.out.printf("strs[%d] = %s%n", i, strs[i]);  
  8.         }  
  9.     }  
  10. }  

 

 

 

substring讲解:

s=s.substring(int begin);截取掉s从首字母起长度为begin的字符串,将剩余字符串赋值给s;

s=s.substring(int begin,int end);截取s中从begin开始至end结束时的字符串,并将其赋值给s;

split讲解:

java.lang.string.split
split 方法
将一个字符串分割为子字符串,然后将结果作为字符串数组返回。
stringObj.split([separator,[limit]])
参数
stringObj
必选项。要被分解的 String 对象或文字。该对象不会被 split 方法修改。
separator
可选项。字符串或 正则表达式 对象,它标识了分隔字符串时使用的是一个还是多个字符。如果忽

略该选项,返回包含整个字符串的单一元素数组。
limit
可选项。该值用来限制返回数组中的元素个数。

说明
split 方法的结果是一个字符串数组,在 stingObj 中每个出现 separator 的位置都要进行分解

。separator 不作为任何数组元素的部分返回。

split 的实现直接调用的 matcher 类的 split 的方法。“ . ”在正则表达式中有特殊的含义,因此我们使用的时候必须进行转义。

Java代码
  1. public static void main(string[] args) {  
  2. string value = "192.168.128.33";  
  3. string[] names = value.split("\\.");  
  4. for (int i = 0; i < names.length; i++) {  
  5. system.out.println(names[i]);  
  6. }}  

 如果用竖线“|”分隔的话,将出现不可得到的结果,必须改为“\\|” 

posted @ 2010-03-19 17:34 redcoatjk 阅读(157791) | 评论 (2)编辑 收藏
 
摘自:http://www.blogjava.net/ghyghost/archive/2008/06/16/208309.html
标题           在Java中实现浮点数的精确计算         AYellow(原作)   修改          
  关键字           Java   浮点数   精确计算        
   
   
  问题的提出:   
  编译运行下面这个程序会看到什么?  
  public   class   Test{  
          public   static   void   main(String   args[]){  
                  System.out.println(0.05+0.01);  
                  System.out.println(1.0-0.42);  
                  System.out.println(4.015*100);  
                  System.out.println(123.3/100);  
          }  
  };  
   
  你没有看错!结果确实是  
  0.060000000000000005  
  0.5800000000000001  
  401.49999999999994  
  1.2329999999999999  
   
  Java中的简单浮点数类型float和double不能够进行运算。不光是Java,在其它很多编程语言中也有这样的问题。在大多数情况下,计算的结果是准确的,但是多试几次(可以做一个循环)就可以试出类似上面的错误。现在终于理解为什么要有BCD码了。  
  这个问题相当严重,如果你有9.999999999999元,你的计算机是不会认为你可以购买10元的商品的。  
  在有的编程语言中提供了专门的货币类型来处理这种情况,但是Java没有。现在让我们看看如何解决这个问题。  
   
     
   
  四舍五入  
  我们的第一个反应是做四舍五入。Math类中的round方法不能设置保留几位小数,我们只能象这样(保留两位):  
  public   double   round(double   value){  
          return   Math.round(value*100)/100.0;  
  }  
   
  非常不幸,上面的代码并不能正常工作,给这个方法传入4.015它将返回4.01而不是4.02,如我们在上面看到的  
  4.015*100=401.49999999999994  
  因此如果我们要做到精确的四舍五入,不能利用简单类型做任何运算  
  java.text.DecimalFormat也不能解决这个问题:  
  System.out.println(new   java.text.DecimalFormat("0.00").format(4.025));  
  输出是4.02  
   
     
   
  BigDecimal  
  在《Effective   Java》这本书中也提到这个原则,float和double只能用来做科学计算或者是工程计算,在商业计算中我们要用 java.math.BigDecimal。BigDecimal一共有4个够造方法,我们不关心用BigInteger来够造的那两个,那么还有两个, 它们是:  
  BigDecimal(double   val)    
                      Translates   a   double   into   a   BigDecimal.    
  BigDecimal(String   val)    
                      Translates   the   String   repre   sentation   of   a   BigDecimal   into   a   BigDecimal.  
   
  上面的API简要描述相当的明确,而且通常情况下,上面的那一个使用起来要方便一些。我们可能想都不想就用上了,会有什么问题呢?等到出了问题的时候,才发现上面哪个够造方法的详细说明中有这么一段:  
  Note:   the   results   of   this   constructor   can   be   somewhat   unpredictable.   One   might   assume   that   new   BigDecimal(.1)   is   exactly   equal   to   .1,   but   it   is   actually   equal   to   .1000000000000000055511151231257827021181583404541015625.   This   is   so   because   .1   cannot   be   represented   exactly   as   a   double   (or,   for   that   matter,   as   a   binary   fraction   of   any   finite   length).   Thus,   the   long   value   that   is   being   passed   in   to   the   constructor   is   not   exactly   equal   to   .1,   appearances   nonwithstanding.    
  The   (String)   constructor,   on   the   other   hand,   is   perfectly   predictable:   new   BigDecimal(".1")   is   exactly   equal   to   .1,   as   one   would   expect.   Therefore,   it   is   generally   recommended   that   the   (String)   constructor   be   used   in   preference   to   this   one.  
   
  原来我们如果需要精确计算,非要用String来够造BigDecimal不可!在《Effective   Java》一书中的例子是用String来够造BigDecimal的,但是书上却没有强调这一点,这也许是一个小小的失误吧。  
     
   
  解决方案  
  现在我们已经可以解决这个问题了,原则是使用BigDecimal并且一定要用String来够造。  
  但是想像一下吧,如果我们要做一个加法运算,需要先将两个浮点数转为String,然后够造成BigDecimal,在其中一个上调用add方法,传入另 一个作为参数,然后把运算的结果(BigDecimal)再转换为浮点数。你能够忍受这么烦琐的过程吗?下面我们提供一个工具类Arith来简化操作。它 提供以下静态方法,包括加减乘除和四舍五入:  
  public   static   double   add(double   v1,double   v2)  
  public   static   double   sub(double   v1,double   v2)  
  public   static   double   mul(double   v1,double   v2)  
  public   static   double   div(double   v1,double   v2)  
  public   static   double   div(double   v1,double   v2,int   scale)  
  public   static   double   round(double   v,int   scale)  
   
   
   
  附录  
   
   
  源文件Arith.java:  
   
  import   java.math.BigDecimal;  
  /**  
    *   由于Java的简单类型不能够精确的对浮点数进行运算,这个工具类提供精  
    *   确的浮点数运算,包括加减乘除和四舍五入。  
    */  
   
  public   class   Arith{  
   
          //默认除法运算精度  
          private   static   final   int   DEF_DIV_SCALE   =   10;  
   
   
          //这个类不能实例化  
          private   Arith(){  
          }  
   
     
          /**  
            *   提供精确的加法运算。  
            *   @param   v1   被加数  
            *   @param   v2   加数  
            *   @return   两个参数的和  
            */  
   
          public   static   double   add(double   v1,double   v2){  
                  BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));  
                  BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));  
                  return   b1.add(b2).doubleValue();  
          }  
   
          /**  
            *   提供精确的减法运算。  
            *   @param   v1   被减数  
            *   @param   v2   减数  
            *   @return   两个参数的差  
            */  
   
          public   static   double   sub(double   v1,double   v2){  
                  BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));  
                  BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));  
                  return   b1.subtract(b2).doubleValue();  
          }    
   
          /**  
            *   提供精确的乘法运算。  
            *   @param   v1   被乘数  
            *   @param   v2   乘数  
            *   @return   两个参数的积  
            */  
   
          public   static   double   mul(double   v1,double   v2){  
                  BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));  
                  BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));  
                  return   b1.multiply(b2).doubleValue();  
          }  
   
     
   
          /**  
            *   提供(相对)精确的除法运算,当发生除不尽的情况时,精确到  
            *   小数点以后10位,以后的数字四舍五入。  
            *   @param   v1   被除数  
            *   @param   v2   除数  
            *   @return   两个参数的商  
            */  
   
          public   static   double   div(double   v1,double   v2){  
                  return   div(v1,v2,DEF_DIV_SCALE);  
          }  
   
     
   
          /**  
            *   提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指  
            *   定精度,以后的数字四舍五入。  
            *   @param   v1   被除数  
            *   @param   v2   除数  
            *   @param   scale   表示表示需要精确到小数点以后几位。  
            *   @return   两个参数的商  
            */  
   
          public   static   double   div(double   v1,double   v2,int   scale){  
                  if(scale<0){  
                          throw   new   IllegalArgumentException(  
                                  "The   scale   must   be   a   positive   integer   or   zero");  
                  }  
                  BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));  
                  BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));  
                  return   b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();  
          }  
   
     
   
          /**  
            *   提供精确的小数位四舍五入处理。  
            *   @param   v   需要四舍五入的数字  
            *   @param   scale   小数点后保留几位  
            *   @return   四舍五入后的结果  
            */  
   
          public   static   double   round(double   v,int   scale){  
                  if(scale<0){  
                          throw   new   IllegalArgumentException(  
                                  "The   scale   must   be   a   positive   integer   or   zero");  
                  }  
                  BigDecimal   b   =   new   BigDecimal(Double.toString(v));  
                  BigDecimal   one   =   new   BigDecimal("1");  
                  return   b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();  
          }  
  };  


posted @ 2010-03-07 17:23 redcoatjk 阅读(455) | 评论 (0)编辑 收藏
 

0
推荐

要学习ANT的使用,要先了解什么是ANT。
什么是ant呢? ant是构建工具;那构建是又什么意思呢?形象来说,你要把代码从某个地方拿来,编译,再拷贝到某个地方去等等操作,当然不仅与此,但是主要用来干这个。
知道这些,我们还要了解为什么要用ANT,呵呵,哦对,就像那位MM说的,当然是有好处的:
A, 跨平台  --因为ant是使用java实现的,所以它跨平台
B,使用简单--与ant的兄弟make比起来
C, 语法清晰--同样是和make相比
D,功能强大--ant能做的事情很多,可能你用了很久,你仍然不知道它能有多少功能。当你自己开发一些ant插件的时候,你会发现它更多的功能。

一,构建ant环境
要使用ant首先要构建一个ant环境,步骤很简单:
1),安装jdk,设置JAVA_HOME ,PATH ,CLASS_PATH(这些应该是看这篇文章的人应该知道的)
2),下载ant 地址http://17xx.zhmy.com找一个你喜欢的版本,或者干脆最新的版本
3),解压ant 你得到的是一个压缩包,解压缩它,并把它放在一个尽量简单的目录,例如D:\ant-1.6虽然你不一 定要这么做,但这么做是有好处的。
4),设置ANT_HOME PATH中添加ANT_HOME目录下的bin目录
5),测试一下你的设置,开始-->运行-->cmd进入命令行-->键入 ant 回车,如果看到
Buildfile: build.xml does not exist!
Build failed
那么恭喜你你已经完成ant的设置

二,体验ant
就像每个语言都有HelloWorld一样,一个最简单的应用能让人感受一下Ant
1,首先你要知道你要干什么,我现在想做的事情是:
编写一些程序
编译它们
把它打包成jar包
把他们放在应该放置的地方
运行它们
这里为了简单起见只写一个程序,就是HelloWorld.java程序代码如下:
package test.ant;
public class HelloWorld{
 public static void main(String[] args){
  System.out.println("Hello world1");
 }
};
2,为了达到上边的目的,你可以手动的用javac 、copy 、jar、java来完成,但是考虑一下如果你有成百上千个类,在多次调试,部署的时候,一次次的javac 、copy、jar、
java那将是一份辛苦的工作。现在看看ant怎么优雅的完成它们。
要运行ant需要有一个build.xml虽然不一定要叫这个名字,但是建议你这么做
下边就是一个完整的build.xml,然后我们来详细的解释每一句
<?xml version="1.0" encoding="UTF-8" ?>
<project name="HelloWorld" default="run" basedir=".">
 <property name="src" value="http://www.zhmy.com/src"/>
 <property name="dest" value="classes"/>
 <property name="hello_jar" value="hello1.jar"/>
 <target name="init">
  <mkdir dir="${dest}"/>
 </target>
 <target name="compile" depends="init">
  <javac srcdir="${src}" destdir="${dest}"/>
 </target>
 <target name="build" depends="compile">
  <jar jarfile="${hello_jar}" basedir="${dest}"/>
 </target>
 <target name="run" depends="build">
  <java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>
 </target>
 <target name="clean">
  <delete dir="${dest}" />
  <delete file="${hello_jar}" />
 </target>
 <target name="rerun" depends="clean,run">
  <ant target="clean" />
  <ant target="run" />
 </target>
</project>
解释:
<?xml version="1.0" encoding="UTF-8" ?>
build.xml中的第一句话,没有实际的意义
<project name="HelloWorld" default="run" basedir=".">
</project>
ant的所有内容必须包含在这个里边,name是你给它取的名字,basedir故名思意就是工作的根目录 .代表当前目录。default代表默认要做的事情。
<property name="src" value="src"/>
类似程序中的变量,为什么这么做想一下变量的作用
<target name="compile" depends="init">
  <javac srcdir="${src}" destdir="${dest}"/>
</target>
把你想做的每一件事情写成一个target ,它有一个名字,depends是它所依赖的target,在执行这个target 例如这里的compile之前ant会先检查init是否曾经被执行过,如果执行
过则直接直接执行compile,如果没有则会先执行它依赖的target例如这里的init,然后在执行这个target
如我们的计划
编译:
<target name="compile" depends="init">
 <javac srcdir="${src}" destdir="${dest}"/>
</target>
做jar包:
<target name="build" depends="compile">
 <jar jarfile="${hello_jar}" basedir="${dest}"/>
</target>
运行:
<target name="run" depends="build">
 <java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>
</target>
为了不用拷贝,我们可以在最开始定义好目标文件夹,这样ant直接把结果就放在目标文件夹中了
新建文件夹:
<target name="init">
 <mkdir dir="${dest}"/>
</target>
为了更多一点的功能体现,又加入了两个target
删除生成的文件
<target name="clean">
 <delete dir="${dest}" />
 <delete file="${hello_jar}" />
</target>
再次运行,这里显示了如何在一个target里边调用其他的target
<target name="rerun" depends="clean,run">
 <ant target="clean" />
 <ant target="run" />
</target>
好了,解释完成了,下边检验一下你的ant吧
新建一个src的文件夹,然后把HelloWorld.java按照包目录放进去
做好build.xml文件
在命令行下键入ant ,你会发现一个个任务都完成了。每次更改完代码只需要再次键入ant
有的时候我们可能并不想运行程序,只想执行这些步骤中的某一两个步骤,例如我只想重新部署而不想运行,键入
ant build
ant中的每一个任务都可以这样调用ant + target name
好了,这样一个简单的ant任务完成了。

到此你应该看出来了,ant的使用,关键就是build.xml的编写,一个优秀的build.xml可以用来做模板,甚至直接用就OK,打开命令提示窗口,键入ANT即可~~
posted @ 2010-03-06 21:20 redcoatjk 阅读(216) | 评论 (0)编辑 收藏
 
  一、利用SQL自带函数
SQL Sever足够强大,可以在需要的时候把大部分数值从一种类型转换为另一种类型。例如,要比较SMALLINT型和INT型数据的大小,你不需要进行显式 的类型转换。SQL Sever会为你完成这项工作。但是,当你想在字符型数据和其它类型的数据之间进行转换时,你的确需要自己进行转换操作。例如,假设你想从一个MONEY 型字段中取出所有的值,并在结果后面加上字符串“US Dollars”。你需要使用函数CONVERT(),如下例所示:
SELECT CONVERT(CHAR(8),price)+’US Dollars’ FROM orders
函数CONVERT()带有两个变量。第一个变量指定了数据类型和长度。第二个变量指定了要进行转换的字段。在这个例子中,字段price被转换成长度为8个字符的CHAR型字段。字段price要被转换成字符型,才可以在它后面连接上字符串’US Dollars’。
当向BIT型,DATETIME型,INT型,或者NUMERIC型字段添加字符串时,你需要进行同样的转换操作。例如,下面的语句在一个SELECT语句的查询结果中加入字符串’The vote is’,该SELECT语句返回一个BIT型字段的值:
SELECT ‘The vote is’+CONVERT(CHAR(1),vote) FROM opinion
下面是这个语句的结果示例:
The vote is 1
The vote is 1
The vote is 0
(3 row(s) affected)
如果你不进行显式的转换,你会收到如下的错误信息:
Implicit conversion from datatype ‘varchar’ to ‘bit’ is not allowec.
Use the CONVERT function to run this query.
操作字符串数据
SQL Sever有许多函数和表达式,使你能对字符串进行有趣的操作,包括各种各样的模式匹配和字符转换。在这一节中,你将学习如何使用最重要的字符函数和表达式。
匹配通配符
假设你想建立一个与Yahoo功能相似的Internet目录。你可以建立一个表用来保存一系列的站点名称,统一资源定位器(URL),描述,和类别,并允许访问者通过在HTML form中输入关键字来检索这些内容。
假如有一个访问者想从这个目录中得到其描述中包含关键字trading card的站点的列表。要取出正确的站点列表,你也许试图使用这样的查询:
SELECT site_name FROM site_directory WHERE site_desc=’trading card’
这个查询可以工作。但是,它只能返回那些其描述中只有trading card这个字符串的站点。例如,一个描述为We have the greatest collection of trading cards in the world!的站点不会被返回。
要把一个字符串与另一个字符串的一部分相匹配,你需要使用通配符。你使用通配符和关键字LIKE来实现模式匹配。下面的语句使用通配符和关键字LIKE重写了上面的查询,以返回所有正确站点的名字:
SELECT SITE_name FROM site_directory
WHERE site_desc LIKE ‘%trading cark%’
在这个例子中,所有其描述中包含表达式trading card的站点都被返回。描述为We have the greatest collection of trading cards in the world!的站点也被返回。当然,如果一个站点的描述中包含I am trading cardboard boxes online ,该站点的名字也被返回。
注意本例中百分号的使用。百分号是通配符的例子之一。它代表0个或多个字符。通过把trading card括在百分号中,所有其中嵌有字符串trading card的字符串都被匹配。
现在,假设你的站点目录变得太大而不能在一页中完全显示。你决定把目录分成两部分。在第一页,你想显示所有首字母在A到M之间的站点。在第二页,你想显示所有首字母在N到Z之间的站点。要得到第一页的站点列表,你可以使用如下的SQL语句:
SELECT site_name FROM site_directory WHERE site_name LIKE ‘[A-M]%’
在这个例子中使用了表达式[A-M],只取出那些首字母在A到M之间的站点。中括号([])用来匹配处在指定范围内的单个字符。要得到第二页中显示的站点,应使用这个语句:
SELECT site_name FROM site_directory
WHERE site_name LIKE ‘[N-Z]%’
在这个例子中,括号中的表达式代表任何处在N到Z之间的单个字符。
假设你的站点目录变得更大了,你现在需要把目录分成更多页。如果你想显示那些以A,B或C开头的站点,你可以用下面的查询来实现:
SELECT site_name FROM site_directory WHERE site_name LIKE ‘[ABC]%’
在这个例子中,括号中的表达式不再指定一个范围,而是给出了一些字符。任何一个其名字以这些字符中的任一个开头的站点都将被返回。
通过在括号内的表达式中同时包含一个范围和一些指定的字符,你可以把这两种方法结合起来。例如,用下面的这个查询,你可以取出那些首字母在C到F之间,或者以字母Y开头的站点:
SELECT site_name FROM site_directory WHERE site_name LIKE ‘[C-FY]%’
在这个例子中,名字为Collegescape和Yahoo的站点会被选取,而名字为Magicw3的站点则不会被选取。
你也可以使用脱字符(^)来排除特定的字符。例如,要得到那些名字不以Y开头的站点,你可以使用如下的查询:
SELECT site_name FROM site_directory WHERE site_name LIKE ‘[^Y]%’
对给定的字符或字符范围均可以使用脱字符。
最后,通过使用下划线字符(_),你可以匹配任何单个字符。例如,下面这个查询返回每一个其名字的第二个字符为任何字母的站点:
SELECT site_name FROM site_directory WHERE site_name LIKE ‘M_crosoft’
这个例子既返回名为Microsoft的站点,也返回名为Macrosoft的站点。但是,名字为Moocrosoft的站点则不被返回。与通配符’%’不同,下划线只代表单个字符。
注意:
如果你想匹配百分号或下划线字符本身,你需要把它们括在方括号中。如果你想匹配连字符(-),应把它指定为方括号中的第一个字符。如果你想匹配方括号,应把它们也括在方括号中。例如,下面的语句返回所有其描述中包含百分号的站点:
SELECT site_name FROM site_directory WHERE site_desc LIKE ‘%[%]%’
匹配发音\r
Microsoft SQL 有两个允许你按照发音来匹配字符串的函数。函数SOUNDEX()给一个字符串分配一个音标码,函数DIFFERENCE()按照发音比较两个字符串。当 你不知道一个名字的确切拼写,但多少知道一点它的发音时,使用这两个函数将有助于你取出该记录。
例如,如果你建立一个Internet目录,你也许想增加一个选项,允许访问者按照站点名的发音来搜索站点,而不是按名字的拼写。考虑如下的语句:
SELECT site_name FROM site_directory
WHERE DIFFERENCE(site_name , ‘Microsoft’>3
这个语句使用函数DEFFERENCE()来取得其名字的发音与Microsoft非常相似的站点。函数DIFFERENCE()返回一个0到4之间的数字。如果该函数返回4,表示发音非常相近;如果该函数返回0,说明这两个字符串的发音相差很大。
例如,上面的语句将返回站点名Microsoft和Macrosoft。这两个名字的发音与Microsoft都很相似。如果你把上一语句中的大于3改为 大于2,那么名为Zicrosoft和Megasoft的站点也将被返回。最后,如果你只需要差别等级大于1即可,则名为Picosoft和 Minisoft的站点也将被匹配。
要深入了解函数DIFFERENCE()是如何工作的,你可以用函数SOUNDEX()来返回函数DIFFERENCE()所使用的音标码。这里有一个例子:
SELECT site_name ‘site name’,SOUNDEX(site_name) ‘sounds like’
这个语句选取字段site_name的所有数据及其音标码。下面是这个查询的结果:
site name sounds like
……………………………………………………………….
Yahoo Y000
Mahoo M000
Microsoft M262
Macrosoft M262
Minisoft M521
Microshoft M262
Zicrosoft Z262
Zaposoft Z121
Millisoft M421
Nanosoft N521
Megasoft M221
Picosoft P221
(12 row(s) affected)
如果你仔细看一下音标码,你会注意到音标码的第一个字母与字段值的第一个字母相同。例如,Yahoo和Mahoo的音标码只有第一个字母不同。你还可以发现Microsoft和Macrosoft的音标码完全相同。
函数DIFFERENDE()比较两个字符串的第一个字母和所有的辅音字母。该函数忽略任何元音字母(包括y),除非一个元音字母是一个字符串的第一个字母。
不幸的是,使用SOUNDEX()和DIFFERENCE()有一个欠缺。WHERE子句中包含这两个函数的查询执行起来效果不好。因此,你应该小心使用这两个函数。
删除空格
有两个函数,TTRIM()和LTRIM(),可以用来从字符串中剪掉空格。函数LTRIM()去除应该字符串前面的所有空格;函数RTRIM()去除一个字符串尾部的所有空格。这里有一个任何使用函数RTRIM()的例子:
SELECT RTRIM(site_name) FROM site_directory
在这个例子中,如果任何一个站点的名字尾部有多余的空格,多余的空格将从查询结果中删去。
你可以嵌套使用这两个函数,把一个字符串前后的空格同时删去:
SELECT LTRIM(RTRIM(site_name)) FROM site_directory
你会发现,在从CHAR型字段中剪掉多余的空格时,这两个函数非常有用。记住,如果你把一个字符串保存在CHAR型字段中,该字符串会被追加多余的空格,以匹配该字段的长度。用这两个函数,你可以去掉无用的空格,从而解决这个问题。
删除空格
update zjkjt.code_subject set code = rtrim(code)
二、利用SQL Update 语句删除空格
Update Table Set Colname=Replace(Colname," ","")
三、利用SQL Update 语句删除回车
Update Table Set Colname=Replace(Colname,char(13),"")
三、利用SQL Update 语句删除硬回车
Update Font Set DemoUrl=Replace(DemoUrl,'
','')
注意:以上语句不要合关成一行,否则无法达到效果。
posted @ 2009-11-13 16:40 redcoatjk 阅读(1450) | 评论 (0)编辑 收藏
 

可以从这2个表中查询,
user_constraints, user_cons_columns
查询的时候观察下表的内容即明白.


posted @ 2009-11-12 10:58 redcoatjk 阅读(155) | 评论 (0)编辑 收藏
 
Ctrl+1 快速修复(最经典的快捷键,就不用多说了)
Ctrl+D: 删除当前行
Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
Ctrl+Alt+↑ 复制当前行到上一行(复制增加)
Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt+↑ 当前行和上面一行交互位置(同上)
Alt+← 前一个编辑的页面
Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)
Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性
Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift+Ctrl+Enter 在当前行插入空行(原理同上条)
Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)
Ctrl+M 最大化当前的Edit或View (再按则反之)
Ctrl+/ 注释当前行,再按则取消注释
Ctrl+O 快速显示 OutLine
Ctrl+T 快速显示当前类的继承结构
Ctrl+W 关闭当前Editer
Ctrl+K 参照选中的Word快速定位到下一个
Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
Ctrl+/(小键盘) 折叠当前类中的所有代码
Ctrl+×(小键盘) 展开当前类中的所有代码
Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)
Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
Ctrl+J 正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有

找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X 把当前选中的文本全部变味小写
Ctrl+Shift+Y 把当前选中的文本全部变为小写
Ctrl+Shift+F 格式化当前代码
Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

下面的快捷键是重构里面常用的,本人就自己喜欢且常用的整理一下(注:一般重构的快捷键都是Alt+Shift开头的了)
Alt+Shift+R 重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)
Alt+Shift+M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)
Alt+Shift+C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)
Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)
Alt+Shift+F 把Class中的local变量变为field变量 (比较实用的功能)
Alt+Shift+I 合并变量(可能这样说有点不妥Inline)
Alt+Shift+V 移动函数和变量(不怎么常用)
Alt+Shift+Z 重构的后悔药(Undo)

编辑
作用域 功能 快捷键
全局 查找并替换 Ctrl+F
文本编辑器 查找上一个 Ctrl+Shift+K
文本编辑器 查找下一个 Ctrl+K
全局 撤销 Ctrl+Z
全局 复制 Ctrl+C
全局 恢复上一个选择 Alt+Shift+↓
全局 剪切 Ctrl+X
全局 快速修正 Ctrl1+1
全局 内容辅助 Alt+/
全局 全部选中 Ctrl+A
全局 删除 Delete
全局 上下文信息 Alt+?
Alt+Shift+?
Ctrl+Shift+Space
Java编辑器 显示工具提示描述 F2
Java编辑器 选择封装元素 Alt+Shift+↑
Java编辑器 选择上一个元素 Alt+Shift+←
Java编辑器 选择下一个元素 Alt+Shift+→
文本编辑器 增量查找 Ctrl+J
文本编辑器 增量逆向查找 Ctrl+Shift+J
全局 粘贴 Ctrl+V
全局 重做 Ctrl+Y

 
查看
作用域 功能 快捷键
全局 放大 Ctrl+=
全局 缩小 Ctrl+-

 
窗口
作用域 功能 快捷键
全局 激活编辑器 F12
全局 切换编辑器 Ctrl+Shift+W
全局 上一个编辑器 Ctrl+Shift+F6
全局 上一个视图 Ctrl+Shift+F7
全局 上一个透视图 Ctrl+Shift+F8
全局 下一个编辑器 Ctrl+F6
全局 下一个视图 Ctrl+F7
全局 下一个透视图 Ctrl+F8
文本编辑器 显示标尺上下文菜单 Ctrl+W
全局 显示视图菜单 Ctrl+F10
全局 显示系统菜单 Alt+-

 
导航
作用域 功能 快捷键
Java编辑器 打开结构 Ctrl+F3
全局 打开类型 Ctrl+Shift+T
全局 打开类型层次结构 F4
全局 打开声明 F3
全局 打开外部javadoc Shift+F2
全局 打开资源 Ctrl+Shift+R
全局 后退历史记录 Alt+←
全局 前进历史记录 Alt+→
全局 上一个 Ctrl+,
全局 下一个 Ctrl+.
Java编辑器 显示大纲 Ctrl+O
全局 在层次结构中打开类型 Ctrl+Shift+H
全局 转至匹配的括号 Ctrl+Shift+P
全局 转至上一个编辑位置 Ctrl+Q
Java编辑器 转至上一个成员 Ctrl+Shift+↑
Java编辑器 转至下一个成员 Ctrl+Shift+↓
文本编辑器 转至行 Ctrl+L

 
搜索
作用域 功能 快捷键
全局 出现在文件中 Ctrl+Shift+U
全局 打开搜索对话框 Ctrl+H
全局 工作区中的声明 Ctrl+G
全局 工作区中的引用 Ctrl+Shift+G

 
文本编辑
作用域 功能 快捷键
文本编辑器 改写切换 Insert
文本编辑器 上滚行 Ctrl+↑
文本编辑器 下滚行 Ctrl+↓

 
文件
作用域 功能 快捷键
全局 保存 Ctrl+X
Ctrl+S
全局 打印 Ctrl+P
全局 关闭 Ctrl+F4
全局 全部保存 Ctrl+Shift+S
全局 全部关闭 Ctrl+Shift+F4
全局 属性 Alt+Enter
全局 新建 Ctrl+N

 
项目
作用域 功能 快捷键
全局 全部构建 Ctrl+B

 
源代码
作用域 功能 快捷键
Java编辑器 格式化 Ctrl+Shift+F
Java编辑器 取消注释 Ctrl+\
Java编辑器 注释 Ctrl+/
Java编辑器 添加导入 Ctrl+Shift+M
Java编辑器 组织导入 Ctrl+Shift+O
Java编辑器 使用try/catch块来包围 未设置,太常用了,所以在这里列出,建议自己设置。
也可以使用Ctrl+1自动修正。

 
运行
作用域 功能 快捷键
全局 单步返回 F7
全局 单步跳过 F6
全局 单步跳入 F5
全局 单步跳入选择 Ctrl+F5
全局 调试上次启动 F11
全局 继续 F8
全局 使用过滤器单步执行 Shift+F5
全局 添加/去除断点 Ctrl+Shift+B
全局 显示 Ctrl+D
全局 运行上次启动 Ctrl+F11
全局 运行至行 Ctrl+R
全局 执行 Ctrl+U

 
重构
作用域 功能 快捷键
全局 撤销重构 Alt+Shift+Z
全局 抽取方法 Alt+Shift+M
全局 抽取局部变量 Alt+Shift+L
全局 内联 Alt+Shift+I
全局 移动 Alt+Shift+V
全局 重命名 Alt+Shift+R
全局 重做 Alt+Shift+Y
posted @ 2009-10-29 09:55 redcoatjk 阅读(128) | 评论 (0)编辑 收藏
 

    对于大多数程序员来说,微软是一家值得崇敬的公司,能够加入微软,也是很多程序 员的愿望。在付出足够的努力后,一旦进入了微软,也就意味着可以和最先进的技术终日为伍,一直沿着技术这条路线走下去了。对吗?错。今年九月份刚刚加入微 软开发合作部的王洪超就为自己规划了一条技术管理的路线,除了在技术方面继续学习之外,他还希望在未来的时间里有意识的提升项目管理的能力。王洪超说:" 微软为员工的职业发展规划提供了足够的学习机会。" 对更多的程序员来说,进入微软仍旧是一个梦想。然而,与以往任何一个时候相比,做出职业规划的必要性更加迫切。面对层出不穷的新技术,激增的就业压力,不 断分化的开发角色,再加上IT发展的不明确,做出职业规划既是一种挑战,也是必须之举。

     以前,学校的学生只要考取一个认证就很容易开始自己的职业生涯,已经工作几年的程序员更是成为公司抢夺的对象,而就在互联网热时,高级程序员更多想到的是 自己出去创业。现在一切都改变了,混乱的认证市场让毕业的学生失去了一块招牌,企业更注重其技能和做项目的经验,而少有工作经验的学生和企业需求之间形成 了无法弥补的裂痕。已经工作的程序员又面临着学习软件工程规范和技术更新换代的压力,不明朗的软件行业前景让他们在走向三十的路途上遭遇困惑。对于已经具 备相当水平的资深技术专家或者技术领导者来说,风险投资对软件项目的谨慎使得创业变得更加困难。即便如此,仍然有很多非软件专业的人员源源不断的加入到这 个大队伍中,更为市场增加了很多竞争的对象。 与企业需求接轨是学生的职业规划的第一步 很久以前,企业要承担起学生的培训工作,毕业的学生要在公司经过一段时间后,才能融入整个开发团队。而现在,很少有公司愿意承担这样的培训费用了,在激烈 的市场竞争下,发着工资却无法带来利润的职员是大部分企业无法容忍的。

     大学教育是普适教育,教给学生的只是知识,而企业对学生的需求是技能。这之间就是一个很难弥补的差距。中科天博总经理王健华表示:"大学生学习完了之后, 只是知道是什么,根本不会用。学习了C、Delphi,学习了Java,只能够按照书本的案例照着做下来。但让他做一个最小的项目,包括一个带后端数据库 的小网站,都很难独立承担。" 前IBM 软件部高级软件工程师李巨锋现在担任科瑞尔思培训中心专职教师,他也表达了同样的看法,"企业更关心你学习到了什么技能,做过什么,如何把学到的技术应用 到实际中去。" 应届毕业生很难克服这个困难,因为学校不具备这样的环境。IT大环境没有解决的情况下,就需要大学生自己想办法。如果在学校通过某些方式已经积累到了经 验,当然是最好的。但如果没有积累到这些知识,就必须寻找机会通过其他途径弥补了。 曾担任亚信公司软件开发技术总监,现在创办达内培训中心的韩少云有也切身的体会。 "原来我也在亚信做人才管理,需要不断从社会上招聘好的软件工程师,组建开发团队。我发现很难找到合适的人选,但是一些被淘汰的人是很可惜的,他的基本素 质,包括计算机专业的相关背景非常不错,但具备的技能和企业不能很好的匹配。"为此,韩少云萌发了要做IT培训的念头,希望将企业需要而学员缺乏的知识和 技能通过这种培训进行弥补,创办达内科技以来也取得了巨大的成功。 对学生来说,提高适应企业需求的技能也是为了寻找到适合自己的公司,职业生涯就是进入正常的轨道中。寻找到适合的入口,面临毕业的学生要谨慎的做出自 己的选择。如果不好找入口,起点太低,对未来的发展也没有好处,甚至导致以后的工作习惯都不好。金山公司负责人力资源的副总裁王春伟说:"《哈里波特3》 中有一句话让我印象非常深刻:选择比能力更重要。一个人年轻也只有很短暂的几年,如果能够选择一个精彩有活力的团队,会使他的职业生涯充满精彩。如果在选 择职业的时候,因为一些失误造成两至三年没有学到什么,自己也会非常惭愧的。" 王健华表示,企业是员工社会价值的附着。"大公司在自身的工作规范和工作习惯会更加正规,其经理的素质会更好。很多人由于没有对未来进行规划,没有想清 楚,工作之后对自己的岗位不尊重,经理也看不上他。" 企业对软件工程流程越来越重视,这是企业做事的方式。要适应企业的需要,甚至先要学会规范的文档,然后才是技术,这样企业知道你受过正规的训练。王健华 说:"我们要求学员注重4方面的能力:眼界、学习的方法、技能和规范,他要学习如何与别人合作,比如在代码风格上统一。虽然只是一名程序员,但仍需要站在 项目经理的层面上看自己的工作,这样才能更好的合作,融入到团队中。"王春伟认为团队能力也是通用软件厂商非常看中的一点,"现在不是凸现个人英雄主义的 年代,在金山公司,一个人如果很孤僻,很冰冷,沟通很艰涩就不行。我们要求程序员心态非常端正,有良好的配合意识,个性特别乐观。" 一些学生也意识到了这点,正在软件学员读大四刘未鹏就表示:"我想当杂志社编辑、从事教育工作或进入研究机构,总之得是一个能够静下心来的地方。如果非要 进公司工作,也得像趋势、金山或微软这样具有开放工作环境的公司。现在国内很多公司还是被市场所奴役,不能建立自己的个性,个人觉得不要在一个终日赶工的 小公司工作。"因此,对现在的学生来说,不断增加和企业能够顺利接轨的砝码就是职业规划的第一步。 工作后程序员的职业规划是要将技术提升与行业结合. 已经工作一段时间的程序员更要注重职业规划。很多人刚毕业时充满活力,然而几年的摸爬滚打后,冲劲就会慢慢减弱甚至消失。再加上IT大环境的起伏不定,一 旦无法跟上技术或者行业发展的步伐,便会迷茫。王洪超说:"以前晚上睡觉之前想事情,经常都不知道自己以后做什么。" 这并不奇怪,工作的新鲜感褪色后,就设法需要通过一个目标为自己输送动力。这便是职业规划。

     程序员首先需要提高系统设计能力。从2000年以后,软件业的编程思维和模式、方法发生了翻天覆地的转变,与九十年代、甚至2000年前是完全不同的。但 是,很多在企业工作的程序员的知识架构很难跟上。中科天博谢新华老师直率的指出:"现在很多程序员不是按照应该如何设计最好做得,而是按照我会什么来做 的,最终造成设计思想落后。现在做项目需要的是新的、巧的设计思想。我们可以将从无数次失败中得到的理念告诉他们,包括如何学习,如何思考,技术变化的原 因在哪里,其核心在哪里。这样程序员的理解力就会完全不同。现在,对程序员的要求降低了,但对系统设计的要求提高了。所以程序员必须要提高系统设计的能 力,否则永远出不了头。" 而曾经从事过宏观经济研究工作的李巨锋更喜欢从行业走向来谈问题。他说:"现在中国纯软件公司不多,但是,中国的经济非常好,从整个社会的经济和行业角度 可以得出很多有价值的内容。很多人不了解行业的需求情况,因此做不了判断。" 跟随一个快速发展的行业,就比较容易取得发展,而在一个发展缓慢的行业中成功就比较困难。当然,有了市场容量有多大和机会,并不代表一定会成功,但没有这 个因素成功的几率会更低。工作一两年的人,最关键的是要有一个方向感,不要太盲目,这就需要程序员有一定的判断力。 李巨锋认为,电信行业新增的市场容量每年有1万亿,而且由于是新增市场,人员也比较容易进入。此外,中国的手机市场非常大,由于无线应用的迅速发展,可以 预料,基于手机和电信结合的软件的就业前景就比较好,事实证明,很多人也在向这个方面转变。达内的成功与行业需求也不无关系,韩少云说:"从金融和电信行 业角度看,对软件人才的需求每年以30-50%的比例增长。熟悉这两个行业所需要的IT技术和背景的人才,需求量是最大,缺口也是最大的。" 中国的信息管理软件市场也是容易就业的市场。现在市场上有数不胜数的小管理软件公司,这是同中国社会走转型之路相关的。李巨锋说,"基于商流、资金 流、信息流、物流的行业都有相当的发展前景。通过产权交易的商流,带动资金流和信息流的发展。物流是新兴的行业,这些都需要主流的IT技术。中国的物流成 本现在是20.9%,美国是9.8%,差距非常很大,这其中有1万亿的市场容量,如果软件和信息化服务占20%的份额,也有几千亿的市场,行业需求很大 了。

    事实也证明供应链等类型的软件市场发展非常迅猛。" 而对于游戏,李巨锋认为这不能称之为一个产业,因为它不像电信那样带动很大的一个产业链,现在取得成功的只有几个游戏,而且还主要偏重销售,不是一个上下 游的产业。尽管比较热,但李巨锋认为相比来说,至少一两年内可能不会有很大的市场容量,这就需要进行判断。 李巨锋认为,已经工作两年以上的程序员可以有几种基本的职业规划:技术专家、软件架构师、实施顾问或销售。其中程序员最主要的发展方向是资深技术专家,无 论是Java还是.NET,还是数据库领域,都要首先成为专家,然后才可能继续发展为架构师。"尽管架构师的职位可以工作一辈子,待遇也非常好,对于科班 出身的程序员最为适合,但这种工作职位非常有限。"一位毕业的学员到IBM软件开发中心后,过了一年左右,开始请教其未来的发展,结合对方的情况,建议他 先深入的技术,因为在中国架构师需要的条件比较复杂,而且需求量也比较少。 实施顾问和销售就比较偏向市场了,除了一定的技术能力外,需要掌握很多IT以外的知识。这些发展方向对于从其他专业转入IT的人员更为适合。比如用友就培 养了很多实施顾问,这些人加上行业背景,收入也很高。要做行业专家,就要比自己的行业客户还了解这个产业的发展现状。李巨锋说:"比如烟草行业,一定要了 解大的趋势,中国最多的烟民在哪里,其实是在山西和辽宁,烟草行业的产业政策是什么,直接导致我的需求是什么,这些信息对于职业发展很重要。IBM的一些 顾问都是行业内的资深专家,他们的发展就非常具有代表性。" 对大多数人来说,首先是要专,在技术上做的比较深入,然后进行工作调整,把自己转变为某个领域的专家,第三步,根据自己的情况,决定自己做软件架构师还是 高级的顾问销售,另外一部分人可能就会走向行政管理,这和个人性格有关。 要获得职业成长,培训也很有帮助。韩少云说:"在北美,职业培训是一种高端的培训,即便是专业的人员也需要职业培训。一个人在一生中需要经过很多职业培训 才能成为一个资深或者专业的人员。而在国内大家的观念中,职业培训还没有被大家广泛的认同。" 对于更高级的技术人员,他们所关注的就不是解决基本的生活问题了。他们所关注的就是发展和成就感。从现在看,他们更为缺乏的是交流,尤其是和水平差不 多或者更高的人进行交流。李巨锋说:"我建议他们做一些国产的产品,做一些自主产权的技术。比如,我们还有产品开发的部门就在做国产数据库设计。" 职业规划带动更好的成长 从中国的软件开发人员的层次看,工作几年以内处于初级水平的程序员占据最大的比例,至少在50%之上,高级的人员最多也就10%左右。但无论处在哪个层 面,一定要有规划,按照自己的个性和优势做一些规划。 一个程序员的成长,学习过程中首先要读到好书,然后是交到好的学友,找到好的老师,在这三个外围的条件下,找到适合的工作环境,结合自己的特点,然后在一 些重要的环节上遇到适合的人和合适的项目,这样才能成功。有些职位可能在开始的时候不适合,但工作一段时间后,可能就可以走上更高的职位。最近,IBM软 件学院就开始做一个"软件人才库"的项目,为的就是跟踪技术人员的成长,给他们在合适的时机提供合适的职位。业内人士说:"IT行业良性的人员流动也是很 好的。"

    有了一定的职业规划,就需要补充自己缺乏的经验,只有经历过足够的项目,才有可能不断积累。对行业的判断有一定的理解之后,对一般的企业适应起来是没有问 题的,但高级的人才需要长时间的积累。 在中国,除了个人的基本技能,还需要具备一定的社会资源,行业资源和资本。学生要学会在提高智商的情况下,提高自己的情商。因为,在人和人交往中情商起很 大的作用。技术人员需要慢慢改变自己的一些思维方式。个人成长要有意识的积累社会资源,认识相关的人,了解相关的政策和行业发展的过程和规则,这些东西是 非技术的,非智商的,只要你关注就是可以得到的。我觉得最关键的就是多认识人,然后有意识的寻找合适的事情来做。情商也就需要有渠道,有多少人能够帮助 你,否则成不了。 机遇和经历对于职业的发展有相当的影响力。某些人或者某些事情都可能会影响到未来的发展。王洪超也认为成为微软MVP是自己的一个转折点,由于成为 MVP,便有机会接触更多的技术朋友和微软人,为自己的发展奠定了基础。 总而言之,每个人至少三年要点评一下自己:是环境的原因,还是自己个人的原因,如果是环境的原因,可以考虑是否需要换地方,如果知道自己,可以调整自 己或者设的目标现实一些。从一个普通的程序员做起,3年时间至少能够做到做独立需求分析和设计的。

posted @ 2009-10-16 17:41 redcoatjk 阅读(421) | 评论 (2)编辑 收藏
 
JNDI是 Java 命名与目录接口(Java Naming and Directory Interface),在J2EE规范中是重要的规范之一,不少专家认为,没有透彻理解JNDI的意义和作用,就没有真正掌握J2EE特别是EJB的知识。
那么,JNDI到底起什么作用?

要了解JNDI的作用,我们可以从“如果不用JNDI我们怎样做?用了JNDI后我们又将怎样做?”这个问题来探讨。

没有JNDI的做法:
程序员开发时,知道要开发访问MySQL数据库的应用,于是将一个对 MySQL JDBC 驱动程序类的引用进行了编码,并通过使用适当的 JDBC URL 连接到数据库。
就像以下代码这样:
  1. Connection conn=null;  
  2. try {  
  3. Class.forName("com.mysql.jdbc.Driver",true, Thread.currentThread().getContextClassLoader());  
  4. conn=DriverManager.getConnection("jdbc:mysql://MyDBServer?user=qingfeng&password=mingyue");   
  5. ......conn.close();  
  6. catch(Exception e) {  
  7. e.printStackTrace();  
  8. finally {  
  9. if(conn!=null) {  
  10. try {conn.close();  
  11. catch(SQLException e) {}  
  12. }  
  13. }  


这是传统的做法,也是以前非Java程序员(如Delphi、VB等)常见的做法。这种做法一般在小规模的开发过程中不会产生问题,只要程序员熟悉Java语言、了解JDBC技术和MySQL,可以很快开发出相应的应用程序。

没有JNDI的做法存在的问题:
1、数据库服务器名称MyDBServer 、用户名和口令都可能需要改变,由此引发JDBC URL需要修改;
2、数据库可能改用别的产品,如改用DB2或者Oracle,引发JDBC驱动程序包和类名需要修改;
3、随着实际使用终端的增加,原配置的连接池参数可能需要调整;
4、......

解决办法:
程 序员应该不需要关心“具体的数据库后台是什么?JDBC驱动程序是什么?JDBC URL格式是什么?访问数据库的用户名和口令是什么?”等等这些问题,程序员编写的程序应该没有对 JDBC 驱动程序的引用,没有服务器名称,没有用户名称或口令 —— 甚至没有数据库池或连接管理。而是把这些问题交给J2EE容器来配置和管理,程序员只需要对这些配置和管理进行引用即可。

由此,就有了JNDI。

用了JNDI之后的做法:
首先,在在J2EE容器中配置JNDI参数,定义一个数据源,也就是JDBC引用参数,给这个数据源设置一个名称;然后,在程序中,通过数据源名称引用数据源从而访问后台数据库。
具体操作如下(以JBoss为例):
1、配置数据源
在JBoss 的 D:\jboss420GA\docs\examples\jca 文件夹下面,有很多不同数据库引用的数据源定义模板。将其中的 mysql-ds.xml 文件Copy到你使用的服务器下,如 D:\jboss420GA\server\default\deploy。
修改 mysql-ds.xml 文件的内容,使之能通过JDBC正确访问你的MySQL数据库,如下:
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <datasources>  
  3. <local-tx-datasource>  
  4.     <jndi-name>MySqlDS</jndi-name>  
  5.     <connection-url>jdbc:mysql://localhost:3306/lw</connection-url>  
  6.     <driver-class>com.mysql.jdbc.Driver</driver-class>  
  7.     <user-name>root</user-name>  
  8.     <password>rootpassword</password>  
  9. <exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter</exception-sorter-class-name>  
  10.     <metadata>  
  11.        <type-mapping>mySQL</type-mapping>  
  12.     </metadata>  
  13. </local-tx-datasource>  
  14. </datasources>  

这里,定义了一个名为MySqlDS的数据源,其参数包括JDBC的URL,驱动类名,用户名及密码等。

2、在程序中引用数据源:
  1. Connection conn=null;  
  2. try {  
  3. Context ctx=new InitialContext();  
  4. Object datasourceRef=ctx.lookup("java:MySqlDS");   
  5. //引用数据源  
  6. DataSource ds=(Datasource)datasourceRef;conn=ds.getConnection();  
  7.  ......c.close();  
  8. catch(Exception e) {  
  9. e.printStackTrace();  
  10. finally {if(conn!=null) {  
  11. try {conn.close();} catch(SQLException e) { }  
  12. }  
  13. }   

直接使用JDBC或者通过JNDI引用数据源的编程代码量相差无几,但是现在的程序可以不用关心具体JDBC参数了。
在系统部署后,如果数据库的相关参数变更,只需要重新配置 mysql-ds.xml 修改其中的JDBC参数,只要保证数据源的名称不变,那么程序源代码就无需修改。

由此可见,JNDI避免了程序与数据库之间的紧耦合,使应用更加易于配置、易于部署。

JNDI的扩展:
JNDI在满足了数据源配置的要求的基础上,还进一步扩充了作用:所有与系统外部的资源的引用,都可以通过JNDI定义和引用。

所以,在J2EE规范中,J2EE 中的资源并不局限于 JDBC 数据源。引用的类型有很多,其中包括资源引用(已经讨论过)、环境实体和 EJB 引用。特别是 EJB 引用,它暴露了 JNDI 在 J2EE 中的另外一项关键角色:查找其他应用程序组件。

EJB 的 JNDI 引用非常类似于 JDBC 资源的引用。在服务趋于转换的环境中,这是一种很有效的方法。可以对应用程序架构中所得到的所有组件进行这类配置管理,从 EJB 组件到 JMS 队列和主题,再到简单配置字符串或其他对象,这可以降低随时间的推移服务变更所产生的维护成本,同时还可以简化部署,减少集成工作。外部资源”。


总结:
J2EE 规范要求所有 J2EE 容器都要提供 JNDI 规范的实现。JNDI 在 J2EE 中的角色就是“交换机” —— J2EE 组件在运行时间接地查找其他组件、资源或服务的通用机制。在多数情况下,提供 JNDI 供应者的容器可以充当有限的数据存储,这样管理员就可以设置应用程序的执行属性,并让其他应用程序引用这些属性(Java 管理扩展(Java Management Extensions,JMX)也可以用作这个目的)。JNDI 在 J2EE 应用程序中的主要角色就是提供间接层,这样组件就可以发现所需要的资源,而不用了解这些间接性。

在 J2EE 中,JNDI 是把 J2EE 应用程序合在一起的粘合剂,JNDI 提供的间接寻址允许跨企业交付可伸缩的、功能强大且很灵活的应用程序。这是 J2EE 的承诺,而且经过一些计划和预先考虑,这个承诺是完全可以实现的。
posted @ 2009-09-07 14:03 redcoatjk 阅读(114) | 评论 (0)编辑 收藏
 

使用脚本能比较稳定和安全的将数据导入导出.不会丢失.

1、数据库导出:exp 用户名/密码@实例名 file=路径/文件名.dmp owner=用户名
2、数据库导入:imp 用户名/密码@实例名 fromuser=导出时用的用户名 touser=用户名 file=路径/文件名.dmp
posted @ 2009-07-27 10:10 redcoatjk 阅读(106) | 评论 (0)编辑 收藏
 

子查询:

用子查询能解决的问题

假想你想要写一个查询来找出挣钱比陆涛的薪水还多的人。为了解决这个问题,你需要两个查询:一

 

个找出陆涛的收入,第二个查询找出收入高于陆涛的人。

你可以用组合两个查询的方法解决这个问题,放置一个查询到另一个查询中。

内查询或子查询返回一个值给外查询或主查询。使用一个子查询相当于执行两个连续查询并且用第一个

 

查询的结果作为第二个查询的搜索值。

 

子查询语法:

SELECT select_list

FROM table

WHERE expr operator

              (SELECT select_list

              FROM table);

1.子查询(内查询) 在主查询之前执行一次

2.子查询的结果被用于主查询(外查询)

首先执行子查询 (内查询) 显示子查询返回的值,然后用内查询返回的结果执行外查询,最后,执行整个查询 (包括子查询),显示相同的结果。

 

 

子查询可嵌套的位置:

子查询是一个SELECT 语句,它是嵌在

另一个 SELECT 语句中的子句。

使用子查询你可以用简单的语句构建功能强大的语句。当你需要从表中用依赖于表本身的数据选择行时

 

它们是非常有用的。

也可以放在

WHERE 子句 HAVING 子句 FROM 子句。

 

在语法中:

operator 包括比较条件,例如 >= IN

比较条件分为两个种类:单行运算符 (>, =, >=, <, <>, <=) 和多行运算符 (IN, ANY, ALL)

子查询通常涉及一个嵌套的 SELECT、子-SELECT 或内 SELECT 语句。字查询通常执行一次。并且它的输出被用于完成主或外查询的查询条件。

 

另外,子查询可以被放在 CREATE VIEW 语句中、CREATE TABLE 语句、UPDATE 语句、INSERT 语句的 INTO 子句和 UPDATE 语句的 SET 子句中。

 

使用子查询的原则:

1.       子查询放在圆括号中

2.将子查询放在比较条件的右边, 以增加可读性。

在子查询中的ORDER BY 子句不需要,除非你正在执行Top-N 分析。

Oracle8i 以前的版本中,子查询不包含 ORDER BY 子句。对一个 SELECT 语句只能用一个 ORDER BY 子句,并且如果指定了它就必须放在主 SELECT 语句的最后。从 Oracle8i 开始,ORDER BY 子句可以使用,并且在进行 Top-N 分析时是必须的。

3.在单行子查询中用单行运算符,在多行子查询中用多行运算符,

在子查询中可以使用两种比较条件:单行运算符和多行运算符。

子查询的个数:

Oracle 服务器没有强制限制子查询的数目;限制只与查询所需的缓冲区大小有关。

 

子查询的类型:

1.    单行子查询:从内 SELECT 语句只返回一行的查询

2.       多行子查询:从内 SELECT 语句返回多行的查询

3.    还有多列子查询:从内 SELECT 语句返回多列的查询。

 

单行子查询

单行子查询是从内查询返回一行的查询。在该子查询类型中用一个单行操作符

SELECT last_name, job_id

FROM employees

WHERE job_id =

(SELECT job_id

FROM employees

WHERE employee_id = 141);

 

 

SELECT  last_name, job_id, salary

FROM employees

WHERE job_id =

(SELECT  job_id  FROM  employees  WHERE  employee_id = 141)  AND  salary >(SELECT  salary  FROM  employees  WHERE  employee_id = 143);

该例子可以由三个查询块组成:外查询和两个内查询。内查询块首先被执行,产生查询结果分别为 ST_CLERK 2600。然后处理外查询块,并且使用内查询的返回值来完成它的查询条件。

两个内查询返回单个值 (分别是 ST_CLERK 2600),所以这种 SQL 语句被称为单行子查询。

注:外和内查询可以从不同的表中取得数据。

 

在子查询中使用组函数:

SELECT  last_name,  job_id,  salary

FROM  employees

WHERE  salary =

(SELECT  MIN(salary) FROM  employees);

你可以从主查询中显示数据,该主查询使用一个带组函数的单行子查询。子查询放在圆括号中并且放在比较条件的后面。

例子显示所有其薪水等于最低薪水的雇员的 last namejob ID salary MIN 组函数返回单个的值 (2500) 给外函数。

 

带子查询的HAVING 子句:

1.Oracle 服务器首先执行子查询

2.Oracle 服务器返回结果到主查询的HAVING 子句中

找出平均薪水为最低平均薪水的工作岗位。

SELECT job_id, AVG(salary)

FROM employees

GROUP BY job_id

HAVING AVG(salary) = (SELECT MIN(AVG(salary))

FROM employees

GROUP BY job_id);

 

子查询错误

使用子查询的一个常见的错误是单行子查询返回返回了多行。

SELECT employee_id, last_name

FROM employees

WHERE salary =

(SELECT MIN(salary) FROM employees  GROUP  BY  department_id);

ERROR at line 4:ORA-01427: single-rowsubqueryreturns more thanone rowERROR

子查询包含一个 GROUP BY 子句,这就暗示该子查询将返回多行,每个对应它所找到的一组,在这种情况下,子查询的结果将是 4400600025004200700017000 8300

外查询得到子查询的结果 (44006000250042007000170008300) 并且在它的 WHERE 子句中使用这些结果。WHERE 子句包含一个等号 (=) 运算符,这是一个单行比较运算符,只能使用一个值。 = 操作符不能接受来自子查询的多个值,并且因此产生错误。

为了纠正该错误,改变 = 操作为 IN

子查询的另一个常见问题是内查询没有返回行。

,子查询包含一个 WHERE 子句,推测起来,其目的是找名字为 Haas 的雇员,该语句是正确的,但在执行时选择无行返回。

没有名叫 Haas 的雇员,所以子查询无返回行,外查询得到子查询的结果 (null) 并且在 WHERE 子句中使用该结果,外查询找不到一个 job ID 等于 null 的雇员,所以也没有行返回。如果一个 job 存在 null 值,也没有返回行,因为比较两个空值还是空,因此 WHERE 子句的条件不为 true

多行子查询:

多行子查询

子查询返回多行被称为多行子查询。对多行子查询要使用多行运算符而不是单行运算符。多行运算符期待多个值。

查找各部门收入为部门最低的那些雇员。

SELECT last_name, salary, department_id

FROM employees

WHERE salary IN (SELECT MIN(salary)

FROM employees

GROUP BY department_id);

内查询先被执行,产生一个查询结果,然后主查询块处理和使用由内查询返回的值完成它的搜索条件。事实上,在 Oracle 服务器看起来主查询象是下面这样:

SELECT last_name, salary, department_id

FROM employees

WHERE salary IN (2500, 4200, 4400, 6000, 7000, 8300, 8600, 17000);

在多行子查询中使用ANY 运算符

SELECT employee_id, last_name, job_id, salary

FROM employees

WHERE salary < ANY(SELECT salaryFROM employeesWHERE job_id = 'IT_PROG')

AND  job_id <> 'IT_PROG';

ANY 运算符 (和它的同义词, SOME 运算符) 比较一个值与一个子查询返回的每一个值。幻灯片中的例子显示不是 IT 程序员的雇员,并且这些雇员的的薪水少于IT 程序员。挣钱最多的程序员的薪水是 $9,000

<ANY

posted @ 2009-07-21 10:15 redcoatjk 阅读(2811) | 评论 (0)编辑 收藏
仅列出标题
共8页: 上一页 1 2 3 4 5 6 7 8 下一页 
CALENDER
<2024年11月>
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

常用链接

留言簿(3)

随笔分类(22)

随笔档案(76)

文章分类(12)

文章档案(17)

搜索

  •  

积分与排名

  • 积分 - 249961
  • 排名 - 227

最新评论

评论排行榜


Powered By: 博客园
模板提供沪江博客