黑马程序员—【Java基础 篇】之集合

------- android培训、java培训、期待与您交流！ ---------

    伙伴们，这篇我们介绍集合类，继续来起。

一、概述

1、由来

/**    面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。*/

2、与数组的区别

<span style="font-size:14px;">/**    数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。*/</span>

3、特点

/**    集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。*/

二、集合体系

1、集合体系图

    集合体系图，如下：

    

三、Collection类

1、简述

/**Collection接口有两个子接口：List（列表） ，Set（集）。（1）、List：可存放重复元素，元素存取是有序的。（2）、Set：不可以存放重复元素，元素存取是无序的。*/

2、共性方法

/**（1）添加元素        add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。（2）删除元素        remove(Objectobj);        removeAll(另一集合);//调用者只保留另一集合中没有的元素。        clear();//清空集合（3）判断元素        contains(Objectobj);//判断是否存在obj这个元素        isEmpty();//是否为空（4）获取个数，集合长度        size();（5）取交集        retainAll(另一集合);//调用者只保留两集合的共性元素。注：集合中存储的都是对象的引用（地址）。*/

3、示例

class  CollectionDemo{public static void main(String[] args) {method_get();}public static void method_get(){ArrayList al = new ArrayList();//1，添加元素。al.add("java01");//add(Object obj);al.add("java02");al.add("java03");al.add("java04");/*Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。while(it.hasNext()){sop(it.next());}*/for(Iterator it = al.iterator(); it.hasNext() ; ){sop(it.next());}}public static void method_2(){ArrayList al1 = new ArrayList();al1.add("java01");al1.add("java02");al1.add("java03");al1.add("java04");ArrayList al2 = new ArrayList();al2.add("java03");al2.add("java04");al2.add("java05");al2.add("java06");//al1.retainAll(al2);//去交集，al1中只会保留和al2中相同的元素。al1.removeAll(al2);sop("al1:"+al1);sop("al2:"+al2);}public static void base_method(){//创建一个集合容器。使用Collection接口的子类。ArrayListArrayList al = new ArrayList();//1、添加元素。al.add("java01");//add(Object obj);al.add("java02");al.add("java03");al.add("java04");//打印原集合。sop("原集合:"+al);//3、删除元素。//al.remove("java02");//al.clear();//清空集合。//4、判断元素。sop("java03是否存在:"+al.contains("java03"));sop("集合是否为空？"+al.isEmpty());//2、获取个数。集合长度。sop("size:"+al.size());//打印改变后的集合。sop(al);}public static void sop(Object obj){System.out.println(obj);}}/**    示例中出现了迭代iterator，下面为大家介绍一下。    迭代是取出集合中元素的一种方式。    因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。    用法：    第1种表达方式：for(Iterator iter = iterator();iter.hasNext();){System.out.println(iter.next());}    第2种表达方式：Iterator iter = l.iterator();while(iter.hasNext()){System.out.println(iter.next());}    迭代器的注意事项：    迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。    迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。    迭代器的next方法返回值类型是Object，所以要记得类型转换。*/

四、List集合

1、定义

/**Collection|--List:元素是有序的，元素可以重复。因为该集合体系有索引。|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快；但是增删稍慢，线程不同步。|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢；线程不同步。|--Vector:底层是数组数据结构。线程同步，被ArrayList替代了；因为效率低。*/

2、List迭代器介绍

/**   （1） List集合特有的迭代器。ListIterator是Iterator的子接口。   （2）在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。   （3）该接口只能通过List集合的listIterator方法获取。*/

   

3、List的特有方法

/**（1）增add(index,element);addAll(index,Collection);（2）删remove(index);（3）改set(index,element);（4）查get(index):subList(from,to);listIterator();int indexOf(obj)://获取指定元素的位置。ListIterator listIterator();<span style="font-size:14px;"> </span>

    示例：

import java.util.*;class ListDemo// List迭代器示例 {public static void sop(Object obj){System.out.println(obj);}public static void method(){ArrayList al = new ArrayList();//添加元素al.add("java01");al.add("java02");al.add("java03");sop("原集合是："+al);//在指定位置添加元素。al.add(1,"java09");//删除指定位置的元素。//al.remove(2);//修改元素。//al.set(2,"java007");//通过角标获取元素。sop("get(1):"+al.get(1));sop(al);//获取所有元素。for(int x=0; x<al.size(); x++){System.out.println("al("+x+")="+al.get(x));}Iterator it = al.iterator();while(it.hasNext()){sop("next:"+it.next());}//通过indexOf获取对象的位置。sop("index="+al.indexOf("java02"));List sub = al.subList(1,3);sop("sub="+sub);}public static void main(String[] args) {//演示列表迭代器。ArrayList al = new ArrayList();//添加元素al.add("java01");al.add("java02");al.add("java03");sop(al);ListIterator li = al.listIterator();//sop("hasPrevious():"+li.hasPrevious());while(li.hasNext()){Object obj = li.next();if(obj.equals("java02"))//li.add("java009");li.set("java006");}while(li.hasPrevious()){sop("pre::"+li.previous());}//sop("hasNext():"+li.hasNext());//sop("hasPrevious():"+li.hasPrevious());sop(al);/*//在迭代过程中，准备添加或者删除元素。Iterator it = al.iterator();while(it.hasNext()){Object obj = it.next();if(obj.equals("java02"))//al.add("java008");it.remove();//将java02的引用从集合中删除了。sop("obj="+obj);}sop(al);}}<span style="font-size:18px;"></span>

4、LinkedList的特有方法

/**LinkedList:特有方法：addFirst();addLast();getFirst();getLast();获取元素，但不删除元素；如果集合中没有元素，会出现NoSuchElementException。removeFirst();removeLast();获取元素，但是元素被删除；如果集合中没有元素，会出现NoSuchElementException。*/在JDK1.6出现了替代方法。offerFirst();offerLast();peekFirst();peekLast();获取元素，但不删除元素。如果集合中没有元素，会返回null。pollFirst();pollLast();获取元素，但是元素被删除。如果集合中没有元素，会返回null。*/

    示例：

class LinkedListDemo // LinkedList练习{public static void main(String[] args) {LinkedList link = new LinkedList();link.addLast("java01");link.addLast("java02");link.addLast("java03");link.addLast("java04");//sop(link);//sop(link.getFirst());//sop(link.getFirst());//sop(link.getLast());//sop(link.removeFirst());//sop(link.removeFirst());//sop("size="+link.size());while(!link.isEmpty()){sop(link.removeLast());}}public static void sop(Object obj){System.out.println(obj);}}

五、Set集合

1、概述

 /**    Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。                |--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。           |--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。        Set集合的功能和Collection是一致的。*/

2、思考

/**HashSet：线程不安全，存取速度快。  它是如何保证元素唯一性的呢？TreeSet： 线程不安全，可以对Set集合中的元素进行排序。  它的排序是如何进行的呢？*/

3、HashSet集合

（1）特点

    底层数据结构时哈希表，且元素取出方式只有迭代器方法。

（2）如何保证集合元素的唯一性

/**    HashSet是如何保证元素唯一性的呢？    通过元素的两个方法，hashCode和equals来完成。    a、如果元素的HashCode值相同，才会判断equals是否为true。    b、如果元素的hashcode值不同，不会调用equals。注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。*/

（3）示例

    示例1：

class HashSetDemo//HashSet示例练习 {public static void sop(Object obj)//封装一个打印函数{System.out.println(obj);}public static void main(String[] args) {HashSet hs = new HashSet();sop(hs.add("java01"));sop(hs.add("java01"));hs.add("java02");hs.add("java03");hs.add("java03");hs.add("java04");Iterator it = hs.iterator();while(it.hasNext()){sop(it.next());}}}

    练习：

import java.util.*;/**需求：    往hashSet集合中存入自定对象姓名和年龄相同为同一个人，重复元素。*/class HashSetTest {public static void sop(Object obj)//定义打印{System.out.println(obj);}public static void main(String[] args) {HashSet hs = new HashSet();hs.add(new Person("a1",11));//增加集合元素hs.add(new Person("a2",12));hs.add(new Person("a3",13));Iterator it = hs.iterator();//迭代取出while(it.hasNext()){Person p = (Person)it.next();sop(p.getName()+"::"+p.getAge());}}}class Person{private String name;private int age;Person(String name,int age){this.name = name;this.age = age;}public int hashCode()//1、判断hashCode是否相同{System.out.println(this.name+"....hashCode");return name.hashCode()+age*37;}public boolean equals(Object obj){if(!(obj instanceof Person))//2、如果相同，再用equals方法return false;Person p = (Person)obj;System.out.println(this.name+"...equals.."+p.name);return this.name.equals(p.name) && this.age == p.age;}public String getName(){return name;}public int getAge(){return age;}}

   分享到这里，那么再分享一个小知识点，关于哈希表。

<span style="font-size:14px;">/**    （1）、哈希表是按照哈希值的大小进行排列的，如果两个哈希值不同，则大的值放后面；如果两个哈希值相同，则再用equals方法比较两个元素的对象是否相同，如果不同，则将第二个值顺延，两个值串起来，放在同一个位置上。    （2）、取值时是按照哈希值取出来的。    （3）、哈希值的取值方式：哈希值存入哈希表中，哈希表也称散列表。散列表是存放记录的数组。具体来说，散列表是根据散列函数H(Key)和处理冲突的方法将一组关键字映象到一个有限的连续的地址集（区间）上，并以关键字在地址集中的“象”，作为这条记录在表中的存储位置，这种表表称为散列表，这一映象过程就称为散列造表或散列，所存储位置称为散列地址（这是百度百科上的内容）。我的理解是：存入的对象的地址是通过提取其信息摘要，通过散列函数计算而获得的一个关键码（Key）即哈希值，然后将这个值存入哈希表，而哈希表的存值方式是按照哈希值的大小顺序存储的，并且在这个哈希表中有自己的索引，但是哈希表的取值方式并不是按照索引的方式取出的。取出方式是按照哈希表中特有的算法取出的哈希值（注意，现在说的是哈希值，不是元素的取出），这些算法有直接寻址法、折叠法、平方取中法以及其他的一些方法等等。具体是按哪种算法查找的，我并不太清楚，所以，取出的哈希值可能就不是按照哈希值的大小顺序取出的了。*/</span>

4、TreeSet集合

/**    |--TreeSet：可以对Set集合中的元素进行排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0.TreeSet排序的第1种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。TreeSet的第2种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。*/

    到了这里，那么就来个练习吧，伙伴们，来咯。。
    示例1（让元素自身具备比较性）：

import java.util.*;  //学生类  class Student implements Comparable  {      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;      }      //复写hashCode以便HashSet集合调用      public int hashCode()      {          return name.hashCode()+age;      }      //复写equals以便HashSet集合和集合中一些比较方法调用      public boolean equals(Object obj)      {          if(!(obj instanceof Student))              throw new RuntimeException();          Student s = (Student)obj;          return this.name.equals(s.name)&&this.age==s.age;      }      //复写compareTo以便TreeSet集合调用      public int compareTo(Object obj)      {          Student s=(Student)obj;          if(this.age==s.age)              return this.name.compareTo(s.name);          return this.age-s.age;          //return new Integer(this.age).compareTo(new Integer(s.age));       }  }    class  TreeSetTest  {      public static void main(String[] args)       {          TreeSet<Student> t=new TreeSet<Student>();          t.add(new Student("wo1",12));          t.add(new Student("wosj",2));          t.add(new Student("wo1sdj",12));          t.add(new Student("wo6sd",12));          t.add(new Student("wo",22));                      for (Iterator<Student> it=t.iterator(); it.hasNext(); )          {              Student s=it.next();              System.out.println(s.getName()+"....."+s.getAge());          }      }  }  

    这种这种方式排序称为：自然排序
    特点：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。

    示例2（容器自身具备比较器）：

/* 需求： 往TreeSet集合中存储自定义对象学生。 想按照学生的年龄进行排序。  */    import java.util.*;  //学生类  class Student implements Comparable  {      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;      }      //复写hashCode以便HashSet集合调用      public int hashCode()      {          return name.hashCode()+age;      }      //复写equals以便HashSet集合和集合中一些比较方法调用      public boolean equals(Object obj)      {          if(!(obj instanceof Student))              throw new RuntimeException();          Student s = (Student)obj;          return this.name.equals(s.name)&&this.age==s.age;      }      //复写compareTo以便TreeSet集合调用      public int compareTo(Object obj)      {          Student s=(Student)obj;          if(this.age==s.age)              return this.name.compareTo(s.name);          return this.age-s.age;          //return new Integer(this.age).compareTo(new Integer(s.age));       }    }    class  TreeSetTest  {      public static void main(String[] args)       {          TreeSet<Student> t=new TreeSet<Student>(new LenCompare());          t.add(new Student("wo1",12));          t.add(new Student("wosj",2));          t.add(new Student("wo1sdj",12));          t.add(new Student("wo6sd",12));          t.add(new Student("wo",22));                      for (Iterator<Student> it=t.iterator(); it.hasNext(); )          {              Student s=it.next();              System.out.println(s.getName()+"....."+s.getAge());          }      }    }  //定义一个比较器，以姓名长度为主要比较  class LenCompare implements Comparator<Student>  {      public int compare(Student s1,Student s2)      {          int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));          if (num==0)          {              return new Integer(s1.getAge()).compareTo(s2.getAge());          }          return num;      }  }  

    说明： 这种排序方式是：定义容器自身拥有比较，当元素自身不具备比较性时，或者具备的比较性不是所需要的；这时就需要让集合自身具备比较性。
    在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法；当两种排序都存在时，以比较器为主。

5、泛型

/**    泛型    （1）、JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。    （2）好处      a、将运行时期出现问题ClassCastException，转移到了编译时期；方便于程序员解决问题，让运行时问题减少，安全。      b、避免了强制转换麻烦         泛型格式：通过<>来定义要操作的引用数据类型。         在使用java提供的对象时，什么时候写泛 型呢？         通常在集合框架中很常见，只要见到<>就要定义泛型。      c、具体使用方式：<> 就是用来接收类型的；当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。*/

六、Map集合

1、概述

/**（1）简述        Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）（2）特点        1）该集合存储键值对，一对一对往里存        2）要保证键的唯一性。*/

2、Map集合子类

/**        |--Hashtable:底层是哈希表数据结构，不可以存入null键null值；该集合是线程同步的。jdk1.0.效率低。|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的；将hashtable替代，jdk1.2.效率高。|--TreeMap：底层是二叉树数据结构，线程不同步；可以用于给map集合中的键进行排序。*/

3、常用方法

/**        1、添加put(K key, V value) putAll(Map<? extends K,? extends V> m) 2、删除clear() remove(Object key) 3、判断containsValue(Object value) containsKey(Object key) isEmpty() 4、获取get(Object key) size() values() entrySet() keySet() */

4、常用方法演示

import java.util.*;class  MapDemo{public static void main(String[] args) {Map<String,String> map = new HashMap<String,String>();//添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。//并put方法会返回被覆盖的值。System.out.println("put:"+map.put("01","zhangsan1"));System.out.println("put:"+map.put("01","wnagwu"));map.put("02","zhangsan2");map.put("03","zhangsan3");System.out.println("containsKey:"+map.containsKey("022"));//System.out.println("remove:"+map.remove("02"));System.out.println("get:"+map.get("023"));map.put("04",null);System.out.println("get:"+map.get("04"));//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。//获取map集合中所有的值。Collection<String> coll = map.values();System.out.println(coll);System.out.println(map);}}

5、Map集合取出方式

<pre name="code" class="java">/**     Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。    Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器，所以可以通过迭代方式取出所以键的值；再通过get方法，获取每一个键对应的值。*/

    第一种取出方式

import java.util.*;  class KeySetDemo   {      public static void main(String[] args)       {          //创建Map集合，并添加元素          Map<Integer,String> map = new HashMap<Integer,String>();          map.put(2,"zhangsan");          map.put(6,"lisi");          map.put(3,"wangwu");          map.put(4,"heihei");          map.put(5,"xixi");          //获取map集合中的所有键的Set集合          Set<Integer> keySet = map.keySet();          //有了Set集合就可以获取其迭代器，取值          Iterator<Integer> it = keySet.iterator();          while (it.hasNext())          {              Integer i = it.next();              String s = map.get(i);              System.out.println(i + " = " + s);          }      }  }/**    思路：    将Map集合中的所有键存入到Set集合中，因为Set集合具备迭代器，所以可以用迭代方式取出所有的键，再根据get方法获取每一个键对应的值。    简洁表达式：Map集合---->Set集合 ---->迭代器取出。*/

    第二种取出方式：

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);          }      }  } /**    说明：    Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？        原因：    a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。    b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。    原理：    将Map集合中的映射关系存入到了Set集合中，而这个映射关系的数据类型是Map.Entry，在通过迭代器将映射关系存入到Map.Entry集合中，并通过其中的getKey()和getValue()放取出键值。*/

6、Map集合应用

/**需求：对学生对象的年龄进行升序排序。思路：学生对象和故籍数据是以键值对形式存在的，所以要使用可以排序的Map集合，TreeMap。*/import java.util.*;class StuNameComparator implements Comparator<Student>{public int compare(Student s1,Student s2){int num = s1.getName().compareTo(s2.getName());if(num==0)return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));return num;}}class  MapTest{public static void main(String[] args) {TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());tm.put(new Student("blisi3",23),"nanjing");tm.put(new Student("lisi1",21),"beijing");tm.put(new Student("alisi4",24),"wuhan");tm.put(new Student("lisi1",21),"tianjin");tm.put(new Student("lisi2",22),"shanghai");Set<Map.Entry<Student,String>> entrySet = tm.entrySet();Iterator<Map.Entry<Student,String>> it = entrySet.iterator();while(it.hasNext()){Map.Entry<Student,String> me = it.next();Student stu = me.getKey();String addr = me.getValue();System.out.println(stu+":::"+addr);}}}

7、Map集合图片说明

    第一张图片说明：keySet（）map集合取出方式

    第二张图片说明：entrySet()方法，取出Map.entry关系类型

<pre name="code" class="java"><pre name="code" class="java">/**1、Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。2、Set<Map.Entry<K,V>>   entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry其实，Entry也是一个接口，它是Map接口中的一个内部接口。   */

    伙伴们，还满意吗，集合呀，集合，这篇到这里了，下篇我们再见。

------- android培训、java培训、期待与您交流！ -------