9910

单飞

   :: 首页 :: 联系 :: 聚合  :: 管理

#

    public static ToolsProject getDefaultProject()throws Exception{
        
if(instance!= null){
            
return instance;
        }

        IWorkspaceRoot root 
= ResourcesPlugin.getWorkspace().getRoot();
        IProject prj 
= root.getProject("DefaultProject");
        
if (!prj.exists()) {
            
final IWorkspace workspace = ResourcesPlugin.getWorkspace();
            
final IProjectDescription desc = workspace.newProjectDescription(prj.getName());
            desc.setNatureIds(
new String[] "com.test.tools" });
            desc.setComment(
"TOOLS");
            prj.create(desc, 
null);
            prj.open(IResource.BACKGROUND_REFRESH, 
null);
        }

        ToolsProject prject 
= new ToolsProject();
        prject.setPrject(prj);
        
return prject;
    }

IContainer container = (IContainer) resource;
            
final IFile file = container.getFile(new Path(sName + "/" + "s" + ".xml"));
            ensureFolder((IFolder) file.getParent());


InputStream stream 
= openContentStream(siteName);
            
if (file.exists()) {
                file.setContents(stream, 
truetrue, monitor);
            }
 else {
                file.create(stream, 
true, monitor);
            }


stream.close();

private InputStream openContentStream(String siteName) {
        Site site 
= new Site();
        site.setName(siteName);
        XStream xstream 
= new XStream(new DomDriver());
                String xml 
= xstream.toXML(site);
        
return new ByteArrayInputStream(xml.getBytes());
    }

创建目录 mkdirs
public static void ensureFolder(IFolder folder) throws CoreException {
        IContainer parent 
= folder.getParent();
        
if (parent instanceof IFolder) {
            ensureFolder((IFolder) parent);
        }

        
if (!folder.exists()) {
            folder.create(
truefalsenull);
        }


    }



删除目录
dFolder.delete(
truenull);


监听到资源发生变化

private void hookResourceListener() {
        IWorkspace workspace 
= ResourcesPlugin.getWorkspace();
        IResourceChangeListener listener 
= new IResourceChangeListener() {
            
public void resourceChanged(IResourceChangeEvent event) {
                viewer.refresh();
            }

        }
;
        workspace.addResourceChangeListener(listener);
    }
posted @ 2009-04-02 13:49 单飞 阅读(705) | 评论 (0)编辑 收藏

验证代理是否可以使用
package src;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.SocketAddress;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class TestProxy {
    
public boolean doTest(String proxyIP, int port) throws Exception {
        URL url 
= new URL("http://www.g.cn/");
        
//URL url = new URL("http://www.g.cn/");
        SocketAddress addr = new InetSocketAddress(proxyIP, port);
        Proxy typeProxy 
= new Proxy(Proxy.Type.HTTP, addr);
        URLConnection conn 
= url.openConnection(typeProxy);
        
if (conn == null)
            
return false;

        conn.setConnectTimeout(
1000);
        InputStream in 
= conn.getInputStream();
        
byte[] b = new byte[1024];
        
while (in.read(b) > 0{
            System.out.print(
new String(b));
        }

        System.out.println();
        
return true;

    }


    
public String[] getProxyIp() throws Exception {
        FileReader fr 
= new FileReader("c://ip.txt");
        BufferedReader br 
= new BufferedReader(fr);
        String line;
        List
<String> rt = new ArrayList<String>();
        String ip, port;
        
while ((line = br.readLine()) != null{
            rt.add(line.trim());
        }

        fr.close();
        String[] aa 
= new String[rt.size()];
        rt.toArray(aa);
        
return aa;
    }


    
/**
     * 
@param args
     * 
@throws IOException
     
*/

    
public static void main(String[] args) {
        TestProxy test 
= new TestProxy();
        String[] items;
        
try {
            items 
= test.getProxyIp();
            
for (String proxy : items) {
                
try {
                    StringTokenizer st 
= new StringTokenizer(proxy, ":");
                    String ip 
= st.nextToken();
                    String port 
= st.nextToken();
                    
if (test.doTest(ip, Integer.parseInt(port))) {
                        System.err.println(proxy);
                    }
 else {
                        System.out.println(proxy);
                    }

                }
 catch (Exception ex) {
                    
// ex.printStackTrace();
                    System.out.println(proxy + ":" + ex.toString());
                }

            }

        }
 catch (Exception e) {
            
// TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


}



ip.txt
125.245.196.194:8080   
203.110.240.22:80       
77.240.82.6:80         
71.5.68.4:3128         
213.41.71.164:80       
203.160.1.103:80       
200.174.85.195:3128     
60.28.194.172:80       
148.233.159.58:8080     
207.248.228.166:80     
203.162.183.222:80     
60.218.99.18:8080       
203.160.1.112:80       
193.93.112.33:8080     
222.134.58.246:3128     
121.57.4.17:8080       
221.214.220.228:3128   
20.132.16.22:80         
121.12.249.207:3128     
219.80.28.24:80         
200.174.85.193:3128     
posted @ 2009-04-01 08:59 单飞 阅读(270) | 评论 (0)编辑 收藏

http://www.cnblogs.com/zephyr/archive/2008/05/30/1210960.html

使用Eclipse RCP创建视图并实现视图间消息传递(二)



posted @ 2009-03-26 13:36 单飞 阅读(122) | 评论 (0)编辑 收藏

public class FMultiPageEditor extends MultiPageEditorPart implements IResourceChangeListener{

/**
     * Creates page f of the multi-page editor,
     * which contains a text editor.
     
*/
    
void createHPage() {
        FEditorInput fInput 
= (FEditorInput) getEditorInput();
        
// h file
        IFile hFile  = formInput.getHFile();
        
try {
            FileEditorInput fed 
= new FileEditorInput(hFile);
            htmlEditorPart 
= makeDefaultEditorFor("default" + ".html");
            
int index = addPage(htmlEditorPart, fed);
            setPageText(index, 
"");
            setPageImage(index, fed.getImageDescriptor().createImage());
        } 
catch (PartInitException e) {
            ErrorDialog.openError(getSite().getShell(),
                    
"r"null, e.getStatus());
        } 
catch (Exception e) {
            e.printStackTrace();
        }
    }

private IEditorPart makeDefaultEditorFor(String name) {
        IEditorDescriptor editorDescriptor 
= getSite().getWorkbenchWindow()
                .getWorkbench().getEditorRegistry().getDefaultEditor(name);
        IEditorRegistry reg 
= WorkbenchPlugin.getDefault().getEditorRegistry();
        EditorDescriptor desc 
= (EditorDescriptor) reg
                .findEditor(editorDescriptor.getId());

        
if (desc == null)
            
return /*new TextEditor()*/null;

        IEditorPart part 
= null;
        
try {
            
if (desc.getClassName() != null
                    
&& desc.getClassName().equals(getClass().getName())) {
                IEditorDescriptor[] editors 
= getSite().getWorkbenchWindow()
                        .getWorkbench().getEditorRegistry().getEditors(name);
                
for (int i = 0; i < editors.length; i++) {
                    
if (editors[i].getId() != editorDescriptor.getId()) {
                        editorDescriptor 
= editors[i];
                        desc 
= (EditorDescriptor) reg
                                .findEditor(editorDescriptor.getId());
                        
if (desc.getClassName() != null
                                
&& !desc.getClassName().equals(
                                        getClass().getName()))
                            
break;
                    }
                }
            }
            
if (desc.getClassName() == null
                    
|| desc.getClassName().equals(getClass().getName()))
                part 
= new TextEditor();
            
else
                part 
= desc.createEditor();

        } 
catch (CoreException e) {
            e.printStackTrace();
            part 
= new TextEditor();
        }
        
return part;
    }
posted @ 2009-03-26 11:04 单飞 阅读(851) | 评论 (0)编辑 收藏

1.图像处理
2.bp神经网络
3.matlab
4.模式识别

posted @ 2009-03-21 14:13 单飞 阅读(128) | 评论 (0)编辑 收藏

public class HtmlEditor extends MultiPageEditorPart
public
 void init(IEditorSite site, IEditorInput editorInput) throws PartInitException {

   initResourceChangeListener();
}
    
    
private IWorkspace getWorkspace() {
        
return ((IFileEditorInput) getEditorInput()).getFile().getWorkspace();
    }
    
    
private void initResourceChangeListener() {
        IResourceChangeListener resourceChangeListener 
= new IResourceChangeListener() {
            
public void resourceChanged(IResourceChangeEvent event) {
                handleResourceChange(event);
            }
        };
        getWorkspace().addResourceChangeListener(resourceChangeListener);
    }

    
private void handleResourceChange(IResourceChangeEvent event) {
        
if (event.getType() == IResourceChangeEvent.POST_CHANGE) {
            IFile file 
= ((IFileEditorInput) getEditorInput()).getFile();
            
// update editor
            
        }
    }
/**
 *当更新或者删除文件的时候
**/
public void resourceChanged(final IResourceChangeEvent event) {
        if (event.getType() == IResourceChangeEvent.POST_CHANGE)
            Display.getDefault().asyncExec(new Runnable() {

                public void run() {
                    IResourceDelta rootDelta = event.getDelta();
                    if(rootDelta ==null){
                        return;
                    }
                    IResourceDelta htmlDelta = rootDelta.findMember(new Path("DefaultProject/t.html"));
                    if(htmlDelta == null){
                        return;
                    }
                }
            });
        if (event.getType() == IResourceChangeEvent.PRE_CLOSE) {
            Display.getDefault().asyncExec(new Runnable() {
                public void run() {
                    IWorkbenchPage[] pages = getSite().getWorkbenchWindow().getPages();
                    for (int i = 0; i < pages.length; i++) {
                        if (((FileEditorInput) getSourceEditor().getEditorInput()).getFile().getProject().equals(event.getResource())) {
                            IEditorPart editorPart = pages[i].findEditor(getSourceEditor().getEditorInput());
                            pages[i].closeEditor(editorPart, true);
                        }
                    }
                }
            });
        }
    }

posted @ 2009-03-20 10:07 单飞 阅读(448) | 评论 (0)编辑 收藏

     摘要: Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ --> import java.util.ArrayList; public final class StringUtils { &n...  阅读全文
posted @ 2009-03-18 15:12 单飞 阅读(222) | 评论 (0)编辑 收藏

     摘要: Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->    public static String convertRGB2HexString(RGB theRGB...  阅读全文
posted @ 2009-03-18 15:02 单飞 阅读(382) | 评论 (0)编辑 收藏

为了便于管理,先引入个基础类:
package algorithms;

/**
 * 
@author yovn
 *
 
*/
public abstract class Sorter<extends Comparable<E>> {
    
    
public abstract void sort(E[] array,int from ,int len);
    
    
public final void sort(E[] array)
    {
        sort(array,
0,array.length);
    }
    
protected final void swap(E[] array,int from ,int to)
    {
        E tmp
=array[from];
        array[from]
=array[to];
        array[to]
=tmp;
    }

}
一 插入排序
该算法在数据规模小的时候十分高效,该算法每次插入第K+1到前K个有序数组中一个合适位置,K从0开始到N-1,从而完成排序:
package algorithms;
/**
 * 
@author yovn
 
*/
public class InsertSorter<extends Comparable<E>> extends Sorter<E> {

    
/* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     
*/
    
public void sort(E[] array, int from, int len) {
         E tmp
=null;
          
for(int i=from+1;i<from+len;i++)
          {
              tmp
=array[i];
              
int j=i;
              
for(;j>from;j--)
              {
                  
if(tmp.compareTo(array[j-1])<0)
                  {
                      array[j]
=array[j-1];
                  }
                  
else break;
              }
              array[j]
=tmp;
          }
    }
        
    

}

二 冒泡排序
这可能是最简单的排序算法了,算法思想是每次从数组末端开始比较相邻两元素,把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。(当然也可以从数组开始端开始比较相邻两元素,把第i大的冒泡到数组的第N-i个位置。i从0一直到N-1从而完成排序。)

package algorithms;

/**
 * 
@author yovn
 *
 
*/
public class BubbleSorter<extends Comparable<E>> extends Sorter<E> {

    
private static  boolean DWON=true;
    
    
public final void bubble_down(E[] array, int from, int len)
    {
        
for(int i=from;i<from+len;i++)
        {
            
for(int j=from+len-1;j>i;j--)
            {
                
if(array[j].compareTo(array[j-1])<0)
                {
                    swap(array,j
-1,j);
                }
            }
        }
    }
    
    
public final void bubble_up(E[] array, int from, int len)
    {
        
for(int i=from+len-1;i>=from;i--)
        {
            
for(int j=from;j<i;j++)
            {
                
if(array[j].compareTo(array[j+1])>0)
                {
                    swap(array,j,j
+1);
                }
            }
        }
    }
    @Override
    
public void sort(E[] array, int from, int len) {
        
        
if(DWON)
        {
            bubble_down(array,from,len);
        }
        
else
        {
            bubble_up(array,from,len);
        }
    }
    
}

三,选择排序
选择排序相对于冒泡来说,它不是每次发现逆序都交换,而是在找到全局第i小的时候记下该元素位置,最后跟第i个元素交换,从而保证数组最终的有序。
相对与插入排序来说,选择排序每次选出的都是全局第i小的,不会调整前i个元素了。
package algorithms;
/**
 * 
@author yovn
 *
 
*/
public class SelectSorter<extends Comparable<E>> extends Sorter<E> {

    
/* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     
*/
    @Override
    
public void sort(E[] array, int from, int len) {
        
for(int i=0;i<len;i++)
        {
            
int smallest=i;
            
int j=i+from;
            
for(;j<from+len;j++)
            {
                
if(array[j].compareTo(array[smallest])<0)
                {
                    smallest
=j;
                }
            }
            swap(array,i,smallest);
                   
        }

    }
 
}
四 Shell排序
Shell排序可以理解为插入排序的变种,它充分利用了插入排序的两个特点:
1)当数据规模小的时候非常高效
2)当给定数据已经有序时的时间代价为O(N)
所以,Shell排序每次把数据分成若个小块,来使用插入排序,而且之后在这若个小块排好序的情况下把它们合成大一点的小块,继续使用插入排序,不停的合并小块,知道最后成一个块,并使用插入排序。

这里每次分成若干小块是通过“增量” 来控制的,开始时增量交大,接近N/2,从而使得分割出来接近N/2个小块,逐渐的减小“增量“最终到减小到1。

一直较好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,这样可使Shell排序时间复杂度达到O(N^1.5)
所以我在实现Shell排序的时候采用该增量序列
package algorithms;

/**
 * 
@author yovn
 
*/
public class ShellSorter<extends Comparable<E>> extends Sorter<E>  {

    
/* (non-Javadoc)
     * Our delta value choose 2^k-1,2^(k-1)-1,.7,3,1.
     * complexity is O(n^1.5)
     * @see algorithms.Sorter#sort(E[], int, int)
     
*/
    @Override
    
public void sort(E[] array, int from, int len) {
        
        
//1.calculate  the first delta value;
        int value=1;
        
while((value+1)*2<len)
        {
            value
=(value+1)*2-1;
        
        }
    
        
for(int delta=value;delta>=1;delta=(delta+1)/2-1)
        {
            
for(int i=0;i<delta;i++)
            {
                modify_insert_sort(array,from
+i,len-i,delta);
            }
        }

    }
    
    
private final  void modify_insert_sort(E[] array, int from, int len,int delta) {
          
if(len<=1)return;
          E tmp
=null;
          
for(int i=from+delta;i<from+len;i+=delta)
          {
              tmp
=array[i];
              
int j=i;
              
for(;j>from;j-=delta)
              {
                  
if(tmp.compareTo(array[j-delta])<0)
                  {
                      array[j]
=array[j-delta];
                  }
                  
else break;
              }
              array[j]
=tmp;
          }

    }
}

五 快速排序
快速排序是目前使用可能最广泛的排序算法了。
一般分如下步骤:
1)选择一个枢纽元素(有很对选法,我的实现里采用去中间元素的简单方法)
2)使用该枢纽元素分割数组,使得比该元素小的元素在它的左边,比它大的在右边。并把枢纽元素放在合适的位置。
3)根据枢纽元素最后确定的位置,把数组分成三部分,左边的,右边的,枢纽元素自己,对左边的,右边的分别递归调用快速排序算法即可。
快速排序的核心在于分割算法,也可以说是最有技巧的部分。
package algorithms;

/**
 * 
@author yovn
 *
 
*/
public class QuickSorter<extends Comparable<E>> extends Sorter<E> {

    
/* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     
*/
    @Override
    
public void sort(E[] array, int from, int len) {
        q_sort(array,from,from
+len-1);
    }

    
    
private final void q_sort(E[] array, int from, int to) {
        
if(to-from<1)return;
        
int pivot=selectPivot(array,from,to);

        
        
        pivot
=partion(array,from,to,pivot);
        
        q_sort(array,from,pivot
-1);
        q_sort(array,pivot
+1,to);
        
    }


    
private int partion(E[] array, int from, int to, int pivot) {
        E tmp
=array[pivot];
        array[pivot]
=array[to];//now to's position is available
        
        
while(from!=to)
        {
            
while(from<to&&array[from].compareTo(tmp)<=0)from++;
            
if(from<to)
            {
                array[to]
=array[from];//now from's position is available
                to--;
            }
            
while(from<to&&array[to].compareTo(tmp)>=0)to--;
            
if(from<to)
            {
                array[from]
=array[to];//now to's position is available now 
                from++;
            }
        }
        array[from]
=tmp;
        
return from;
    }


    
private int selectPivot(E[] array, int from, int to) {
    
        
return (from+to)/2;
    }

}

还有归并排序,堆排序,桶式排序,基数排序,下次在归纳。
posted @ 2009-03-09 08:44 单飞 阅读(145) | 评论 (0)编辑 收藏

com.mysql.jdbc.exceptions.MySQLSyntaxErrorException: Unknown table engine 'InnoDB'
    at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1026)
    at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:956)
    at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3491)
    at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3423)
    at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:1936)
    at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2060)
原来我使用了绿色版的mysql,以前能用是因为my.ini文件已经存在了。而我重新ghost一下,就没有这个文件了。

默认情况下配置文件可以放在以下目录中(假定我的mysql安装在d:\server\mysql下):
C:\my.ini C:\my.cnf C:\WINDOWS\my.ini C:\WINDOWS\my.cnf D:\server\mysql\my.ini D:\server\mysql\my.cnf

你可以用mysqld-nt.exe --install,把mysql添加到系统服务中,然后就可以了。

另外我发现原来可以指定表的engine



MySQL两种表存储结构MyISAM和InnoDB

MySQL支持的两种主要表存储 格式MyISAM,InnoDB,上个月做个项目时,先使用了InnoDB,结果速度特别慢,1秒钟只能插入10几条。后来换成MyISAM格式,一秒钟 插入上万条。当时决定这两个表的性能也差别太大了吧。后来自己推测,不应该差别这么慢,估计是写的插入语句有问题,决定做个测试:
测试环境:Redhat Linux9,4CPU,内存2G,MySQL版本为4.1.6-gamma-standard
测试程序:Python+Python-MySQL模块。
测试方案:
1、MyISAM格式分别测试,事务和不用事务两种情况:
2、InnoDB格式分别测试AutoCommit=1(不用begin transaction和用begin transaction模式),
     AutoCommit=0 (不用begin transaction和用begin transaction模式)四种情况。

测试方法为插入10000条记录。为了测试不互相影响,单独建立了专用的测试表,建表语句如下:

1、MyISAM不用事务表:
CREATE TABLE `MyISAM_NT` (
  `TableId` int(11) NOT NULL default '0',
  `TableString` varchar(21) NOT NULL default ''
) ENGINE=MyISAM;

2、MyISAM用事务表:
CREATE TABLE `MyISAM_TS` (
  `TableId` int(11) NOT NULL default '0',
  `TableString` varchar(21) NOT NULL default ''
) ENGINE=MyISAM;

3、InnoDB关闭AutoCommit,不用事务:
CREATE TABLE `INNODB_NA_NB` (
  `TableId` int(11) NOT NULL default '0',
  `TableString` varchar(21) NOT NULL default ''
) ENGINE=InnoDB;




posted @ 2009-02-13 09:49 单飞 阅读(3286) | 评论 (0)编辑 收藏

仅列出标题
共12页: First 上一页 3 4 5 6 7 8 9 10 11 下一页 Last