俄罗斯方块游戏

如有疑问请查看：http://zh.wikipedia.org/zh-tw/%E4%BF%84%E7%BD%97%E6%96%AF%E6%96%B9%E5%9D%97

更多疑问请参考：http://java.itcast.cn/news/b4c1f433/34fd/4a7b/96bf/f1ae5e00ce70.shtml

游戏的运行结果如下：

代码的整体目录结构如下：

游戏发生的场地是在面板（panel）上，是JFrame框架把面板圈了起来

图形具有自己本身的特征，比如说形状，颜色，会定时落下一个单位，以及被触发的变幻，左移，右移，下移，

障碍物是图形落下后到底边框或其它图形产生的障碍物由图形生成的，

控制器负责接受按键事件来控制面板上的图形的移动和产生

这里是程序的入口处：

  1. package com.kodoyang.tetris.test;
  2.  
  3. import javax.swing.JFrame;
  4.  
  5. import com.kodoyang.tetris.control.Controller;
  6. import com.kodoyang.tetris.pojo.Ground;
  7. import com.kodoyang.tetris.pojo.ShapeFactory;
  8. import com.kodoyang.tetris.view.Panel;
  9.  
  10. public class Game {
  11.  
  12.     public static void main(String[] args) {
  13.         // TODO Auto-generated method stub
  14.  
  15.         ShapeFactory shapeFactory = new ShapeFactory();
  16.         Ground ground = new Ground();
  17.         Panel panel = new Panel();
  18.  
  19.         Controller controller = new Controller(shapeFactory, ground, panel);
  20.  
  21.         JFrame frame = new JFrame();
  22.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  23.         frame.setSize(panel.getSize().width + 10, panel.getSize().height + 35);
  24.         frame.add(panel);
  25.         panel.addKeyListener(controller);
  26.  
  27.         frame.addKeyListener(controller);
  28.         frame.setVisible(true);
  29.         controller.newGame();
  30.  
  31.     }
  32.  
  33. }

先来看看图形类：

图形的body回填上制造啊它的工厂传给它的参数，

以及它的移动方式，坐标，颜色，画自己的方法，不断下落的线程

  1. package com.kodoyang.tetris.pojo;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Graphics;
  5.  
  6. import com.kodoyang.tetris.listen.ShapeListener;
  7. import com.kodoyang.tetris.util.Global;
  8.  
  9. public class Shape {
  10.  
  11.     public static final int ROTATE = 0;
  12.     public static final int LEFT = 1;
  13.     public static final int RIGHT = 2;
  14.     public static final int DOWN = 3;
  15.  
  16.     private int[][] body;
  17.     private int status;
  18.     private Color color;
  19.  
  20.     private int left;
  21.     private int top;
  22.  
  23.     public void setBody(int body[][]){
  24.         this.body = body;
  25.     }
  26.  
  27.     public void setStatus(int status) {
  28.         this.status = status;
  29.     }
  30.  
  31.     public int getTop(){
  32.         return top;
  33.     }
  34.     public int getLeft(){
  35.         return left;
  36.     }
  37.  
  38.     private ShapeListener listener;
  39.  
  40.     public void moveLeft() {
  41.         System.out.println("Shape's moveLeft");
  42.         --left;
  43.     }
  44.  
  45.     public void moveRight() {
  46.         System.out.println("Shape's moveRight");
  47.         ++left;
  48.     }
  49.  
  50.     public void moveDown() {
  51.         System.out.println("Shape's moveDown");
  52.         ++top;
  53.     }
  54.  
  55.     public void rotate() {
  56.         System.out.println("Shape's rotate");
  57.         status = (status + 1) % body.length;
  58.     }
  59.  
  60.     public void drawMe(Graphics g) {
  61.         System.out.println("Shape's drawMe");
  62.  
  63.         g.setColor(color);
  64.         for(int x = 0; x < 4; ++x){
  65.             for(int y = 0; y < 4; ++y){
  66.                 if(getFlagByPoint(x, y)){
  67.                     g.fill3DRect(
  68.                             (left + x) * Global.CELL_SIZE,
  69.                             (top + y) * Global.CELL_SIZE,
  70.                             Global.CELL_SIZE,
  71.                             Global.CELL_SIZE,
  72.                             true);
  73.                 }
  74.             }
  75.         }
  76.  
  77.     }
  78.  
  79.     private boolean getFlagByPoint(int x, int y){
  80.         /*boolean res = false;
  81.         try {
  82.             // return body[status][x + y * 4] == 1;
  83.             res = body[status][x + y * 4] == 1;
  84.         } catch (Exception e) {
  85.             // TODO Auto-generated catch block
  86.             System.out.println("(x, y) = (" + x + ", " + y + ")");
  87.             e.printStackTrace();
  88.         }
  89.         return res;*/
  90.         return body[status][x + y * 4] == 1;
  91.     }
  92.  
  93.     public boolean isMember(int x, int y, boolean rotate){
  94.         int tempStatus = status;
  95.         if(rotate){
  96.             tempStatus = (status + 1) % body.length;
  97.         }
  98.         return body[tempStatus][x + y * 4] == 1;
  99.     }
  100.  
  101.     private class ShapeDriver implements Runnable {
  102.  
  103.         @Override
  104.         public void run() {
  105.             while(listener.isShapeMoveDownable(Shape.this)) {
  106.                 moveDown();
  107.                 listener.shapeMoveDown(Shape.this);
  108.  
  109.                 try {
  110.                     Thread.sleep(1000);
  111.                 } catch (InterruptedException e) {
  112.                     e.printStackTrace();
  113.                 }
  114.             }
  115.         }
  116.  
  117.     }
  118.  
  119.     public Shape() {
  120.         new Thread(new ShapeDriver()).start();
  121.     }
  122.  
  123.     public void addShapeListenner(ShapeListener l) {
  124.         if(l != null)
  125.             this.listener = l;
  126.     }
  127.  
  128.     public Color getColor() {
  129.         return color;
  130.     }
  131.  
  132.     public void setColor(Color color) {
  133.         this.color = color;
  134.     }
  135.  
  136. }

产生图形的工厂类如下：

shapes中定义了一些预置的图形，colors中定义了一些图形可以使用的颜色

  1. package com.kodoyang.tetris.pojo;
  2.  
  3. import java.awt.Color;
  4. import java.util.Random;
  5.  
  6. import com.kodoyang.tetris.listen.ShapeListener;
  7.  
  8. public class ShapeFactory {
  9.  
  10.     private int[][][] shapes = new int[][][]{
  11.             {
  12.                 {
  13.                     1, 0, 0, 0,
  14.                     1, 1, 1, 0,
  15.                     0, 0, 0, 0,
  16.                     0, 0, 0, 0
  17.                 },
  18.                 {
  19.                     1, 1, 0, 0,
  20.                     1, 0, 0, 0,
  21.                     1, 0, 0, 0,
  22.                     0, 0, 0, 0
  23.                 },
  24.                 {
  25.                     1, 1, 1, 0,
  26.                     0, 0, 1, 0,
  27.                     0, 0, 0, 0,
  28.                     0, 0, 0, 0
  29.                 },
  30.                 {
  31.                     0, 1, 0, 0,
  32.                     0, 1, 0, 0,
  33.                     1, 1, 0, 0,
  34.                     0, 0, 0, 0
  35.                 }
  36.             },
  37.             {
  38.                 {
  39.                     1, 1, 1, 1,
  40.                     0, 0, 0, 0,
  41.                     0, 0, 0, 0,
  42.                     0, 0, 0, 0
  43.                 },
  44.                 {
  45.                     1, 0, 0, 0,
  46.                     1, 0, 0, 0,
  47.                     1, 0, 0, 0,
  48.                     1, 0, 0, 0
  49.                 }
  50.             },
  51.             {
  52.                 {
  53.                     1, 1, 0, 0,
  54.                     1, 1, 0, 0,
  55.                     0, 0, 0, 0,
  56.                     0, 0, 0, 0
  57.                 }
  58.             },
  59.             {
  60.                 {
  61.                     1, 1, 1, 0,
  62.                     1, 0, 0, 0,
  63.                     0, 0, 0, 0,
  64.                     0, 0, 0, 0
  65.                 },
  66.                 {
  67.                     1, 0, 0, 0,
  68.                     1, 0, 0, 0,
  69.                     1, 1, 0, 0,
  70.                     0, 0, 0, 0
  71.                 },
  72.                 {
  73.                     0, 0, 1, 0,
  74.                     1, 1, 1, 0,
  75.                     0, 0, 0, 0,
  76.                     0, 0, 0, 0
  77.                 },
  78.                 {
  79.                     1, 1, 0, 0,
  80.                     0, 1, 0, 0,
  81.                     0, 1, 0, 0,
  82.                     0, 0, 0, 0
  83.                 }
  84.             },
  85.             {
  86.                 {
  87.                     1, 0, 0, 0,
  88.                     1, 1, 0, 0,
  89.                     0, 1, 0, 0,
  90.                     0, 0, 0, 0
  91.                 },
  92.                 {
  93.                     0, 1, 1, 0,
  94.                     1, 1, 0, 0,
  95.                     0, 0, 0, 0,
  96.                     0, 0, 0, 0
  97.                 },
  98.                 {
  99.                     0, 1, 0, 0,
  100.                     1, 1, 0, 0,
  101.                     1, 0, 0, 0,
  102.                     0, 0, 0, 0
  103.                 },
  104.                 {
  105.                     1, 1, 0, 0,
  106.                     0, 1, 1, 0,
  107.                     0, 0, 0, 0,
  108.                     0, 0, 0, 0
  109.                 }
  110.             },
  111.             {
  112.                 {
  113.                     1, 0, 0, 0,
  114.                     1, 1, 0, 0,
  115.                     1, 0, 0, 0,
  116.                     0, 0, 0, 0
  117.                 },
  118.                 {
  119.                     0, 1, 0, 0,
  120.                     1, 1, 1, 0,
  121.                     0, 0, 0, 0,
  122.                     0, 0, 0, 0
  123.                 },
  124.                 {
  125.                     0, 1, 0, 0,
  126.                     1, 1, 0, 0,
  127.                     0, 1, 0, 0,
  128.                     0, 0, 0, 0
  129.                 },
  130.                 {
  131.                     1, 1, 1, 0,
  132.                     0, 1, 0, 0,
  133.                     0, 0, 0, 0,
  134.                     0, 0, 0, 0
  135.                 }
  136.             },
  137.             {
  138.                 {
  139.                     0, 1, 1, 0,
  140.                     1, 0, 0, 1,
  141.                     1, 0, 0, 1,
  142.                     0, 1, 1, 0
  143.                 },
  144.                 {
  145.                     1, 0, 0, 1,
  146.                     0, 1, 1, 0,
  147.                     0, 1, 1, 0,
  148.                     1, 0, 0, 1
  149.                 }
  150.             },
  151.             {
  152.                 {
  153.                     0, 1, 0, 0,
  154.                     1, 1, 1, 1,
  155.                     0, 1, 0, 0,
  156.                     0, 1, 0, 1
  157.                 },
  158.                 {
  159.                     1, 0, 1, 0,
  160.                     0, 0, 1, 0,
  161.                     1, 1, 1, 1,
  162.                     0, 0, 1, 0
  163.                 }
  164.             },
  165.             {
  166.                 {
  167.                     0, 1, 0, 0,
  168.                     1, 1, 1, 1,
  169.                     1, 0, 0, 1,
  170.                     1, 0, 0, 1
  171.                 },
  172.                 {
  173.                     0, 1, 1, 0,
  174.                     1, 0, 1, 0,
  175.                     0, 1, 0, 1,
  176.                     0, 1, 1, 0
  177.                 }
  178.             }
  179.     };
  180.  
  181.     private Color[] colors = new Color[]{
  182.         Color.CYAN,
  183.         Color.BLACK,
  184.         Color.BLUE,
  185.         Color.GREEN,
  186.         Color.MAGENTA,
  187.         Color.ORANGE,
  188.         Color.PINK,
  189.         Color.RED,
  190.         Color.WHITE,
  191.         Color.YELLOW
  192.     };
  193.  
  194.     public Shape getShape(ShapeListener listener) {
  195.         System.out.println("ShapeFactory's getShape");
  196.         Shape shape = new Shape();
  197.         shape.addShapeListenner(listener);
  198.  
  199.         int type = new Random().nextInt(shapes.length);
  200.         shape.setBody(shapes[type]);
  201.         shape.setStatus(0);
  202.         shape.setColor(colors[new Random().nextInt(colors.length)]);
  203.  
  204.         return shape;
  205.     }
  206.  
  207. }

图形监听器的接口类：

实现这个接口的类必须要实现两个方法，让图形下移，判断图形是否可以移动

  1. package com.kodoyang.tetris.listen;
  2.  
  3. import com.kodoyang.tetris.pojo.Shape;
  4.  
  5. public interface ShapeListener {
  6.  
  7.     void shapeMoveDown(Shape shape);
  8.  
  9.     boolean isShapeMoveDownable(Shape shape);
  10.  
  11. }

接受图形的静寂大地类：

当图形不能移动时就变为寂静大地了，构成静寂大地的是一个个的障碍物，

它通过计算图形下一步的位置来得出图形能不能移动的信息

如果障碍物出现在面板的顶部，就表示已经满了，游戏结束

判断某一行满行就把满了的行消掉

  1. package com.kodoyang.tetris.pojo;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Graphics;
  5.  
  6. import com.kodoyang.tetris.util.Global;
  7.  
  8. public class Ground {
  9.  
  10.     private int[][] obstacles = new int[Global.WIDTH][Global.HEIGHT];
  11.  
  12.     public void accept(Shape shape) {
  13.         System.out.println("Ground's accept");
  14.         for(int x = 0; x < 4; ++x){
  15.             for(int y = 0; y < 4; ++y){
  16.                 if(shape.isMember(x, y, false)){
  17.                     obstacles[shape.getLeft() + x][shape.getTop() + y]
  18.                             = 1;
  19.                 }
  20.             }
  21.         }
  22.         deleteFullLine();
  23.     }
  24.  
  25.     private void deleteFullLine(){
  26.         for(int y = Global.HEIGHT - 1; y >= 0; --y){
  27.             boolean full = true;
  28.             for(int x = 0; x < Global.WIDTH; ++x){
  29.                 if(obstacles[x][y] == 0)
  30.                     full = false;
  31.             }
  32.             if(full){
  33.                 deleteLine(y);
  34.             }
  35.         }
  36.     }
  37.  
  38.     private void deleteLine(int lineNum) {
  39.         for(int y = lineNum; y > 0; --y){
  40.             for(int x = 0; x < Global.WIDTH; ++x){
  41.                 obstacles[x][y] = obstacles[x][y - 1];
  42.             }
  43.         }
  44.         for(int x = 0; x < Global.WIDTH; ++x){
  45.             //obstacles[x][0] = 0;
  46.         }
  47.     }
  48.  
  49.     public void drawMe(Graphics g) {
  50.         System.out.println("Ground's drawMe");
  51.  
  52.         g.setColor(Color.DARK_GRAY);
  53.         for(int x = 0; x < Global.WIDTH; ++x){
  54.             for(int y = 0; y <Global.HEIGHT; ++y){
  55.                 if(obstacles[x][y] == 1){
  56.                     g.fill3DRect(
  57.                             x * Global.CELL_SIZE,
  58.                             y * Global.CELL_SIZE,
  59.                             Global.CELL_SIZE,
  60.                             Global.CELL_SIZE,
  61.                             true);
  62.                 }
  63.             }
  64.         }
  65.     }
  66.  
  67.     public boolean isMoveable(Shape shape, int action){
  68.  
  69.         int left = shape.getLeft();
  70.         int top = shape.getTop();
  71.         switch(action){
  72.         case Shape.LEFT:
  73.             --left;
  74.             break;
  75.         case Shape.RIGHT:
  76.             ++left;
  77.             break;
  78.         case Shape.DOWN:
  79.             ++top;
  80.             break;
  81.         }
  82.  
  83.         for(int x = 0; x < 4; ++x){
  84.             for(int y = 0; y < 4; ++y){
  85.                 if(shape.isMember(x, y, action == Shape.ROTATE)){
  86.                     if(top + y >= Global.HEIGHT ||
  87.                             left + x < 0 ||
  88.                             left + x >= Global.WIDTH ||
  89.                             obstacles[left + x][top + y] == 1)
  90.                         return false;
  91.                 }
  92.             }
  93.         }
  94.         return true;
  95.     }
  96.  
  97.     public boolean isFull(){
  98.         for(int x = 0; x < Global.WIDTH; ++x){
  99.             if(obstacles[x][0] == 1)
  100.                 return true;
  101.         }
  102.         return false;
  103.     }
  104.  
  105. }

用于显示的面板类：

它的画图方法就是在清空整个面板后，调用图形和静寂大地的画图方法

它的构造方法会决定游戏界面的大小

  1. package com.kodoyang.tetris.view;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Graphics;
  5.  
  6. import javax.swing.JPanel;
  7.  
  8. import com.kodoyang.tetris.pojo.Ground;
  9. import com.kodoyang.tetris.pojo.Shape;
  10. import com.kodoyang.tetris.util.Global;
  11.  
  12. public class Panel extends JPanel {
  13.  
  14.     private Ground ground;
  15.     private Shape shape;
  16.  
  17.     public void display(Ground ground, Shape shape) {
  18.         System.out.println("TetrisPanel's display");
  19.         this.ground = ground;
  20.         this.shape = shape;
  21.         this.repaint();
  22.     }
  23.  
  24.     @Override
  25.     protected void paintComponent(Graphics g) {
  26.         // 重新显示
  27.  
  28.         g.setColor(Color.LIGHT_GRAY);
  29.         g.fillRect(0, 0, Global.WIDTH * Global.CELL_SIZE,
  30.                          Global.HEIGHT * Global.CELL_SIZE);
  31.  
  32.         if(shape != null && ground != null){
  33.             shape.drawMe(g);
  34.             ground.drawMe(g);
  35.         }
  36.     }
  37.  
  38.     public Panel() {
  39.         this.setSize(
  40.                 Global.WIDTH * Global.CELL_SIZE,
  41.                 Global.HEIGHT * Global.CELL_SIZE);
  42.     }
  43.  
  44. }

常量定义在全局类中：

每一个正方形小块的大小，面板拥有多少个正方形的边长个单位

  1. package com.kodoyang.tetris.util;
  2.  
  3. public class Global {
  4.  
  5.     public static final int CELL_SIZE = 20;
  6.     public static final int WIDTH = 20;
  7.     public static final int HEIGHT = 25;
  8.  
  9. }

控制它们的中央控制器：

它继承自按键事件的监听并实现了图形监听的接口

它控制当前活动图形以及产生它的工厂，障碍物，面板

产生一个新游戏的方法，判断图形是否可以下落，更新面板上的图形和障碍物，

  1. package com.kodoyang.tetris.control;
  2.  
  3. import java.awt.event.KeyAdapter;
  4. import java.awt.event.KeyEvent;
  5.  
  6. import com.kodoyang.tetris.listen.ShapeListener;
  7. import com.kodoyang.tetris.pojo.Ground;
  8. import com.kodoyang.tetris.pojo.Shape;
  9. import com.kodoyang.tetris.pojo.ShapeFactory;
  10. import com.kodoyang.tetris.view.Panel;
  11.  
  12. public class Controller extends KeyAdapter implements ShapeListener {
  13.  
  14.     private Shape shape;
  15.     private ShapeFactory shapeFactory;
  16.     private Ground ground;
  17.     private Panel panel;
  18.  
  19.     @Override
  20.     public synchronized boolean isShapeMoveDownable(Shape shape) {
  21.         // TODO Auto-generated method stub
  22.         if(this.shape != shape){
  23.             return false;
  24.         }
  25.         if( ground.isMoveable(shape, Shape.DOWN) )
  26.             return true;
  27.         ground.accept(this.shape);
  28.         if(!ground.isFull()){
  29.             this.shape = shapeFactory.getShape(this);
  30.         }
  31.         return false;
  32.     }
  33.  
  34.     @Override
  35.     public void keyPressed(KeyEvent e) {
  36.  
  37.         switch(e.getKeyCode()) {
  38.         case KeyEvent.VK_UP:
  39.             if(ground.isMoveable(shape, Shape.ROTATE))
  40.                 shape.rotate();
  41.             break;
  42.         case KeyEvent.VK_DOWN:
  43.             // if(ground.isMoveable(shape, Shape.DOWN))
  44.             if(isShapeMoveDownable(shape))
  45.                 shape.moveDown();
  46.             break;
  47.         case KeyEvent.VK_LEFT:
  48.             if(ground.isMoveable(shape, Shape.LEFT))
  49.                 shape.moveLeft();
  50.             break;
  51.         case KeyEvent.VK_RIGHT:
  52.             if(ground.isMoveable(shape, Shape.RIGHT))
  53.                 shape.moveRight();
  54.             break;
  55.         }
  56.  
  57.         panel.display(ground, shape);
  58.     }
  59.  
  60.     @Override
  61.     public void shapeMoveDown(Shape shape) {
  62.         panel.display(ground, shape);
  63.  
  64.     }
  65.  
  66.     public void newGame() {
  67.         shape = shapeFactory.getShape(this);
  68.     }
  69.  
  70.     public Controller(ShapeFactory shapeFactory,
  71.             Ground ground, Panel panel) {
  72.         this.shapeFactory = shapeFactory;
  73.         this.ground = ground;
  74.         this.panel = panel;
  75.  
  76.     }
  77.  
  78. }

跟多好文请查看：http://www.cnblogs.com/kodoyang/

俄罗斯方块游戏 --- java的更多相关文章

  1. java俄罗斯方块游戏代码

    java俄罗斯方块游戏代码: package com; import java.awt.Color; import java.awt.Graphics; import java.awt.event.K ...

  2. 经典 HTML5 & Javascript 俄罗斯方块游戏

    Blockrain.js 是一个使用 HTML5 & JavaScript 开发的经典俄罗斯方块游戏.只需要复制和粘贴一段代码就可以玩起来了.最重要的是,它是响应式的,无论你的显示屏多么宽都能 ...

  3. 从零开始---控制台用c写俄罗斯方块游戏（1）

    从零开始---控制台用c写俄罗斯方块游戏(1) 很少写博文,一来自身知识有限,二来自己知道,已经有很多这样的博文了,三就是因为懒,文笔也一般,四来刚出来工作,时间也不多 之所以写这篇博文,是因为应群里 ...

  4. 用C写的俄罗斯方块游戏 By: hoodlum1980 编程论坛

    /************************************ * Desc: 俄罗斯方块游戏 * By: hoodlum1980 * Email: jinfd@126.com * Dat ...

  5. 教你看懂网上流传的60行JavaScript代码俄罗斯方块游戏

    早就听说网上有人仅仅用60行JavaScript代码写出了一个俄罗斯方块游戏,最近看了看,今天在这篇文章里面我把我做的分析整理一下(主要是以注释的形式). 我用C写一个功能基本齐全的俄罗斯方块的话,大 ...

  6. 俄罗斯方块游戏JavaScript代码

    JavaScript代码俄罗斯方块游戏 早就听说网上有人仅仅用60行JavaScript代码写出了一个俄罗斯方块游戏,最近看了看,今天在这篇文章里面我把我做的分析整理一下(主要是以注释的形式). 我用 ...

  7. 使用JS实现俄罗斯方块游戏

    简单的JS俄罗斯方块游戏源码 效果图: 代码如下,复制即可使用: <!DOCTYPE html> <html> <head> <meta charset=&q ...

  8. C++编写简单的俄罗斯方块游戏

    代码地址如下:http://www.demodashi.com/demo/14593.html C++编写简单的俄罗斯方块游戏 使用C++编写一个简单的俄罗斯方块游戏. 1 环境要求 使用C++图形库 ...

  9. electron写俄罗斯方块游戏（Tetris）

    背景 在折腾ES6,突然想起大学时用c语言写过俄罗斯方块,本项目中主要是利用ES6的Class特性进行面向对象编程.项目采用node.js v6.2.0 + electron v1.1.0 进行桌面开 ...

随机推荐

  1. MyBatis学习总结_01_MyBatis快速入门

    一.Mybatis介绍 MyBatis是一个支持普通SQL查询,存储过程和高级映射的优秀持久层框架.MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装.MyBatis可以 ...

  2. CentOS查看系统信息命令和方法

    收集整理的一些linux查看系统信息的命令和方法: 一.linux查看服务器系统信息的方法: 1.查看主机名/内核版本/CPU构架: # uname -n -r -p -o localhost.loc ...

  3. JVM生产环境参数实例及分析

    java application项目(非web项目) 改进前: -Xms128m-Xmx128m-XX:NewSize=64m-XX:PermSize=64m-XX:+UseConcMarkSweep ...

  4. 爬虫Larbin解析(二)——sequencer()

    分析的函数: void sequencer() //位置:larbin-2.6.3/src/fetch/sequencer.ccvoid sequencer() { bool testPriority ...

  5. HDU 4664 Triangulation（SG函数）

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4664 题意:给出一个n个点的凸包(不存在三点共线).每次可以选择两个点连线,但是任意两条线只能在顶点处 ...

  6. Itext导出PDF,word,图片案例

    iText导出pdf.word.图片 一.前言 在企业的信息系统中,报表处理一直占比较重要的作用,本文将介绍一种生成PDF报表的Java组件--iText.通过在服务器端使用Jsp或JavaBean生 ...

  7. 无锁编程(一) - Double-checked Locking

      Double-checked Locking,严格意义上来讲不属于无锁范畴,无论什么时候当临界区中的代码仅仅需要加锁一次,同时当其获取锁的时候必须是线程安全的,此时就可以利用 Double-che ...

  8. win7 64位系统 Oracle32bit + PL/SQL访问Orale服务，Oracle 11g的安装，中文乱码问题的解决

    前几天装了个Oracle32bit客户端 + PL/SQL连接不上oracle,我安装完打开PL/SQL登录界面跟正常的界面不一样,没有那个连接为Normal.SYSDBA的选项,下面有解释,至于我为 ...

  9. 用VS2005开发WinCE程序调试图文教程

    一.WinCE 模拟器通过ActiveSync 6.1(即Windows Mobile设备中心)连接P 1.启动WinCE模拟器 命令行:  start .\DeviceEmulator.exe WI ...

  10. HDU 1527 (Wythoff 博弈) 取石子游戏

    对于Wythoff博弈中的两个数列,An和Bn有这样的关系: An + n = Bn, An = floor(φ * n) 所以我们可以根据a b的差值来计算一个新的a出来看看这两个值是否相等. 想等 ...