import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;

//生成等比例高质量缩略图
public class ThumbnailUtil {
 private static int width;
 private static int height;
 private static int scaleWidth;
 static double support = (double) 3.0;
 static double PI = (double) 3.14159265358978;
 static double[] contrib;
 static double[] normContrib;
 static double[] tmpContrib;
 static int startContrib, stopContrib;
 static int nDots;
 static int nHalfDots;

 public static void saveImage(String fromFileStr, String saveToFileStr, int formatWidth, int formatHeight) throws Exception {
  File saveFile = new File(saveToFileStr);
  File fromFile = new File(fromFileStr);
  saveImage(fromFile, saveFile, formatWidth, formatHeight);
 }
 
 public static void saveImage(File fromFile  , File saveFile, int formatWidth, int formatHeight) throws Exception {
  BufferedImage srcImage;
  srcImage = javax.imageio.ImageIO.read(fromFile); // construct image
  int imageWidth = srcImage.getWidth(null);
  int imageHeight = srcImage.getHeight(null);
  int changeToWidth = 0;
  int changeToHeight = 0;
  if (formatWidth > 0 && formatHeight > 0) {
   changeToWidth = formatWidth;
   changeToHeight = formatHeight;
  } else {
   if (imageWidth > 0 && imageHeight > 0) {
    if (imageWidth / imageHeight >= formatWidth / formatHeight) {
     if (imageWidth > formatWidth) {
      changeToWidth = formatWidth;
      changeToHeight = (imageHeight * formatWidth) / imageWidth;
     } else {
      changeToWidth = imageWidth;
      changeToHeight = imageHeight;
     }
    } else {
     if (imageHeight > formatHeight) {
      changeToHeight = formatHeight;
      changeToWidth = (imageWidth * formatHeight) / imageHeight;
     } else {
      changeToWidth = imageWidth;
      changeToHeight = imageHeight;
     }
    }
   }
  }
  
  srcImage = imageZoomOut(srcImage, changeToWidth, changeToHeight);
  ImageIO.write(srcImage, "JPEG", saveFile);
 }

 public static BufferedImage imageZoomOut(BufferedImage srcBufferImage, int w, int h) {
  width = srcBufferImage.getWidth();
  height = srcBufferImage.getHeight();
  scaleWidth = w;

  if (DetermineResultSize(w, h) == 1) {
   return srcBufferImage;
  }
  CalContrib();
  BufferedImage pbOut = HorizontalFiltering(srcBufferImage, w);
  BufferedImage pbFinalOut = VerticalFiltering(pbOut, h);
  return pbFinalOut;
 }

 /**
  * 决定图像尺寸
  */
 private static int DetermineResultSize(int w, int h) {
  double scaleH, scaleV;
  scaleH = (double) w / (double) width;
  scaleV = (double) h / (double) height;
  // 需要判断一下scaleH，scaleV，不做放大操作
  if (scaleH >= 1.0 && scaleV >= 1.0) {
   return 1;
  }
  return 0;

 }

 private static double Lanczos(int i, int inWidth, int outWidth, double Support) {
  double x;

  x = (double) i * (double) outWidth / (double) inWidth;

  return Math.sin(x * PI) / (x * PI) * Math.sin(x * PI / Support)
    / (x * PI / Support);

 }

 private static void CalContrib() {
  nHalfDots = (int) ((double) width * support / (double) scaleWidth);
  nDots = nHalfDots * 2 + 1;
  try {
   contrib = new double[nDots];
   normContrib = new double[nDots];
   tmpContrib = new double[nDots];
  } catch (Exception e) {
   System.out.println("init contrib,normContrib,tmpContrib" + e);
  }

  int center = nHalfDots;
  contrib[center] = 1.0;

  double weight = 0.0;
  int i = 0;
  for (i = 1; i <= center; i++) {
   contrib[center + i] = Lanczos(i, width, scaleWidth, support);
   weight += contrib[center + i];
  }

  for (i = center - 1; i >= 0; i--) {
   contrib[i] = contrib[center * 2 - i];
  }

  weight = weight * 2 + 1.0;

  for (i = 0; i <= center; i++) {
   normContrib[i] = contrib[i] / weight;
  }

  for (i = center + 1; i < nDots; i++) {
   normContrib[i] = normContrib[center * 2 - i];
  }
 }

 // 处理边缘
 private static void CalTempContrib(int start, int stop) {
  double weight = 0;

  int i = 0;
  for (i = start; i <= stop; i++) {
   weight += contrib[i];
  }

  for (i = start; i <= stop; i++) {
   tmpContrib[i] = contrib[i] / weight;
  }

 }

 private static int GetRedValue(int rgbValue) {
  int temp = rgbValue & 0x00ff0000;
  return temp >> 16;
 }

 private static int GetGreenValue(int rgbValue) {
  int temp = rgbValue & 0x0000ff00;
  return temp >> 8;
 }

 private static int GetBlueValue(int rgbValue) {
  return rgbValue & 0x000000ff;
 }

 private static int ComRGB(int redValue, int greenValue, int blueValue) {

  return (redValue << 16) + (greenValue << 8) + blueValue;
 }

 // 行水平滤波
 private static int HorizontalFilter(BufferedImage bufImg, int startX, int stopX,
   int start, int stop, int y, double[] pContrib) {
  double valueRed = 0.0;
  double valueGreen = 0.0;
  double valueBlue = 0.0;
  int valueRGB = 0;
  int i, j;

  for (i = startX, j = start; i <= stopX; i++, j++) {
   valueRGB = bufImg.getRGB(i, y);

   valueRed += GetRedValue(valueRGB) * pContrib[j];
   valueGreen += GetGreenValue(valueRGB) * pContrib[j];
   valueBlue += GetBlueValue(valueRGB) * pContrib[j];
  }

  valueRGB = ComRGB(Clip((int) valueRed), Clip((int) valueGreen),
    Clip((int) valueBlue));
  return valueRGB;

 }

 // 图片水平滤波
 private static BufferedImage HorizontalFiltering(BufferedImage bufImage, int iOutW) {
  int dwInW = bufImage.getWidth();
  int dwInH = bufImage.getHeight();
  int value = 0;
  BufferedImage pbOut = new BufferedImage(iOutW, dwInH,
    BufferedImage.TYPE_INT_RGB);

  for (int x = 0; x < iOutW; x++) {

   int startX;
   int start;
   int X = (int) (((double) x) * ((double) dwInW) / ((double) iOutW) + 0.5);
   int y = 0;

   startX = X - nHalfDots;
   if (startX < 0) {
    startX = 0;
    start = nHalfDots - X;
   } else {
    start = 0;
   }

   int stop;
   int stopX = X + nHalfDots;
   if (stopX > (dwInW - 1)) {
    stopX = dwInW - 1;
    stop = nHalfDots + (dwInW - 1 - X);
   } else {
    stop = nHalfDots * 2;
   }

   if (start > 0 || stop < nDots - 1) {
    CalTempContrib(start, stop);
    for (y = 0; y < dwInH; y++) {
     value = HorizontalFilter(bufImage, startX, stopX, start,
       stop, y, tmpContrib);
     pbOut.setRGB(x, y, value);
    }
   } else {
    for (y = 0; y < dwInH; y++) {
     value = HorizontalFilter(bufImage, startX, stopX, start,
       stop, y, normContrib);
     pbOut.setRGB(x, y, value);
    }
   }
  }

  return pbOut;

 }

 private static int VerticalFilter(BufferedImage pbInImage, int startY, int stopY,
   int start, int stop, int x, double[] pContrib) {
  double valueRed = 0.0;
  double valueGreen = 0.0;
  double valueBlue = 0.0;
  int valueRGB = 0;
  int i, j;

  for (i = startY, j = start; i <= stopY; i++, j++) {
   valueRGB = pbInImage.getRGB(x, i);

   valueRed += GetRedValue(valueRGB) * pContrib[j];
   valueGreen += GetGreenValue(valueRGB) * pContrib[j];
   valueBlue += GetBlueValue(valueRGB) * pContrib[j];
  }

  valueRGB = ComRGB(Clip((int) valueRed), Clip((int) valueGreen), Clip((int) valueBlue));
  
  return valueRGB;

 }

 private static BufferedImage VerticalFiltering(BufferedImage pbImage, int iOutH) {
  int iW = pbImage.getWidth();
  int iH = pbImage.getHeight();
  int value = 0;
  BufferedImage pbOut = new BufferedImage(iW, iOutH,
    BufferedImage.TYPE_INT_RGB);

  for (int y = 0; y < iOutH; y++) {

   int startY;
   int start;
   int Y = (int) (((double) y) * ((double) iH) / ((double) iOutH) + 0.5);

   startY = Y - nHalfDots;
   if (startY < 0) {
    startY = 0;
    start = nHalfDots - Y;
   } else {
    start = 0;
   }

   int stop;
   int stopY = Y + nHalfDots;
   if (stopY > (int) (iH - 1)) {
    stopY = iH - 1;
    stop = nHalfDots + (iH - 1 - Y);
   } else {
    stop = nHalfDots * 2;
   }

   if (start > 0 || stop < nDots - 1) {
    CalTempContrib(start, stop);
    for (int x = 0; x < iW; x++) {
     value = VerticalFilter(pbImage, startY, stopY, start, stop,
       x, tmpContrib);
     pbOut.setRGB(x, y, value);
    }
   } else {
    for (int x = 0; x < iW; x++) {
     value = VerticalFilter(pbImage, startY, stopY, start, stop,
       x, normContrib);
     pbOut.setRGB(x, y, value);
    }
   }

  }

  return pbOut;

 }

 static int Clip(int x) {
  if (x < 0)
   return 0;
  if (x > 255)
   return 255;
  return x;
 }
}

1.小强每天在村里晃悠，爹妈看着发愁，心想这孩子将来怎么办呀；小明每日都苦读诗书，父母喜在心里，村里人都认定他必有出息。
2.那年，小强和小明都是十九岁。小强跟着村里的外出打工，来到了高速公路的工地，保底工资三千块；小明考上了一所重点大学，读的是道路与桥梁专业，学费每年五千多。
3.那年，小强和小明都是二十三岁。小强的爹妈给他说个巧媳妇，是邻村的，特别贤惠；小明在大学里谈了个女朋友，是邻校的，很有文化。
4.那年，小强和小明都是二十四岁。小强在老家结了婚，把媳妇带到工地上，来给他洗衣做饭，恩爱有加；小明终于大学毕业，找了施工单位工作，跟女友分居两地，朝思暮想。
5.小强每天很快乐，下了班就没事，吃了饭和媳妇散散步，晚上便和工友打麻将看电视；小明每天很忙碌，白天跑遍工地，晚上还做资料画图纸，好久不见的女友跟他分手了。
6.那年，小强和小明都是二十八岁。小强攒下了二十万，已是两个娃娃的爹，心想着回家盖栋漂亮的楼房；小明过了中级职称，还是单身一个人过，心想着再干几年就是高级了。
7.小强在农村老家盖了两层小楼，装修很漂亮，剩的钱买了一群猪仔，让媳妇回家种地养猪；小明在城里贷款买了一套新房，按揭三千多，父母给介绍了新女朋友，在城里上班很少见面。
8. 那年，小强和小明都是三十一岁。小强媳妇从老家打电话来说：小强，现在家里有房有存款，咱喂喂猪，种种地，很幸福了，家里不能没有男人，你快回来吧；小明媳妇从城里打电话来说：小明，小孩的借读费要十五万呢，家里没有存款了，你看能不能找公司借点。
9.小强听了媳妇的话，离开了工地，回老家跟老婆一起养猪，照顾父母小孩；小明听了妻子的话，更努力工作，去了偏远又艰苦的工地，很难回家一次。
10.那年，小强和小明都是三十五岁。猪肉价格疯涨，小强的一大圈猪成了宝贝，一年赚了十几万；通货膨胀严重，小明的公司很难接到项目，很多人都待岗了。
11.那年，小强和小明都是五十岁了。小强已是三个孙子的爷爷，天天晒着太阳抽着旱烟在村里转悠；小明已是高级路桥工程师，天天顶着太阳皱着眉头在工地检查。
12.那年，小强和小明都是六十岁了。小强过六十大寿，老伴说：一家团圆多好呀，家里的事就让娃们操心吧，外面有啥好玩的地方咱出去转转；小明退休摆酒席，领导说：回家歇着没意思，返聘回单位做技术顾问吧，工地上有什么问题您给指导指导。
13.小强病了一场，小强拉着老伴的手说：我活了快七十岁了，有儿有孙的，知足了；小明病了一场，小明抚着妻子的手说：我在外工作几十年，让你受苦了，对不起。
14.……由于长期体力劳动，吃的是自家种的菜、养的猪，小强身体一直很硬朗，慢慢就恢复了。由于长期熬夜加班、小明喝酒应酬、工地食堂饭菜也很差，身上落下很多毛病，很快就去世了。
15.八十岁的小强蹲在村头抽着旱烟袋，看着远远的山；远远的山上有一片公墓，小明已在那里静静睡去；小强在鞋底磕磕烟灰，拄着拐杖站起身，望了望那片公墓，自言自语地说：唉，都是一辈子呀……
谨以此向工作在大城市，付出了青春、爱情、亲情甚至生命的人。
人的一生很短暂，希望大家给自己多一些时间，给家人多一些关爱

关键词位置、密度、处理

首先在PL/Sql中分别执行：

create or replace and compile java source named TestJava1 as 
public class TestJava1 
{ 
  public static void test() 
  { 
   System.out.println("Hello"); 
  } 
}

create or replace procedure testJava1 as language java name 'TestJava1.test()';

---------------------------------------------------------------------------------------------------------

在SQLPlus中

C:\Windows\System32>sqlplus nc5520110105/nc5520110105@192.168.10.87

SQL*Plus: Release 11.2.0.1.0 Production on Fri Apr 1 14:06:02 2011

Copyright (c) 1982, 2010, Oracle.  All rights reserved.

Connected to:
Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - 64bit Production
With the Partitioning, OLAP and Data Mining options

SQL> set serveroutput on;
SQL> show serveroutput;
serveroutput ON SIZE UNLIMITED FORMAT WORD_WRAPPED
SQL> call dbms_java.set_output(2000);

Call completed.

SQL>
SQL> show serveroutput;
serveroutput ON SIZE UNLIMITED FORMAT WORD_WRAPPED
SQL> exec testJava1();
Hello

PL/SQL procedure successfully completed.

SQL>

---------------------------------------------------------------------------------------------------------

再看一个例子：

在PL/Sql中执行：

SQL> set serveroutput on
SQL> DECLARE a INTEGER;
  2  BEGIN
  3  myProc(1, 2, a);
  4  DBMS_OUTPUT.PUT_LINE(a);
  5  END;
  6  /
3

PL/SQL procedure successfully completed.

SQL> select myFunc(1,2) from dual;

MYFUNC(1,2)
-----------
          3

SQL>