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

 -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

         Java的集合类

为什么出现了集合类？

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

数组和集合同时容器，不何不同？

数组虽然也是存储对象，但长度是固定的；集合长度是可变的。

数组汇总可以存储基本数据类型，集合只能存储对象。

集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象

 

集合框架:Collection

 

  |--------List元素是有序的，元素可以重复。因为该集合体系有索引。

         |-----ArrayList

             |-----LinkedList

             |-----Vector

      |----------Set元素是无序的，元素不可以重复。

          |----HashSet

      |----TreeSet

为什么会出现这么多的容器呢？

因为每一个容器对数据的存储方式不同。

这个存储方式称为：数据结构

1.add方法的参数类型是Object.以便于接收任意类型对象。

2.集合存储的都是对象的引用（地址）

3.retainAll是取交集用的；也可以认为是对集合的改变

4.removeAll删除相同的部分。

Iterator是迭代器接口

什么是迭代器呢？

其实就是集合的去除元素的方式。

就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。

那些取出方式就被定义成了内部类。

而且每个容器的数据结构不同，所以取出的多种细节也不一样。但是都有共性内容判断和取出。

那么可以将共性部分抽取。那么这些内类都符合一个规则。该规则是Iterator.

如何集合的去除对象呢？

通过一个对外提供的方法。iterator();

Collection

   |---List:元素是有序的，元素可以重复。因为该集合体系有索引。

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

       |----LinkedList:底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

       |----Vector:底层是数组数据结构。线程时同步。被ArrayList替代。有枚举。

 

   |---Set :元素是无序的，运算不可以重复。

 

   List:

   特有方法。凡是可以操作角标的方法都是该体系特有的方法。

   增

add(index,element);在指定位置添加元素

addAll(index,collection);在指定位置添加一堆元素

   删

remove(index);删除指定位置的元素

   改

set(index,element);修改元素

   查

get(index);通过角标获取元素

subList(from,to);

listIterator();

 

List集合特有的迭代器。ListIterator是Iterator的子类接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素。

因为会发生并发操作异常ConcurrentModificationException异常。

所有，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。

值能对元素进行判断，取出，删除的操作。

如果想要其他的操作如添加，修改等，就需要使用其子类接口，ListIterator

该接口只能通过List集合的listIterator方法获取

枚举

枚举就是Vector特有的取出方式。发现枚举和迭代器很像。

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

所以被迭代器取代了。枚举郁郁而终了。

LinkedList；链表数据结构。

Set：无序，不可以重复元素，

 |----HashSet:数据结构是哈希表。线程是非同步的。

            保证元素唯一性的原理：判断元素的hashCode值是否相同。

             如果相同，还会继续判断元素的equals方法。是否为true.

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

底层数据结构二叉树。

保证元素唯一性的依据。

compareTo方法的return 0;

TreeSet排序的第一种方式：

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

TreeSet的第二种排序方式：

当元素自身不具备比较性时，或者具备的比较性不是所需的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。

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

定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

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

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

泛型：

JDk1.5版本以后出现的新特性。用于解决安全问题。是一个类型安全机制。

泛型的好处：

1.将运行时期出现问题ClassCastException,转移到了编译时期。

方便于程序员解决问题。让运行时的问题减少，安全。

2.避免了强制转换的麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？

同过集合框架中的很常见，只要见到<>就要定义泛型。

其实<>就是用来解释类型的。

当使用集合时，将集合中药存储的数据类型作为参数传递当<>中即可。

泛型类

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候。

早期定义Object来完成扩展。

现在定义泛型来完成扩展。

泛型类定义的泛型，在整个类中有效，如果累方法使用。

那么泛型类的对象明确要操作的具体类型后，所以要操作的类型就就已经固定有了。

为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。

特殊之处：

静态方法不可以访问类上定义的泛型。

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

? 通配符。也可以理解为占位符。

泛型限定：

？extends E:可以接收E类型或者E的子类型。上限。

？super E ： 可以接收E类型或者E的父类型。下限。

泛型限定用于泛型扩展用的。

Map集合;该集合存储键值对，一对一对往里存。而且要保证键的唯一性。

1.添加：(K key,V vaule) 添加键和值

put();添加元素

2.删除      void    clear()

  remove(Object key)根据键删除值。

3.判断

 boolean containsValue(Object value) 判断值

 boolean containsKey(Object Key)    判断键

 boolean isEmpty()   如果次映射未包含键 值映射关系，则返回true.

4.获取。

 get(Object Key)

              返回指定键所映射的值，如果此映射不包含该键的映射关系，则返回null.

 int size() 返回此映射中的键-值关系，长度。

 values() 获取值

 

 entrySet()

 keySet()

 

Map

|------Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。jdk1.0效率低

|------HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合不同步的。jdk1.2 效率高

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

 

和Set很像。

其实大家，Set底层就是使用了Map集合。

map集合的两种取出方式。

1.Set<k> keySet:将map中所有的键存入到Set集合。因为Set具备迭代器。

 所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值

 

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

2.Set<Map.EntrySet<k,v>> entrySet:将map集合的映射关系存入到了set集合中，

而这个关系的数据类型就是Map.Entry.

将map集合中的映射关系取出。这个关系就是Map.Entry类型，

那么关系对象Map.Entry获取到后，就可以通过Map.Entry中的getKey和getValue方法获取关系中的键和值。

使用集合的技巧： 

看到Array就是数组结构，有角标，查询速度很快。 

看到link就是链表结构：

增删速度快，而且有特有方法。

addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()； 

看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。 

看到tree就是二叉树，就要想到排序，就想要用到比较。 

比较的两种方式： 

一个是Comparable：覆盖compareTo方法； 

一个是Comparator：覆盖compare方法。

 LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。

 集合什么时候用？ 

当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。 

保证唯一，就用Set。不保证唯一，就用List。 

Collections.sort(list);//list集合进行元素的自然顺序排序。 

Collections.sort(list,new ComparatorByLen());///按指定的比较器方法排序。

int index = Collections.binarySearch(list,"zz");//二分查找，返回角标。

Collections.reverseOrder();//逆向反转排序。 

Collections.shuffle(list);//随机对list中的元素进行位置的置换。

Collections.fill();全部替换元素

原理：定义一个类，将集合所有的方法加同一把锁后返回。 

Collection 和 Collections的区别： 

Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。

 Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,

提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

Arrays:用于操作数组的工具类。里面都是静态方法。

asList:将数组变成list集合。

 

把数组变成list集合有什么好处？

可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法。

因为数组的长度是固定的。

contains

get

indexOf()

subList();

如果你增删。那么会发生UnsupportedOperationException.不支持的操作异常。

如果数组中的元素都是对象。那么变成集合时，数组中的元素就是直接转成集合中的元素。如果数组中的元素都是基本数据类型，

那么会将该数组作为集合中的元素存在。

1.指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新数组。长度为集合的size。当指定类型的数组长度大于了集合的size,

就不会新创建了数组，而是使用传递进来的数组。

所以创建一个刚刚还的数组最优。

2.为什么要将集合变数组？

为了限制对元素的操作。不需要进行增删了。

高级for循环

格式：

for(数据ForEachDemo类型 变量名：被遍历的集合(Collection)或者数组)

{要执行的语句}

对集合进行遍历。

只能获取集合元素，但是不能对集合进行操作。

 

迭代器除了遍历，还可以进行remove集合中的元素的动作。如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须被遍历的目标。建议在遍历数组的时候，还希望是用传统for,因为传统for可以定义角标。

Jdk1.5版本出现的新特性。

方法的可变参数一定要定义在参数列表的最后面。可变参数。其实就是上一种数组参数的简化形式。不用每一次都手动建立数组对象只要将要操作的元素作为参数传递即可。

隐式将这些参数封装成了数组。