Java之集合框架（二）

              List实现类的继续学习

List 实现类之Vector向量类学习

向量类能够实现类似动态数组的功能。创建一个向量类的对象后，可以使用插入不同类的对象。不需要顾及类型也不需预先选定向量的容量。

作用：对于预先不能确定元素多少，并需频繁进行查找，插入和删除工作的情况，可以使用向量类

 

这里引用了网上的一个朋友的总结：

 

比如我们有一个Vector: Vector myVec=new Vector(a_Array.length)  

取得vector的长度:myVec.size(); 

赋值：set(int position,Object obj) / setElementAt(Object obj, int position) –不支持动态增长  

      add(Object obj )/ addElement(Object obj) 在Vector末尾加入对象  

e.g.：myVec.add(new a_Array[0]); 

取出元素：get(int position) / getElement(int position)

实际上Vector向量类在实际开发中使用的也不是特别多，因为有一个继承了他的子类Stack

那么，Vector里面的具体方法就不一一列出来，有很多方法，大家可以到ＪＤＫ的ＡＰＩ里面去查看，先上一个简单的使用代码

 

import java.util.*;
class Student{
 String name;
 int age;
 Student(){
  
 }
 Student(String name,int age){
  this.name=name;
  this.age=age;
 }
 void printInfo(){
  System.out.println (name+"\t"+age);
 }
}

public class VectorDemo {
 public static void main (String[] args) {
     //实例化Vector对象
     Vector v=new Vector();
     //实例化三个学生
     Student s1=new Student("aaa",28);
     Student s2=new Student("bbb",30);
     Student s3=new Student("ccc",25);
     
     v.add(s1);
     v.add(s2);
     v.add(s3);
     //System.out.println (v);
     //移除一个学生
     v.remove(s2);
     
     System.out.println ("姓名\t年龄");
     System.out.println ("===============");
     for(Object o:v){
      Student s=(Student)o;
      s.printInfo();
     }
    } 
}

 

栈类 Stack（Vector的子类）

学过数据结构的同学都知道，栈是先进后出的。

它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

方法摘要
boolean	empty()           测试堆栈是否为空。
E	peek()           查看堆栈顶部的对象，但不从堆栈中移除它。
E	pop()           移除堆栈顶部的对象，并作为此函数的值返回该对象。
E	push(E item)           把项压入堆栈顶部。
int	search(Object o)           返回对象在堆栈中的位置，以 1 为基数。

import java.util.Stack;
public class StackDemo {
 public static void main(String[] args) {
    Stack<String> sta=new Stack<String>();
    //压入push
    sta.push("aaa");
    sta.push("bbb");
    sta.push("ccc");
    sta.push("ddd");
    System.out.println(sta);
    //返回栈顶元素，但不弹出元素
    if(sta.peek().equals("ddd")){
     //弹出方法
     sta.pop();
    }
    //search()方法
    System.out.println("查找的bbb的所在位置是:"+sta.search("bbb"));
    //empty()方法使用
    while(!sta.empty()){
     System.out.println(sta.pop());
    }  
 }
}

 

是不是很简单。。。那是肯定的了，就这五个方法。和栈的操作差不多

 

链表类LinkedList

LinkedList
LinkedList是通过节点直接彼此连接来实现的。每一个节点都包含前一个节点的引用，后一个节点的引用和节点存储的值。当一个新节点插入时，只需要修改其中保持先后关系的节点的引用即可，当删除记录时也一样。这样就带来以下有缺点：
操作其中对象的速度快 只需要改变连接，新的节点可以在内存中的任何地方
不能随即访问 虽然存在get()方法，但是这个方法是通过遍历接点来定位的所以速度慢。

可以说，它的就是为增加删除而生的。

ArrayList就是为查找而生的。

LinkedList里面有很多的方法，这里就不一一列举出来。

比较常用的也不过几个。

E	pop()           从此列表所表示的堆栈处弹出一个元素。
void	push(E e)           将元素推入此列表所表示的堆栈。

E	poll()           获取并移除此列表的头（第一个元素）

E	peek()           获取但不移除此列表的头（第一个元素）。

 

	add(E e)           将指定元素添加到此列表的结尾。
void	add(int index, E element)           在此列表中指定的位置插入指定的元素。
boolean	addAll(Collection<? extends E> c)           添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
boolean	addAll(int index, Collection<? extends E> c)           将指定 collection 中的所有元素从指定位置开始插入此列表。

 

这里面使用方法不是重点。重点是如果有个时候突然需求是频繁增加和删除操作的话，想要使用LinkedList而不是ArrayList，那么我们就算掌握的。在使用的过程中看下JDK就知道他们的方法如何使用了。

import java.util.*;

public class TestLinkedList {
 public static void main (String[] args) {
     Queue q=new LinkedList();//因为实现了Queue接口，所以可以这样写。
  //LinkedList<String> q = new LinkedList<String>(5);
     q.add("Jack");
     q.add("Rose");
     q.add("Cock");
     q.add("Bob");
     q.add("Tom");
  q.add("Ala");
     System.out.println(q);
  String name = (String)q.poll();
  System.out.println("取出队头元素（先进先出）：" + name);
  System.out.println(q);
    }
}

 

实现List接口的实现类ArrayList，Vector，Stack（也是实现Vector的），LinkedList就学习完了

 

接下来就是学习实现了Set接口的TreeSet和HashSet类

复习下Set接口的特点：

Set是一个不包含重复元素的（也称为集）。更正式地说，set 不包含满足e1.equals(e2)的元素对e1和e2，并且最多包含一个 null 元素。它的特性主要包括：

不允许出现重复的元素。

存储在集中的元素的排列顺序是不固定的，其排列策略各实现类有所不同

使用Iterator（迭代器）来进行遍历

实现了Set接口的常用类有HashSet、TreeSet等。

 

正是因为Set接口不允许存储重复的元素这个重要特征使得某些时候我们需要使用它来完成我们的任务

使用了Set接口的TreeSet和HashSet当然也是Set的特性了

HashSet类（多用于大的集合），使用HashSet并不会按照添加的顺序存储，而是根据数据的Flash码计算的存储位置进行存储。

TreeSet类（适合于需要快速检索数据的场合并且线程安全访问）。

使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

 

 

import java.util.*;
public class TreeSetDemo {

 public static void main(String[] args) {
  HashSet<String> hashSet=new HashSet<String>();
  hashSet.add("aaa");
  hashSet.add("bbb");
  hashSet.add("ccc");
  hashSet.add("ddd");
  System.out.println(hashSet);
  hashSet.remove("ddd");
  System.out.println(hashSet);
  //获得集合的迭代器
  Iterator<String> it=hashSet.iterator();
  while(it.hasNext()){
   String str=it.next();
   System.out.println(str);
  }
  //Collections.sort(set);不可以排序
  
  System.out.println("===========TreeSet============");
  TreeSet<Integer> treeSet=new TreeSet<Integer>();
        treeSet.add(new Integer(10));
        treeSet.add(new Integer(20));
        treeSet.add(new Integer(30));
        treeSet.add(new Integer(40));
        System.out.println(treeSet);
        //也是使用迭代器来遍历
        for(Iterator<Integer> it1=treeSet.iterator();it1.hasNext();){
         Integer integer=it1.next();
         System.out.println(integer);
        }
 }

}

 

实际上，集合本身是很简单的，但是它确实是一个很重要的基础。这要求我们一定要清晰地知道他们到底有什么特点。

 

接下来就是Map接口了

映射 (Map) 是另外一种存储数据的方法，这种方法具有较快的查找速度。每个对象都有一个关键字与之对应，关键字决定了这个对象引用的存储位置，并且关键字和对象都存储在 Map 中，在应用中，只要给出关键字，总能直接或间接找到存储在映射中的相应对象。

键值不允许重复

Map 接口包括四类方法：（ JDK API ）

添加和修改： put 、 putAll 等，如果关键字已经存在，则该方法修改与该关键字关联的值

删除元素： remove 、 Clear…

查询元素： containsKey 、 get 、 containsValue …

其它方法：（工具方法） keySet 、 values 、 entrySet …

 

Map的主要实现类：

 

 

类名	null	元素顺序	线程安全
HashMap	允许null键和值	不保证元素的顺序	线程不安全
Hashtable	不允许有null键和值	不保证元素的顺序	线程安全
TreeMap	不允许有null键	可以按键的自然顺序将值排序	线程不安全

 

 

Map学习案例：

 

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class MapDemo {
 public static void main(String[] args) {
   HashMap<String,String> hm=new HashMap<String,String> ();
   //使用put方法加入
   hm.put("S01", "aaa");
   hm.put("S02", "bbb");
   hm.put("S03", "ccc");
   hm.put("S04", "ddd");
   Iterator<String> it=hm.keySet().iterator();
   while (it.hasNext()) {
      String key=it.next();
      String value=hm.get(key);
      System.out.println(key+"===="+value);
  }
   //删除元素
   hm.remove("S04");
   System.out.println ("\n移除之后\n");
   System.out.println ("================");
   //获得键值集合的迭代器
   it=hm.keySet().iterator();
   while(it.hasNext()){
    //使用Map的时候总是先获得key，再通过key找到对应的Value
    String key=(String)it.next();
    String value=(String)hm.get(key);
    System.out.println (key+"===="+value);
   }
   //containsKey方法使用
   if(hm.containsKey("S02")){
    System.out.println(hm.get("S02"));
   }
   
   System.out.println("========================");
   
   //TreeMap学习
   TreeMap<String, String> m=new TreeMap<String, String>();
      //添加元素
      m.put("广州","广东省");
      m.put("长沙","湖南省");
      m.put("杭州","浙江省");
      m.put("南京","江苏省");
      m.put("济南","山东省");
      
      //获得Key集合，返回值是Set类型
      Set key=m.keySet();
      System.out.println("KEY集合：" + key);
      //获得Values集合
   Collection values = m.values();
   System.out.println("Value集合：" + values);
   Set keyvalues=m.entrySet();
   System.out.println("entrySet集合：" + keyvalues);
 }
}

 

运行结果：

S01====aaa
S02====bbb
S03====ccc
S04====ddd

移除之后

================
S01====aaa
S02====bbb
S03====ccc
bbb
========================
KEY集合：[南京, 广州, 杭州, 济南, 长沙]
Value集合：[江苏省, 广东省, 浙江省, 山东省, 湖南省]
entrySet集合：[南京=江苏省, 广州=广东省, 杭州=浙江省, 济南=山东省, 长沙=湖南省]

 

到这里，我们的集合框架基本知识我们的学习好了。