Java基础知识：集合

黑马程序员---------Java基础知识：集合

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

                

一：为什么要出现集合类？

       因为在JAVA中，对事物的体现都是以对象的形式来体现，对象多了，为了方便对类的操作就出现了集合对类的存储。其实集合就是一个存储对象的一种方式。作用和数组差不多，不过又与数组有所差别。集合内存的都是对象，集合长度都是可变的，这与数组不一样。

二：常用的集合类

       在编程过程中常用的集合类有以下几个

1.      list，特点是list中元素是有序的，元素是可以重复，可以用索引查找对象。

List下又分有三种ArrayList ，LinkedList和Vector.这三种的特点如下。

~ArrayList底层的数据结构是数组结构，查询快，增删慢些，线程不同步。

~LinkedList底层使用链表结构，所以增删快，查询慢些。线程不同步。

~Vector 底层是数组结构。线程同步。但是因为效率低所以被ArrayList取代，在合并流中有使用到。

2.      Set,元素是无序的，因而元素不能重复，而且存入取出的顺序不一样。

Set下有份为两种HashSet和 TreeSet..特点如下：

~HashSet底层是哈希表，线程不安全，通过hashCode 和equals来完成元素的唯一性。

~ TreeSet可以对元素进行排序。

3.      Map<k,v>集合，该集合存的是键值的对，一对一对的存取而且要保证唯一。

Mapf分为三类Hashtable , HashMap , TreeMap,其特点如下：

~Hashtable底层是哈希表，不能存NULL，线程同步。

~ HashMap底层哈希表，可以存NULL，线程不同步。

~ TreeMap 底层二叉树，线程不同步，可以进行键排序。

三：集合的操作

       这几种集合类操作都有所不同。以下通过例程来说明。

  List集合可以通过使用角标对元素进行增删改查，ArrayList ，LinkedList使用迭代器进行元素的取出，而Vector则使用枚举取出元素。HashSet和 TreeSet通过hashCode 和equals保证元素的唯一性。TreeSet可以对元素进行排序，可以通过实现Comparable中compareTo(Object
o)对指定顺序进行排序。Map<k,v>集合有两种取出方式，一种是Set keyset ,另一种是Set<Map.Entry<String, String>>，用法可以参照例程。
 
 import java.util.*;
importjava.util.Map.Entry;
 
public
class JiHeDemo {
 
   public
static void main(String[]
args) {
      arrayListDemo();
      linkedListDemo();
      vectorListDemo();
      hashSetDemo();
      treeSetDemo();
      hashMapDemo();
   }
 public
static void arrayListDemo()
 {
   ArrayList<String> a =new ArrayList<String>();//创建对象
 
   a.add("香蕉");//添加元素
   a.add("香蕉");
   a.add("香橙");
   a.add("桃子");
 
   sop(a.size());//获取集合长度 7
   a.remove(2);//删除位号为2的元素
   //a.retainAll(c);//取交集，a保留与c相同的元素
   //a.removeAll(c);//取交集，A保留与c不同的元素
   Iterator<String> it =a.iterator();
//迭代器取出元素
   while(it.hasNext())//判断是否还有元素
   {
      sop(it.next());//取出元素并打印
   }
  
  
   Object[] ch =a.toArray();//将集合转数组
   for(int
x=0;x<ch.length;x++)
   {
      sop(ch[x]);//打印出来
   }
 }
 public
static void linkedListDemo()
 {
    LinkedList<String> a =new LinkedList<String>();
    a.addFirst("西红柿");//特有方法
    a.addFirst("黄花菜");
    a.addLast("金针菇");//特有方法
    a.add("马铃薯");
    a.add("娃娃菜");
    //使用特有方法可以实现堆先进先出，栈先进后出
    Iterator<String> it =a.iterator();
//迭代器取出元素
      while(it.hasNext())//判断是否还有元素
      {
         sop("linkedList"+it.next());//取出元素并打印
      }
    
 }
 public
static void vectorListDemo()
 {
    Vector<String> v =
newVector<String>();
    v.add("园的");
    v.add("方的");
    v.add("长的");
    v.add("短的");
    Enumeration<String>en=v.elements();//枚举，特有的方法
    while(en.hasMoreElements())//判断是否还有元素
    {
       sop(en.nextElement());//打印元素
    }
 }
 public
static void hashSetDemo()
 {
    //因为存的是类，所以需要有一个类，内部复写hashCoe equals,去除相同元素
    HashSet<Flower> ha =newHashSet<Flower>();
    ha.add(new Flower("红色",50));
    ha.add(new Flower("红色",40));
    ha.add(new Flower("粉色",50));
    ha.add(new Flower("绿色",15));
    ha.add(new Flower("桃色",20));
    ha.add(new Flower("红色",50));
    Iterator<Flower> it =
ha.iterator();
    while(it.hasNext())
    {
       Flowerf=it.next();
       sop(f.getColor()+" "+f.getNum());
    }
    
    
 }
 public 
static void treeSetDemo()//使用TreeSet时为了让对象有比较性需要实现Comparable,复写comparaTo(Object
obj)
 {//按照数量先排序，如果数量相同按照名字排序，去掉重复的对象
    TreeSet<Flower> tr =
newTreeSet<Flower>();
    tr.add(new Flower("粉梅花1",50));
    tr.add(new Flower("粉梅花2",50));
    tr.add(new Flower("粉梅花1",45));
    tr.add(new Flower("红梅花2",45));
    tr.add(new Flower("蓝梅花3",12));
    tr.add(new Flower("绿梅花0",18));
    tr.add(new Flower("绿梅花0",18));
    Iterator<Flower> it =tr.iterator();
    while(it.hasNext())
    {
       Flower fl =(Flower)it.next();
       sop(fl.getColor()+" "+fl.getNum());
    }
 }
 
 public 
static void hashMapDemo()
 {//使用集合存入数据并取出打印
    Map<String, String> map =new HashMap<String, String>();
    map.put("01",
"张山");
    map.put("02",
"赵一");
    map.put("03",
"李四");
    map.put("05",
"钱二");
    map.put("04",
"吴六");
    //map取出元素有两种方法，一种是使用Set<String>
keyset，一种是
    Set<String> keyset =map.keySet();//将获取KEY放入set集合当中
    Iterator<String> it =keyset.iterator();//使用迭代器
    while(it.hasNext())//判断有没有元素
    {
       String key=it.next();//将KEY取出，然后就可以使用get(key)获取值
       String vaule =
map.get(key);//获取值
       sop(key+" ... "+vaule);//打印见和值
    }
    //第二种取出方式Set<Map.Entry<String,String>> ,
    Set<Map.Entry<String,String>>   entrySet =map.entrySet();//将键值关系存入集合
    Iterator<Entry<String, String>> it1 = 
entrySet.iterator();//迭代器
    while(it1.hasNext())
    {
      Map.Entry<String, String> me =it1.next();//把键值关系取出
      String key1 =me.getKey();//获取键
      String vaule1 =me.getValue();//获取值
      sop(key1+" : "+vaule1);
       
    }
       
 }
 
 public
static void sop(Object
obj)
 {
    System.out.println(obj);
 }
}
class Flower
implements Comparable<Object>
{
   private String
color;//颜色
   private
int num;//数量
   Flower(String color,int
num)
   {
      this.color =color;
      this.num =
num;
   }
   public
int hashCode()//复写
   {
      return
color.hashCode()+num*41;
   }
   public
boolean equals(Object obj)
   {
      if(!(obj
instanceof Flower))//当输入的类不是Flower
      {
         return
false;
      }
      Flower f=(Flower)obj;
      return
this.color.equals(f.color)&&this.num==f.num;
   }
   public String getColor() {
      return
color;
   }
  
   public
int getNum() {
      return
num;
   }
  
   public
int compareTo(Object o) {
      if(!(o
instanceof Flower))
         throw
new RuntimeException("这个不是花对象");
      Flower f=(Flower)o;
      if(this.num>f.num)
         return 1;
      if(this.num==f.num)
      {
         return
this.color.compareTo(f.color);
      }
     
      return -1;
   }
  
  
}

 

 

总结：集合其实用法差不多，用处却不大一样，假如需要排序，则使用TreeSet。假如只需要保证元素的唯一性则使用hashset。假如输入输出需要取第一个元素，最后一个元素则使用Linkedlist。假如需要按位操作，最好使用Arraylist。假如是键值对，则使用Map集合。