2013
10.28

步骤如下:

(1)在html中定义1个form表单

<form id=”picForm” name=”picForm” action=”uploadPic.htm” enctype=”multipart/form-data” method=”post”>
    <table>
        <tr>
            <td>
                <label>图片:</label>
            </td>
            <td>
                <input id="picUpload" name="picUpload" type="file">
            </td>
        </tr>
        <tr>
            <td colspan=”2″>
            <input type="button" onclick="uploadPic();" value="上传">
            </td>
        </tr>
    </table>
</form>

(2)定义js函数

function uploadPic(){
    if($("#picUpload").val()==''){
        alert("please select picture first!");
        return;
    }
    var data = new FormData();
    data.append('file', document.picForm.picUpload.files[0]);
    $.ajax({
        type: "POST",
        url: "uploadPic.htm",
        processData:false,
        contentType:false,
        data: data,
        success: function (data) {
            var obj = jQuery.parseJSON(data);
            var result = obj.result;
            if(result !="1"){
                alert("Uploade file fail");
            }
            else{
                alert("Uploade file succeed");

            }

        }
    });
}

注意上面的document.picForm.picUpload.files[0],这里,javascript是通过name属性来找元素的。

(3)服务器端配置

在spring的配置文件里加入以下内容。

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- one of the properties available; the maximum file size in bytes -->
    <property name="maxUploadSize" value="1000000"/>
</bean>

(4)服务器端代码

@Controller
public class MyController {

@RequestMapping("/uploadPic.htm")
@ResponseBody
public void uploadPic(ModelMap modelMap, HttpServletRequest req, HttpServletResponse res)
throws Exception {
      JSONObject json = new JSONObject();
      InputStream input = null;
      OutputStream output = null;
      try{
          MultipartHttpServletRequest multipartReq = (MultipartHttpServletRequest) req;
          MultipartFile rawFile = multipartReq.getFile("file");
          String rawFilename = rawFile.getOriginalFilename();
          String saveFileName = "d:\\"+rawFilename;
          input = rawFile.getInputStream();
          output = new BufferedOutputStream(new FileOutputStream(saveFileName));
          byte[] buffer = new byte[1024];
          int n = -1;
          while ((n = input.read(buffer)) != -1) {
              output.write(buffer, 0, n);
          }
          json.put("result", 1);
          res.setContentType("text/html;charset=utf-8");
          res.getWriter().write(json.toString());
      }
      catch(Exception e){
          json.put("result", 0);
          res.setContentType("text/html;charset=utf-8");
          res.getWriter().write(json.toString());
          return;
      }
      finally{
          input.close();
          output.close();
      }
   }
}

2013
10.24

我们在使用hibernate时,有时遇到比较复杂的查询,不好写HQL语句,只能写SQL。但是这时查询出来的是Object对象,我们需要将这些Ojbect对象转换成我们想要的域对象。

如果我们已经在hbm.xml文件里定义过表和领域类的映射关系,这时就很简单,只要加上addEntity方法就可以解决,如下。为了简化,下面的sql语句比较简单。

String sql = "select s.* from software s";
Query query = getHibernateTemplate().getSessionFactory().openSession().createSQLQuery(sql).addEntity(Software.class);
return (List<Software>)query.list();

需要强调的是:必须已经定义过software表和Software类的映射关系。

比如我已经在software.hbm.xml有如下定义了:

<hibernate-mapping>
    <class name="com.lixiaodong.Software" table="software" catalog="lixiaodong">
        <id name="id" type="int">
            <column name="id" />
            <generator class="identity" />
        </id>
        <property name="name" type="string">
            <column name="name" length="50" />
        </property>
    </class>
</hibernate-mapping>
2013
10.03

2PMMS(2-phase multiway merge sort),顾名思义,由2个阶段组成。第一个阶段将源文件分批次读到内存中,采用某种内部排序算法进行排序,然后将每次排序后的结果写到硬盘上,1个批次对应1个文件;第二个阶段将n个文件批量读到缓存里,从N个缓存序列里找到最小数,放到输出缓存里。每次放完后,要检查每个输入缓存是否读完,如果读完则从对应的文件里继续读数据到缓存,直到文件全部读完为止;并检查输出缓存是否已满,如满则输出到文件并清空输出缓存。

4个类:

(1)

public class Main {

/*
* 2 arguments
* first argument: inputfile ex: d:\\data\\input.dat
* second argument: output folder ex: d:\\data
*/
public static void main(String[] args) throws Exception {
    if(args.length!=2){
        System.out.println("arguments are not valid");
        return;
    }
    long startTime = System.currentTimeMillis();
    //read data, sort, output sorted data to files
    PhaseOne phaseOne = new PhaseOne();
    List<String> fileNameList = phaseOne.generateSortedFile(args[0], args[1]);
    //merge
    PhaseTwo phaseTwo = new PhaseTwo();
    phaseTwo.merge(fileNameList, args[1]);
    //delete temp files
    for(String fileName: fileNameList){
        new File(fileName).delete();
    }
    long finishTime = System.currentTimeMillis();
    double totalTime = (double)(finishTime - startTime) / 1000;
    System.out.println("total time: " + totalTime + " seconds");
}

}

(2)

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class PhaseOne {

private final int amountOnce = 550000;

public List<String> generateSortedFile(String inputFile, String outputFolder) {
    List<String> fileNameList = new ArrayList<String>();
    BufferedReader reader = null;
    try {
        reader = new BufferedReader(new FileReader(inputFile));
        String tempString = null;
        int line = 0;
        int[] array = new int[amountOnce];
        while ((tempString = reader.readLine()) != null) {
        //System.out.println("line " + line + ": " + tempString);
        array[line % amountOnce] = Integer.parseInt(tempString);
        if(line % amountOnce == amountOnce -1){
            String fileNO = (line/amountOnce)<10 ? "0"+ line/amountOnce : String.valueOf(line/amountOnce);
            String fileName = outputFolder+ "/tmp"+ fileNO+".dat";
            writeData(array, line%amountOnce+1, fileName,fileNameList);
        }
        line++;
    }
    String fileNO = (line/amountOnce)<10 ? "0"+ line/amountOnce : String.valueOf(line/amountOnce);
    String fileName = outputFolder+ "/tmp"+ fileNO+".dat";
    writeData(array, line%amountOnce, fileName, fileNameList);
    reader.close();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
    try {
        reader.close();
    }
    catch (IOException e1) {
    }
}
return fileNameList;
}
}

private void writeData(int[] array, int length, String fileName, List<String> fileNames) throws IOException{
    Quicksort.quickSort(array, length);
    BufferedWriter output = new BufferedWriter(new FileWriter(fileName));
    for(int i=0;i<length;i++){
        output.write(String.valueOf(array[i]));
        output.write("\r\n");
    }
    output.close();
    fileNames.add(fileName);
    array = new int[amountOnce];
}
}

(3)

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;

public class PhaseTwo {

public static int inputBufferSize = 30000;

public static int outputBufferSize = 100000;

public static boolean finishFlag = false;

public void merge(List<String> fileNameList, String outputFolder) {
    int[] outputBuffer = new int[outputBufferSize];
    int[][] inputBuffers = new int[fileNameList.size()][inputBufferSize];
    List<BufferedReader> readers = new ArrayList<BufferedReader>();
    try {
        for(int i=0;i<fileNameList.size();i++){
            BufferedReader reader = new BufferedReader(new FileReader(fileNameList.get(i)));
            readers.add(reader);
            String tempString = null;
            int line = 0;
            while ((tempString = readers.get(i).readLine()) != null) {
            inputBuffers[i][line] = Integer.parseInt(tempString);
            line++;
            if(line >= inputBufferSize){
                break;
            }
        }
    }


    int[] pointers = new int[fileNameList.size()];

    int outputBufferIndex = 0;
    while(true){
        int min = findMin(inputBuffers,pointers, readers);
        outputBuffer[outputBufferIndex % outputBufferSize] = min;
        if(outputBufferIndex % outputBufferSize == outputBufferSize-1){
            outputData(outputBuffer, outputBufferSize, outputFolder+"/result.dat");
        }
        outputBufferIndex++;
        if(finishFlag){
            break;
        }
    }
    outputData(outputBuffer, outputBufferIndex%outputBufferSize, outputFolder+"/result.dat");

    for(int i=0;i<fileNameList.size();i++){
        readers.get(i).close();
    }
    System.out.println("------------------");

} catch (IOException e) {
    e.printStackTrace();
} finally {
    for(int i=0;i<fileNameList.size();i++){
    if (readers.get(i) != null) {
    try {
        readers.get(i).close();
    }
    catch (IOException e1) {
    }
}
}
}
}

private int findMin(int[][] arrays, int[] pointers, List<BufferedReader> readers) throws IOException{
    int min = 0;
    int index = 0;
    for(int i=0;i<arrays.length;i++){
        if(arrays[i][pointers[i]]>0){
            min = arrays[i][pointers[i]];
            index = i;
            break;
        }
    }

    for(int i=index+1;i<arrays.length;i++){
        if(arrays[i][pointers[i]]<=0){
            continue;
        }
        if(arrays[i][pointers[i]] < min){
            min = arrays[i][pointers[i]];
            index = i;
        }
    }
    pointers[index] = pointers[index]+1;

    for(int i=0;i<pointers.length;i++){
        if(pointers[i]>=inputBufferSize){
            arrays[i] = new int[inputBufferSize];
            String tempString = null;
            int line = 0;
            while ((tempString = readers.get(i).readLine()) != null) {
                arrays[i][line] = Integer.parseInt(tempString);
                line++;
                if(line >= inputBufferSize){
                    break;
                }
            }
            pointers[i]= 0;
        }
    } 

    //update finishFlag
    if(!finishFlag){
        boolean flag = true;
        for(int i=0;i<arrays.length;i++){
        if(arrays[i][pointers[i]]>0){
            flag = false;
            break;
        }
    }
    finishFlag = flag;
}
return min;
}

private void outputData(int[] outputBuffer, int length, String outputFile) throws IOException{
BufferedWriter output = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputFile, true)));
for(int i=0;i<length;i++){
    StringBuffer sb = new StringBuffer();
    sb.append(outputBuffer[i]);
    sb.append("\r\n");
    output.write(sb.toString());
}
output.close();
outputBuffer = new int[outputBufferSize];
}

}

(4)

public class Quicksort {
    public static void quickSort(int[] data, int length) {
        recQuickSort(data, 0, length-1);
    }

private static void recQuickSort(int[] data,int left, int right) {
    if(right-left <= 0){
    return;
}
else {
    long pivot = data[right];
    int partition = partitionIt(data, left, right, pivot);
    recQuickSort(data, left, partition-1);
    recQuickSort(data, partition+1, right);
}
}

private static int partitionIt(int[] data, int left, int right, long pivot) {
    int leftPtr = left-1;
    int rightPtr = right;
    while(true) {
        while(data[++leftPtr] < pivot )
        ;
        while(rightPtr > 0 && data[--rightPtr] > pivot)
        ;
        if(leftPtr >= rightPtr){
        break;
    }
    else{
        swap(data, leftPtr, rightPtr);
    }
}
swap(data, leftPtr, right);
    return leftPtr;
}

private static void swap(int[] data, int dex1, int dex2) {
    int temp = data[dex1];
    data[dex1] = data[dex2];
    data[dex2] = temp;
}
}
2013
10.01

首先,我们要明确如何用LISP表示二叉树节点结构。一个节点由本身,左子树,右子树3部分组成。我们就可以用如下结构表示1个节点:

(node (left-subtree) (right-subtree))

比如,1个二叉树由3个节点组成,根为20, 左子树1个节点30, 右子树1个节点40。可以表示为:'(20 (30 () ()) (40 () ()))。

更复杂的情况,1个由7个节点组成的完全二叉树,从上到下从左到右,分别是1,2,3,4,5,6,7。则表示成 ‘(1 (2 (4 () ()) (5 () ())) (3 (6 () ()) (7 () ())))。

定义好二叉树的LISP表示方法后,就可以定义3种遍历算法了。

前序遍历:


(defun preorder(tree)
(if (or (null tree)
(not (listp tree))
(null (car tree))
(listp (car tree))
(not (= (length tree) 3))
(not (listp (car (cdr tree))))
(not (listp (car (cdr (cdr tree)))))
)
nil
(cons (car tree) (append (preorder (car (cdr tree))) (preorder (car (cdr (cdr tree))))))))

中序遍历:

(defun inorder(tree)
(if (or (null tree)
(not (listp tree))
(null (car tree))
(listp (car tree))
(not (= (length tree) 3))
(not (listp (car (cdr tree))))
(not (listp (car (cdr (cdr tree)))))
)
nil
(append (inorder (car (cdr tree))) (cons (car tree) '()) (inorder (car (cdr (cdr tree)))))))

后序遍历:

(defun postorder(tree)
(if (or (null tree)
(not (listp tree))
(null (car tree))
(listp (car tree))
(not (= (length tree) 3))
(not (listp (car (cdr tree))))
(not (listp (car (cdr (cdr tree)))))
)
nil
(append (postorder (car (cdr tree))) (postorder (car (cdr (cdr tree)))) (cons (car tree) '()))))

Hit Counter by http://yizhantech.com/