国产一区二区丝袜高跟鞋图片,美女主播一区,欧美肥婆bbw

JDBC如何操作long/long raw/blob/clob数据�c�d��

奇奇 — Mon, 08 May 2006 08:54:00 GMT

如何写long和long raw�c�d��

  代码:
     case Types.LONGVARCHAR:
                java.io.StringReader long_var =
                    new java.io.StringReader(oldval.toString());
                stmt.setCharacterStream(pos,long_var,32768);
                return;
            case Types.LONGVARBINARY:
                java.io.File os_file = new java.io.File(oldval.toString());
                if (os_file.exists() && os_file.isFile() && os_file.canRead())
                {
                    try {
                        java.io.FileInputStream long_bin =
                            new java.io.FileInputStream(os_file);
                        stmt.setBinaryStream(pos,long_bin,(int)(os_file.length()));
                    } catch (java.io.IOException ioe) {}
                }
                else
                    stmt.setNull(pos,1);
                return;
                  __________________

                  如何操作BLOB/CLOB�c�d��
                  ============================
                  操作blob/clob�Ӟ��先用select lobfld from tab where ... for
                  update�Q�取得java.sql.Blob或javq.sql.Clob�c�d��

  代码:
     stmt = prepareStatement(Database,p_query,variable_table);
            stmt.bind(variable_table);
            rset = stmt.stmt.executeQuery();
            java.sql.ResultSetMetaData rsetmeta = rset.getMetaData();
            if (rset.next())
            {
                if (rsetmeta.getColumnType(1) == java.sql.Types.LONGVARCHAR)
                {
                    java.io.Reader long_out = rset.getCharacterStream(1);
                    if (long_out != null)
                    {
                        char[] long_buf=new char[8192];
                        try {
                            int len=0;
                            java.io.FileWriter long_file = new java.io.FileWriter(os_file);
                            while((len = long_out.read(long_buf))>0)
                                long_file.write(long_buf,0,len);
                            long_file.close();
                            long_out.close();
                        }
                         catch ( java.io.IOException ioe)
                        {
                            log.println(ioe.getMessage());
                        }
                    }
                }
                else if (rsetmeta.getColumnType(1) == java.sql.Types.LONGVARBINARY)
                {
                    java.io.InputStream long_out = rset.getBinaryStream(1);
                    if (long_out != null)
                    {
                        byte[] long_buf=new byte[8192];
                        try {
                            int len=0;
                            java.io.FileOutputStream long_file = new java.io.FileOutputStream(os_file);
                            while((len = long_out.read(long_buf))>0)
                                long_file.write(long_buf,0,len);
                            long_file.close();
                            long_out.close();
                        }
                         catch ( java.io.IOException ioe)
                        {
                            log.println(ioe.getMessage());
                        }
                    }
                }
                else if (rsetmeta.getColumnType(1) == java.sql.Types.CLOB)
                {
                    java.sql.Clob clob = rset.getClob(1);
                    if (clob != null)
                    {
                        java.io.Reader long_out = clob.getCharacterStream();
                        if (long_out != null)
                        {
                            char[] long_buf=new char[8192];
                            try {
                                int len=0;
                                java.io.FileWriter long_file = new java.io.FileWriter(os_file);
                                while((len = long_out.read(long_buf))>0)
                                    long_file.write(long_buf,0,len);
                                long_file.close();
                                long_out.close();
                            }
                             catch ( java.io.IOException ioe)
                            {
                                log.println(ioe.getMessage());
                            }
                        }
                    }
                }
                else if (rsetmeta.getColumnType(1) == java.sql.Types.BLOB)
                {
                    java.sql.Blob blob = rset.getBlob(1);
                    if (blob != null)
                    {
                        java.io.InputStream long_out = blob.getBinaryStream();
                        if (long_out != null)
                        {
                            byte[] long_buf=new byte[8192];
                            try {
                                int len=0;
                                java.io.FileOutputStream long_file = new java.io.FileOutputStream(os_file);
                                while((len = long_out.read(long_buf))>0)
                                    long_file.write(long_buf,0,len);
                                long_file.close();
                                long_out.close();
                            }
                             catch ( java.io.IOException ioe)
                            {
                                log.println(ioe.getMessage());
                            }
                        }
                    }
                }
                data = getMessage(jdbc_cfg,"JDBC.COMMAND.COMPLETED");
                log.println(data.getColumn(1));
            }
            else
            {
                log.println("0 "+jdbc_cfg.getNLSString("JDBC.COMMAND.ROWSSELECTED"));
            }
                  __________________

奇奇 2006-05-08 16:54 发表评论

Java的输入输出流

奇奇 — Mon, 08 May 2006 08:52:00 GMT

Java语言的输入输出功能是十分强大而灵�zȝ��Q�美中不��的是看上去输入输出的代码�ƈ不是很简�z�，因�ؓ你往往需要包装许多不同的对象。在Java�c�d��中，IO部分的内�Ҏ(gu��)��很庞大的�Q�因为它涉及的领域很�q�泛:标准输入输出�Q�文件的操作�Q�网�l�上的数据流�Q�字�W�串��，对象��，zip文�g��?...本文的目的是为大家做一个简要的介绍�?/p>

　　��是一个很形象的概念，当程序需要读取数据的时候，��׃��开启一个通向数据源的��，�q�个数据源可以是文�g�Q�内存，或是�|�络�q�接。类似的�Q�当�E�序需要写入数据的时候，��׃��开启一个通向目的地的��。这时候你��可以想象数据好像在�q�其中“流”动一��P��如下图：

　　Java中的��分��Z��U�，一�U�是字节��，另一�U�是字符��，分别由四个抽象类来表�C�（每种��包括输入和输出两种所以一共四个）:InputStream�Q�OutputStream�Q�Reader�Q�Writer。Java中其他多�U�多样变化的��均是由它们�z��出来�?

　　在这其中InputStream和OutputStream在早期的Java版本中就已经存在了，它们是基于字节流的，而基于字�W�流的Reader和Writer是后来加入作��充的。以上的层次图是Java�c�d��中的一个基本的层次体系�?/p>

　　在这四个抽象�c�M��Q�InputStream和Reader定义了完全相同的接口�Q?/p>

int read�Q�）
int read�Q?font color="#0000ff">char cbuf[]�Q?br />int read�Q?font color="#0000ff">char cbuf[], int offset, int length�Q?/span>

　　而OutputStream和Writer也是如此�Q?/p>

int write�Q?font color="#0000ff">int c�Q?br />int write�Q?font color="#0000ff">char cbuf[]�Q?br />int write�Q?font color="#0000ff">char cbuf[], int offset, int length�Q?/span>

　　�q�六个方法都是最基本的，read�Q�）和write�Q�）通过�Ҏ(gu��)��的重载来��d��一个字节，或者一个字节数�l��?/p>

　　更多灉|��多变的功能是由它们的子类来扩充完成的。知道了Java输入输出的基本层�ơ结构以后，本文在这里想�l�大家一些以后可以反复应用例子，对于所有子�cȝ��l�节及其功能�q�不详细讨论�?/p>

import java.io.*�Q?/span>

public class IOStreamDemo {

public void samples�Q�） throws IOException {

           //1. �q�是从键盘读入一行数�?�q�回的是一个字�W�串
           BufferedReader stdin =new BufferedReader�Q�new InputStreamReader�Q�System.in�Q�）�Q?
           System.out.print�Q?font color="#ff00ff">"Enter a line:"�Q�；
           System.out.println�Q�stdin.readLine�Q�）�Q�；

//2. �q�是从文件中逐行��d��数据

BufferedReader in = new BufferedReader�Q?font color="#0000ff">new FileReader�Q?font color="#ff00ff">"IOStreamDemo.java"�Q�）�Q?br /> String s, s2 = new String�Q�）�Q?br /> while�Q�（s = in.readLine�Q�）�Q?= null�Q?br /> s2 += s + "\n"�Q?br /> in.close�Q�）�Q?br />

           //3. �q�是从一个字�W�串中逐个��d��字节
           StringReader in1 = new StringReader�Q�s2�Q�；
           int c�Q?br />           while�Q�（c = in1.read�Q�）�Q?!= -1�Q?br />                      System.out.print�Q�（char�Q�c�Q�；

           //4. �q�是��一个字�W�串写入文�g
           try {
                      BufferedReader in2 = new BufferedReader�Q�new StringReader�Q�s2�Q�）�Q?br />                      PrintWriter out1 = new PrintWriter�Q�new BufferedWriter�Q�new FileWriter�Q?font color="#ff00ff">"IODemo.out"�Q�）�Q�；
                      int lineCount = 1�Q?br />                      while�Q�（s = in2.readLine�Q�）�Q?!= null �Q?br />                                 out1.println�Q�lineCount++ + ": " + s�Q�；
                      out1.close�Q�）�Q?br />           } catch�Q�EOFException e�Q?{
                      System.err.println�Q?font color="#ff00ff">"End of stream"�Q�；
           }
      }

}

　　对于上面的例子，需要说明的有以下几点：

　　1. BufferedReader�?font color="#ff0000">Reader的一个子�c�，它具有缓冲的作用�Q�避免了频繁的从物理讑֤�中读取信息。它有以下两个构造函敎ͼ�

BufferedReader �Q?font color="#0000ff">Reader in�Q?
BufferedReader�Q?font color="#0000ff">Reader in, int sz�Q?

　　�q�里的sz是指定缓冲区的大��?/p>

　　它的基本�Ҏ(gu��)��Q?/p>

void close�Q?/font>�Q?//关闭��?

           void mark�Q�int readAheadLimit�Q?font color="#006600"> //标记当前位置

           boolean markSupported�Q�） //是否支持标记

           int read�Q�） //�l�承自Reader的基本方�?/font>

           int read�Q?font color="#0000ff">char[] cbuf, int off,int len�Q?//�l�承自Reader的基本方�?/font>

           String readLine�Q�） //��d��一行内容�ƈ以字�W�串形式�q�回

           boolean ready�Q�） //判断��是否已�l�做好读入的准备

           void reset�Q�） //重设到最�q�的一个标�?/font>

           long skip�Q?font color="#0000ff">long n�Q?//跌��指定个数的字�W�读�?/font>

　　2. InputStreamReader�?font color="#000000">InputStream�?font color="#000000">Reader之间的桥梁，�׃��System.in是字节流�Q�需要用它来包装之后变�ؓ字符��供�l? BufferedReader使用�?br />

　　3. PrintWriter out1 = new PrintWriter�Q?font color="#0000ff">new BufferedWriter�Q?font color="#0000ff">new FileWriter�Q?font color="#ff00ff">"IODemo.out"�Q�）�Q�；

　　�q�句话体��C��Java输入输出�pȝ��的一个特点，��Z��辑ֈ�某个目的�Q�需要包装好几层。首先，输出目的地是文�gIODemo.out�Q�所以最内层包装的是FileWriter�Q�徏立一个输出文件流�Q�接下来�Q�我们希望这个流是缓冲的�Q�所以用BufferedWriter来包装它以达到目的，最后，我们需要格式化输出�l�果�Q�于是将PrintWriter包在最外层�?br />

　　Java提供了这样一个功能，��标准的输入输出��{向，也就是说�Q�我们可以将某个其他的流设�ؓ标准输入或输出流�Q�看下面�q�个例子�Q?/p>

import java.io.*�Q?/span>

public class Redirecting {

       public static void main�Q?font color="#0000ff">String[] args�Q?throws IOException {
              PrintStream console = System.out�Q?br />              BufferedInputStream in = newBufferedInputStream�Q?new FileInputStream�Q?"Redirecting.java"�Q�）�Q?br />              PrintStream out = newPrintStream�Q?new BufferedOutputStream�Q?font color="#0000ff"> new FileOutputStream�Q?font color="#ff00ff">"test.out"�Q�）�Q�；
              System.setIn�Q�in�Q�；
              System.setOut�Q�out�Q�；

              BufferedReader br = newBufferedReader�Q?newInputStreamReader�Q�System.in�Q�）�Q?br />              String s�Q?br />              while�Q�（s = br.readLine�Q�）�Q?!= null�Q?br />                     System.out.println�Q�s�Q�；
              out.close�Q�）�Q?
              System.setOut�Q�console�Q�；
      }
}

　　在这里java.lang.System的静态方�?/p>

static void setIn�Q�InputStream in�Q?
static void setOut�Q�PrintStream out�Q?

　　提供了重新定义标准输入输出流的方法，�q�样做是很方便的�Q�比如一个程序的�l�果有很多，有时候甚臌��页昄��Q�这样不便于观看�l�果�Q�这是你��可以将标准输出��定义�ؓ一个文件流�Q�程序运行完之后打开相应的文件观看结果，��q��观了许多�?/p>

　　Java��有着另一个重要的用途，那就是利用对象流对对象进行序列化。下面将开始介�l�这斚w��的问题�?/p>

　　在一个程序运行的时候，其中的变量数据是保存在内存中的，一旦程序结束这些数据将不会被保存，一�U�解决的办法是将数据写入文�g�Q�而Java中提供了一�U�机�Ӟ��它可以将�E�序中的对象写入文�g�Q�之后再从文件中把对象读出来重新建立。这��是所谓的对象序列化Java中引入它主要是�ؓ了RMI�Q�Remote Method Invocation�Q�和Java Bean所用，不过在��^时应用中�Q�它也是很有用的一�U�技术�?/p>

　　所有需要实现对象序列化的对象必��首先实现Serializable接口。下面看一个例子：

import java.io.*�Q?br />import java.util.*�Q?/span>

public class Logon implements Serializable {

private Date date = new Date�Q�）�Q?br /> private String username�Q?br /> private transient String password�Q?/p>

Logon�Q?font color="#0000ff">Stringname, String pwd�Q?{
username = name�Q?br /> password = pwd�Q?br /> }

public String toString�Q�） {
String pwd = �Q�password == null�Q?? "�Q�n/a�Q? : password�Q?br /> return "logon info: \n " + "username: " + username + "\n date: " + date + "\n password: " + pwd�Q?br /> }

       public static void main�Q?font color="#ff0000">String[] args�Q?throws IOException, ClassNotFoundException {
              Logon a = new Logon�Q?font color="#ff00ff">"Morgan", "morgan83"�Q�；
              System.out.println�Q?"logon a = " + a�Q�；
              ObjectOutputStream o = newObjectOutputStream�Q?newFileOutputStream�Q?font color="#ff00ff">"Logon.out"�Q�）�Q?br />              o.writeObject�Q�a�Q�；
              o.close�Q�）�Q?/p>

              int seconds = 5�Q?br />              long t = System.currentTimeMillis�Q�） + seconds * 1000�Q?br />              while�Q?font color="#ff0000">System.currentTimeMillis�Q�） < t�Q?�Q?br />
              ObjectInputStream in = new ObjectInputStream�Q?newFileInputStream�Q?font color="#ff00ff">"Logon.out"�Q�）�Q?br />              System.out.println�Q?"Recovering object at " + new Date�Q�）�Q�；
              a = �Q�Logon�Q�in.readObject�Q�）�Q?br />              System.out.println�Q?font color="#ff00ff">"logon a = " + a�Q�；
       }
}

　　�c�Logon是一个记录登录信息的�c�，包括用户名和密码。首先它实现了接口Serializable�Q�这��标志着它可以被序列化。之后再main�Ҏ(gu��)��?font color="#ff0000">ObjectOutputStream o = newObjectOutputStream�Q?newFileOutputStream�Q?font color="#ff00ff">"Logon.out"�Q�）�Q�新��Z��个对象输出流包装一个文件流�Q�表�C�对象序列化的目的地是文件Logon.out。然后用�Ҏ(gu��)��writeObject开始写入。想要还原的时候也很简�?font color="#ff0000">ObjectInputStream in = newObjectInputStream�Q?newFileInputStream�Q?font color="#ff00ff">"Logon.out"�Q�）�Q�新��Z��个对象输入流以文件流Logon.out为参敎ͼ�之后调用readObject�Ҏ(gu��)��可以了�?/p>

　　需要说明一点，对象序列化有一个神奇之处就是，它徏立了一张对象网�Q�将当前要序列化的对象中所持有的引用指向的对象都包含�v来一起写入到文�g�Q�更为奇妙的是，如果你一�ơ序列化了好几个对象�Q�它们中相同的内容将会被�׃�n写入。这的确是一个非常好的机制。它可以用来实现深层拯��?/p>

　　关键字transient在这里表�C�当前内容将不被序列化，比如例子中的密码�Q�需要保密，所以没有被写入�?/p>

奇奇 2006-05-08 16:52 发表评论

奇奇 — Wed, 04 Jan 2006 09:54:00 GMT

11、写java�E�序�Ӟ��你随时可以System.out.println("things");只要你想打印�?BR>12、JDK:Java Developer's Kit
13�?A >http://www.bruceeckel.com/
14、sdk安装后，要设�|�path和java_home环境变量
Java 2环境变量的设�|�如下例所�C?
Solaris�q�_��: setenv JAVA_HOME Java2的安装�\�?
setenv PATH $JAVA_HOME/bin:${PATH}
Windows�q�_��: set JAVA_HOME=Java2的安装�\�?
set PATH=$JAVA_HOMEbin;%PATH%
15、javadoc�q�个提取注释的工��P��会输出HTML文�g�Q�自动生成一份文�?BR>开始：/**
�l�束�Q?/
两种用法�Q�嵌入式的HTML和用“文档标记@(doc tags)�?BR>16、对象的赋��|��实际上是在拷贝它的reference。如�Q�n1=n2;�q�时n1、n2指向同一个对象。原先的reference被覆盖，指向的对象被清除。这�U�现象被�U�Cؓaliasing�Q�别名效应）
17、正则表辑ּ� -?\\d+ “前面可能有一个减��P��后面跟着一串阿拉伯数字�?BR>阿拉伯数字用‘\d’表�C�，但是必须再加一个反斜杠才能把它转义��Z��个反斜杠�?BR>18、have a cookie。递增�q�算�W�也是C++命名的原因之一�Q�它的寓意是“比C更进一步”，Bill Joy(Sun 的创��之一�Q�说�Q�“java=C++--�?他的意思是�Q�java 是一�U�去除了C++中多余的复杂性的语言�?BR>19�?=�?=比较的是对象的reference�Q�即使对象的内容相同�Q�但是reference是不同的话，比较也是不等的�?BR>要想比较两个对象的实际内容，可以用equals()�Ҏ(gu��)��。但是对于自己创建的�c�，必须重新复写equals()�Q�因为它的缺省行为是比较reference�?BR>20、处理逻辑�q�算�W�的时候会��到一�U�叫“短接”，只要能准��的知道整个表达式是真是假，��q��d��出判断，无需计算逻辑表达式的后半部分�?BR>21、在java里，唯一能放标签的地�Ҏ(gu��)��在��@环语句的外面。而且必须直接�䏀�—在循环语句和标�{�之间不能有��M��东西。continue label会在中断内部循环的同时中断外部��@环，在一气退到l(f��)abel�Q�然后从头开始执行��@环，但是�q�次是从外部开始；break label也会退到l(f��)abel�Q�但是它不会在进入��@环。实际上它是同时退��Z��个��@环�?BR>

奇奇 2006-01-04 17:54 发表评论

奇奇 — Wed, 04 Jan 2006 07:35:00 GMT

1、OOP: 面向对象的编�E?Object_Oriented Programming)

2、抽象的�q�程�Q�对机器建模-〉对问题建模-〉面向对象的�Ҏ(gu��)��
机器模型“解决空间”；待解决的问题的模型“问题空间�?BR>
3、我们将问题�I�间的元素同它在解决�I�间的表�q�称为“对象”�?BR>对象有状态、行为和标识�?BR>
4、HTML:HyperText Markup Language

5、CGI:通用�|�关接口(Common Gateway Interface)

6、Sun Microsystems的Java语言和类库（可从java.sun.com自由下蝲�Q�会附带一份可以用Web��览器阅�ȝ��?sh��)子文档�?BR>
7、数据存在哪里？
1)寄存�?registers),�q�是反映最快的存储。因为它的位�|�在存储器里�?BR>2)栈（stack),位于常规内存区，处理器通过栈指针直接访问。栈指针向下�U�d��创��Z��新的存储�I�间�Q�向上移动就释放内存�I�间。java把某些数据，别是对象的refernce存放在栈里，但对象本�w��ƈ没有攑֜�栈里�?BR>3)�?heap),�q�是一�D�“多用途的内存池”，也在内存里面。所有java对象都保存在�q�里。分配堆的存储空间要比分配栈的慢一些。new来创建�?BR>4)静态存�?static storage),“在固定的位�|�”（��管它还是在RAM里面�Q�，用static关键词来指明。但java对象本��n是绝不会攑ֈ�静态存储中�ȝ��?BR>5)固定存储�Q�constant storage),帔R��倹{�?BR>6)非内存的存储(Non-RAM storage),完全独立于程序，即�ɽE�序失去了对数据的控�Ӟ��它也仍然�q�在。“流对象”：会被送往另一台机器的�Q�由对象转化而成的字节流�Q�“persistent对象”：保存在磁盘上的，能在�E�序中止之后仍保存在其他介质上的东西�?BR>
8、特例：primitive�c�d��“非reference的自动变量”�?BR>primitive�c�d��               Wrapper�c�d��
boolean                          Boolean
char                               Character
byte                               Byte
short                               Short
int                                  Integer
long                               Long
float                               Float
double                           Double
void                               Void

9、两�U�方法可以引用static变量�?)通过一个对象st1.i�Q?)直接用类的名字StaticTest.i。静态方法的思�\也差不多�?BR>class StaticTest{
static int i=47;
}
StaticTest st1=new StaticTest();
10、有一个类库java.lang会被自动的引入所有java文�g�?/P>

javac *.java
java *
appletviewer *.html

code =*.class width=100 height=100>

奇奇 2006-01-04 15:35 发表评论