ArrayList和LinkedList的用法区别

4.查找操作indexOf,lastIndexOf,contains等,两者差不多。
5.随机查找指定节点的操作get,ArrayList速度要快于LinkedList.
这里只是理论上分析,事实上也不一定,ArrayList在末尾插入和删除数据的话,速度反而比LinkedList要快。我做过一个插入和删除200000条数据的试验。

String类:

  • 不可变的字符序列(如:String str = “atguigu”; str += “java”)
  • String是final的

图片 1

String底层存储

  • String类与基本数据类型、包装类;与字符数组、字节数组;
    • 字符串 与基本数据类型、包装类之间转换
      1、字符串
      —>基本数据类型、包装类:调用相应的包装类的parseXxx(String
      str);
      2、基本数据类型、包装类—>字符串:调用字符串的重载的valueOf()方法
    • 字符串与字节数组间的转换
      1、字符串—->字节数组:调用字符串的getBytes()
      2、字节数组—->字符串:调用字符串的构造器
    • 字符串与字符数组间的转换
      1、字符串—->字符数组:调用字符串的toCharArray();
      2、字符数组—->字符串:调用字符串的构造器
    • String与StringBuffer的转换
      1、String —>StringBuffer:使用StringBuffer的构造器:new
      StringBuffer(String str);
      2、StringBuffer—–>String:使用StringBuffer的toString()方法

StringBuffer类:可变的字符序列
StringBuilder类:可变的字符序列,jdk5.0新加入的,效率更高,线程不安全。
常用的方法:添加:append(…) 删除 delete(int startIndex, int
endIndex) 修改:setCharAt(int n ,char ch) 查询:charAt(int
index)插入:insert(int index, String str) 反转reverse() 长度:length()

String / StringBuffer
/StringBuilder,在字符串连接操作上性能依次加强,我曾经做过一个实验,连续进行10000次的字符串操作,三者速度上的差距是惊人的。在确切知道是不变字符串的情况下,还是用String最好,因为Java语言中String采用了享元模式(Flyweight),在JVM中只存在一份相同的String
。在确定循环次数时,尽量使用for循环,在循环嵌套中尽量将大循环放到外层,小循环放到内层,这点与VB等语言恰好相反,经过代码测试的,不过还不知道原因。总之,在VB等微软系列语言中用小套大会快很多,而在JAVA中用大套小会快很多!当然这是指两者能互相替换的时候,比如二维数组遍觅等!

BigInteger BigDecimal类

1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
2.对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
3.对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。
   
这一点要看实际情况的。若只对单条数据插入或删除,ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据,LinkedList的速度大大优于ArrayList.
因为ArrayList每插入一条数据,要移动插入点及之后的所有数据。 
这一点我做了实验。在分别有200000条“记录”的ArrayList和LinkedList的首位插入20000条数据,LinkedList耗时约是ArrayList的20分之1。

时间、日期类:

1、System类currentTimeMillis():返回当前时间的long型值。此long值是从1970年1月1日0点0分00秒开始到当前的毫秒数。
此方法常用来计算时间差。

2、Date类:java.util.Date

  • Date d = new Date();//返回当前时间的Date:Mon May 12 15:17:01 CST
    2014
  • Date d1 = new Date(15231512541241L);//返回形参处此long型值对应的日期
  • getTime():返回当前日期对应的long型值。 toString()*

3、SimpleDateFormat:java.text.SimpleDateFormat

  • 格式化 :日期—>文本 使用SimpleDateFormat的format()
  • 方法解析:文本—>日期 使用SimpleDateFormat的parse()方法

格式化
SimpleDateFormat sdf = new SimpleDateFormat();
String date = sdf.format(new Date());
System.out.println(date);//14-5-12 下午3:24//
格式化2
SimpleDateFormat sdf1 = new SimpleDateFormat(“EEE, d MMM yyyy HH:mm:ss
Z”);
date = sdf1.format(new Date());
System.out.println(date);//星期一, 12 五月 2014 15:29:16 +0800
解析:
Date date1 = sdf.parse(“14-5-12 下午3:24”);
System.out.println(date1);

4、 Calendar:日历类
获取实例: get()/set()/add()/date getTime()/setTime()
Calendar c = Calendar.getInstance();

插入:
LinkedList 578ms
ArrayList 437ms
删除:
LinkedList 31ms
ArrayList 16ms

Math类

long time1 = new Date().getTime(); String s1 = (String)
linkedlist.get(100000);//
总记录200000,linkedlist加载第100000条数据耗时15~32ms不等 long time2 =
new Date().getTime(); System.out.println(time2 – time1); String s2 =
(String) arraylist.get(100000);//
总记录200000,linkedlist加载第100000条数据耗时0ms long time3 = new
Date().getTime(); System.out.println(time3 – time2);
/**//*分别insert200000条数据到linkedlist和arraylist
*由于是在末尾插入数据,arraylist的速度比linkedlist的速度反而要快 */
public static void insertList(LinkedList linklist, ArrayList arraylist)
…{ long time1 = new Date().getTime(); System.out.println(time1); for
(int i = 0; i < 200000; i++) …{ linklist.add(i, “linklist” + i); }
long time2 = new Date().getTime(); System.out.println(time2 – time1);
for (int j = 0; j < 200000; j++) …{ arraylist.add(j, “arraylist” +
j); } long time3 = new Date().getTime(); System.out.println(time3 –
time2); } /**//*delete linkedlist和arraylist中的200000条数据
*由于是在末尾删除数据,arraylist的速度比linkedlist的速度反而要快 */
public static void deleteList(LinkedList linklist, ArrayList arraylist)
…{ long time1 = new Date().getTime(); System.out.println(time1); for
(int i = 199999; i >= 0; i–) …{ linklist.remove(i); } long time2 =
new Date().getTime(); System.out.println(time2 – time1); for (int j =
199999; j >= 0; j–) …{ arraylist.remove(j); } long time3 = new
Date().getTime(); System.out.println(time3 – time2); } public static
void main(String args[]) …{ LinkedList linkedlist = new
LinkedList(); ArrayList arraylist = new ArrayList();
insertList(linkedlist, arraylist); //以下代码省略

关于使用SESSION问题上,尽量不要将大对象放到HttpSession或其他须序列化的对象中,并注意及时清空Session。

  1. for(int m=0;m<20000;m++)…{   
  2.      linkedlist.add(m,null);    //当在200000条数据之前插入20000条数据                                       //时,LinkedList只用了1125多ms.这就是                                       //LinkedList的优势所在
      
  3.      }   
  4.      long time4 = new Dte().getTime();   
  5.      System.out.print(“batch linkedlist add:”);   
  6.      System.out.println(time4 – time3);   
  7.      for(int n=0;n<20000;n++)…{   
  8.      arraylist.add(n, null);  //当在200000条数据之前插入20000条数据时,ArrayList用了18375多ms.时间花费是arraylist的近20倍(视测试时机器性能)
      
  9.      }   
  10.      long time5 = new Date().getTime();   
  11.      System.out.print(“batch arraylist add:”);   
  12.      System.out.println(time5 – time4);  
  1.         long time1 = new Date().getTime();   
  2.         String s1 = (String) linkedlist.get(100000);//  总记录200000,linkedlist加载第100000条数据耗时15~32ms不等
      
  3.         long time2 = new Date().getTime();   
  4.         System.out.println(time2 – time1);   
  5.         String s2 = (String) arraylist.get(100000);//  总记录200000,linkedlist加载第100000条数据耗时0ms
      
  6.         long time3 = new Date().getTime();   
  7.         System.out.println(time3 – time2);   
  8.     
  9.   
  10.     /**//*分别insert200000条数据到linkedlist和arraylist
     
  11.     *由于是在末尾插入数据,arraylist的速度比linkedlist的速度反而要快 
     
  12.     */  
  13.     public static void insertList(LinkedList linklist, ArrayList arraylist) …{
      
  14.         long time1 = new Date().getTime();   
  15.         System.out.println(time1);   
  16.         for (int i = 0; i < 200000; i++) …{   
  17.             linklist.add(i, “linklist” + i);   
  18.         }   
  19.         long time2 = new Date().getTime();   
  20.         System.out.println(time2 – time1);   
  21.         for (int j = 0; j < 200000; j++) …{   
  22.             arraylist.add(j, “arraylist” + j);   
  23.         }   
  24.         long time3 = new Date().getTime();   
  25.         System.out.println(time3 – time2);   
  26.     }   
  27.   
  28.   
  29. /**//*delete linkedlist和arraylist中的200000条数据
     
  30.     *由于是在末尾删除数据,arraylist的速度比linkedlist的速度反而要快 
     
  31.     */  
  32.     public static void deleteList(LinkedList linklist, ArrayList arraylist) …{
      
  33.         long time1 = new Date().getTime();   
  34.         System.out.println(time1);   
  35.         for (int i = 199999; i >= 0; i–) …{   
  36.             linklist.remove(i);   
  37.         }   
  38.         long time2 = new Date().getTime();   
  39.         System.out.println(time2 – time1);   
  40.         for (int j = 199999; j >= 0; j–) …{   
  41.             arraylist.remove(j);   
  42.         }   
  43.         long time3 = new Date().getTime();   
  44.         System.out.println(time3 – time2);   
  45.     }   
  46.   
  47.     public static void main(String args[]) …{   
  48.         LinkedList linkedlist = new LinkedList();   
  49.         ArrayList arraylist = new ArrayList();   
  50.         insertList(linkedlist, arraylist);   
  51.   
  52.                                       //以下代码省略  

for(int m=0;m<20000;m++)…{ linkedlist.add(m,null);
//当在200000条数据之前插入20000条数据
//时,LinkedList只用了1125多ms.这就是 //LinkedList的优势所在 } long
time4 = new Dte().getTime(); System.out.print(“batch linkedlist add:”);
System.out.println(time4 – time3); for(int n=0;n<20000;n++)…{
arraylist.add(n, null);
//当在200000条数据之前插入20000条数据时,ArrayList用了18375多ms.时间花费是arraylist的近20倍(视测试时机器性能)
} long time5 = new Date().getTime(); System.out.print(“batch arraylist
add:”); System.out.println(time5 – time4);

发表评论

电子邮件地址不会被公开。 必填项已用*标注