黑马程序员-集合框架

最新推荐文章于 2022-11-29 13:49:05 发布

夏德宇

最新推荐文章于 2022-11-29 13:49:05 发布

阅读量446

点赞数

本文链接：https://blog.csdn.net/u013196932/article/details/17469661

版权

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

集合类

集合类的由来：我们知道面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储。集合就是存储对象最常用的一种方式。对象里面封装数据，集合里面封装对象。
集合和数据的区别
- 数组中可以存储基本数据类型和对象类型；集合中只能存储对象类型。
- 数组的长度是固定的；集合的长度是可变的。
- 数组中存储的数据类型要一致；集合可以存储不同类型的对象。
- 在遇到不明确对象数量和类型的情况下，可以选择用集合存储。
集合框架的构成及分类
- 在java中定义了很多集合，每种集合存储数据的方式不同，将其中共性的内容不断的向上抽取，就形成了集合框架。如图所示：
- 为什么会出现这么多的集合容器呢？
  因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构。

集合框架中的常用接口
- 集合框架中常用的接口有：Collection接口、Map接口、List接口、Set接口和Iterator接口等。
- 各自的特点和作用：
  - Collection接口存储一组不唯一（允许重复）、无序的对象。
  - Set接口继承Collection接口，存储一组唯一（不允许重复）、无序的对象。
  - List接口继承Collection接口，存储一组不唯一（允许重复）、有序（以元素插入的次序来放置元素，不会重新排列）的对象。
  - Map接口存储一组成对的键-值对象，提供key（键）到value（值）的映射。Map中的key不要求有序，不允许重复（如果重复，key对应的value会有覆盖操作）。value同样不要求有序，但允许重复。
  - Iterator接口是对collection进行迭代的迭代器。
Collection接口中的常用方法
首先创建一个集合容器：ArrayList al=new ArrayList();
- 添加
  boolean add(element)：向该集合的末尾添加指定的元素。
  该方法的参数类型是Object，以便于接收任意类型的对象。集合中存储的并不是对象实体，而是对象的引用（地址）。
  al.add("java01");
  al.add("java02");
  al.add("java03");
  System.out.println("原集合al:"+al); //打印结果：原集合al:[java01,java02,java03]
  boolean addAll(Collection)：将指定 collection 中的所有元素都添加到此 collection 中。（可以添加一堆元素）
- 移除
  boolean remove(Object)：从此 collection 中移除指定元素的单个实例，如果存在的话。
  al.remove("java01");
  System.out.println("现集合al:"+al); //打印结果：现集合al:[java02,java03]
  boolean removeAll(Collection)：移除此collection中那些也包含在指定collection中的所有元素（移除交集）。
  boolean retainAll(Collection)：仅保留此 collection 中那些也包含在指定 collection 的元素（仅保留交集）。
  void clear()：移除此collection中的所有元素（清空）。
- 判断
  boolean contains(Object o)：判断某一元素是否存在于集合中。
  System.out.println(al.contains("java03")); //打印结果：true
  boolean containsAll(Collection)：如果此collection包含指定collection中的所有元素，则返回true。
  ArrayList al2=new ArrayList();
  al2.add("java03");
  System.out.println(al.containsAll(al2)); //打印结果：true
  boolean equals(Object o)：比较此collection与指定对象是否相等。
  ArrayList arrl1=new ArrayList();
  arrl1.add("java");
  arrl1.add(333);
  ArrayList arrl2=new ArrayList();
  arrl2.add("java");
  arrl2.add(333);
  System.out.println(arrl1.equals(arrl2)); //打印结果：true
  boolean isEmpty()：判断此集合中是否有内容。
- 查询
  int size()：返回此collection中的元素数。
  System.out.println(al.size()); //返回结果：2
  int haseCode()：返回此collection的哈希码值。
- 将集合中的元素存放到某一数组中：Object[] toArray()：

List接口中常用类
- List集合中的元素是有序的，元素可以重复，是因为该集合体系有索引。
- Vector：线程同步，但效率没有ArrayList高，而且没有ArrayList节省内存空间，已被ArrayList替代，从JDK1.0版本出现。底层是数组数据结构。（枚举Enumeration是Vector特有的取出方式，从JDK1.0版本出现）
- ArrayList：线程不同步，查询修改速度快，但是增加删除稍慢，从JDK1.2版本出现。底层是数组数据结构。
- LinkedList：增加删除速度快，查询修改速度慢。底层是链表数据结构。
- 特有方法：addFirst(),addLast(),getFirst(),getLast(),removeFirst(),removeLast()。
  JDK1.6的上述替代方法：offerFirst(),offerLast(),peekFirst(),peekLast(),pollFirst(),pollLast()。
List接口中的常用方法：（不包括复写Collection接口中的方法）
首先创建一个集合并初始化：ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
1、添加
void add(index,element)：在指定的位置添加元素。
al.add(1,"java04");
System.out.println("现集合al:"+al); //打印结果：现集合al:[java01,java04,java02,java03]
boolean addAll(index,Collection)：将指定collection中的所有元素都插入到列表中的指定位置。
ArrayList al2=new ArrayList();
al2.add("java04");
al2.add("java05");
al.addAll(1,al2);
System.out.println(al); //打印结果：[java01,java04,java04,java05,java02,java03]
2、移除：
E remove(int index)：移除列表中指定位置的元素。
al.remove(1);
System.out.println("现集合al:"+al); //打印结果：现集合al:[java01,java04,java05,java02,java03]
3、修改：
E set(int index, E element)：用指定元素替换列表中指定位置的元素。
al.set(1,"java004");
System.out.println("现集合al:"+al); //打印结果：现集合al:[java01,java004,java05,java02,java03]
4、查询：
int indexOf(Object o)：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int index=al.indexOf("java03");
System.out.println("index="+index); //打印结果：index=4
int lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
E get(int index)：返回列表中指定位置的元素。（可用于遍历集合中的元素）
System.out.println(al.get(1)); //打印结果：java004
Iterator iterator()：返回按适当顺序在列表的元素上进行迭代的迭代器。
代码演示：
```
public static void main(String[] args)   
    {  
        //创建一个集合容器  
        ArrayList al=new ArrayList();  
        al.add("java01");  
        al.add("java02");  
        al.add("java03");  
  
        //使用迭代器遍历过程中，如果通过集合中的方法对集合进行并发操作  
        //则会发生异常：java.util.ConcurrentModificationException（并发操作异常）  
        //当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。  
        /*for (Iterator in=al.iterator();in.hasNext() ; ) 
        { 
            Object obj=in.next(); 
            if(obj.equals("java02")) 
            { 
                al.add("java04"); 
            } 
            System.out.println("obj:"+obj); 
        }*/  
  
  
        //此迭代器没有添加方法  
        /*for (Iterator in=al.iterator();in.hasNext() ; ) 
        { 
            Object obj=in.next(); 
            if(obj.equals("java02")) 
            { 
                in.remove(); 
            } 
            System.out.println("obj:"+obj); 
        } 
        System.out.println("现集合al:"+al);*/  
        /* 
        输出结果： 
        obj:java01 
        obj:java02 
        obj:java03 
        现集合al:[java01, java03] 
        问题：为什么"java02"已经删除了，怎么还会打印obj:java02呢？ 
        因为in.remove()方法只是把此元素的引用从集合al中删除了，但是obj的指向仍然在， 
        所以会打印，但是集合中却没有了此元素。 
        */  
  
        /*for (ListIterator li=al.listIterator();li.hasNext() ; ) 
        { 
            Object obj=li.next(); 
            if(obj.equals("java02")) 
            { 
                li.add("java04"); 
                //修改元素内容 
                //li.set("java04"); 
            } 
            System.out.println("obj="+obj); 
        } 
        System.out.println("现集合al:"+al);*/  
        /* 
        输出结果： 
        obj=java01 
        obj=java02 
        obj=java03 
        现集合al:[java01, java02, java04, java03] 
        此操作会在"java02"的后面添加元素！ 
        */  
  
        ListIterator li=al.listIterator();  
        //正向遍历集合中的元素  
        while(li.hasNext())  
        {  
            System.out.println(li.next());  
        }  
        //逆向遍历集合中的元素  
        while(li.hasPrevious())  
        {  
            System.out.println(li.previous());  
        }  
    }  
```
ListIterator listIterator()：返回此列表元素的列表迭代器（按适当顺序）。操作方法参见上面的代码。
ListIterator是Iterator的子接口，该接口只能通过List集合的ListIterator方法获取。
ListIterator listIterator(int index)：返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
List subList(int fromIndex, int toIndex)：返回列表中指定的fromIndex（包括）和toIndex（不包括）之间的部分视图。超出集合长度会发生：IndexOutOfBoundsException。
ArrayList al4=new ArrayList();
al4.add("java01");
al4.add("java02");
al4.add("java03");
al4.add("java04");
List sub=al.subList(0,3); //从0角标（包括）开始截取，到2角标（不包括）结束。
System.out.println("sub="+sub); //打印结果：sub=[java01,java02,java03]

迭代：迭代是取出集合中元素的一种方式。因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。
- 两种方式：
  - for(Iterator iter = iterator();iter.hasNext(); )
    {
    System.out.println(iter.next());
    }
  - Iterator iter = l.iterator();
    while(iter.hasNext())
    {
    System.out.println(iter.next());
    }
- 这两种方式的打印的结果是一样的，但是有一个区别：第一种方式iter变量会在迭代结束后在内存中释放，而第二种方式iter变量为全局变量，迭代结束后不会被释放。
- 迭代时的注意事项：
  - 迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
  - 迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
  - 迭代器的next方法返回值类型是Object，所以要记得类型转换。

Set接口中常用类
Set接口中的元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。Set接口的功能和Collection接口是一致的。
- HashSet：底层数据结构是哈希表。线程不安全，存取速度快。
- 哈希表数据结构：首先判断对象在内存中的地址是否相同，如果相同，那么判断对象是否相同，如果也相同，就不会存储。因为Set接口中的元素是无序的，唯一的。如果不相同，那么在此地址下在顺延一个地址，这两个地址相同，但指向的对象不同。这就是哈希表存储方式。
- HashSet保证元素唯一性的方式：通过元素的两个方法：hashCode()和equals()来完成。如果元素的hashcode值相同，才会判断equals是否为true。如果元素的hashcode值不同，不会调用equals()方法。
- TreeSet：底层数据结构是二叉树。线程不安全。可以对Set集合中的元素进行排序。不具备比较性的对象是不能存入TreeSet集合的！
- 二叉树数据结构的原理：大元素放右边，小元素放左边，按顺序从小到大打印输出。
- TreeSet集合有两种排序方式：
  - TreeSet集合排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo()方法。这种方式也称为元素的自然排序，或者叫做默认顺序。
  - TreeSet集合的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。自定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。在集合初始化时，就有了比较方式。当两种排序都存在时，以比较器为主。如何自定义比较器？定义一个类，实现Comparator接口，覆盖compare()方法。
泛型：泛型是JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
- 泛型的好处：
  1、将运行时期出现的问题：ClassCastException，转移到了编译时期。方便于程序员解决问题，让运行期间问题减少，安全。
  2、避免了强制转换的麻烦。
- 泛型定义的格式：
  通过<>来定义要操作的引用数据类型。泛型通常在java的集合框架中很常见，只要见到<>就要定义泛型。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
- 自定义泛型类：当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
  例如：class Utils<MyType>{}
  泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
- 泛型方法：为了让不同的方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
- 静态泛型方法：静态方法不可以访问类上定义的泛型。泛型类里面不可以定义静态非泛型方法。也就是说只要类是泛型类，那么静态方法也就是静态泛型方法。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
- 泛型的限定：
  ？通配符，也可以理解为占位符。
  ？ extends E ：可以接收E类型或者E类型的子类型。上限。
  ？ super E ：可以接收E类型或者E类型的父类型。下限。
  注意：实例化泛型类或者泛型接口的子类对象时，如果左右两边都用到泛型，那么左右两边类型要一致，否则编译错误！
Map集合中常用类
Map集合存储键值对。一对一对的往里存，而且要保证键的唯一性。和Set集合很像，其实Set集合底层就是使用了Map集合。
- Hashtable,HashMap,TreeMap。
- Hashtable：底层是哈希表数据结构，不可以存入null键和null值。线程同步，效率比HashMap低，是从JDK1.0版本中出现的，已被HashMap替代。
- HashMap：底层是哈希表数据结构，允许使用null键和null值。线程不同步，效率高，是从JDK1.2版本中出现的。
- TreeMap：底层是二叉树数据结构，线程不同步。可以用于给Map集合中的键进行排序。
Map集合的常用方法
首先定义一个Map集合对象：Map<String,String> m=new HashMap<String,String>();
- 添加
  put(K key,V value)：将指定的值与此映射中的指定键关联。添加元素，如果键相同，那么后一个值会覆盖前一个值。但是put()方法会返回前一个值！
  m.put("01","zhangsan01");
  m.put("02","zhangsan02");
  m.put("03","zhangsan03");
  m.put("04","zhangsan04");
  m.put("05","zhangsan05");
  m.put("06","zhangsan06");
  System.out.println(m); //打印结果：{04=zhangsan04, 05=zhangsan05, 06=zhangsan06, 01=zhangsan01, 02=zhangsan02, 03=zhangsan03}
  void putAll(Map<? extends K,? extends V> m)：从指定映射中将所有映射关系复制到此映射中。（添加一堆键值对）
- 删除
  void clear()：从此映射中移除所有映射关系。
  m.clear();
  System.out.println(m); //打印结果
  remove(Object key)：如果存在一个键的映射关系，则将其从此映射中移除。
  首先重新添加元素：
  m.put("01","zhangsan01");
  m.put("02","zhangsan02");
  m.put("03","zhangsan03");
  m.put("04","zhangsan04");
  m.put("05","zhangsan05");
  m.put("06","zhangsan06");
  m.remove("02");
  System.out.println(m); //打印结果：{04=zhangsan04, 05=zhangsan05, 06=zhangsan06, 01=zhangsan01, 03=zhangsan03}
- 判断
  boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回true。
  System.out.println(m.containsKey("04")); //打印结果：true
  boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回true。
  System.out.println(m.containsValue("zhangsan04")); //打印结果：true
  boolean isEmpty()：如果此映射未包含键-值映射关系，则返回true。
  System.out.println(m.isEmpty()); //打印结果：false
- 获取
  get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。
  System.out.println(m.get("04")); //打印结果：zhangsan04
  int size()：返回此映射中的键-值映射关系数。
  Collection<V> values()：返回此映射中包含的值的Collection视图。
  System.out.println(m.values()); //打印结果：[zhangsan04, zhangsan05, zhangsan06, zhangsan01, zhangsan03]
  Set<Map.Entry<K,V>> entrySet()：返回此映射中包含的映射关系的Set视图。通常用于遍历集合中的元素。Entry其实也是一个接口，是Map接口中的一个内部接口。
  Set<K> keySet()：返回此映射中包含的键的Set视图。通常用于遍历集合中的元素。
  [java] view plaincopy
- ```
import java.util.*;  
  
class MapDemo   
{  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
  
    public static void main(String[] args)   
    {  
        //创建一个集合容器  
        Map<String,String> m=new HashMap<String,String>();  
        //添加元素  
        //添加元素，如果键相同，那么后一个值会覆盖前一个值，  
        //但是put()方法会返回前一个值！	m.put("01","lisi1");  
        m.put("02","lisi2");  
        m.put("03","lisi3"); m.put("04","lisi4"); m.put("05","lisi5"); m.put("06","lisi6"); sop("原集合："+m); sop("根据键找值是否存在：03="+m.containsKey("03")); sop("根据键移除对应的值并返回：03="+m.remove("03")); sop("根据键返回对应的值，不移除：02="+m.get("02")); sop("现集合："+m); //返回m集合中所有的（值）。 Collection<String>
 coll=m.values(); sop(coll); /* 根据键找值 Map集合的keySet()方法可以返回集合中所有的键，是一个Set集合 使用迭代器遍历Set集合，然后根据键找值 */ Set<String> keySet=m.keySet(); for (Iterator<String> it=keySet.iterator();it.hasNext() ; ) { String key=it.next(); sop(key+""+m.get(key)); } sop("---------------映射关系获得键和值-----------------");
 /* Map集合的entrySet()方法可以获取集合中所有的映射关系，也是一个Set集合 使用迭代器遍历Set集合，然后根据映射关系查找键和值。 */ Set<Map.Entry<String,String>> mapEntry=m.entrySet(); for (Iterator<Map.Entry<String,String>> it=mapEntry.iterator(); it.hasNext() ; ) { Map.Entry<String,String> me=it.next(); String
 key=me.getKey(); String value=me.getValue(); sop(key+"→→"+value); } } }
```
Map接口Collection接口的区别
- Map与Collection在集合框架中属并列存在。
  1、Map存储的是键值对。
  2、Map存储元素使用put方法，Collection使用add方法。
  3、Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素。
  4、Map集合中键要保证唯一性。
集合框架中的工具类
Collections类完全由在 collection 上进行操作或返回 collection 的静态方法组成。比如：对集合进行查找、取出集合中的最大值，最小值，对List集合进行排序……
Arrays类包含用来操作数组（比如排序和搜索）的各种方法。可以将数组转成List集合、对数组进行排序、对数组进行二分查找