来源: 互联网  发布时间: 2014-02-18

简单易行的番茄时间管理法——学会专注
“很忙，很忙”似乎成为现代人的口头禅，也似乎成为了一个人是否成功的标志。特别感叹我们祖先的智慧，“忙”=“心”+“忘”，如果心都死了，忙又有什么意义呢？想要忙的有意义，就要学会管理自己的时间。

       对于刚入职的新人，各种适应、各种调整，还没有建立起属于自己的一套时间管理方法，总觉得时间不够用，总觉得事情太多，尤其会有这种体会。以前也有看过很多关于时间管理的书，比如四象限原则、20/80原则、5W 2H原则等，听着挺有道理，执行起来却觉得太过理论、太复杂。

       近期读了一本书——《番茄工作法图解》，里面提供了很多能帮助我们进行时间管理的方法，简单易行，拿出来分享给大家。

1、 为什么会有番茄工作法？

      人际间的交流手段以及获取信息的手段不断丰富，人们的时间利用效率却变得越来越低。沉下心思专心做一件事情，对绝大多数人来说已经变成一件不可能的任务。其实要完成大量的工作，重点不在完成工作上，而在于能否集中注意力，提高效率。番茄工作法更关注“微观”层面，帮我们将100%的心智专注在当下，避免不必要的压力和负担。

2、 什么是番茄工作法？

      简单说就是选择一个待完成的任务，将番茄时间设定为25分钟，然后全然专注于该任务，中途不允许做任何与该任务无关的事，直到番茄时钟响起，哪怕工作没有完成莫也要定时休息，然后进入下一个番茄时间。番茄法以25分钟的短期迭代为节奏，帮你建立可持续发展的步伐，休息时安心休息，工作时一心一意。

3、 哪些人适合用番茄法？

      1）工作时不知不觉走神去干别的事了。

      2）工作中常被旺旺、邮件、电话等外部中断困扰。

      3）工作中常常由于时间不知不觉的流逝，工作却没有完成产生焦虑。

4、 方法

      番茄工作法的工具很简单：一只钢笔、一枚计时器以及三张白纸。

      三张白纸的用途如下：

      1）“今日待办”表格——填写今天的日期、列出打算在今天进行的活动，把最重要的活动排到第一位。每天早上需要更换此表格。

      2）“活动清单”表格——列出近期要进行的活动，不要排序。同一张“活动清单”可以用很多天，增加新的活动，划去已完成的。

      3）“记录”表格——记录所采用的流程指标，以便对流程进行优化。同一张“记录”表格可以用很多天，以便比较每天的跟踪记录。

5、 原则

      1）定期评估活动的重要程度，及时调整活动的优先级。

      2）番茄钟具有原子性，不可分割。对于内部中断，比如突然想起有一个重要电话要打，饿了想吃点东西，记录这些内部中断，然后继续手头的工作。对于外部中断，比如同事找你面谈，提醒你有新邮件，旺旺弹出消息，除了刻不容缓的事件，在可接受范围内的，记录为“计划外紧急”，均可在稍后的番茄中重新计划中断事件，尽量不要在当时直接处理。

      3）每完成一个番茄钟，一定要休息，每四个番茄钟后进行阶段性休息（15分钟），休息期间不允许思考工作，不打重要电话，不写重要邮件，让大脑充分休息。可以清理下办公桌，或者去喜欢的社交网站转转。

     4）不要频繁地修改番茄钟的长度，在某个固定长度至少坚持两个星期，否则会破坏你的节奏。

6、 我的番茄钟

      “活动清单”表格和“今日待办”表格不一定非要两张纸，可以用卡片来代替。“活动清单”是一叠卡卡片，每天早上的计划阶段，挑出几张卡片，就是当天的“今日待办”卡片，按优先级顺序排列他们，最重要的放在最上面。

       早晨的第一个番茄钟，我总是用来回复昨天下班后到今天这段时间的新邮件，如果25分钟不够，我就不继续回复。午饭回来后再安排另一个番茄钟继续回复。对于邮件的处理—— 如果某项活动不能马上进行，需要获取其他人的信息，我会将问题发给那个人，并将邮件移入存档文件夹；将对我没用的邮件立即删掉，大量的不知所谓的电子邮件会将新的、重要的、真正需要行动的邮件淹没在其中；将你需要在近期完成的任务、计划书等设置为任务，并在任务到期前一天添加提醒。

       在下班前的零碎时间段，我给自己定了一个40分钟的番茄钟用于梳理一天的工作，整理各项事务，并对第二天计划做个大致安排。这个40分钟的番茄钟和其他25分钟的番茄钟没有可比性，因此不作记录。

       当我从一堆活动中无法确定优先级时，我会对活动的重要度两两进行比较，比从一堆活动中排除优先级顺序容易的多。

       每天，我们都要有一个承诺：一个番茄钟、一个活动、一个目标。

       番茄工作法能让我们把重点放在执行力上，它提供简单而具体的实践方法，每半个小时，从工作中跳出来，纵览全局，定期的短暂休息，采取可持续的步伐，让人在最佳状态下全速前进，而不是一面埋头苦干，一面抵抗越来越多的中断。

资料：

番茄计时器：search （pomodoro timer download）
VN:F [1.9.7_1111]
please wait...
Rating: 6.4/10 (13 votes cast)
简单易行的番茄时间管理法——学会专注, 6.4 out of 10 based on 13 ratings 转载务必注明出处Taobao QA Team，原文地址：http://qa.taobao.com/?p=13476

    

    来源: 互联网  发布时间: 2014-02-18

JAVA 反射机制

一、什么是反射：
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提 出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中 LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。

反射本身并不 是一个新概念，尽管计算机科学赋予了反射概念新的含义。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机 制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用 所描述行为的状态和相关的语义。

二、什么是Java中的类反射：
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性和方法。Java 的这一能力在实际应用中用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。
Reflection 是 Java 被视为动态（或准动态）语言的关键，允许程序于执行期 Reflection APIs 取得任何已知名称之 class 的內部信息，包括 package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可于执行期生成instances、变更 fields 內容或唤起 methods。

三、Java类反射中所必须的类：
Java的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object，下面我将对这些类做一个简单的说明。
Field类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。
Constructor类：提供关于类的单个构造方法的信息以及对它的访问权限。这个类和Field类不同，Field类封装了反射类的属性，而Constructor类则封装了反射类的构造方法。
Method类：提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。 这个类不难理解，它是用来封装反射类方法的一个类。
Class类：类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
Object类：每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

四、Java的反射类能做什么：
看完上面的这么多我想你已经不耐烦了，你以为我在浪费你的时间，那么好吧！下面我们就用一些简单的小例子来说明它。
首先我们来看一下通过Java的反射机制我们能得到些什么。
首先我们来写一个类：

你可能被我这个类弄糊涂了，你看不出我要做什么，那就不要看这个类了，这个类是用来测试的，你知道知道它继承了Object类，有一个接口是ActionListener，两个属性int和Integer,两个构造方法和两个方法，这就足够了。
下面我们把A这个类作为一个反射类，来过去A类中的一些信息，首先我们先来过去一下反射类中的属性和属性值。

这 里用到了两个方法，getFields()、getDeclaredFields()，它们分别是用来获取反射类中所有公有属性和反射类中所有的属性的方 法。另外还有getField(String)和getDeclaredField(String)方法都是用来过去反射类中指定的属性的方法，要注意的 是getField方法只能取到反射类中公有的属性，而getDeclaredField方法都能取到。
这里还用到了Field 类的setAccessible方法，它是用来设置是否有权限访问反射类中的私有属性的，只有设置为true时才可以访问，默认为false。另外 Field类还有set(Object AttributeName,Object value)方法，可以改变指定属性的值。

下面我们来看一下如何获取反射类中的构造方法

这个例子很简单,只是用getConstructors()方法获取了反射类的构造方法的集合，并用Constructor类的getParameterTypes()获取该构造方法的参数。

下面我们再来获取一下反射类的父类（超类）和接口

这 个例子也很简单，只是用Class类的getInterfaces()方法获取反射类的所有接口，由于接口可以有多个，所以它返回一个 Class数组。用getSuperclass()方法来获取反射类的父类（超类），由于一个类只能继承自一个类，所以它返回一个Class对象。

下面我们来获取一下反射类的方法

这个例子并不难，它只是获得了反射类的所有方法，包括继承自它父类的方法。然后获取方法的返回类型、方法名和方法参数。

接下来让我们回过头来想一想，我们获取了反射类的属性、构造方法、父类、接口和方法，可这些东西能帮我们做些什么呢！！
下面我写一个比较完整的小例子，来说明Java的反射类能做些什么吧！！

这是我在工作中写的一个实现Java在运行时加载指定的类，并调用指定方法的一个小例子。这里没有main方法，你可以自己写一个。
Load方法接收的五个参数分别是，Java的类名，方法名，参数的类型和参数的值。

结束语：
Java 语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的 方式与对象协作的库。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远 慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况 下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

    

    来源: 互联网  发布时间: 2014-02-18

转：java操作文件

 

 

package cn.edu.tongji.cims.wade.system;  
import java.io.*;  
public class FileOperate {  
  public FileOperate() {  
  }  
  /** 
   * 新建目录 
   * @param folderPath String 如 c:/fqf 
   * @return boolean 
   */  
  public void newFolder(String folderPath) {  
    try {  
      String filePath = folderPath;  
      filePath = filePath.toString();  
      java.io.File myFilePath = new java.io.File(filePath);  
      if (!myFilePath.exists()) {  
        myFilePath.mkdir();  
      }  
    }  
    catch (Exception e) {  
      System.out.println("新建目录操作出错");  
      e.printStackTrace();  
    }  
  }  
  /** 
   * 新建文件 
   * @param filePathAndName String 文件路径及名称 如c:/fqf.txt 
   * @param fileContent String 文件内容 
   * @return boolean 
   */  
  public void newFile(String filePathAndName, String fileContent) {  
    try {  
      String filePath = filePathAndName;  
      filePath = filePath.toString();  
      File myFilePath = new File(filePath);  
      if (!myFilePath.exists()) {  
        myFilePath.createNewFile();  
      }  
      FileWriter resultFile = new FileWriter(myFilePath);  
      PrintWriter myFile = new PrintWriter(resultFile);  
      String strContent = fileContent;  
      myFile.println(strContent);  
      resultFile.close();  
    }  
    catch (Exception e) {  
      System.out.println("新建目录操作出错");  
      e.printStackTrace();  
    }  
  }  
  /** 
   * 删除文件 
   * @param filePathAndName String 文件路径及名称 如c:/fqf.txt 
   * @param fileContent String 
   * @return boolean 
   */  
  public void delFile(String filePathAndName) {  
    try {  
      String filePath = filePathAndName;  
      filePath = filePath.toString();  
      java.io.File myDelFile = new java.io.File(filePath);  
      myDelFile.delete();  
    }  
    catch (Exception e) {  
      System.out.println("删除文件操作出错");  
      e.printStackTrace();  
    }  
  }  
  /** 
   * 删除文件夹 
   * @param filePathAndName String 文件夹路径及名称 如c:/fqf 
   * @param fileContent String 
   * @return boolean 
   */  
  public void delFolder(String folderPath) {  
    try {  
      delAllFile(folderPath); //删除完里面所有内容  
      String filePath = folderPath;  
      filePath = filePath.toString();  
      java.io.File myFilePath = new java.io.File(filePath);  
      myFilePath.delete(); //删除空文件夹  
    }  
    catch (Exception e) {  
      System.out.println("删除文件夹操作出错");  
      e.printStackTrace();  
    }  
  }  
  /** 
   * 删除文件夹里面的所有文件 
   * @param path String 文件夹路径 如 c:/fqf 
   */  
  public void delAllFile(String path) {  
    File file = new File(path);  
    if (!file.exists()) {  
      return;  
    }  
    if (!file.isDirectory()) {  
      return;  
    }  
    String[] tempList = file.list();  
    File temp = null;  
    for (int i = 0; i < tempList.length; i++) {  
      if (path.endsWith(File.separator)) {  
        temp = new File(path + tempList[i]);  
      }  
      else {  
        temp = new File(path + File.separator + tempList[i]);  
      }  
      if (temp.isFile()) {  
        temp.delete();  
      }  
      if (temp.isDirectory()) {  
        delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件  
        delFolder(path+"/"+ tempList[i]);//再删除空文件夹  
      }  
    }  
  }  
  /** 
   * 复制单个文件 
   * @param oldPath String 原文件路径 如：c:/fqf.txt 
   * @param newPath String 复制后路径 如：f:/fqf.txt 
   * @return boolean 
   */  
  public void copyFile(String oldPath, String newPath) {  
    try {  
      int bytesum = 0;  
      int byteread = 0;  
      File oldfile = new File(oldPath);  
      if (oldfile.exists()) { //文件存在时  
        InputStream inStream = new FileInputStream(oldPath); //读入原文件  
        FileOutputStream fs = new FileOutputStream(newPath);  
        byte[] buffer = new byte[1444];  
        int length;  
        while ( (byteread = inStream.read(buffer)) != -1) {  
          bytesum += byteread; //字节数 文件大小  
          System.out.println(bytesum);  
          fs.write(buffer, 0, byteread);  
        }  
        inStream.close();  
      }  
    }  
    catch (Exception e) {  
      System.out.println("复制单个文件操作出错");  
      e.printStackTrace();  
    }  
  }  
  /** 
   * 复制整个文件夹内容 
   * @param oldPath String 原文件路径 如：c:/fqf 
   * @param newPath String 复制后路径 如：f:/fqf/ff 
   * @return boolean 
   */  
  public void copyFolder(String oldPath, String newPath) {  
    try {  
      (new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹  
      File a=new File(oldPath);  
      String[] file=a.list();  
      File temp=null;  
      for (int i = 0; i < file.length; i++) {  
        if(oldPath.endsWith(File.separator)){  
          temp=new File(oldPath+file[i]);  
        }  
        else{  
          temp=new File(oldPath+File.separator+file[i]);  
        }  
        if(temp.isFile()){  
          FileInputStream input = new FileInputStream(temp);  
          FileOutputStream output = new FileOutputStream(newPath + "/" +  
              (temp.getName()).toString());  
          byte[] b = new byte[1024 * 5];  
          int len;  
          while ( (len = input.read(b)) != -1) {  
            output.write(b, 0, len);  
          }  
          output.flush();  
          output.close();  
          input.close();  
        }  
        if(temp.isDirectory()){//如果是子文件夹  
          copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);  
        }  
      }  
    }  
    catch (Exception e) {  
      System.out.println("复制整个文件夹内容操作出错");  
      e.printStackTrace();  
    }  
  }  
  /** 
   * 移动文件到指定目录 
   * @param oldPath String 如：c:/fqf.txt 
   * @param newPath String 如：d:/fqf.txt 
   */  
  public void moveFile(String oldPath, String newPath) {  
    copyFile(oldPath, newPath);  
    delFile(oldPath);  
  }  
  /** 
   * 移动文件到指定目录 
   * @param oldPath String 如：c:/fqf.txt 
   * @param newPath String 如：d:/fqf.txt 
   */  
  public void moveFolder(String oldPath, String newPath) {  
    copyFolder(oldPath, newPath);  
    delFolder(oldPath);  
  }  
}  

 

 

转自：http://blog.csdn.net/yuzhu2008/article/details/4373674