语源科技BlogJava-笑着生活

[导入]IO流（1）

999 — Tue, 09 Jun 2009 05:41:00 GMT

输入流和输出流：往程序中读入的流就是输入流（InputStream和Reader的子类），从程序写出到其他介质的流就是输出流（OutputStream和Writer的子类）。

节点流和处理流：节点流为直接操作外部介质的类如FileOutputStream，FileInputStream，FileWriter，FileReader等。处理流为套接在节点流上的流如缓冲流BufferedInputStream，BufferReader，数据流DateInputStream，DateOutputStream，转换流InputStreamReader。

字节流和字符流：以stream结尾的都为字节流。

范围：ascll：0-126 unicode：0-65535

原来很多国家和地区都有自己的编码：gbk，gb2312等，不统一。Unicode则统一了全世界文字的编码，一个字符占两个字节。

java中用的是unicode，一个字符占两个字节，16位.

char（字符）类型使用国际通用的16位Unicode字符集，所以能自动表达大多数国家的字符。

String 字串里的每个字符都是16位，或者说2个字节、长整数，以便提供对Unicode字符的支持。

Java所提供的所有流类型位于包java.io内，且都分别继承自以下四种抽象流类型。

简单理解这四个抽象类就是：写出，读入（写出，读入都是以程序为参考物的）

区别：InputStream的int read（）方法的返回值范围为0-255（字节）

Reader的int read（）方法的返回值范围为0-65535（字符）

OutputStream和Writer的write（）方法的区别看API，写得很详细。

下面分别介绍这四个抽象类：

InputStream：继承自InputStream的流都是用于向程序中输入数据，且数据的单位为字节（8bit）[这些类中的read（）方法获取的都是unicode码（两字节，16位），因此对于ascll码中的字符可以正确读取，因为他们的unicode码和ascll 码是一样的（unicode码前一个字节为0，后一个字节则为相应的ascll码）。但是不能读取汉字，因为汉字的unicode码大于256，占两个字节].

OutputStream：继承自OutputStream的流都是用于向程序中输出数据，且数据的单位为字节（8bit）

Reader：继承自Reader的流都是用于向程序中输入数据，且数据的单位为字符（16bit）

Writer：继承自Writer的流都是用于程序中输出数据，且数据的单位为字符（16bit）

以上为对IO的总体概述，后续会写出一些类的例子。

文章来源:http://java999.blog.51cto.com/259217/159843

999 2009-06-09 13:41 发表评论

[导入]IO流（2）

999 — Tue, 09 Jun 2009 05:41:00 GMT

ByteArrayToDataStream.java

public class ByteArrayToDataStream {

  public static void main(String[] args) {
    // 节点流（节点对象为字节数组）
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    //数据处理流，套接在字节数组节点流上。方便写数据
    DataOutputStream dos = new DataOutputStream(baos);
    try {
      //由于套接了数据处理流，所以可以直接写long，double类型数据
      dos.writeLong(999999999999999L);
      dos.writeDouble(Math.random());
      ByteArrayInputStream bais = new ByteArrayInputStream(baos
          .toByteArray());
      //数据处理流，套接在字节数组节点流上。方便读数据
      DataInputStream dis = new DataInputStream(bais);
      System.out.println(dis.readLong());
      System.out.println(dis.readDouble());
      dos.close();
      dis.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

TestBufferedReader.java

/**
* Title:TestBufferedReader.java
* Description:BufferedReader为处理缓冲流，其中的readline（）
*                         方法很好用，经常套接在别的节点流上使用。
*
* @author winwin
* @version 1.0
* @since May 20, 20092:55:21 PM
*/
public class TestBufferedReader {

  public static void main(String[] args) {
    try {
      //创建一个文件节点输入流
      FileReader fr = new FileReader("d:\\test.txt");
      //创建一个处理缓冲流
      BufferedReader br = new BufferedReader(fr);
      String string = null;
      while((string=br.readLine())!=null){
        System.out.println(string);
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

TestByteArryStream.java

public class TestByteArryStream {

  public static void main(String[] args) {
    //节点流，节点为字符数组，存储在内存中
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ByteArrayInputStream bis = null;
    int a = 0;
    byte[] bytes = {'a','b','c','1','2','3'};
    try {
      bos.write(bytes);
      bis = new ByteArrayInputStream(bos.toByteArray());
      while((a = bis.read())!=-1){
        System.out.print((char)a);
      }
      bos.close();
      bis.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

}

TestFileInputStream.java

/**
* Title:TestFileInputStream.java
* Description:FileInputStream为输入流，字节流，节点流（操作的节点为文件），
* 通过此流可以读取文件中的内容到程序中，但由于是字节流，将不能正确
* 读取中文。
* @author winwin
* @version 1.0
* @since May 20, 200911:12:45 AM
*/

public class TestFileInputStream {

  public static void main(String[] args) {
    FileInputStream fileInputStream = null;
    int read;
    String string = "D:\\test.txt";

    try {
      //在文件上创建输入流
      fileInputStream = new FileInputStream(string);
      //按字节读取文件，直至结尾（-1）,不能读取中文
      while((read=fileInputStream.read())!=-1){
        System.out.print((char)read);
      }
      fileInputStream.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

文章来源:http://java999.blog.51cto.com/259217/160015

999 2009-06-09 13:41 发表评论

[导入]有计划，多复习

999 — Tue, 09 Jun 2009 05:41:00 GMT

计划很重要，复习也很重要。有了计划做事情将不会浮躁；学会经常复习，将会提高效率。

做一件事情如果有计划地去做，将会顺风顺雨；如果没有计划去做一件事情，运气好的话可能很快就做好，运气不好的话你费尽心思也毫无头绪，好像始终在起点上。比如我们学习一门新技术，不能一上来就从头至尾啃，这样的话今天你学过的东西，明天可能就忘记了。我们应该先看看这门技术有什么流程图或原理图之类按照去学习，或者先看看这门技术有什么用途，根据用途去看它是怎么实现的，这样就比较有针对性，学习起来也会事半功倍。再比如对于程序中的错误，我们就应该有计划的从错误的日志开始去程序中找bug所在，而不要想当然的去读程序找bug。

对于学过的知识如果及时去复习，将会提高很多效率。就像我们写在博客上的技术文章，如果不及时复习，也会很快忘记的。所以有事没事多复习吧。

文章来源:http://java999.blog.51cto.com/259217/162456

999 2009-06-09 13:41 发表评论

[导入]java中的值传递和引用传递

999 — Tue, 09 Jun 2009 05:41:00 GMT

此篇文章为转载，原文地址不详，红色部分为我添加的注解。

值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参数的值。
引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。

Java中的基本数据类型作为参数都是值传递，另外还要注意基本数据类型的包装类作为函数参数时也是值传递。（至于String和StringBuilder作为参数时传递的是引用，但由于String类里没有提供方法改变它的值，所以不能改变它的值，StringBuilder可以通过append（）方法改变它的值。具体的例子请参加这篇文章：http://java999.blog.51cto.com/259217/162739）

对象作为函数参数时是引用传递，对象可以是JAVA中的非简单数据类型对象，也可以是自定义对象。

下面举例说明：
传值---传递基本数据类型参数
public    class           PassValue{
    static void exchange(int a, int b){//静态方法，交换a,b的值
        int temp;
        temp = a;
        a = b;
        b = temp;
    }
    public static void main(String[] args){
       int i = 10;
       int j = 100;
       System.out.println("before call: " + "i=" + i + "\t" + "j = " + j);//调用前
        exchange(i, j);                                                                    //值传递，main方法只能调用静态方法
        System.out.println("after call: " + "i=" + i + "\t" + "j = " + j);//调用后
    }
}
运行结果：
        before call: i = 10        j = 100
        after    call: i = 10        j = 100
说明：调用exchange(i, j)时，实际参数i，j分别把值传递给相应的形式参数a，b,在执行方法exchange()时，形式参数a，b的值的改变不影响实际参数i和j的值，i和j的值在调用前后并没改变。
引用传递---对象作为参数
如果在方法中把对象（或数组）作为参数，方法调用时，参数传递的是对象的引用（地址），即在方法调用时，实际参数把对对象的引用（地址）传递给形式参数。这是实际参数与形式参数指向同一个地址，即同一个对象（数组），方法执行时，对形式参数的改变实际上就是对实际参数的改变，这个结果在调用结束后被保留了下来。
class Book{
    String name;
    private folat price;
    Book(String n,    float ){                //构造方法
        name = n;
        price = p;
    }
    static  void change(Book a_book,    String n,    float p){    //静态方法，对象作为参数
            a_book.name = n;
            a_book.price = p;
    }
    public void output(){        //实例方法，输出对象信息
        System.out.println("name: " + name + "\t" + "price: " + price);
    }
}
public class PassAddr{
    public static void main(String [] args){
        Book b = new Book("java2",    32.5f);
        System.out.print("before call:\t");        //调用前
        b.output();
        b.change(b,    "c++",    45.5f);            //引用传递，传递对象b的引用，修改对象b的值
        System.out.print("after call:\t");            //调用后
        b.output();
    }
}
运行结果：
        before    call:    name:java2        price:32.5
        after       call:    name:c++          price:45.5
说明：调用change(b,"c++",45.5f)时，对象b作为实际参数，把引用传递给相应的形式参数a_book,实际上a_book也指向同一个对象，即该对象有两个引用名：b和a_book。在执行方法change()时，对形式参数a_book操作就是对实际参数b的操作。

文章来源:http://java999.blog.51cto.com/259217/162732

999 2009-06-09 13:41 发表评论

[导入]String和StringBuilder区别

999 — Tue, 09 Jun 2009 05:41:00 GMT

string的“+”操作就是根据StringBuilder（或 StringBuffer）类及其 append 方法实现的。

String不可变其实就是说一个String对象创建之后不能再在这个对象上做其他操作（如追加，删除一个字符），只能通过创建别的String对象来获取这个效果，而StringBuilder就可以在一个StringBuilder对象上进行改变：

String str = “hello”；

str = str+“，world！”；//这时并不是在原来的“hello”对象上追加“，world！”，而是重新创建了一个“hello，world！”对象

String 不能被修改，事实上很简单。就是因为 String 没有提供写操作方法，没有提供能够修改String对象的成员变量的方法。而StringBuilder则提供了这样的方法（append（）等方法）。

也许有人会说String不是有个concat方法可以在字符串后面追加字符串吗？呵呵，我们看过API的解释就知道是怎么回事了：

Concat

public String concat(String str)

将指定字符串联到此字符串的结尾。

如果参数字符串的长度为 0，则返回此 String 对象。否则，创建一个新的 String 对象，用来表示由此 String 对象表示的字符序列和由参数字符串表示的字符序列串联而成的字符序列。

对了，区别就在于String的调用concat方法会新建立一个String对象，而StringBuilder的append方法返回的还是原来对象的应用。

public class TestValue {
  public static void main(String[] args) {
    String string = new String("Hello");
    modify(string);
    System.out.println(string);
  }
  public static void modify(String s) {
    s += "world!";//这里通过"+"操作创建了一个新对象让s指向它。但string的引用并没有变。
    s = s.concat("winwin");//这里的concat方法重新创建了一个String对象，所以string的引用没有变，只是s的引用变了。
  }
}

public class TestValue {
  public static void main(String[] args) {
    StringBuilder string = new StringBuilder("Hello");
    modify(string);
    System.out.println(string);
  }
  public static void modify(StringBuilder s) {
    s.append(",world!");//由于StringBuilder类有方法可以改变，所以就能够改变string的值。
  }
}

此篇文章为我自己写的笔记，既然是笔记，顺便再写一点与题目无关的内容：

String str = “winwin”；

String str = new String(“winwin”)；

的区别：

字符串直接赋值时，String类型的变量所引用的值是存储在类的常量池中的。这种情况下，变量的内存空间大小是在编译期就已经确定的。

new对象的方式是将” winwin”存储到String对象的内存空间中，而这个存储动作是在运行期进行的。

文章来源:http://java999.blog.51cto.com/259217/162739

999 2009-06-09 13:41 发表评论

[导入]面试题目字符统计

999 — Tue, 09 Jun 2009 05:41:00 GMT

求第一个无重复字符,如"total"的第一个无重复字符是o,"teeter"的第一个无重复字符是r,效率要优于O(n的平方)
public static Character FirstNonRepeated(String)

下面是我把别人写的c程序翻译成java程序：

public class firstNonRepeatedChar {
        private    static final int MAX_CHAR = 256;

        public static void main(String[] args) {
                String str = "total";
                firstNoRepeatedChar(str);
        }

        public static int firstNoRepeatedChar(String str) {
                 int i = 0;
                 int j = 0;
                 int[] p = new int[MAX_CHAR];
                 char[] chars = str.toCharArray();
                 //初始化数组p，p用于保存字符出现的次数
                 for (j = 0; j < MAX_CHAR; j++) {
                    p[j] = 0;
                 }

                 //统计字符出现的次数
                 for(i=0;i                         p[chars[i]]++;
                 }

                 //寻找第一个统计次数为1的字符
                 for (i = 0; chars[i] != -1; i++) {
                            if (p[chars[i]] == 1) {
                             System.out.println(chars[i]);
                             return 1;
                            }
                         }
                return 0;

        }
}

文章来源:http://java999.blog.51cto.com/259217/162744

999 2009-06-09 13:41 发表评论

Jsp&Servlet之Cookie

999 — Tue, 09 Jun 2009 05:41:00 GMT

声明：此篇文章为我从网上下载的doc文档里面的一部分内容，具体作者不知。

Cookie 简介： Cookie 是服务器保存在客户端上的一组数据。例如，一些登陆网站时会提示是否保存密码，或是选择登陆有效期（浏览器进程、一天、一个月等等），这些都可以使用 Cookie 来实现。

Cookie 类	javax.servlet.http.Cookie
构造方法	Cookie(String name,String value)
服务器向客户端设置 cookie	addCookie(Cookie cookie) 由 response 调用，可反复使用该方法设置多个 Cookie
服务器从客户端取回之前保留在客户端上的 cookie	Cookie[] getCookies() 由 request 调用
设置 cookie 在本地留存的时间	setMaxAge (int expiry) 由 cookie 对象调用

l 示例：设置 Cookie

cookie01.jsp à 服务器响应客户的请求时，设置 cookie 到客户端：

² 先准备好 cookie 对象

然后利用 response.addCookie(Cookie cookie) 进行设置

<%
          //构造Cookie对象，构造方法：Cookie(String name,String value)
          Cookie c1= new Cookie("name","Jerry");
          Cookie c2= new Cookie("password","1234");
          Cookie c3= new Cookie("access_time",new Date().toString());

          //将Cookie设置给客户端
          //服务器向客户端传递数据，使用response对象
          //方法：reponse.addCookie(Cookie cookie)

          response.addCookie(c1);
          response.addCookie(c2);
          response.addCookie(c3);
%>

【注】浏览器窗口中看不到 Cookie 的信息

Cookie02.jsp à 如果需要，服务器可以从客户端取回 cookie ，这是从客户端传数据到服务器，故要使用 request 的方法： Cookie[] request.getCookies() 。

² 利用 request.getCookies() 取得 cookie 数组

遍历数组，取得其中每一个 cookie

<%
          //Cookie[] request.getCookies()方法
          Cookie[] cs = request.getCookies();

          for(int i=0;i            Cookie tmp = cs[i];
            //每一个Cookie由 name--value构成
            //可以使用 String getName() 和 String getValue() 获得各成分的值

        %>

<%= tmp.getName() %> <%=tmp.getValue() %>

        <%
          }

          //JSESSIONID ACCE027387AADBD63525E4446F1DFD83是服务器自动设置的
          //代表这个客户端在服务器上的一个唯一编号
%>

【注】：每一个 cookie 都是由 name – value 构成（由构造方法可知）， Cookie 类提供了如下 2 个方法获取 cookie 的 name 和 value 的值：

String getName()

String getValue()

l 设置 Cookie 的保存时间

² 默认情况下： cookie 是仅在浏览器进程中有效。

（在一个窗口中先运行 cookie01.jsp 实现设置 cookie ，然后仍然在这个窗口中运行 cookie02.jsp 取回 cookie 并显示是可以实现。但，如果在另外的浏览器窗口中直接运行 cookie02.jsp ，则无法再取回之前设置的 cookie 了）

² 如果希望 cookie 能在本地留存一段时间，使得在一段时间之内都可以取回 cookie ，则可以利用 Cookie 类的 setMaxAge(int expiry) 方法， expiry 表多少秒后 cookie 过期。

修改 cookie01.jsp 为 cookie03.jsp ，增加 cookie 留存时间的设置，仍然使用 cookie02.jsp 取回 cookie

利用Cookie类的setMaxAge(int expiry)可是设置cookie在本地计算机上留存一段时间，单位是秒

    <%
              //构造Cookie对象，构造方法：Cookie(String name,String value)
              Cookie c1= new Cookie("name","Jerry");
              Cookie c2=new Cookie("password","1234");
              Cookie c3=new Cookie("access_time",new Date().toString());

              //设置留存时间30秒
              c1.setMaxAge(30);
              c2.setMaxAge(30);
              c3.setMaxAge(30);

              //将Cookie设置给客户端
              //服务器向客户端传递数据，使用response对象
              //方法：reponse.addCookie(Cookie cookie)

              response.addCookie(c1);
              response.addCookie(c2);
              response.addCookie(c3);
    %>

则运行 cookie03.jsp 完成设置 cookie 后，即使另开一个浏览器窗口，直接运行 cookie02.jsp 仍然可以取回 cookie ，但时限到了之后 cookie 还是会失效。

但是，服务器自动设置的 JSESSIONID 还在。

我的备注：一个 servlet/jsp 设置的路径能够被同一路径或子路径下的 servlet/jsp 访问到，其它路径不能访问到。

999 2009-06-09 13:41 发表评论

Jsp&Servlet之Session对象

999 — Tue, 09 Jun 2009 05:41:00 GMT

摘要: 声明：此篇文章为从网上下载的doc文档中的摘取，彩色部分为本人的笔记。 u session ... 阅读全文

999 2009-06-09 13:41 发表评论

forward、sendRedirect及Jsp和Servlet之间的跳转

999 — Tue, 09 Jun 2009 05:41:00 GMT

使用同一个 request ，是在服务器端跳转，浏览器显示的是第一个页面的名字，因为客户端（浏览器）不知道它在服务器端跳转了。

Response.sendRedirect 是两个不同的 request ，是在客户端跳转，浏览器显示的是跳转后的页面的名字。因为它是从客户端跳转到第二个页面的。

使用 forward 时，由于只是发送一次 request 请求， request 设置的属性（ setAttribute ）依然能保留在下一个页面。

使用 sendRedirect 时，由于发送两次 request 请求，所以在下一个不能获取 request 属性。但可以通过重写 URL 的方式将内容传递过去。

下面举例说明：

tian.jsp
<%request.setAttribute("river","redwater");
request.setAttribute("country","daguaiwan");
%>
"fengshan.jsp" />

donglan.jsp
<%request.setAttribute("river","redwater");
request.setAttribute("country","daguaiwan");
%>
"fengshan.jsp">fengshan

bama.jsp
<%request.setAttribute("river","redwater");
    request.setAttribute("country","daguaiwan");
    response.sendRedirect("fengshan.jsp");
%>

fengshan.jsp
<%=request.getAttribute("river")%>

<%=request.getAttribute("country")%>

http://localhost:8080/ForwardRedirect/tiane.jsp跳转后结果为：

redwater
daguaiwan

http://localhost:8080/ForwardRedirect/donglan.jsp跳转后结果为：

null
null

http://localhost:8080/ForwardRedirect/bama.jsp跳转后结果为：

null
null

结果分析：

tiane.jsp是通过forward跳转到fengshan.jsp的，这两个页面享用的是同一个request，故fengshan.jsp可以接收到tiane.jsp通过 request设置的属性。

而donglan.jsp是通过href发送了另外的request请求，bama.jsp是通过sendRedirect跳转，用的也是另外的request请求，故fengshan.jsp不可以接收到这两个页面通过 request设置的属性。

Jsp和Servlet之间的跳转：

从Jsp跳转Servlet可以使用或者response.sendRedirect(URL)都可以，它们之间的区别上面已经说明了。

从Servlet跳转Jsp：

² getRequestDispatcher的forward(request, response)方法，这里也只是发送了一次请求，可以在下一个页面接受request设置的属性。

² response.sendRedirect(URL),这里发送了两次请求，不可以在下一个页面接受request设置的属性。

例子如下：

servlettiane.jsp
<%request.setAttribute("river","redwater");
request.setAttribute("country","daguaiwan");
%>
"/tiane" />

servletbama.jsp
<%request.setAttribute("river","redwater");
    request.setAttribute("country","daguaiwan");
    response.sendRedirect("/ForwardRedirect/tiane");
%>

Tiane.java
publicclass Tiane extends HttpServlet {

  publicvoid doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
//    response.sendRedirect("/ForwardRedirect/fengshan.jsp");
    this.getServletConfig().getServletContext()
            .getRequestDispatcher("/fengshan.jsp").forward(request, response);
  }

  publicvoid doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    doGet(request, response);
  }
}

再在web.xml中配置servlet：
  <servlet>
  <servlet-name>tianeservlet-name>
  <servlet-class>com.dvnchina.test.Tianeservlet-class>
  servlet>
  <servlet-mapping>
  <servlet-name>tianeservlet-name>
  <url-pattern>/tianeurl-pattern>
servlet-mapping>

具体的结果我就不分析了，和第一个例子差不多的。代码见附件。

999 2009-06-09 13:41 发表评论

[导入]Powerdesigner的使用

999 — Sun, 07 Jun 2009 12:39:00 GMT

sql脚本如何导入Powerdesigner ？

答：1.打开pd,新建PhysicalData Model

选择New Model，DBMS为你使用的数据库，例如:sql server 2000

First diagram选择Physical Diagram

2.选择DataBase下的Reverse Engineer Database

------Using Script files---Add files，选中脚本所在地址,确定即可。

文章来源:http://java999.blog.51cto.com/259217/128798

999 2009-06-07 20:39 发表评论