java基础---集合框架
一、集合与数组 区别
数组(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知的情况下使用。
集合(只能存储对象,对象类型可以不一样)的长度可变,可在多数情况下使用。
二、集合类结构
Java中的集合包含多种数据结构,如链表、队列、哈希表等。从类的继承结构来说,可以分为两大类,一类是继承自Collection接口,这类集合包含List、Set和Queue等集合类。另一类是继承自Map接口,这主要包 含了哈希表相关的集合类。下面我们看一下这两大类的继承结构图:
图中的绿色的虚线代表实现,绿色实线代表接口之间的继承,蓝色实线代表类之间的继承。
三、集合详解
collection接口是集合类的根接口,Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口,就是Set和List。Set中不能包含重复的元素。List是一个有序的集合,可以包含重复的元素,提供了 按索 引访问的方式。
List接口
List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。
和下面要提到的Set不同,List允许有相同的元素。
除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个 ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素, 还能向前或向后遍历。
实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。
LinkedList类
LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。
注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:
List list = Collections.synchronizedList(new LinkedList(...));
ArrayList类
ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。
size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并 没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
和LinkedList一样,ArrayList也是非同步的(unsynchronized)。
Vector类
Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的 Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例 如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该 异常。
Stack 类
Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方 法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
自定义的集合arraylist
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package cn.bjsxt.collection; /** * 自己实现一个ArrayList,帮助我们更好的理解ArrayList类的底层结构! * */ public class SxtArrayList /*implements List*/ { private Object[] elementData; private int size; public int size(){ return size; } public boolean isEmpty(){ return size==0; } public SxtArrayList(){ this(10); } public SxtArrayList(int initialCapacity){ if(initialCapacity<0){ try { throw new Exception(); } catch (Exception e) { e.printStackTrace(); } } elementData = new Object[initialCapacity]; } public void add(Object obj){ //数组扩容和数据的拷贝 if(size==elementData.length){ Object[] newArray = new Object[size*2+1]; System.arraycopy(elementData, 0, newArray, 0, elementData.length); // for(int i=0;i<elementData.length;i++){ // newArray[i] = elementData[i]; // } elementData = newArray; } elementData[size++]=obj; // size++; } public Object get(int index){ rangeCheck(index); return elementData[index]; } public void remove(int index){ rangeCheck(index); //删除指定位置的对象 //a b d e int numMoved = size - index - 1; if (numMoved > 0){ System.arraycopy(elementData, index+1, elementData, index, numMoved); } elementData[--size] = null; // Let gc do its work } public void remove(Object obj){ for(int i=0;i<size;i++){ if(get(i).equals(obj)){ //注意:底层调用的equals方法而不是==. remove(i); } } } public Object set(int index,Object obj){ rangeCheck(index); Object oldValue = elementData[index]; elementData[index] = obj; return oldValue; } public void add(int index,Object obj){ rangeCheck(index); ensureCapacity(); //数组扩容 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = obj; size++; } private void ensureCapacity(){ //数组扩容和数据的拷贝 if(size==elementData.length){ Object[] newArray = new Object[size*2+1]; System.arraycopy(elementData, 0, newArray, 0, elementData.length); // for(int i=0;i<elementData.length;i++){ // newArray[i] = elementData[i]; // } elementData = newArray; } } private void rangeCheck(int index){ if(index<0||index>=size){ try { throw new Exception(); } catch (Exception e) { e.printStackTrace(); } } } public static void main(String[] args) { SxtArrayList list = new SxtArrayList(3); list.add("333"); list.add("444"); list.add("5"); list.add("344433"); list.add("333"); list.add("333"); System.out.println(list.size()); // System.out.println(list.get(6)); list.remove("444"); System.out.println(list.size()); } }
自定义linkedlist
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.bdqn; //用来表示一个节点 public class Node { Node previous; //上一个节点 Object obj; Node next; //下一个节点 public Node() { } public Node(Node previous, Object obj, Node next) { super(); this.previous = previous; this.obj = obj; this.next = next; } public Node getPrevious() { return previous; } public void setPrevious(Node previous) { this.previous = previous; } public Object getObj() { return obj; } public void setObj(Object obj) { this.obj = obj; } public Node getNext() { return next; } public void setNext(Node next) { this.next = next; } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.bdqn; import java.util.LinkedList; public class SxtLinkedList /*implements List*/ { private Node first; private Node last; private int size; public void add(Object obj){ Node n = new Node(); if(first==null){ n.setPrevious(null); n.setObj(obj); n.setNext(null); first = n; last = n; }else{ //直接往last节点后增加新的节点 n.setPrevious(last); n.setObj(obj); n.setNext(null); last.setNext(n); last = n; } size++; } public int size(){ return size; } private void rangeCheck(int index){ if(index<0||index>=size){ try { throw new Exception(); } catch (Exception e) { e.printStackTrace(); } } } public Object get(int index){ //2 rangeCheck(index); // 0 1 2 3 4 Node temp = node(index); if(temp!=null){ return temp.obj; } return null; } public Node node(int index){ Node temp = null; if(first!=null){ temp = first; for(int i=0;i<index;i++){ temp = temp.next; } } LinkedList l; return temp; } public void remove(int index){ Node temp = node(index); if(temp!=null){ Node up = temp.previous; Node down = temp.next; up.next = down; down.previous = up; size--; } } public void add(int index,Object obj){ Node temp = node(index); Node newNode = new Node(); newNode.obj = obj; if(temp!=null){ Node up = temp.previous; up.next = newNode; newNode.previous = up; newNode.next = temp; temp.previous = newNode; size++; } } public static void main(String[] args) { SxtLinkedList list = new SxtLinkedList(); list.add("aaa"); list.add("bbb"); list.add(1,"BBBB"); list.add("ccc"); // list.remove(1); System.out.println(list.get(1)); } }
Set接口
Set是一种不包含重复的元素的Collection,即任意的两个元素e1和e2都有e1.equals(e2)=false,Set最多有一个null元素。
很明显,Set的构造函数有一个约束条件,传入的Collection参数不能包含重复的元素。
请注意:必须小心操作可变对象(Mutable Object)。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
HashSet
HashSet有以下特点
不能保证元素的排列顺序,顺序有可能发生变化
不是同步的
集合元素可以是null,但只能放入一个null
当向HashSet集合中存入一个元素时,HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据 hashCode值来决定该对象在HashSet中存储位置。
简单的说,HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等,并且两个对象的hashCode()方法返回值相 等
注意,如果要把一个对象放入HashSet中,重写该对象对应类的equals方法,也应该重写其hashCode()方法。其规则是如果两个对 象通过equals方法比较返回true时,其hashCode也应该相同。另外,对象中用作equals比较标准的属性,都应该用来计算 hashCode的值。
TreeSet类
TreeSet是SortedSet接口的唯一实现类,TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式,自然排序 和定制排序,其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false,或者通过CompareTo方法比较没有返回0
自然排序
自然排序使用要排序元素的CompareTo(Object obj)方法来比较元素之间大小关系,然后将元素按照升序排列。
Java提供了一个Comparable接口,该接口里定义了一个compareTo(Object obj)方法,该方法返回一个整数值,实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0,则说明被比较的两个对象相等,如果返回一个正数,则表明obj1大于obj2,如果是 负数,则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true,则这两个对象的compareTo方法返回应该返回0
定制排序
自然排序是根据集合元素的大小,以升序排列,如果要定制排序,应该使用Comparator接口,实现 int compare(T o1,T o2)方法。
最重要:
1、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的,不允许放入null值。
2、HashSet 是哈希表实现的,HashSet中的数据是无序的,可以放入null,但只能放入一个null,两者中的值都不能重复,就如数据库中唯一约束。
3、HashSet要求放入的对象必须实现HashCode()方法,放入的对象,是以hashcode码作为标识的,而具有相同内容的 String对象,hashcode是一样,所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。
自定义hashset
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package cn.bjsxt.collection; import java.util.HashMap; /** * 自定义自己的HashSet * @author Administrator * */ public class SxtHashSet { HashMap map; private static final Object PRESENT = new Object(); public SxtHashSet(){ map = new HashMap(); } public int size(){ return map.size(); } public void add(Object o){ map.put(o, PRESENT); //set的不可重复就是利用了map里面键对象的不可重复! } public static void main(String[] args) { SxtHashSet s = new SxtHashSet(); s.add("aaa"); s.add(new String("aaa")); System.out.println(s.size()); } }
hashSet使用
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.zwj.set; public class Food { private String name; private double price; public Food() { // TODO Auto-generated constructor stub } public Food(String name, double price) { super(); this.name = name; this.price = price; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); long temp; temp = Double.doubleToLongBits(price); result = prime * result + (int) (temp ^ (temp >>> 32)); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Food other = (Food) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (Double.doubleToLongBits(price) != Double .doubleToLongBits(other.price)) return false; return true; } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.zwj.set; import java.util.HashSet; import java.util.Iterator; import java.util.Set; /** * 默认的hashcode时地址转换码,需要重写 * 先比较hashcode * 再比较equals * * @author Administrator * */ public class SetDemo01 { /** * @param args */ public static void main(String[] args) { Food food1 = new Food("瓜子",5); Food food2 = new Food("糖果",10); Food food3 = new Food("瓜子",5); Food food4 = new Food("瓜子2",5); Set<Food> set = new HashSet<Food>(); set.add(food1); set.add(food1); set.add(food2); set.add(food3); set.add(food4); System.out.println(set.size()); System.out.println("===foreach====="); for(Food temp:set){ System.out.println(temp.getPrice()+"-->"+temp.getName()); } System.out.println("======iterator========="); Iterator<Food> it =set.iterator(); while(it.hasNext()){ //判断,不会移动游标 |指针 Food temp =it.next(); //一次移动一个游标 不能移动多次 //System.out.println(it.next().getPrice()+"-->"+it.next().getName()); System.out.println(temp.getPrice()+"-->"+temp.getName()); } } } /* 3 ===foreach===== 10.0-->糖果 5.0-->瓜子2 5.0-->瓜子 ======iterator========= 10.0-->糖果 5.0-->瓜子2 5.0-->瓜子 */
使用自定义类型 接收签名:从界面上接收 到会人员的名单 放入 HashSet中点名:遍历输出名单
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.zwj.set; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashSet; import java.util.Iterator; import java.util.Scanner; import java.util.Set; /** * 使用自定义类型 接收签名:从界面上接收 到会人员的名单 放入 HashSet中 点名:遍历输出名单 * @author Administrator * */ public class SetDemo04 { private Scanner sc ; private Set<Member> members; SetDemo04(){ sc = new Scanner(System.in); members= new HashSet<Member>(); } public String getStringFromConsole(){ return sc.nextLine(); } //签名: public void addMemeber(Member mem){ members.add(mem); } //点名:遍历输出名单 public void showMemeber(){ Iterator<Member> it = members.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } /** * @param args */ public static void main(String[] args) { SetDemo04 demo = new SetDemo04(); System.out.println("====签名======"); while(true){ String name =demo.getStringFromConsole(); if(name.equalsIgnoreCase("over")){ break; } Member m =new Member(name); demo.addMemeber(m); } System.out.println("=========参会人员有===="); demo.showMemeber(); /*====签名====== in am me over =========参会人员有==== 名单:me,签名时间:2017-11-18 18:00:39 名单:am,签名时间:2017-11-18 18:00:36 名单:in,签名时间:2017-11-18 18:00:33 */ } } class Member{ private String name; private Date attendTime; public Member() { attendTime = new Date(); } public Member(String name) { this(); this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Date getAttendTime() { return attendTime; } public void setAttendTime(Date attendTime) { this.attendTime = attendTime; } public Member(String name, Date attendTime) { super(); this.name = name; this.attendTime = attendTime; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Member other = (Member) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return "名单:"+name+",签名时间:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(attendTime); } }
Map接口
请注意,Map没有继承Collection接口,Map提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个 value。Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。
Hashtable类
Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。
添加数据使用put(key, value),取出数据使用get(key),这两个基本操作的时间开销为常数。
Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大,这会影响像get和put这样的操作。
使用Hashtable的简单示例如下,将1,2,3放到Hashtable中,他们的key分别是”one”,”two”,”three”:
Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
要取出一个数,比如2,用相应的key:
Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置,因此任何作为key的对象都必须实现hashCode和equals方 法。hashCode和equals方法继承自根类Object,如果你用自定义的类当作key的话,要相当小心,按照散列函数的定义,如果两个对象相 同,即obj1.equals(obj2)=true,则它们的hashCode必须相同,但如果两个对象不同,则它们的hashCode不一定不同,如 果两个不同对象的hashCode相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的hashCode()方法,能加快哈希 表的操作。
如果相同的对象有不同的hashCode,对哈希表的操作会出现意想不到的结果(期待的get方法返回null),要避免这种问题,只需要牢记一条:要同时复写equals方法和hashCode方法,而不要只写其中一个。
Hashtable是同步的。
HashMap类
HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null key。,但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap 的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。
WeakHashMap类
WeakHashMap是一种改进的HashMap,它对key实行“弱引用”,如果一个key不再被外部所引用,那么该key可以被GC回收。
总结
如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。
如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。
要特别注意对哈希表的操作,作为key的对象要正确复写equals和hashCode方法。
尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。
自定义集合sxtHashMap
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.bdqn; import java.util.LinkedList; /** * 自定义Map的升级版: * 1. 提高查询的效率 * * */ public class SxtMap002 { LinkedList[] arr = new LinkedList[9]; //Map的底层结构就是:数组+链表! int size; public void put(Object key,Object value){ SxtEntry e = new SxtEntry(key,value); int a = key.hashCode()%arr.length; if(arr[a]==null){ LinkedList list = new LinkedList(); arr[a] = list; list.add(e); }else{ LinkedList list = arr[a]; for(int i=0;i<list.size();i++){ SxtEntry e2 = (SxtEntry) list.get(i); if(e2.key.equals(key)){ e2.value = value; //键值重复直接覆盖! return; } } arr[a].add(e); } //a:1000-->1 b:10000-->13 } public Object get(Object key){ int a = key.hashCode()%arr.length; if(arr[a]!=null){ LinkedList list = arr[a]; for(int i=0;i<list.size();i++){ SxtEntry e = (SxtEntry) list.get(i); if(e.key.equals(key)){ return e.value; } } } return null; } public static void main(String[] args) { SxtMap002 m = new SxtMap002(); m.put("高琪", new Wife("杨幂")); m.put("高琪", new Wife("李四")); Wife w = (Wife) m.get("高琪"); System.out.println(w.name); } } class SxtEntry { Object key; Object value; public SxtEntry(Object key, Object value) { super(); this.key = key; this.value = value; } } class Wife{ public static String name; public Wife(String name) { this.name = name; } public Wife() {} }
四、遍历
在类集中提供了以下四种的常见输出方式:
1)Iterator:迭代输出,是使用最多的输出方式。
2)ListIterator:是Iterator的子接口,专门用于输出List中的内容。
3)foreach输出:JDK1.5之后提供的新功能,可以输出数组或集合。
4)for循环
代码示例如下:
for的形式:for(int i=0;i<arr.size();i++){...}
foreach的形式: for(int i:arr){...}
iterator的形式:
Iterator it = arr.iterator();
while(it.hasNext()){ object o =it.next(); ...}
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.bdqn; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Dmeo { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); //第一种遍历list 集合 for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } //第二种遍历list集合 for (String str : list) { System.out.println(str); } //第三种遍历list集合 Iterator<String> stu=list.iterator(); while (stu.hasNext()) { //String string = (String) stu.next(); System.out.println( stu.next()); } } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.bdqn; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class Dmeo { public static void main(String[] args) { Set<String> set=new HashSet<String>(); set.add("a"); set.add("b"); set.add("c"); set.add("d"); //iterrator 迭代 Iterator<String> iterator=set.iterator(); while (iterator.hasNext()) { String string = (String) iterator.next(); System.out.println(string); } //用增强for循环去遍历 for (String string1 : set) { System.out.println(string1); } } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.bdqn; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Dmeo { public static void main(String[] args) { Map<Integer, String> map = new HashMap<Integer, String>(); map.put(1, "a"); map.put(2, "b"); map.put(3, "c"); map.put(4, "d"); map.put(5, "e"); System.out.println("第一种遍历map集合 "); Iterator<Integer> iterator=map.keySet().iterator(); while (iterator.hasNext()) { Integer integer = (Integer) iterator.next(); System.out.println(integer+":"+map.get(integer)); } System.out.println("第二种for循环遍历 前兩中都是先得到key的集合,在得到values"); for (Integer integer : map.keySet()) { System.out.println(integer+":"+map.get(integer)); } System.out.println("第三种遍历的方式 iterraotr直接得到key values集合"); Iterator<Map.Entry<Integer, String>> iterator2=map.entrySet().iterator(); while (iterator2.hasNext()) { Map.Entry<java.lang.Integer, java.lang.String> entry = (Map.Entry<java.lang.Integer, java.lang.String>) iterator2 .next(); System.out.println(entry.getKey()+":"+entry.getValue()); } System.out.println("第四种遍历的方式 for直接得到key values集合"); for (Map.Entry<Integer, String> entry2 : map.entrySet()) { System.out.println(entry2.getKey()+":"+entry2.getValue()); } } }
五、主要实现类区别
Vector和ArrayList
1,vector是线程同步的,所以它也是线程安全的,而arraylist是线程异步的,是不安全的。如果不考虑到线程的安全因素,一般用arraylist效率比较高。
2,如果集合中的元素的数目大于目前集合数组的长度时,vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度的50%。如果在集合中使用数据量比较大的数据,用vector有一定的优势。
3,如果查找一个指定位置的数据,vector和arraylist使用的时间是相同的,如果频繁的访问数据,这个时候使用vector和arraylist都可以。而如果移动一个指定位置会导致后面的元素都发生移动,这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据时其它元素不移动。
ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要涉及到数组元素移动等内存操作,所以索引数据快,插入数据慢,Vector由于使用了synchronized方法(线程安全)所以性能上比ArrayList要差,LinkedList使用双向链表实现存储,按序号索引数据需要进行向前或向后遍历,但是插入数据时只需要记录本项的前后项即可,所以插入数度较快。
arraylist和linkedlist
1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
2.对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
3.对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除,ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据,LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据,要移动插入点及之后的所有数据。
HashMap与TreeMap
1、 HashMap通过hashcode对其内容进行快速查找,而TreeMap中所有的元素都保持着某种固定的顺序,如果你需要得到一个有序的结果你就应该使用TreeMap(HashMap中元素的排列顺序是不固定的)。
2、在Map 中插入、删除和定位元素,HashMap是最好的选择。但如果您要按自然顺序或自定义顺序遍历键,那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。
两个map中的元素一样,但顺序不一样,导致hashCode()不一样。
同样做测试:
在HashMap中,同样的值的map,顺序不同,equals时,false;
而在treeMap中,同样的值的map,顺序不同,equals时,true,说明,treeMap在equals()时是整理了顺序了的。
HashTable与HashMap
1、同步性:Hashtable是线程安全的,也就是说是同步的,而HashMap是线程序不安全的,不是同步的。
2、HashMap允许存在一个为null的key,多个为null的value 。
3、hashtable的key和value都不允许为null。