黑马程序员——Java基础---集合

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

一、 集合框架

1.概念

     集合类的由来：
     对象用于封装特有数据，对象多了需要存储；如果对象的个数不确定，就使用集合容器进行存储。

     集合特点：
     1. 用于存储对象的容器。
     2. 集合的长度是可变的。
     3. 集合中不可以存储基本数据类型值。

     集合容器因为内部的数据结构不同，有多种具体容器。
     不断的向上抽取，就形成了集合框架。

     P.S.
     数组和集合类同是容器，有何不同？
     数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。
     数组中可以存储基本数据类型，集合只能存储对象。

   

2.Collection接口

     框架的顶层Collection接口：
      Collection的常见方法：
      1、添加：
      boolean add(Object obj);
      boolean addAll(Collection coll);

      2、删除：
       boolean remove(Object obj);
      boolean removeAll(Collection coll);
      void clear();

      3、判断：
      boolean contains(Object obj);
      boolean containsAll(Collection coll);
      boolean isEmpty();判断集合中是否有元素。

      4、获取：
      int size();
      Iterator iterator();
      取出元素的方式：迭代器。
      该对象必须依赖于具体容器，因为每一个容器的数据结构都不同，所以该迭代器对象是在容器中进行内部实现的，也就是iterator方法在每个容器中的实现方式是不同的。
     对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就是iterator方法。
     Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

.     集合类的itreator()方法，返回的是一个Iterator接口，这个接口有三个方法。

        Iterator it= c.iterator(); 

        it.next()获取元素，返回值是Object类型，所以记得类型转换。

        it.hasNext()判断是否还有下一个元素

        it.remove 从迭代器指向的 collection中移除迭代器返回的最后一个元素。

import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class IteratorDemo{       public static void main(String[] args){            Collection coll = new ArrayList();            coll.add( "abc1");            coll.add( "abc2");            coll.add( "abc3");            coll.add( "abc4");            System.out.println(coll);             //使用了Collection中的iterator()方法。调用集合中的迭代器方法，是为了获取集合中的迭代器对象。            Iterator it1 = coll.iterator();             while(it1.hasNext()){                  System.out.println(it1.next());            }             //for循环结束，Iterator变量内存释放，更高效             for(Iterator it2 = coll.iterator();it2.hasNext();){                  System.out.println(it2.next());            }      }}

     5、其他：
     boolean retainAll(Collection coll);取交集
     Object toArray();将集合转成数组

/** * 需求：演示collection集合通用方法 *  * @author jinlong * */package com.blog.part4.集合;import java.util.*;public class CollectionDemo {public static void main(String[] args) {// Collection coll=new ArrayList();show(coll);sop("-------------------------------------------");Collection c1=new ArrayList();Collection c2=new ArrayList();show(c1,c2);}public static void show(Collection coll){//1、添加元素addcoll.add("abc");coll.add("bcd");coll.add("efg");sop(coll);//2、删除元素removecoll.remove("abc");sop(coll);//3、清空集合coll.clear();    sop(coll);}public static void show(Collection coll1,Collection coll2){//给c1添加元素coll1.add("abc");coll1.add("bcd");coll1.add("cde");coll1.add("def");//给c2添加元素coll2.add("abc");coll2.add("xyz");coll2.add("ghf");sop("coll1::"+coll1);sop("coll2::"+coll2);//取交集boolean b2=coll1.retainAll(coll2);sop("retainAll::"+coll1);//演示addAllcoll1.addAll(coll2);sop("addAll::"+coll1);//演示removeAll//从coll1集合中删除与coll2相同的元素boolean b=coll1.removeAll(coll2);sop("removeAll::"+coll1);//演示containAllboolean b1=coll1.containsAll(coll2);sop("containAll"+coll1);}   //打印public static void sop(Object obj){System.out.println(obj);}}

        

3.List类

   Collection：常用子类
          |--List：有序（存入和取出的顺序一致），元素都有索引（角标），允许重复元素。
          |--Set：元素不能重复，无序。

  这里我们先介绍List类及其子类

1.List子类共性

     有一个共性特点就是都可以操作角标。
     1、添加
          void add(index,element);
          void addAll(index,collection);

     2、删除
          Object remove(index);

     3、修改
          Object set(index,element);

     4、获取：
          Object get(index);
          int indexOf(object);
          int lastIndexOf(object);
          List subList(from,to);

2.List子类共性

        三个常用子类

         1.ArrayList:底层数据结构使用的是数组结构。查询速度很快，但是增删较慢。百分之五十延长。

         2.LinkList： 底层使用的是链表数据结构。查询速度稍慢，增删的速度很快。

         3.Vector  :  底层是数组结构。1.0版本的时候，当时没有集合框架。线程是是同步的。百分之百延长。

        List集合判断元素是否相同，依据的是元素的equals方法，可以重写定义自己需要的equals。这个是底层调用的。

3.LinkedList    

       1.链表结构特有方法。

           addFirst( ); addLast( );

         getFirst( );  getLast( );             获取元素但不删除元素。

        removeFirst( );removeLast( );获取元素，但元素会被删除。

      2.在JDK1.6出现了替代方法：

            offerFirst();offerLast();   peekFirest();  peekLast();

          pollFirst(); pollLast();

 

        1和2的区别在于，获取元素如果集合中没有元素，1会返回NoSuchElementException异常,2会返回null；

 

经典示例：

/** * 需求：请使用LinkedList来模拟一个堆栈数据结构。 * 思路：这里我们要先要确定队列的特点 *           堆栈：如同一个杯子：先进后出 *           队列：如同一个水管：先进先出 *           所以模拟队列就是模拟先进先出的特点 *           *            * @author jinlong * */package com.blog.part4.集合;import java.util.LinkedList;//定义一个队列类class DuiLie{   //定义私有变量LinkedList       private LinkedList link;       //构造函数初始化私有变量       public DuiLie()       {            link = new LinkedList();      }       //队列的添加元素的功能。       public void myAdd(Object obj)       {       //用addLast从后往前添加元素            link.addLast(obj);      }            //获取元素       public Object myGet()       {       //removeFirst();从前往后读             return link.removeFirst();      }      //判断是否还有元素       public boolean isNull()       {             return link.isEmpty();      }}public class DuiLieDemo{       public static void main(String[] args)       {            DuiLie dl = new DuiLie();            dl.myAdd( "abc1");            dl.myAdd( "abc2");            dl.myAdd( "abc3");            dl.myAdd( "abc4");            //循环打印             while(!dl.isNull())             {                  System.out.println(dl.myGet());            }      }}

4.Vector  

       Vector有一个自己特殊的取出方式，枚举。

       其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

5.ArrayList 

/** * 需求：将一个自定义对象存储到ArrayList集合中去，并去除重复元素。 * 思路:每个元素都是一个对象。 * @author jinlong * */package com.blog.part4.集合;import java.util.*;//定义Person类class Person{//基本属性private String name;private int age;    //构造函数 Person (String name,int age){this.name=name;this.age=age;}//暴露方法获取属性public String getName(){return this.name;}    public int getAge()    {return this.age;    }//重写equals方法public boolean equals(Object obj){   //判断是否是同一个对象。if(!(obj instanceof Person))return false;        //判断是否符合需求：姓名和年龄相同及作为相同元素Person p=(Person)obj; return this.name.equals(p.name)&&this.age==p.age;}}class ArrayListDemo

运算结果：

4.Set类

      Set:元素不可以重复，是无序。

      Set接口中的方法和Collection一致。
       |--HashSet：内部数据结构是哈希表，是不同步的。
       |--TreeSet：可以对Set集合中的元素进行排序，是不同步的。

1.HashSet类

        保证元素的唯一性原理：hashCode返回值相同，并且equals方法return true，那么两个元素相同。

/** * 需求：像hashSet容器中添加自定义对象，并且年龄和姓名相同作为重复元素。 * 思路：因为hashSet中不能存在相同元素，那么添加自定义对象元素时，也要自定义判断相同元素的方法 *           HashSet中判断两个元素是否相同，首先是判断两元素HashCode值，如果相同再判断equals返回是否为true * @author jinlong * */package com.blog.part4.集合;import java.util.*;//建立人这个对象类class Person{//定义基本属性private String name;private int age; //构造函数 Person(String name,int age){this.name=name;this.age=age;  }//对外接口public String getName(){return name;}public int getAge(){return age;}//重写equals方法。public boolean equals(Object obj){//看传入的是不是Person对象的一个实例if(!(obj instanceof Person))return false;//如果是Person的实例，才能转型Person p= (Person)obj;//然后定义自己的判断元素相同的判断方法。如果姓名年龄都相同返回真。return p.name.equals(this.name)&&this.age==p.age;}//自定义hashcode算法方法  public int hashCode(){  return this.name.hashCode()+37*age;}}class  HashSetDemo{public static void main(String[] args) {//定义一个HashSet容器HashSet ts=new HashSet();      //添加元素ts.add(new Person("zhangsan",20));ts.add(new Person("zhangsi",20));ts.add(new Person("zhangsan",20));ts.add(new Person("lisi",20));ts.add(new Person("wangwu",20));ts.add(new Person("lisi",20));ts.add(new Person("wangwu",22));//定义迭代器Iterator it= ts.iterator();//打印while(it.hasNext()){Person p= (Person)it.next();sop("name:"+p.getName()+":::"+"age:"+p.getAge());}}//打印方法public static void sop(Object obj){     System.out.println(obj);}}

运算结果：

        jdk1.4后新添加了一个类，LinkHashSet，当无序HashSet集合想变有序时，可以使用。

import java.util.HashSet;import java.util.Iterator;import java.util.LinkedHashSet;public class LinkedHashSetDemo{       public static void main(String[] args){            HashSet hs = new LinkedHashSet();            hs.add( "hahaa");            hs.add( "hehe");            hs.add( "heihei");            hs.add( "xixii");            Iterator it = hs.iterator();             while(it.hasNext()){                  System.out.println(it.next());            }      }}

2.TreeSet类

       TreeSet判断元素唯一性的方式：就是根据比较方法compareTo的返回结果是否是0，是0，就是相同元素，不存。           

      1、特点

      a.底层的数据结构为二叉树结构（红黑树结构）

      b.可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写                    compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。

         java中的很多类都具备比较性，其实就是实现了Comparable接口。

         注意：排序时，当主要条件相同时，按次要条件排序。

     c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。

1.自然排序

/** * 需求：像hashset容器中添加自定义对象，并且年龄和姓名相同作为重复元素。 * 思路:   根据重复元素条件重写compareTo方法 * @author jinlong * */package com.blog.part4.集合;import java.util.*;//建立人这个对象类//通过接口让对象具有比较性class Person implements Comparable{//定义基本属性private String name;private int age; //构造函数 Person(String name,int age){this.name=name;this.age=age;  }//对外接口public String getName(){return name;}public int getAge(){return age;}  //重写接口方法public int compareTo(Object obj){if(!(obj instanceof Person))throw new RuntimeException("传入对象不是人");//转型  Person p= (Person)obj;        //主要比较条件age  if(this.age>p.age)  return 1;  if(this.age==p.age)    {  //这里的conmpareTo方法，是String类本身就实现了comparable接口所具有的方法。  //这里定义了次要比较条件name  return this.name.compareTo(p.name);    }  return -1;}}class  TreeSetDemo{public static void main(String[] args) {//定义一个HashSet容器TreeSet ts=new TreeSet();      //添加元素ts.add(new Person("zhangsan",20));ts.add(new Person("zhangsi",20));ts.add(new Person("zhangsan",20));ts.add(new Person("lisi",20));ts.add(new Person("wangwu",20));ts.add(new Person("lisi",20));ts.add(new Person("wangwu",22));//定义迭代器Iterator it= ts.iterator();//打印while(it.hasNext()){Person p= (Person)it.next();sop("name:"+p.getName()+":::"+"age:"+p.getAge());}}public static void sop(Object obj){     System.out.println(obj);}}

运行结果：

2.实现方法排序

         当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。

        在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

        比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。

        当两种排序都存在时，以比较器为主。

/** * 需求：像hashset容器中添加自定义对象，按姓名排序。 * 思路:   实现接口comparator，重写compare方法 *            重写compare的时候要明确主要比较条件和次要比较条件 *             * @author jinlong * */package com.blog.part4.集合;import java.util.*;//建立人这个对象类class Person {//定义基本属性private String name;private int age; //构造函数 Person(String name,int age){this.name=name;this.age=age;  }//对外接口public String getName(){return name;}public int getAge(){return age;}}//自定义比较方法，实现Comparatorclass Mycomp implements Comparator{//重写compare方法public int compare(Object obj1,Object obj2){if(obj1 instanceof Person&&obj2 instanceof Person){  Person p1=(Person)obj1;  Person p2=(Person)obj2;  //主要判断条件  int num= p1.getName().compareTo(p2.getName());  if(num==0) {    //次要判断条件return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge())); }return num;}return 0;}}class  TreeSetDemo{public static void main(String[] args) {//定义一个HashSet容器TreeSet ts=new TreeSet(new Mycomp());      //添加元素ts.add(new Person("zhangsan",20));ts.add(new Person("zhangsi",20));ts.add(new Person("zhangsan",22));ts.add(new Person("lisi",20));ts.add(new Person("wangwu",20));ts.add(new Person("lisi",20));ts.add(new Person("wangwu",22));//定义迭代器Iterator it= ts.iterator();//打印while(it.hasNext()){Person p= (Person)it.next();sop("name:"+p.getName()+":::"+"age:"+p.getAge());}}public static void sop(Object obj){     System.out.println(obj);}}

运行结果：

示例二;

/** * 需求：根据元素的字符串长度作为排序条件给TreeSet集合中元素排序 * 思路：要自定义条件，所以用Comparetor *          元素的长度作为主要排序条件 * @author jinlong * */package com.blog.part4.集合;import java.util.*;class TreeSetLengthDemo{public static void main(String[] args) {   TreeSet ts=new TreeSet(new Mycomp1());       ts.add("beijinghuanying");   ts.add("beijinghuanyingni");   ts.add("beijinghuan");   ts.add("hei");   ts.add("heilong");   ts.add("beijing");   ts.add("bei");   Iterator it=ts.iterator();   while(it.hasNext()){sop(it.next());    }}public static void sop(Object obj){System.out.println(obj);}}class Mycomp1 implements Comparator{public int compare(Object o1,Object o2){String s1= (String)o1;String s2= (String)o2;//主要判断条件int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));//次要判断条件        if(num==0)return s1.compareTo(s2);return num;}}

5.Map集合

1.概述

       1、简述：

        Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）

        2、特点：

        1）该集合存储键值对，一对一对往里存

        2）要保证键的唯一性。

 

2.Map集合的子类

        Map
            |--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。
            |--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。
            |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
        Map和Set很像。其实Set底层就是使用了Map集合。
 

3.Map集合的常用方法

      1、添加

        Vput(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。

        voidputAll(Map <? extends K,? extends V> m);//添加一个集合

       2、删除

        clear();//清空

        Vremove(Object key);//删除指定键值对

      3、判断

        containsKey(Objectkey);//判断键是否存在

        containsValue(Objectvalue)//判断值是否存在

        isEmpty();//判断是否为空

     4、获取

        Vget(Object key);//通过键获取对应的值

        size();//获取集合的长度

        Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合

还有两个取出方法，接下来会逐个讲解：

        Set<Map.Entry<K,V>>entrySet();

        Set<K>  keySet();

注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

 

4.Map集合的两种取出方式

        Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。

       1. Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取               每一个键对应的值。

/*每一个学生都有对应的归属地。学生Student，地址String。学生属性：姓名，年龄。注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。思路：1、描述学生类  2、定义一个Map集合，存储学生对象和地址值  3、获取Map中的元素*/import java.util.*;//描述学生类class Student implements Comparable<Student>{private String name;private int age;Student(String name,int age){this.name=name;this.age=age;}public String getName(){return name;}public int getAge(){return age;}//复写hashCodepublic int hashCode(){return name.hashCode()+age*33; }//复写equals，比较对象内容public boolean equals(Object obj){if(!(obj instanceof Student))throw new ClassCastException("类型不匹配");Student s=(Student)obj;return this.name.equals(s.name)&&this.age==s.age;}//复写compareTo,以年龄为主public int compareTo(Student c){int num=new Integer(this.age).compareTo(new Integer(c.age));if(num==0){return this.name.compareTo(c.name);}return num;}//复写toString，自定义输出内容public String toString(){return name+"..."+age;}}class  HashMapTest{public static void main(String[] args) {HashMap<Student,String > hm=new HashMap<Student,String >();hm.put(new Student("zhangsan",12),"beijing");hm.put(new Student("zhangsan",32),"sahnghai");hm.put(new Student("zhangsan",22),"changsha");hm.put(new Student("zhangsan",62),"USA");hm.put(new Student("zhangsan",12),"tianjing");keyset(hm);}//keySet取出方式public static void keyset(HashMap<Student,String> hm){Iterator<Student> it=hm.keySet().iterator();while(it.hasNext()){Student s=it.next();String addr=hm.get(s);System.out.println(s+":"+addr);}}}

   

    2.Set<Map.Entry<K,V>>   entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry

        Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？

        原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。

                     b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

 

 interface Map     {          public static interface Entry          {               public abstract Object getKey();               public abstract Object getValue();          } }

  示例:

class  HashMapTest{public static void main(String[] args) {HashMap<Student,String > hm=new HashMap<Student,String >();hm.put(new Student("zhangsan",12),"beijing");hm.put(new Student("zhangsan",32),"sahnghai");hm.put(new Student("zhangsan",22),"changsha");hm.put(new Student("zhangsan",62),"USA");hm.put(new Student("zhangsan",12),"tianjing");entryset(hm);}//entrySet取出方式public static void entryset(HashMap<Student,String> hm){Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();while(it.hasNext()){Map.Entry<Student,String> me=it.next();Student s=me.getKey();String addr=me.getValue();System.out.println(s+":::"+addr);}}}

5.Map集合的应用及扩展

/*需求：获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(0).....思路：    1、将字符串转换为字符数组  2、定义一个TreeMap集合，用于存储字母和字母出现的次数  3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入  4、将TreeMap集合中的元素转换为字符串*/package TreeMapTest;import java.util.*;class CharCount{public static void main(String[] args) {String s="sdfgzxcvasdfxcvdf";System.out.println("s中各字母出现的次数："+charCount(s));}//定义一个方法获取字符串中字母出现的次数public static String charCount(String str){char[] cha=str.toCharArray();//转换为字符数组//定义一个TreeMap集合，因为TreeMap集合会给键自动排序TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();int count=0;//定义计数变量for (int x=0;x<cha.length ;x++ ){if(!(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z'))continue;//如果字符串中非字母，则不计数Integer value=tm.get(cha[x]);//获取集合中的值if(value!=null)//如果集合中没有该字母，则存入count=value;count++;tm.put(cha[x],count);//存入键值对count=0;//复位计数变量}  StringBuilder sb=new StringBuilder();//定义一个容器//遍历集合，取出并以题目格式存入容器中for(Iterator<Character> it=tm.keySet().iterator();it.hasNext();){Character ch=it.next();Integer value=tm.get(ch);sb.append(ch+"("+value+")");}return sb.toString();//返回字符串 }}<strong></strong>

/*map扩展知识。map集合被使用是因为具备映射关系。以下是班级对应学生，而学生中学号对应着姓名的映射关系："yureban"   Student("01" "zhangsan");"yureban" Student("02" "lisi");"jiuyeban" "01" "wangwu";"jiuyeban" "02" "zhaoliu";就如同一个学校有多个教室。每一个教室都有名称。*/import java.util.*;class  MapExpandKnow{public static void main(String[] args) {//预热班集合HashMap<String,String> yureban=new HashMap<String,String>();//就业班集合HashMap<String,String> jiuyeban=new HashMap<String,String>();//学校集合               HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();//学校中班级集合和名称的映射czbk.put("yureban",yureban);czbk.put("jiuyueban",jiuyeban);                //预热班级中学号与姓名的映射yureban.put("01","zhangsan");yureban.put("02","lisi");//就业班级中学号与姓名的映射jiuyeban.put("01","wangwu");jiuyeban.put("02","zhouqi");//直接显示全部学生信息      getAllStudentInfo(czbk);}//定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm){for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式{String s= it.next();//班级名称System.out.println(s+":");HashMap<String,String> stu=hm.get(s);//班级集合getStudentInfo(stu);}}//获取班级中学生的信息，包括姓名和学号public static void getStudentInfo(HashMap<String,String> hm){for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; ){String key=it.next();//学号String value=hm.get(key);//姓名System.out.println(key+"..."+value);}}}