The NoteBook of EricKong

  BlogJava :: 首页 :: 联系 :: 聚合  :: 管理
  611 Posts :: 1 Stories :: 190 Comments :: 0 Trackbacks

#

      ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动等内存操作,所以索引数据快插入数据慢,Vector由于使用了synchronized方法(线程安全)所以性能上比ArrayList要差LinkedList使用双向链表实现存储,按序号索引数据需要进行向前或向后遍历,但是插入数据时只需要记录本项的前后项即可,所以插入数度较快!
posted @ 2014-01-02 16:03 Eric_jiang 阅读(175) | 评论 (0)编辑 收藏

java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap

Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复了覆盖了),但允许值重复。
Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值,具有很快的访问速度,遍历时,取得数据的顺序是完全随机的。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步,即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步,可以用 Collections的synchronizedMap方法使HashMap具有同步的能力,或者使用ConcurrentHashMap。

Hashtable与 HashMap类似,它继承自Dictionary类,不同的是:它不允许记录的键或者值为空;它支持线程的同步,即任一时刻只有一个线程能写Hashtable,因此也导致了 Hashtable在写入时会比较慢。
LinkedHashMap保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的.也可以在构造时用带参数,按照应用次数排序。在遍历的时候会比HashMap慢,不过有种情况例外,当HashMap容量很大,实际数据较少时,遍历起来可能会比LinkedHashMap慢,因为LinkedHashMap的遍历速度只和实际数据有关,和容量无关,而HashMap的遍历速度和他的容量有关。
TreeMap实现SortMap接口,能够把它保存的记录根据键排序,默认是按键值的升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。
一般情况下,我们用的最多的是HashMap,HashMap里面存入的键值对在取出的时候是随机的,它根据键的HashCode值存储数据,根据键可以直接获取它的值,具有很快的访问速度。在Map 中插入、删除和定位元素,HashMap 是最好的选择。
TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键,那么TreeMap会更好。
LinkedHashMap 是HashMap的一个子类,如果需要输出的顺序和输入的相同,那么用LinkedHashMap可以实现,它还可以按读取顺序来排列,像连接池中可以应用。
posted @ 2014-01-02 15:56 Eric_jiang 阅读(223) | 评论 (0)编辑 收藏

String 字符串常量
StringBuffer 字符串变量(线程安全)
StringBuilder 字符串变量(非线程安全)

      简要的说, String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,然后将指针指向新的 String 对象,所以经常改变内容的字符串最好不要用 String ,因为每次生成对象都会对系统性能产生影响,特别当内存中无引用对象多了以后, JVM 的 GC 就会开始工作,那速度是一定会相当慢的。
     而如果是使用 StringBuffer 类则结果就不一样了,每次结果都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ,特别是字符串对象经常改变的情况下。而在某些特别情况下, String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接,所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢,而特别是以下的字符串对象生成中, String 效率是远要比 StringBuffer 快的:
 String S1 = “This is only a” + “ simple” + “ test”;
 StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
     你会很惊讶的发现,生成 String S1 对象的速度简直太快了,而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏,在 JVM 眼里,这个
 String S1 = “This is only a” + “ simple” + “test”; 其实就是:
 String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是,如果你的字符串是来自另外的 String 对象的话,速度就没那么快了,譬如:
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做

在大部分情况下 StringBuffer > String

StringBuffer
    Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区,但不能修改。虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。
    可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步,因此任意特定实例上的所有操作就好像是以串行顺序发生的,该顺序与所涉及的每个线程进行的方法调用顺序一致。
    StringBuffer 上的主要操作是 append 和 insert 方法,可重载这些方法,以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端;而 insert 方法则在指定的点添加字符。
例如,如果 z 引用一个当前内容是“start”的字符串缓冲区对象,则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”,而 z.insert(4, "le") 将更改字符串缓冲区,使之包含“starlet”。
在大部分情况下 StringBuilder > StringBuffer
java.lang.StringBuilde
java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API,但不保证同步。该类被设计用作 StringBuffer 的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。如果可能,建议优先采用该类,因为在大多数实现中,它比 StringBuffer 要快。两者的方法基本相同。
posted @ 2014-01-02 15:48 Eric_jiang 阅读(311) | 评论 (0)编辑 收藏

根据《佛山市公安局交警支队汽车驾驶培训考试质量监督管理考评办法》的有关规定,佛山市交警支队近日对全市15家汽车驾驶人培训机构1-3月份的考试质量进行综合考评。

佛山市2013 年 3 月份驾驶培训机构汽车类的考试合格率、培训质量排名

看你选对驾校没

posted @ 2013-12-27 13:22 Eric_jiang 阅读(204) | 评论 (0)编辑 收藏

驾校学员在训练中适应了自己教练车的离合高低,等考试时一换车就容易出现不适应的现象,这很正常的,老司机也会出现这种现象。那么,如何做才能快速适应考试车离合的高低呢?对此,资深教练为我们支招。

  教练介绍,想要在短时间内快速适应考试车的离合高低,就用挂上一档,松抬离合的方法,来适应踏板的高低不同,同时保证不熄火不溜车。这种方法我和学员在考试中反复的试验过多次,比较可靠,所以推荐给大家。

资深教练支招:如何适应考试车离合高低

  上车前看看考试车,没有什么特殊的地方,和我们平时训练是一模一样的车型。

  资深教练支招:如何适应考试车离合高低

  打开车门,看看也是与教练车一样的布置,转向盘、离合器。刹车和仪表,一样的操作部件,没有什么不同的。

资深教练支招:如何适应考试车离合高低

  上车准备好后,开始适应离合踏板高低,将离合踩到底,挂一档后,松开离合,看转速表明显的上下舞动,这就是准确的离合半联动位置,然后马上踩下离合,再次试验,反复几次,就明确离合高低了。

资深教练支招:如何适应考试车离合高低

  左边是发动机转速表,这是发动机没启动时的状况。

资深教练支招:如何适应考试车离合高低

  看左侧就是发动机转速表,看红色表针在这个位置就是启动了。

posted @ 2013-12-27 13:16 Eric_jiang 阅读(226) | 评论 (0)编辑 收藏

 汽车起步熄火是许多车友常见的问题,尤其是对于新手来说,了解起步熄火的原因并学习掌握怎样起步不易熄火对于许多车友来说都是必要的。

  一、汽车起步熄火的原因:

  1、油箱没油了;

  2、蓄电池电压过低导致启动马达无法启动或达不到启动转速;

  3、怠速马达故障,特征是启动如果不给油后立即熄火;

  4、油路堵塞(常见于日常使用较差汽油的车辆上),特征同上;

  5、车载控制系统故障,此故障极少见,但也不能排除,控制系统故障故障会导致车辆所有功能都失灵;

  6、进气管路堵塞(可能有异物进入),查一查从进气口、空气滤清到节气门的管道;

  7、火花塞、高压线故障。

起步熄火

  了解了日常汽车起步熄火的常见原因,现在我们来看看在实操中如何起步才不易熄火。

  二、怎样起步不熄火

  不同情况用不同方法:

  1、平地起步

  确保车停在不拉手刹也不会溜后的路面。操作:踩尽离合,挂一档,先加油(加油),使转速达1500转以上,稳住油门;快放至总行程的三分之一,(快放) 慢慢放离合,同时感觉车是否向前动(慢放);当车慢慢向前动时,左脚踩住离合保持不动,右脚加些油(停放-加油),慢放尽离合(慢放)(刚好配合油门滞后性),起步成功!总结:加油--快放--慢放--车动停放-加油--慢放

  2、小斜坡起步

  操作:右脚踩刹车,用一点力就可,但确保车不会溜后;(刹车) 踩尽离合,挂一档,快放离合至总行程三分之一后,慢慢放离合;(快放--慢放), 注意:当转速表一出现下降时,左脚踩住离合保持不动;(停放)抬头看前面,同时右脚迅速从脚刹踏板移到加速踏板加些油(加油),左脚慢慢放离合,当车慢慢向前动时,可以使离合保持一下,再慢慢放离合。(慢放)总结:刹车--快放--慢放--表降停放-加油--慢放

  3、大斜坡起步

  由于坡度较大,需借助手刹起步。操作:拉起手刹;(手刹),踩尽离合,挂一档,右脚加些油,使转速达1500 转,稳住油门;(加油)快放至总行程的三分之一后,慢慢放离合;(快放--慢放)注意:当转速表一出现下降时,发动机声音会变沉;左脚踩住离合保持不动(停放),右脚再加些油(再加油),抬头看前面;左脚再慢放一点离合后保持不动,松手刹,起步成功!(再慢放--松手刹)总结:手刹--加油--快放--慢放--表降停放-再加油--再慢放--松手刹 起步方法的掌握是:熟能生巧。

  三、起步时机的掌握

  起步时机的掌握就是有预见性的驾驶,这里是其中的技巧之一。不同情况,有不同的参照物,多总结,要点就是:提前预测!

  1、红绿灯口排首位起步时机: 注意垂直方向的交通指示灯,当垂直方向的交 通指示灯变成橙色时,就可作起步准备了,如果看不到垂直方向的交通指示灯,可留意行人道的交通指示灯,以此作参照物。

  2、双车道在其他车后面的起步时机:透过前车的玻璃,看再前面的车,当再前面的车起动时,就可作起步准备了,借助其他方法,能判断再前面的车的状态,如 果实在没有方法找到参照物,就只好等到你前面的车的刹车灯亮起时,你就要注 意作起步准备了。

  3、四车道在其他车后面的起步时机:首先可用双车道在其他车后面的起步时机,看旁边车道的同排车的前一辆车,如果它起步,你就可作起步准备了。

posted @ 2013-12-27 12:49 Eric_jiang 阅读(205) | 评论 (0)编辑 收藏

新手起步如何防止死火?
Q:新手起步容易死火,怎么办?
A :起步时的正确操作是在离合踏板抬起开始时快抬,当发动机的声音有变化,踏板抬起的速度稍慢。在离合器踏板抬起的同时,根据发动机阻力大小逐渐踩下油门踏板,使汽车平稳起步。
半离合状态能防死火吗?
Q:新手开手动挡车老担心死火,在左右有车时会下意识地踩离合器,或长时间把脚放在离合器上,半离合状态能防死火吗?
A:新手无事不要踩离合,在开车时除汽车起步、换挡和低速刹车需要踩下离合器踏板外,其他时间都不要没事踩离合,或把脚放在离合器踏板上,否则很容易造成离合器打滑等现象,同时还会费油。
什么时候该离合和刹车一起踩?
Q:什么时候该离合和刹车一起踩,什么时候又不用呢?
A:在驾驶中,除低速踩刹车停车,需要踩下离合器踏板外,其他情况下的踩刹车都尽量不要踩下离合器踏板。
posted @ 2013-12-26 13:27 Eric_jiang 阅读(389) | 评论 (0)编辑 收藏

尽管我所知道的浏览器都支持cookie的设置,不过用户可以有意识的将它关闭,或者无意识的将它关闭。当你在你的servlets/JSP页面中使用cookie时,你不能保证用户的浏览器是否可以接受cookie--你需要先检查一下。这儿有一个检查用户的浏览器的cookie是否有效的小技巧。

这个技巧很简单。你从servlet或JSP向用户的浏览器发出一个HTTP回应,强行使浏览器在第二次返回。在第一次的响应中,你发出一个cookie。当浏览器第二次返回的时候,检查上一次发出的cookie。如果cookie存在,说明浏览器的cookie功能可用。否则说明用户的浏览器太老,不支持cookie,或者浏览器的cookie功能被关闭。

JSP页面用下面这段代码检查cookie是否有效。如果有效,那么页面的返回字符串为“Cookie is on”.若无效则为“Cookie is off”:

<%
  if (request.getParameter("flag")==null) {
    // the first request
    Cookie cookie = new Cookie("cookieSetting", 
"on");
    response.addCookie(cookie);
    String nextUrl = request.getRequestURI() + 
"?flag=1";
    // force the browser to refresh
    out.println("<META HTTP-EQUIV=Refresh 
CONTENT=0;URL=" + nextUrl +">");
  }
  else {
    // the second request
    Cookie[] cookies = request.getCookies();
    boolean cookieFound = false;
    if (cookies!=null) {
      int length = cookies.length;
      for (int i=0; i<length; i++) {
        Cookie cookie = cookies[i];
        if 
(cookie.getName().equals("cookieSetting") &&
          cookie.getValue().equals("on")) {
          cookieFound = true;
          break;
        }
      }
    }
    if (cookieFound) {
      out.println("Cookie is on.");
    }
    else {
      out.println("Cookie is off.");
    }
  }
%>
posted @ 2013-12-25 16:39 Eric_jiang 阅读(450) | 评论 (0)编辑 收藏

import java.io.BufferedReader;
 
import java.io.File;
 
import java.io.FileInputStream;
 
import java.io.IOException;
 
import java.io.RandomAccessFile;
 
import java.nio.ByteBuffer;
 
import java.nio.channels.FileChannel;
 
 
 
public class TestNio {
 
 
 
 
 
    
public static void main(String args[]) throws Exception{
 
 
 
    
//String infile = "D:\\workspace\\test\\usagetracking.log";
 
    
//FileInputStream fin= new FileInputStream(infile);
 
    
//FileChannel fcin = fin.getChannel();
 
 
 
    
int bufSize = 100;
 
    File fin 
= new File("D:\\workspace\\test\\usagetracking.log");
 
    File fout 
= new File("D:\\workspace\\test\\usagetracking2.log");
 
 
 
    FileChannel fcin 
= new RandomAccessFile(fin, "r").getChannel();
 
    ByteBuffer rBuffer 
= ByteBuffer.allocate(bufSize);
 
 
 
    FileChannel fcout 
= new RandomAccessFile(fout, "rws").getChannel();
 
    ByteBuffer wBuffer 
= ByteBuffer.allocateDirect(bufSize);
 
 
 
 
 
    readFileByLine(bufSize, fcin, rBuffer, fcout, wBuffer);
 
 
 
    System.out.print(
"OK!!!");
 
    }
 
 
 
    
public static void readFileByLine(int bufSize, FileChannel fcin, ByteBuffer rBuffer, FileChannel fcout, ByteBuffer wBuffer){
 
        String enterStr 
= "\n";
 
        
try{
 
        
byte[] bs = new byte[bufSize];
 
 
 
        
int size = 0;
 
        StringBuffer strBuf 
= new StringBuffer("");
 
        
//while((size = fcin.read(buffer)) != -1){
 
        
while(fcin.read(rBuffer) != -1){
 
              
int rSize = rBuffer.position();
 
              rBuffer.rewind();
 
              rBuffer.get(bs);
 
              rBuffer.clear();
 
              String tempString 
= new String(bs, 0, rSize);
 
              
//System.out.print(tempString);
 
              
//System.out.print("<200>");
 
 
 
              
int fromIndex = 0;
 
              
int endIndex = 0;
 
              
while((endIndex = tempString.indexOf(enterStr, fromIndex)) != -1){
 
               String line 
= tempString.substring(fromIndex, endIndex);
 
               line 
= new String(strBuf.toString() + line);
 
               
//System.out.print(line);
 
               
//System.out.print("</over/>");
 
               
//write to anthone file
 
               writeFileByLine(fcout, wBuffer, line);
 
 
 
                
 
               strBuf.delete(
0, strBuf.length());
 
               fromIndex 
= endIndex + 1;
 
              }
 
              
if(rSize > tempString.length()){
 
              strBuf.append(tempString.substring(fromIndex, tempString.length()));
 
              }
else{
 
              strBuf.append(tempString.substring(fromIndex, rSize));
 
              }
 
        }
 
        } 
catch (IOException e) {
 
        
// TODO Auto-generated catch block
 
        e.printStackTrace();
 
        }
 
    }
 
 
 
    
public static void writeFileByLine(FileChannel fcout, ByteBuffer wBuffer, String line){
 
        
try {
 
            
//write on file head
 
            
//fcout.write(wBuffer.wrap(line.getBytes()));
 
            
//wirte append file on foot
 
            fcout.write(wBuffer.wrap(line.getBytes()), fcout.size());
 
 
 
        } 
catch (IOException e) {
 
            
// TODO Auto-generated catch block
 
            e.printStackTrace();
 
        }
 
    }
 
 
 
}
 
posted @ 2013-12-17 15:14 Eric_jiang 阅读(1790) | 评论 (0)编辑 收藏

     离合器运用不当是汽车起步最大的障碍,特别是在上坡起步时。要正确运用离合器,必须学会体会离合器半联动位置。当离合器松抬到某一位置(也可以是某一点),发动机的动力开始传递给传动机构,这个传力的开始点称为半联动。如果在半联动位置上油门、离合器、手制动三者的联合动作配合得当,就能使汽车平稳起步。

离合器

  ● 如何体会半联动的位置呢?可以根据三种现象作出判断。

  (1)听发动机声音的变化。当发动机在没有负荷时,发动机的声音比较轻松,如果加上负荷,即抬离合器达到传力的开始点时,发动机的声音就开始低沉下来,尤其是在汽车负荷较大的情况下反应更加明显。

  (2)发动机抖动的感觉。在离合器抬到半联动位里时,汽车由静到动会先有一股抖动的感觉,如果将双手轻轻地浮搁在方向盘上,那么就很容易感觉到这种抖动的现象。这时离合器就恰在半联动状态。

  (3)凭脚感。当发动机的声音开始变化,车辆发生轻徽震动的同时,离合器踏板即会有顶脚的感觉产生,这时的离合器正处在半联动状态。

  利用听觉和触觉来寻找半联动位置是一种十分有效的办法。

  ● 松抬离合器的过程常常归纳为:

  一快:当开始松抬离合器,消除其自由行程时,动作要快。

  一慢:当离合器松抬到即将要进入接力状态时(初联动),动作要慢。

  一停顿:当离合器松抬到刚进入接力状态时(半联动),动作稍有停顿。

  二慢:当离合器松抬至离开半联动位里(全联动状态)时,动作要慢。

  二快:当离合器松抬至完全结合时(进入离合器的自由行程).动作要快。

  掌握好离合器的两快、两慢、一停顿的操作要领,是做到汽车平稳起步的关健。

posted @ 2013-12-13 11:13 Eric_jiang 阅读(527) | 评论 (0)编辑 收藏

仅列出标题
共57页: First 上一页 12 13 14 15 16 17 18 19 20 下一页 Last