黑马程序员-----集合

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

集合

一、概述

和数组区别：数组长度固定，集合长度可变；数组只能存储基本数据类型且只能存储一种类型；集合只能存储对象。 

集合类的特点：

集合值用于存储对象，集合长度可变，集合可以存储不同类型对象。 

每个容器对数据的存储方式不同，该存储方式为数据结构。

---|Collection: 单列集合

--------|List: 有存储顺序, 可重复

----------------|ArrayList: 数组实现, 查找快, 增删慢

----------------|LinkedList: 链表实现, 增删快, 查找慢

----------------|Vector: 和ArrayList原理相同, 但线程安全, 效率略低                   

--------|Set: 无存储顺序, 不可重复

----------------|HashSet

----------------|TreeSet

----------------|LinkedHashSet

--------| Map: 键值对

----------------|HashMap

----------------|TreeMap

----------------|HashTable

----------------|LinkedHashMap

二、集合类collection

所属包为import java.util.*;

//创建一个集合容器使用collection接口的子类 ArrayList a1 = new ArrayList();

Collection类接口的共性方法：

//添加 a1.add(“drfv”);

//获取长度 a1.size();

//删除元素 a1.remove(“abc”);

//清空集合 a1.clear();

//判断元素是否存在 a1.contains(“cvb”);

//是否为空 a1.isEmpty();

//a1中只保留和a2相同的元素 a1.retainAll(a2); 

注意：

1、集合中添加的是对象的引用（地址）

2、add方法的参数类型是Object,以便于接收任意类型对象 

三、迭代器：集合的取出元素的方式 

linkedList li = new LinkedList(); li.add("java01"); Iterator it = a1.iterator(); While(it.hasNext()) {      sop(it.next()) } 复制代码

列表迭代器：List集合特有的迭代器，listIterator()是Iterator的子接口，比Iterator方法多 增删改查等等

迭代时不可以通过集合对象的方法操作集合中的元素，因为会发生并发修改异常

1. ListIterator li = al.listIterator();
2. While(li.hasNext())
3. {
4.     Object obj = li.Next();
5.     If(obj.equals(“abc”))
6.            Li.add(“def”);
7. }

复制代码 方法：

hasNext()

next()

hasPrevious();

Previous();

四、List集合共性方法

1、list元素有序，元素可以重复，因为该集合有索引

2、Set元素无序，元素不可以重复 

特有方法：可以操作角标 

1.1增加add(index,element);

      addAll(index,Collection) 

1.2删除 Remove(inidex)

1.3更改 Set(index,element)

1.4查找 Get(index)

      Sublist(from,to)   返回list型  

      listIterator();列表迭代器 

 五、List集合具体对象的特点 

|---ArrayList:底层的数据结构使用的数组结构，特点查询速度快但是增删慢，线程不同步。

|---LinkList：链表数据结构，特点增删速度快，查询稍慢

|---Vector:底层是数组数据结构。JDK1.0出现，在此基础上实现List接口。被ArrayList替代。线程同步. 

六、Vector中的枚举类型

枚举是Vector特有的取出方式,同迭代器，但是枚举名称过长被迭代器代替。

Enumeration en = v.elements();

While(en.hasMoreElement())

{

en.nextElement()

} 

七、LinkedList链表结构

LinkedList link = new LinkenList();

//增加 link.addFirst(“java01”);

link.addLast(“java02”);

offerFirst();JDK1.6

offerLast(); 

获取元素

getFirst();

getLast();

peekFirst();JDK1.6后出现，如果集合中没有元素不报错返回null

peekLast();

可以获取元素同时删除

removeFirst();

removeLast()；

pollFirst();JDK1.6后出现，如果集合中没有元素不报错返回null

pollLast(); 

八、Set

元素是无序的，（存入和取出的顺序不一定一致）元素不能重复

|---HashSet底层数据结构是哈希表,线程是非同步的

保证元素唯一性的原理：判断元素的hashCode是否相同，如果相同继续判断元素的equals方法是否为true

|---TreeSet 底层数据结构：二叉树，保证元素唯一性的依据：CompareTo()

Set集合的功能和Collection是一致的。 

HashSet存储自定义对象

HashSet hs = new HashSet();

Hs.add(new Person(“a1”,11));

Hs.add(new Person(“a1”,11));

Hs.add(new Person(“a1”,11));

TreeSet:可以对Set集合中的元素进行排序

TreeSet排序

第一种方式：让元素自身具备比较性元素需要实现Comparable借口，覆盖CompareTo方法。元素的自然顺序。

第二种排序方式：当元素自身不具备比较性时，或具备的比较性不是所需要的，让集合自身具备比较方式。定义一个类：实现Comparator接口，覆盖compare方法 

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

九：泛型概述：JDK1.5版本出现新特性，用于解决安全问题,是一个安全机制

好处：

1：将运行时期出现数据类型不一致问题转移到编译时期提示

2：避免强制转换麻烦

ArrayList<String> al = new ArrayList<String>();

Iterator<String> it = al.iterator();

String s = it.next(); 

泛型使用：通过<>来定义要操作的引用数据类型，通常在集合框架中常见，只要见到<>就要定义泛型。 

泛型类：当类中要操作的引用数据类型不确定时早期定义Object完成扩展，现在定义泛型扩展。

例如： 

[java]  view plain copy

1. Class Utils<QQ>  
2. {   
3.     Private QQ q;  
4.     Public void setObject(QQ q)  
5.     {   
6.          this.q = q;  
7.     }  
8.     Public QQgetObject()  
9.    {  
10.        Return q  
11.    }  
12. }  

泛型方法：

[java]  view plain copy

1. Class Demo{  
2.     Public <T> void show(T t)  
3.     {  
4.          //方法体  
5.          return;  
6.      }  
7.      Public <Q> void print(Q q)  
8.      {  
9.            //方法体  
10.            return;  
11.       }  
12. }  

静态方法泛型:静态方法不可以访问类上的泛型，如果静态方法要操作的引用数据类型不确定，可以将泛型定义在方法上

[java]  view plain copy

1. Public static <w> void method(W w)  
2. {  
3.     //方法体  
4. }  

泛型接口：

[java]  view plain copy

1. Interface Inter<T>  
2. {  
3.     Void show(T t);  
4. }  
5. Class InterImpl implements Inter<String>  
6. {  
7.     Pubic void show (String t)  
8.         {  
9.               System.out.print(str);  
10.          }  
11. }  
12. Class InterImpl<T> implements Inter<T>  
13. {  
14.          pubic void show (T t)  
15.          {  
16.                 System.out.print(t);  
17.           }  
18. }   

十、Map集合

特点：该集合存储键值对，要保证键的唯一性。

Map

---|HashTable底层是哈希表数据结构，不可以存入NLL键null值，该集合线程同步JDK1.0

---|HashMap底层是哈希表数据结构，允许null值null键，线程不同步JDK1.2效率较高

---|TreeMap底层是二叉树数据结构，线程不同步，可以用于给map集合中的键排序

Map集合共性方法：

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)  可以通过get方法的返回值来判断一个键是否存在通过返回null来判断

Size()

Values()

entrySet()

keySet()

Map集合的两种取出方法：

1.keySet ：   将map中所有键存入到Set集合，根据迭代方式取出所有的键，根据get方法获取每一个键对应的值。

1. Set<String>  keySet = map.keySet();
2. Iterator<String> it = keySet.iterator();
3. While(it.hasNext())
4. {
5. String key = it.next();
6. String value = map.get(key);
7. }

复制代码 Map集合取出原理：将map集合转成set集合，再通过迭代器取出

2.entrySet     将Map集合中的映射关系取出，存入到Set集合

1. Set<Map.Entry<String,String>>  entySet = map.entrySet();
2. Iterator<Map.Entry<String,String>> it = entrySet.iterator();
3. While(it.hasNext())
4. {    Map.Entry<String,String>me=It.next();
5. String key = me.getKey();
6. String vlaue = me.getValue();
7. }

复制代码