成人综合久久精品色婷婷,色综合色天天久久婷婷基地,狠狠人妻久久久久久综合蜜桃

luis — Wed, 21 Nov 2012 16:44:00 GMT

原文�Q?a >http://www.cnblogs.com/tonyqus/archive/2004/12/07/73710.html

熟悉C++的�h对于两个字符串比较的代码一定很了解�Q?nbsp;
(string1==string2)
但在java中，�q�个代码即��在两个字�W�串完全相同的情况下也会�q�回false
Java中必��M��用string1.equals(string2)来进行判�?nbsp;

补充
如果�Q?nbsp;
string s1=new String("Hello");
string s2=new String("Hello");
�?s1==s2)=false

如果�Q?nbsp;
string s1="Hello";
string s2="Hello";
�?s1==s2)=true;
因�ؓ他们指向的同一个对象�?nbsp;

如果把其他变量的��D��l�s1和s2�Q�即使内容相同，�׃��不是指向同一个对象，也会�q�回false。所以徏议��用equals()�Q�因为equals比较的才是真正的内容

luis 2012-11-22 00:44 发表评论

Java 中的 Hashmap serialization 非常耗费�I�间 Java�U�程

luis — Thu, 05 Apr 2012 20:32:00 GMT

不需要序列化的变量请用transient 注释

调试Java�E�序的时候，一定要注意Java�U�程�Q�何时挂��P��是否会终止，能否需要新建，start �q�是resume.

luis 2012-04-06 04:32 发表评论

Eclipse Fatjar包的调试

luis — Thu, 05 Apr 2012 01:14:00 GMT

使用命��o�?�Q?br />到其路径下运�?java -jar xxx.jar -pause �q�行�q�个文�g�Q�这时进行操作就可以看到所报错�?/span>

luis 2012-04-05 09:14 发表评论

事�g响应�E�序写成异步�U�程

luis — Tue, 03 Apr 2012 20:36:00 GMT

基本的需求是�Q?按下Btn Begin, 开始处理，同时监听Btn Pause,一旦Pause��Pause�Q�如果没有Pause��执行直到结�?br />我们需要将事�g响应�E�序写成Thread�Q�实现异步监听�?br />在嵌入类中调用this,需要类�?this.
代码1�Q�响应部�?br />

package firstversion;

public class ThreadForUpdate extends Thread{
    ControlPanel cp;
    Simulator r;

    public ThreadForUpdate(ControlPanel cp,Simulator r)
    {
        this.cp=cp;
        this.r=r;
    }

    public void run()
    {
        while(cp.flag==true)
     {
        r.DisplaySolutionRecursive();
        cp.textFieldStability.setText(r.node.stabilityState.stability.toString());
        cp.textFieldDirection.setText(r.node.controlledState.direction.toString());
        cp.textFieldDifficulty.setText(r.node.controlledState.difficulty.toString());
        cp.textFieldActionExecuting.setText("("+r.node.stabilityState.actor+","+r.node.stabilityState.actionBeExecuting+")");
        cp.textFieldStability.setText(r.node.stabilityState.stability.toString());
        cp.textFieldX.setText(""+r.node.controlledState.x);
        cp.textFieldY.setText(""+r.node.controlledState.y);
        cp.textFieldTraffic.setText(r.node.traffic.toString());
        if(r.node.isTerminal==true)
            cp.textFieldNextAction.setText("");
        else
            cp.textFieldNextAction.setText(r.node.bestAction.toString());
        cp.textFieldEngagement.setText(r.node.engagement.toString());

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      }
    }

}

代码2�Q�事件响�?br />

btnBegin = new JButton("Begin");
        btnBegin.setEnabled(false);
        final ThreadForUpdate threadUpdate=new ThreadForUpdate(ControlPanel.this,r);;
        btnBegin.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent arg0) {
                threadUpdate.start();
                }
        });

luis 2012-04-04 04:36 发表评论

[转]Java反射�l�典实例 Java Reflection Cookbook

luis — Thu, 16 Feb 2012 01:19:00 GMT

摘要: Java提供了一套机制来动态执行方法和构造方法，以及数组操作�{�，�q�套机制��叫——反射。反��机制是如今很多��行框架的实现基��Q�其中包括Spring、Hibernate�{�。原理性的问题不是本文的重点，接下来让我们在实例中学习�q�套�_�ֽ�的机制�?. 得到某个对象的属性public Object getProperty(Object owner,&nbs... 阅读全文

luis 2012-02-16 09:19 发表评论

luis — Thu, 16 Feb 2012 01:17:00 GMT

package homework1;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Vector;

public class BayesianNetwork {
    public static final String Less="<45";
    public static  final String Middle="45-55";
    public static  final String More=">=55";
enum A{Less,Middle,More};
public class NodeA extends Node{
    A value;
}
enum G{Female,Male};
public class NodeG extends Node{
    G value;
}
enum CP{Typical,Atypical,NonAnginal,None};
public class NodeCP extends Node{
    CP value;
}
enum BP{Low,High};
class NodeBP extends Node{
    BP value;
}
enum CH{Low,High};
class NodeCH extends Node{
    CH value;
}
enum ECG{Normal,Abnormal};
class NodeECG extends Node{
    ECG value;
}
enum HR{Low,High};
class NodeHR extends Node{
    HR value;
}
enum EIA{No,Yes};
class NodeEIA extends Node{
    EIA value;
}
enum HD{No,Yes};
class NodeHD extends Node{
    HD value;
}

class Node{
public    Vector<Node> parent;
public    String name;
public    int cpt[];

public  Node(){
        this.parent=new Vector<Node>();
        cpt=new int[64];
    }
}

public static void main(String[] args) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, Exception, NoSuchMethodException
{
    Vector <Node> nodeList=new Vector<Node>();
    String[] nameList={"A","G","CP","BP","CH","ECG","HR","EIA","HD"};
    System.out.println(NodeA.class);
    for(String a:nameList)
    {
        Class newoneClass = Class.forName("homework1.BayesianNetwork$Node"+a);//classname也不一�?/span>
        Constructor cons = newoneClass.getDeclaredConstructors()[0];
        cons.setAccessible(true);
        Object node= cons.newInstance(new BayesianNetwork()); //需要的是外部类的构造方�?  }

}
        nodeList.add((Node) node);
    }

luis 2012-02-16 09:17 发表评论

luis — Tue, 27 Dec 2011 04:40:00 GMT

Java enum 枚�D的遍�?br />

private enum Action{left,right,forward,continued };

for(Action action:Action.values())
{
//Use variable action
}

luis 2011-12-27 12:40 发表评论

Java Hashtable HashMap ArrayList Vector �{�等

luis — Tue, 27 Dec 2011 04:00:00 GMT

摘要: http://selives.blogbus.com/logs/27714366.htmlArrayList 和Vector是采用数�l�方式存储数据，此数�l�元素数大于实际存储的数据以便增加和插入元素�Q�都允许直接序号索引元素�Q�但是插入数据要设计到数�l�元素移动等内存操作�Q�所以烦引数据快插入数据慢，Vector�׃��使用了synchronized�Ҏ��Q�线�E�安全）所以性能上比ArrayList要差�Q?.. 阅读全文

luis 2011-12-27 12:00 发表评论

Eclipse快捷键大全[zt]

luis — Thu, 17 Nov 2011 04:47:00 GMT

http://blog.csdn.net/zt2oo8/article/details/959280

有时我们复制�?em style="color: #d14836; font-style: normal; ">Eclipse中的代码比较混�ؕ�Q�这时按Ctrl + Shift + F��?/span>可以自动调整好代码的格式

Ctrl+1 快速修�?最�l�典的快捷键,��׃��用多说了)
Ctrl+D: 删除当前�?nbsp;
Ctrl+Alt+↓ 复制当前行到下一�?复制增加)
Ctrl+Alt+↑ 复制当前行到上一�?复制增加)
Alt+↓ 当前行和下面一行交互位�|?特别实用,可以省去先剪�?再粘贴了)
Alt+↑ 当前行和上面一行交互位�|?同上)
Alt+← 前一个编辑的��面
Alt+→ 下一个编辑的��面(当然是针对上面那条来说了)
Alt+Enter 昄��当前选择资源(工程,or 文�g or文�g)的属�?br />Shift+Enter 在当前行的下一行插入空�?�q�时鼠标可以在当前行的�Q一位置,不一定是最�?
Shift+Ctrl+Enter 在当前行插入�I��(原理同上�?
Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某�?nbsp;(对于�E�序��过100的�h��有��音�?
Ctrl+M 最大化当前的Edit或View (再按则反�?
Ctrl+/ 注释当前�?再按则取消注�?br />Ctrl+O 快速显�C?nbsp;OutLine
Ctrl+T 快速显�C�当前类的��承结�?br />Ctrl+W 关闭当前Editer
Ctrl+K 参照选中的Word快速定位到下一�?br />Ctrl+E 快速显�C�当前Editer的下拉列�?如果当前��面没有昄��的用黑体表示)
Ctrl+/(��键�? 折叠当前�c�M��的所有代�?br />Ctrl+×(��键�? 展开当前�c�M��的所有代�?br />Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代�?
Ctrl+Shift+E 昄��理当前打开的所有的View的管理器(可以选择关闭,�Ȁ�zȝ��操作)
Ctrl+J 正向增量查找(按下Ctrl+J�?你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显�C�没有找��C��,查一个单词时,特别实用,�q�个功能Idea两年前就有了)
Ctrl+Shift+J 反向增量查找(和上条相�?只不�q�是从后往前查)
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X 把当前选中的文本全部变呛_��?br />Ctrl+Shift+Y 把当前选中的文本全部变为小�?br />Ctrl+Shift+F 格式化当前代�?br />Ctrl+Shift+P 定位到对于的匚w��W?譬如{}) (从前面定位后面时,光标要在匚w��W�里�?后面到前�?则反�?

下面的快捷键是重构里面常用的,本�h��p��己喜�Ƣ且常用的整理一�?�?一般重构的快捷键都是Alt+Shift开头的�?
Alt+Shift+R 重命�?nbsp;(是我自己最��q��的一个了,��其是变量和�cȝ��Rename,比手工方法能节省很多力_��?
Alt+Shift+M 抽取�Ҏ�� (�q�是重构里面最常用的方法之一�?��其是对一大堆泥团代码有用)
Alt+Shift+C 修改函数�l�构(比较实用,有N个函数调用了�q�个�Ҏ��,修改一�ơ搞�?
Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变�?��其是多处调用的时�?
Alt+Shift+F 把Class中的local变量变�ؓfield变量 (比较实用的功�?
Alt+Shift+I 合�ƈ变量(可能�q�样说有点不妥Inline)
Alt+Shift+V �U�d��函数和变�?不怎么常用)
Alt+Shift+Z 重构的后悔药(Undo)

�~�辑
作用�?nbsp;功能快捷�?nbsp;
全局查找�q�替�?nbsp;Ctrl+F
文本�~�辑�?nbsp;查找上一�?nbsp;Ctrl+Shift+K
文本�~�辑�?nbsp;查找下一�?nbsp;Ctrl+K
全局撤销 Ctrl+Z
全局复制 Ctrl+C
全局恢复上一个选择 Alt+Shift+↓
全局剪切 Ctrl+X
全局快速修�?nbsp;Ctrl1+1
全局内容辅助 Alt+/
全局全部选中 Ctrl+A
全局删除 Delete
全局上下文信�?nbsp;Alt+�Q?br />Alt+Shift+?
Ctrl+Shift+Space
Java�~�辑�?nbsp;昄��工具提示描述 F2
Java�~�辑�?nbsp;选择��装元素 Alt+Shift+↑
Java�~�辑�?nbsp;选择上一个元�?nbsp;Alt+Shift+←
Java�~�辑�?nbsp;选择下一个元�?nbsp;Alt+Shift+→
文本�~�辑�?nbsp;增量查找 Ctrl+J
文本�~�辑�?nbsp;增量逆向查找 Ctrl+Shift+J
全局 �_�脓 Ctrl+V
全局重做 Ctrl+Y

查看
作用�?nbsp;功能快捷�?nbsp;
全局攑֤� Ctrl+=
全局 �~�小 Ctrl+-

�H�口
作用�?nbsp;功能快捷�?nbsp;
全局 �Ȁ�zȝ��辑器 F12
全局切换�~�辑�?nbsp;Ctrl+Shift+W
全局上一个编辑器 Ctrl+Shift+F6
全局上一个视�?nbsp;Ctrl+Shift+F7
全局上一个透视�?nbsp;Ctrl+Shift+F8
全局下一个编辑器 Ctrl+F6
全局下一个视�?nbsp;Ctrl+F7
全局下一个透视�?nbsp;Ctrl+F8
文本�~�辑�?nbsp;昄��标尺上下文菜�?nbsp;Ctrl+W
全局昄��视图菜单 Ctrl+F10
全局昄��pȝ��菜单 Alt+-

��D��
作用�?nbsp;功能快捷�?nbsp;
Java�~�辑�?nbsp;打开�l�构 Ctrl+F3
全局打开�c�d�� Ctrl+Shift+T
全局打开�c�d��层次�l�构 F4
全局打开声明 F3
全局打开外部javadoc Shift+F2
全局打开资源 Ctrl+Shift+R
全局后退历史记录 Alt+←
全局前进历史记录 Alt+→
全局上一�?nbsp;Ctrl+,
全局下一�?nbsp;Ctrl+.
Java�~�辑�?nbsp;昄��大纲 Ctrl+O
全局在层�ơ结构中打开�c�d�� Ctrl+Shift+H
全局转至匚w��的括�?nbsp;Ctrl+Shift+P
全局转至上一个编辑位�|?nbsp;Ctrl+Q
Java�~�辑�?nbsp;转至上一个成�?nbsp;Ctrl+Shift+↑
Java�~�辑�?nbsp;转至下一个成�?nbsp;Ctrl+Shift+↓
文本�~�辑�?nbsp;转至�?nbsp;Ctrl+L

搜烦
作用�?nbsp;功能快捷�?nbsp;
全局出现在文件中 Ctrl+Shift+U
全局打开搜烦对话�?nbsp;Ctrl+H
全局工作��Z��的声�?nbsp;Ctrl+G
全局工作��Z��的引�?nbsp;Ctrl+Shift+G

文本�~�辑
作用�?nbsp;功能快捷�?nbsp;
文本�~�辑�?nbsp;改写切换 Insert
文本�~�辑�?nbsp;上滚�?nbsp;Ctrl+↑
文本�~�辑�?nbsp;下滚�?nbsp;Ctrl+↓

文�g
作用�?nbsp;功能快捷�?nbsp;
全局保存 Ctrl+X
Ctrl+S
全局打印 Ctrl+P
全局关闭 Ctrl+F4
全局全部保存 Ctrl+Shift+S
全局全部关闭 Ctrl+Shift+F4
全局属�?nbsp;Alt+Enter
全局新徏 Ctrl+N

��目
作用�?nbsp;功能快捷�?nbsp;
全局全部构徏 Ctrl+B

源代�?br />作用�?nbsp;功能快捷�?nbsp;
Java�~�辑�?nbsp;格式�?nbsp;Ctrl+Shift+F
Java�~�辑�?nbsp;取消注释 Ctrl+\
Java�~�辑�?nbsp;注释 Ctrl+/
Java�~�辑�?nbsp;��d��导入 Ctrl+Shift+M
Java�~�辑�?nbsp;�l�织导入 Ctrl+Shift+O
Java�~�辑�?nbsp;使用try/catch块来包围未设�|�，太常用了�Q�所以在�q�里列出,��自己讄��?br />也可以��用Ctrl+1自动修正�?nbsp;

�q�行
作用�?nbsp;功能快捷�?nbsp;
全局单步�q�回 F7
全局单步跌�� F6
全局单步跛_�� F5
全局单步跛_��选择 Ctrl+F5
全局调试上次启动 F11
全局 �l�箋 F8
全局使用�q��o器单步执�?nbsp;Shift+F5
全局 ��d��/去除断点 Ctrl+Shift+B
全局昄�� Ctrl+D
全局 �q�行上次启动 Ctrl+F11
全局 �q�行臌�� Ctrl+R
全局执行 Ctrl+U

重构
作用�?nbsp;功能快捷�?nbsp;
全局撤销重构 Alt+Shift+Z
全局抽取�Ҏ�� Alt+Shift+M
全局抽取局部变�?nbsp;Alt+Shift+L
全局内联 Alt+Shift+I
全局 �U�d�� Alt+Shift+V
全局重命�?nbsp;Alt+Shift+R
全局重做 Alt+Shift+Y

luis 2011-11-17 12:47 发表评论

Java 中scanner 可以代替C中的Scanf[zt]

luis — Thu, 17 Nov 2011 02:57:00 GMT

源文�Q? http://hi.baidu.com/yfwz100/blog/item/61f8c08bf0ff79cbfd1f1098.html
从C语言转到Java的时候，对Java的输入输出可能会颇�ؓ沮��Q�因为Java没有昑ּ�提供scanf()/printf()的函数�?/span>

其实�Q�Java�l�我们提供了格式化输入输出的面向对象方式�?/p>
格式化输出：
最��单的��是直接使用重蝲了的“+”来连接各�U�数据，�q�样比printf()个直观的�Ҏ��。但也有�~�点�Q�太多的“+”号反而打乱所有的输出�Q�而且输出格式不好控制�?/p>
�q�有一�U�方式是使用InputStream的format()�Ҏ��Q�或者，如果使用的JDK版本�?.0以后的话�Q�可以考虑相同的printf()�Ҏ��。这两个�Ҏ��和printf()是相同的�?/p>
格式化输入：
�q�个问题比较困难�Q�我现在扑ֈ�的方法都是从JDK 5.0以后引入的。而且�Q�还是没有像scanf()那样直接替代的方法。但我们可以使用java.util.Scanner。但可惜的是
sc.nextInt();
是读取一行数据，然后转换为整敎ͼ�而我们在使用scanf()�Ӟ��可能会这��P��
scanf("%d %d", &a, &b);
采用�I�格分割两个整数的输入，�Ҏ��之下�Q�java.util.Scanner�c�L��供的�Ҏ��显得局限了�?/p>
但事实上�Q�java.util.Scanner�c�L��供了useDelimiter()�Ҏ��来指明分割符。注意，“分割�W?#8221;是��用正则表辑ּ�的�Ş式，参看Pattern�c?/a>�?/span>
如上�q?/span>
scanf("%d %d", &a, &b);
替代�?/span>
sc.useDelimiter("\\s+");a=sc.nextInt();b=sc.nextInt();
来替代（假设sc是一个java.util.Scanner�c�d��象）。注意，在Java正则表达式中�Q?#8220;\s”代表了[\t\n\x0B\f\r ]��M��者（表示�I�白字符�Q�。�?#8220;+”表示不仅仅一个，卌��l�的“�I�白字符”也可以�?/span>
详细信息参见java.util.Scanner�c?/a>�?/span>

http://download.oracle.com/javase/7/docs/api/java/util/Scanner.html

luis 2011-11-17 10:57 发表评论

Java IO

luis — Thu, 17 Nov 2011 01:30:00 GMT

BufferedReader in= new BufferedReader(new FileReader( "d:\\co\\work3.sql "));
String input=new String();
String tablename=new String( " ");
StringBuffer transresult=new StringBuffer();
int lbracketpos,rbracketpos;
boolean newtable;
input=in.readLine();

-------

用java.io.RandomAccessFile的readLine()�Ҏ��

------

FileReader对象只有read�Ҏ��
---------------
/*
* ��单的�?写文本文件的�C�Z��
* �q�里包含了三个例子，�?nbsp;
* 1. ��文件读入到内存�Q�这里是StringBuffer�Q�的例子
* 2. ��内容中的文本写到文�?nbsp;
* 3. ��一个文件的内容��d��来写入另一个文件中
* 同时也展�C�Z��如果从输入流中读出来内容写入输出��中�Q�仅限文本流�Q?nbsp;
* 三个例子可以独立存在�Q�所以根据需要只看其中一个就行了�?nbsp;
*/

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;

public final class AccessTextFile {

/**
* 1. 演示��流中的文本��d��一�?StringBuffer �?nbsp;
* @throws IOException
*/
public void readToBuffer(StringBuffer buffer, InputStream is)
throws IOException {
String line; // 用来保存每行��d��的内�?nbsp;
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
line = reader.readLine(); // ��d��W�一�?nbsp;
while (line != null) { // 如果 line 为空说明��d��?nbsp;
buffer.append(line); // ��读到的内容��d��?buffer �?nbsp;
buffer.append("\n"); // ��d��换行�W?nbsp;
line = reader.readLine(); // ��d��下一�?nbsp;
}
}

/**
* 2. 演示��?StringBuffer 中的内容��d��到流�?nbsp;
*/
public void writeFromBuffer(StringBuffer buffer, OutputStream os) {
// �?PrintStream 可以方便的把内容输出到输出流�?nbsp;
// 其对象的用法�?System.out 一�?nbsp;
// �Q�System.out 本��n��是 PrintStream 对象�Q?nbsp;
PrintStream ps = new PrintStream(os);
ps.print(buffer.toString());
}

/**
* 3*. 从输入流中拷贝内容到输入��中
* @throws IOException
*/
public void copyStream(InputStream is, OutputStream os) throws IOException {
// �q�个读过�q�程可以参阅 readToBuffer 中的注释
String line;
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
PrintWriter writer = new PrintWriter(new OutputStreamWriter(os));
line = reader.readLine();
while (line != null) {
writer.println(line);
line = reader.readLine();
}
writer.flush(); // 最后确定要把输出流中的东西都写出去�?nbsp;
// �q�里不关�?writer 是因�?os 是从外面传进来的
// 既然不是从这里打开的，也就不从�q�里关闭
// 如果关闭�?writer�Q�封装在里面�?os 也就被关�?nbsp;
}

/**
* 3. 调用 copyStream(InputStream, OutputStream) �Ҏ��拯��文本文�g
*/
public void copyTextFile(String inFilename, String outFilename)
throws IOException {
// 先根据输�?输出文�g生成相应的输�?输出��?nbsp;
InputStream is = new FileInputStream(inFilename);
OutputStream os = new FileOutputStream(outFilename);
copyStream(is, os); // �?copyStream 拯��内容
is.close(); // is 是在�q�里打开的，所以需要关�?nbsp;
os.close(); // os 是在�q�里打开的，所以需要关�?nbsp;
}

public static void main(String[] args) throws IOException {
int sw = 1; // 三种��试的选择开�?nbsp;
AccessTextFile test = new AccessTextFile();

switch (sw) {
case 1: // ��试�?nbsp;
{
InputStream is = new FileInputStream("E:\\test.txt");
StringBuffer buffer = new StringBuffer();
test.readToBuffer(buffer, is);
System.out.println(buffer); // ��读�?buffer 中的内容写出�?nbsp;
is.close();
break;
}
case 2: // ��试�?nbsp;
{
StringBuffer buffer = new StringBuffer("Only a test\n");
test.writeFromBuffer(buffer, System.out);
break;
}
case 3: // ��试拯��
{
test.copyTextFile("E:\\test.txt", "E:\\r.txt");
}
break;
}
}

}

==============

//�q�个是用reader的，�q�个不会出现异常

import java.io.*;
import java.util.*;

public class Test {
    public static void main(String[] args) throws Exception {
        File file = new File("Test.java");
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String line = null;

        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        reader.close();
    }
}

luis 2011-11-17 09:30 发表评论

Java 计时 Java timing

luis — Mon, 26 Sep 2011 15:15:00 GMT

apps.hi.baidu.com/share/detail/33559179

Java �E�序计时�Q�Java Timing�Q?/div>

�Q?�Q�如何精��给代码计时�Q?/div>

�Q?�Q�计时机制本�w�的旉��开销�Q?/p>

�l�典的程序计时利用Java API�Ҏ��Q?font face="新宋�?>System.currentTimeMillis()�Q�在待测代码前后攄��一个秒表（stopwatch�Q�，计算前后旉��差即可�?/div>

下面是一个引�?#8220;”的stopwatch�c�，

import java.io.PrintStream;

final class Timer{
private long startTime;

private long endTime;

public Timer() { reset(); }

public void start() {
System.gc();

startTime = System.currentTimeMillis();

    }
    public void end() {
        System.gc();
        endTime = System.currentTimeMillis();

}

public long duration() {
return (endTime - startTime);

}

    public void printDuration( PrintStream out ) {
        long elapsedTimeInSecond = duration() / 1000;
        long remainderInMillis = duration() % 1000;
        out.println("\nTotal execution time:"
              + elapsedTimeInSecond + "."
                + remainderInMillis
                + " seconds");

}

    public void reset() {
        startTime = 0;
         endTime = 0;

}

    public static void main( String[] args ) {
        Timer timer = new Timer();
        timer.start();

        for (int i = 0; i < 500; i++) {
           System.out.print("#");
        }

timer.end();
timer.printDuration(System.out); }

}

�q�是一�U�常规做法�?/div>

在多�U�程环境中，�U�程切换由OS控制�Q�因此两�ơ掐表之间可能记录了被OS切换到的其它�U�程的执行时��_��q�期间甚臛_��含其它线�E�的长耗时I/O操作�?/div>

多次掐表然后求其�q�_��可一定程度上�q�x��q�种误差�Q�然而，对于高精度要求，上述API�U�表计时方式是有�~�陷的�?/div>

Jesper �?#8220;Use the JVM Profiler Interface for accurate timing”中描�q�C��一�U�利用Java Virtual Machine Profiler Interface (JVMPI)的方�?br />

发现了两个新的函�?System.currentTimeMillis()和System.nanoTime()。其中System.nanoTime()�?.5版以后的新函数。这两个函数都是�q�回当前�pȝ��的时��_��只是System.nanoTime()�q�回的精度更高�?/span>

luis 2011-09-26 23:15 发表评论

luis — Fri, 08 Apr 2011 10:35:00 GMT

多�?nbsp;(Polymorphism) 大家应该都不陌生�Q�它是我们开发面向对象系�l�的“老朋�?#8221;�?nbsp;。但是老朋友也会有“烦心”的时候啊�Q�呵��c��有时候不注意�Q�还真会被它隑ֈ�。譬如下面这个例子（thank Hayden�Q�。大家可以先不看下面的答案，在自��p��中�q�行一道，看看自己想的跟实际结果是否相�W��?br style="line-height: normal" />

public class Polymorphism{
public static void main(String[] args) {
A b = new B();
b.fb();
}
}

class A {
public A(){

}
public void fa() {
  System.out.println("CLASS A :Function fa Runing......");
}

public void fb() {
  System.out.println("CLASS A :Function fb Runing......");
  fa();
  System.out.println("CLASS A :Function fb Stop......");
}
}

class B extends A {
public B(){
}
public void fa() {
  System.out.println("CLASS B :Function fa Runing......");
}

public void fb() {
  System.out.println("CLASS B :Function fb Runing......");
  super.fb();
  System.out.println("CLASS B :Function fb Stop......");
}
}

下面是它的运行结果：

CLASS B :Function fb Runing......
CLASS A :Function fb Runing......
CLASS B :Function fa Runing......
CLASS A :Function fb Stop......
CLASS B :Function fb Stop......

怎么��P��猜对�l�果了吗�Q�如果结果跟你想象的一模一��P��那么恭喜你，你对多态已�l�有初步了解了，��L��在语法层�ơ上是比较熟悉了。但是，千万不要“�z�洋得意”�Q�你可否解析�l�果��Z��么会是这样吗�Q�我们可以先来梳理一下程序流�E�：
1、运行main函数�Q�创建B对象(A b = new B(),完全可以替代B b=new B();)�Q�调用B的方法fb�Q�于是打印出"CLASS B :Function fb Runing......"�Q�都在情理之中�?br style="line-height: normal" /> 2、执行super.fb()�Q�调用父�c�A的方法fb�Q�首先打印出"CLASS A :Function fb Runing......"�Q�预料之�?br style="line-height: normal" /> 3、执行方法fa()�Q�打印出"CLASS B :Function fa Runing......"�Q�呃�Q�奇怪了�Q��ؓ什么不是执行A的方法fa(),而是子类B中的fa()呢？当前被执行的是类A的方法，那么虚拟机找到的应该是A�cȝ��Method Table�Q�找到的应该是A�cȝ��Ҏ��fa()啊？难解�?br style="line-height: normal" /> 4、打�?CLASS A :Function fb Stop......"�Q�返�?br style="line-height: normal" /> 5、打�?strong style="line-height: normal">"CLASS A :Function fb Stop....."�Q�返回，�E�序�l�束�?br style="line-height: normal" /> 现在问题清楚了，��是虚拟机在执行�c�A�Ҏ��的时候查扄��Method Table竟然是子�c�B的。�ؓ什么呢�Q�其实，只要我们清楚java�Ҏ��调用的方式，�q�个问题��p��刃而解了。在Java虚拟��Z��Q�每启动一个新的线�E�，虚拟机都会�ؓ它分配一个Java栈，而每当线�E�调用一个java�Ҏ��Ӟ��虚拟机就会在该线�E�的java栈中压入一个新帧，用以存储参数�Q�局部变量等数据。我们将�q�个正在被执行的�Ҏ��U�Cؓ该线�E�的当前�Ҏ��Q�其相应的栈帧�ؓ当前帧�?br style="line-height: normal" /> 好了�Q�当我们调用一个方法时�Q�我们需要往当前帧中压入哪些参数呢？��单，�Ҏ��的参数列表中不是都说得清清楚楚的吗？嗯，对于C语言来说�Q�这个说法是正确的，但是对于诸如C++�Q�Java�Q�Python�{�面向对象语�a�来说�Q�却是不对的�?span style="background-color: yellow">大家�q�记得那�?this"指针吗？�Q?/span>不错�Q?strong style="line-height: normal">在Java中，所有的实例�Ҏ��Q�Instance Method�Q�调用的时候都会把当前对象压入当前帧中�Q�Java虚拟机正是通过�q�个参数来决定当前所使用的类�Q�通过判断该对象的�c�d��Q?/strong>�?br style="line-height: normal" /> 在上面的例子中，main中调用b.fb()�Ӟ��压入的当前对象自然是B�c�d��象，我们��Cؓb。在B的fb()中调用super.fb()�Ӟ��压入的就是刚刚压入的对象�Q�也��是b了。同��P��在A的fb中调用fa()�Ӟ��压入的也是b。因此，在��?nbsp;invokevirtual指��o调用fa()�Ӟ��扄��是B的方法表�Q�当前对象b的类型�ؓB�Q�，也就执行了类B的fa了�?br style="line-height: normal" /> �q�种现象在构造函��C��特别常见�Q�因为构造函��C��会隐含��用调用父�cȝ��构造函数的�Q�如果在父类的构造函��C��调用了实例方法（�?nbsp;A的fa�Q�，而在子类中又覆盖了这个实例方法（�?nbsp;B的fa�Q�，那么得到的结果往往不是我们所要的。因此，我们最好不要在构造函��C��使用多态方法，不然�Q�Debug会很痛苦的：�Q?/p>

luis 2011-04-08 18:35 发表评论

luis — Wed, 22 Dec 2010 12:03:00 GMT

public class Msg {
    Agent.agent_actor actor;
    /**消息�c�d��Q�接受对方出�?谈判��p�|退�?��Z�h;�Ҏ��接受自己��Z�h谈判成功;新进入谈�?向所有对手出完�h或已�l�退��判结束回�{�，注意ACCPET只向发出一个agent发出*/
    enum answer{ACCEPT,REJECT,OFFER,OK,NEWMEM,ENDANSWER};
    answer msg_type;
    Offer offer;
    int from_no;
    int to_no;

    double min[];

    double max[];
    Msg(
    {
        min= new double[Negotiation.NUM_ISSUE+1];
        max=new double[Negotiation.NUM_ISSUE+1];
    }
}

如果对象成员中有非基本类型成员，比如上例中的 offer对象是Msg的成员，
则必��d��构造函��C��初始化该对象�Q�否则�ؓnull�?br />
应该��构造函数Msg改�ؓ
Msg()
{
  min= new double[Negotiation.NUM_ISSUE+1];
  max=new double[Negotiation.NUM_ISSUE+1];
     offer=new Offer();
}

luis 2010-12-22 20:03 发表评论

Java对象及其引用

luis — Wed, 22 Dec 2010 02:33:00 GMT

原文地址�Q?span class=f>blog.csdn.net/beepbug/archive/2006/08/14/1062790.aspx
      初学Java�Ӟ��在很长一�D�|��间里�Q�总觉得基本概念很模糊。后来才知道�Q�在许多Java书中�Q�把对象和对象的引用混�ؓ一谈。可是，如果我分不清对象与对象引用，那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来�Q�或许能让初学Java的朋友们��走一点弯路�?br>       ��Z��于说明，我们先定义一个简单的�c�：
class Vehicle {
int passengers;
int fuelcap;
int mpg;
}
有了�q�个模板�Q�就可以用它来创建对象：
       Vehicle veh1 = new Vehicle();
通常把这条语句的动作�U�C��为创��Z��个对象，其实�Q�它包含了四个动作�?br>1�Q�右边的“new Vehicle”�Q�是以Vehicle�c�Mؓ模板�Q�在堆空间里创徏一个Vehicle�c�d��象（也简�U�CؓVehicle对象�Q��?br>2�Q�末��()意味着�Q�在对象创徏后，立即调用Vehicle�cȝ��构造函敎ͼ�对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写�Q�Java会给你补上一个默认的构造函数�?br>3�Q�左边的“Vehicle veh1”创徏了一个Vehicle�c�d��用变量。所谓Vehicle�c�d��用，��是以后可以用来指向Vehicle对象的对象引用�?br>4�Q?#8220;=”操作�W��对象引用指向刚创建的那个Vehicle对象�?br>我们可以把这条语句拆成两部分�Q?br>Vehicle veh1;
veh1 = new Vehicle();
效果是一��L��。这样写�Q�就比较清楚了，有两个实体：一是对象引用变量，一是对象本�w��?br>       在堆�I�间里创建的实体�Q�与在数据段以及栈空间里创徏的实体不同。尽��它们也是确��实实存在的实体�Q�但是，我们看不见，也摸不着。不仅如此，我们仔细研究一下第二句�Q�找扑ֈ�创徏的对象叫什么名字？有�h��_��它叫“Vehicle”。不对，“Vehicle”是类�Q�对象的创徏模板�Q�的名字。一个Vehicle�c�d��以据此创建出无数个对象，�q�些对象不可能全�?#8220;Vehicle”�?br>       对象�q�名都没有，没法直接讉K��它。我们只能通过对象引用来间接访问对象�?br>       ��Z��形象地说明对象、引用及它们之间的关�p�，可以做一个或�怸�很妥当的比喻。对象好比是一只很大的气球�Q�大到我们抓不住它。引用变量是一根��Q�可以用来系汽球�?br>       如果只执行了�W�一条语句，�q�没执行�W�二条，此时创徏的引用变量veh1�q�没指向��M��一个对象，它的值是null。引用变量可以指向某个对象，或者�ؓnull。它是一根��Q�一根还没有�p�M��M��一个汽球的�l�뀂执行了�W�二句后�Q�一只新汽球做出来了�Q��ƈ被系在veh1�q�根�l�上。我们抓住这根��Q�就�{�于抓住了那只汽球�?br>       再来一句：
       Vehicle veh2;
��又做了一根��Q�还没系上汽球。如果再加一句：
       veh2 = veh1;
�p�M��了。这里，发生了复制行为。但是，要说明的是，对象本��n�q�没有被复制�Q�被复制的只是对象引用。结果是�Q�veh2也指向了veh1所指向的对象。两根�Ѿpȝ��是同一只汽球�?br>       如果用下句再创徏一个对象：
veh2 = new Vehicle();
则引用变量veh2�Ҏ��向第二个对象�?br>       从以上叙�q�再推演下去�Q�我们可以获得以下结论：�Q?�Q�一个对象引用可以指�?个或1个对象（一根��子可以不�p�L��球，也可以系一个汽球）�Q�（2�Q�一个对象可以有N个引用指向它�Q�可以有N条��子系住一个汽球）�?br>       如果再来下面语句�Q?br>       veh1 = veh2;
按上面的推断�Q�veh1也指向了�W�二个对象。这个没问题。问题是�W�一个对象呢�Q�没有一条��子系住它�Q�它飞了。多��C��里说�Q�它被Java的垃圑֛�收机制回收了。这不确切。正��地��_��它已成�ؓ垃圾回收机制的处理对象。至于什么时候真正被回收�Q�那要看垃圾回收机制的心情了�?br>       由此看来�Q�下面的语句应该不合法吧�Q�至��是没用的吧�Q?br>new Vehicle();
不对。它是合法的�Q�而且可用的。譬如，如果我们仅仅��Z��打印而生成一个对象，��׃��需要用引用变量来系住它。最常见的就是打印字�W�串�Q?br>       System.out.println(“I am Java!”);
字符串对�?#8220;I am Java!”在打印后卌��丢弃。有人把�q�种对象�U�C��Z��时对象�?br>       对象与引用的关系��持�l�到对象回收。但是，关于�q�一点，打算在下�?#8220;��q�Java回收机制”再说�?br>

-------------------
补充�Q?br>test�c?/p>

package test;

public class test {
public int value;
private int price;
     test()
     {
         this.value=0;
         this.price=0;
     }
public static void main(String[] args) {
    test _test=new test();
    fun.changeTest(_test);
    System.out.println(_test.value);
}

}

fun�Q�类

package test;

public class fun {
public static void changeTest(test _test)
{
_test.value=-1;
}
}

执行��L��输出为：
-1,
说明传递引用修改了对象的倹{�?

luis 2010-12-22 10:33 发表评论

luis — Tue, 21 Dec 2010 12:03:00 GMT

import java.util.*;
import java.math.*;
public class Negotiation {
public    static final int  NUM_MAXTIME=10;
    /**最大轮��?/span>*/
public    static final int MAX_TURN=50;
public    static final int NUM_ISSUE=3;
    /**最大对手数*/
public    static final int MAX_PARTNER=10;

    /**谈判�q�程
     *
     */
void negotiationProcess()
    {

    }

}

然后在其他类中只需要调�?Negotiation.NUM_MAXTIME,NUM_ISSUE,�{��?img src ="http://www.shnenglu.com/luyulaile/aggbug/137139.html" width = "1" height = "1" />

luis 2010-12-21 20:03 发表评论

Java对象数组

luis — Tue, 21 Dec 2010 11:57:00 GMT

摘要: class Issue(){} class Offer { Issue _issue[]; Offer() { _issue= new Issue[NUM_ISSUE+1]; } }实际上我们往往用Vector ... 阅读全文

luis 2010-12-21 19:57 发表评论

Java 命名规范zt

luis — Tue, 21 Dec 2010 08:44:00 GMT

完全版java规范�Q?a >http://www.huihoo.org/code/java_code_conventions.html#71

luis 2010-12-21 16:44 发表评论

[转蝲]Vector遍历

luis — Tue, 26 Jan 2010 01:08:00 GMT

import java.util.Iterator;
import java.util.Vector;

public class VectorIterator implements Iterator{

     private Vector v;

     private int currentIndex=0;

     public VectorIterator(){

     }

     public VectorIterator(Vector v){
         this.v=v;
     }

     public boolean hasNext() {
         if(this.currentIndex             System.out.println("current index is :   "+this.currentIndex);
             return true;
         }else{
             System.out.println("out of the bound ");
         }
         return false;
     }

     public Object next() {
         return this.v.get(this.currentIndex++);
     }

     public void remove() {
         this.v.remove(this.currentIndex);
     }


     public static void main(String[] args){
         Vector v=new Vector();
         v.add(new String("aaa"));
         v.add(new String("bbb"));
         v.add(new String("ccc"));
         //System.out.println(v);


         Iterator iter=new VectorIterator(v);
         while(iter.hasNext()){
             String str=(String)iter.next();
             System.out.println(str);
         }
     }

}

luis 2010-01-26 09:08 发表评论

luis — Mon, 25 Jan 2010 17:48:00 GMT

temp=CustomerMaker.quickPassQueue.get(0);//获得首元�?br />  CustomerMaker.quickPassQueue.remove(0);//删除首元�?br />
quickPassQueue.add();在末��添加元�?br />----演示�E�序-----

import java.util.*;
import java.io.*;

public class test
{
Vector v = new Vector();

public void testMethod(){
v.add("a");
v.add("b");
v.add("c");

System.out.println("\n原来的vecotr");
for(int i=0;i   System.out.println("\n"+" index is: "+ i + " element is: " +v.get(i));
}

v.remove(0);

System.out.println("\n��L��一个vector中第一个元�?);
for(int i=0;i   System.out.println("\n"+" index is: "+ i + " element is: " +v.get(i));
}
}

public static void main(String[] args)
{
test t = new test();
t.testMethod();
System.out.println("Hello World!");
}
}
-----------------排序�E�序------------------------------
import java.util.*;

class MyCompare implements Comparator //实现Comparator�Q�定义自��q��比较�Ҏ��
{
public int compare(Object o1, Object o2) {
Elem e1=(Elem)o1;
Elem e2=(Elem)o2;

if(e1.get() > e2.get())//�q�样比较是降�?如果�?1�Ҏ��1��是升序.
{
   return -1;
}
else if(e1.get(){
   return 1;
}
else
{
   return 0;
}
}
}

class Elem {
private int iVal;

public Elem(int i) {
this.iVal = i;
}

public int get() {
return this.iVal;
}
}

public class Vector1 {
public static void main(String[] args) {
   List v = new Vector();
   v.add(new Elem(1));
   v.add(new Elem(22));
   v.add(new Elem(3));
   v.add(new Elem(14));
   Comparator ct = new MyCompare();
   Collections.sort(v, ct);
   for (int i = 0; i < v.size(); i++)
    System.out.println(((Elem) v.get(i)).get());

}

luis 2010-01-26 01:48 发表评论

[转蝲]使用 Java �~�程语言实现�U�程

luis — Mon, 25 Jan 2010 17:17:00 GMT

使用 Java �~�程语言实现�U�程

　　Java�~�程语言使多�U�程如此��单有效，以致于某些程序员说它实际上是自然的。尽��在 Java 中��用线�E�比在其他语�a�中要�Ҏ��得多�Q�仍然有一些概念需要掌握。要��C��的一仉��要的事情�?/span> main() 函数也是一个线�E�，�q�可用来做有用的工作。程序员只有在需要多个线�E�时才需要创建新的线�E��?/span>

　　Thread �c?/span>

　　Thread �c�L��一个具体的�c�，即不是抽象类�Q�该�c�d��装了�U�程的行为。要创徏一个线�E�，�E�序员必��d��Z��个从 Thread �c�d��出的新类。程序员必须覆盖 Thread �?/span> run() 函数来完成有用的工作。用户�ƈ不直接调用此函数�Q�而是必须调用 Thread �?/span> start() 函数�Q�该函数再调�?/span> run()。下面的代码说明了它的用法：

　　创徏两个新线�E?/span>

import java.util.*;

class TimePrinter extends Thread {
　int pauseTime;
　String name;
　public TimePrinter(int x, String n) {
　　pauseTime = x;
　　name = n;
　}

　public void run() {
　　while(true) {
　　　try {
　　　　System.out.println(name + ":" + new Date(System.currentTimeMillis()));
　　　　Thread.sleep(pauseTime);
　　　} catch(Exception e) {
　　　　System.out.println(e);
　　　}
　　}
　}

　static public void main(String args[]) {
　　TimePrinter tp1 = new TimePrinter(1000, "Fast Guy");
　　tp1.start();
　　TimePrinter tp2 = new TimePrinter(3000, "Slow Guy");
　　tp2.start();

　}
}

　　在本例中�Q�我们可以看��C��个简单的�E�序�Q�它按两个不同的旉��间隔�Q?/span>1 �U�和 3 �U�）在屏�q�上昄��当前旉��。这是通过创徏两个新线�E�来完成的，包括 main() �׃��个线�E�。但是，因�ؓ有时要作为线�E�运行的�c�d��能已�l�是某个�c�d��ơ的一部分�Q�所以就不能再按�q�种机制创徏�U�程。虽然在同一个类中可以实��C�Q意数量的接口�Q�但 Java �~�程语言只允�怸�个类有一个父�c�R��同�Ӟ��某些�E�序员避免从 Thread �c�d��出，因�ؓ它强加了�c�d��ơ。对于这�U�情况，��p�� runnable 接口�?/span>

　　Runnable 接口

　　此接口只有一个函敎ͼ�run()�Q�此函数必须由实��C��此接口的�c�d��现。但是，��p��行这个类而论�Q�其语义与前一个示例稍有不同。我们可以用 runnable 接口改写前一个示例。（不同的部分用黑体表示。）

　　创徏两个新线�E�而不强加�c�d��?/span>

import java.util.*;

class TimePrinter implements Runnable {
　int pauseTime;
　String name;
　public TimePrinter(int x, String n) {
　　pauseTime = x;
　　name = n;
　}

　public void run() {
　　while(true) {
　　　try {
　　　　System.out.println(name + ":" + new Date(System.currentTimeMillis()));
　　　　Thread.sleep(pauseTime);
　　　} catch(Exception e) {
　　　　System.out.println(e);
　　　}
　　}
　}

　static public void main(String args[]) {
　　Thread t1 = new Thread(new TimePrinter(1000, "Fast Guy"));
　　t1.start();
　　Thread t2 = new Thread(new TimePrinter(3000, "Slow Guy"));
　　t2.start();
　}
}

　　��h��意，当��?/span> runnable 接口�Ӟ��您不能直接创建所需�cȝ��对象�q�运行它�Q�必��M�� Thread �cȝ��一个实例内部运行它。许多程序员更喜��?/span> runnable 接口�Q�因��Z�� Thread �cȝ��承会强加�c�d��ơ�?/span>

　　synchronized 关键�?/span>

　　到目前�ؓ止，我们看到的示例都只是以非常简单的方式来利用线�E�。只有最��的数据��，而且不会出现两个�U�程讉K��同一个对象的情况。但是，在大多数有用的程序中�Q�线�E�之间通常有信息流。试考虑一个金融应用程序，它有一�?/span> Account 对象�Q�如下例中所�C�：

　　一个银行中的多��Ҏ��?/span>

public class Account {
　String holderName;
　float amount;
　public Account(String name, float amt) {
　holderName = name;
　amount = amt;
}

public void deposit(float amt) {
　amount += amt;
}

public void withdraw(float amt) {
　amount -= amt;
}

public float checkBalance() {
　return amount;
}
}

　　在此代码样例中潜伏着一个错误。如果此�cȝ��于单�U�程应用�E�序�Q�不会有��M��问题。但是，在多�U�程应用�E�序的情况中�Q�不同的�U�程��有可能同时讉K��同一�?/span> Account 对象�Q�比如说一个联合帐��L��所有者在不同�?/span> ATM 上同时进行访问。在�q�种情况下，存入和支出就可能以这��L��方式发生�Q�一个事务被另一个事务覆盖。这�U�情况将是灾难性的。但是，Java �~�程语言提供了一�U�简单的机制来防止发生这�U�覆盖。每个对象在�q�行旉��有一个关联的锁。这个锁可通过为方法添加关键字 synchronized 来获得。这��P��修订�q�的 Account 对象�Q�如下所�C�）��不会遭受像数据损坏�q�样的错误：

　　对一个银行中的多��Ҏ��动进行同步处�?/span>

public class Account {
　String holderName;
　float amount;
　public Account(String name, float amt) {
　holderName = name;
　amount = amt;
}

public synchronized void deposit(float amt) {
　amount += amt;
}

public synchronized void withdraw(float amt) {
　amount -= amt;
}

public float checkBalance() {
　return amount;
}
}

　　deposit() �?/span> withdraw() 函数都需要这个锁来进行操作，所以当一个函数运行时�Q�另一个函数就被阻塞。请注意�Q?/span> checkBalance() 未作更改�Q�它严格是一个读函数。因�?/span> checkBalance() 未作同步处理�Q�所以�Q何其他方法都不会��d��它，它也不会��d��M��其他�Ҏ��Q�不��那些方法是否进行了同步处理

luis 2010-01-26 01:17 发表评论