Collection

一、集合概述；

集合类，或者叫集合框架；

数据多了，封装为对象；对象多了，封装为集合；

对象多了，可以存储于数组，但是数组是固定长度的，集合是可变长度的；而且数组中只能同类类型数据，集合不限类型；

集合中的对象，被称为元素；

 

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

集合的作用就相当于是一个封装对象的容器；

容器分很多中，容器的共性不断的抽取就产生了体系，这个体系就叫做集合框架；

在一个体系中通过最顶层来认识共同基本的功能，再让底层子类进行功能的实现和扩展并加以利用；

接口的方法有了，下面就要建立其子类对象来对其进行使用；

 

集合框架是工具包的成员，Java.util.中的Collection成员；Collection是这个工具包的接口；

 

Collection接口有两个常见的子接口，一个是List，一个是Set；

List接口中常见的子类有：ArrayList，LinkedList，Vector；

Set接口中常见的子类有HashSet，TreeSet；

 

为什么会出现这么多的容器呢？因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构；

数据在内存中的构成情况，存储方式称为数据结构，所以他们的特点不一样，所以就要单独的划分；

 

二：Collection接口中的共性方法；

 

集合作为一个容器，应该有的功能有增删改查；

接口的使用是，先实现子类，然后建立子类对象即ok；

 

 

ArrayList al = new ArrayList ();

1、添加元素：

al.add(“abc”);   字符串也是对象；

集合中存在的不可能是集合实体；否则还要让实体移位置；

集合和数组一样，里面存放的都是地址值；

 

注意：add方法的参数类型是Object，以便于接受任意类型对象；

集合中存储的都是对象的引用（地址）；

al.size(al);获取集合的长度；

sop（al）

添加完成后直接打印集合的声明变量，结果是这个集合里面的所有元素，不是哈希值；

 

2、删除元素：

al.remove();删除指定元素；

al.clear();清空集合；

3、判断元素：

al.contains();

al.isEmpty();

 

al1.retainAll(al2);取交集，al1中只会保留和al2中相同的元素，会对原集合进行改变；先把原集合清空，然后添加相同的元素，如果没有相同的元素，则原集合为空；

 

al1.removeAll(al2);指去掉与给定集合中相同的元素；

 

还有addAll等都是对相同的元素进行操作；

 

3、取出元素：（迭代器Iterator()）

通过取出元素后对元素进行操作，直接打印集合没有什么实际意义；

Iterator it = al.iterator();  获取迭代器，用于去处集合中的元素；

该表达式返回的是一个对象，然后可以通过对象去调用其对应的类的内部方法；

（这就是单例设计模式的一个例子；）完成这步之后就用it去调用方法了。

但问题的关键是接口不是都是抽象没有方法不，这个比较疑惑；是在子类中实现了该方法，只不过用接口去声明类型，避免引入更多的变量，也是一样的；最后引入的还是子类实现的内部类的方法

it .hasNext();判断是否有元素；it.next();获取下一个元素；

 

什么是迭代器呢？

其实就是集合的取出元素的方式；

迭代动作；

 

每个容器（集合）里面都有自己的存取方式，因为每个容器的数据结构不一样，所以他们存取的动作细节以及存取的方式也有可能不一样；

 

因为取出的工作没有像添加那么的简单，比如还需要判断等，所以取出不能用一个方法判断完，虽然取出的动作细节都不一样，即所以就把取出功能封装成一个类，这个类就定义到了集合的内部（内部类更方便操作）；因为都是有共性的内容，判断和取出，，所以就可以将这些进行共性抽取，而这些内部类都是符合一个规则，该规则是Iterator。如何获取集合的取出对象呢？通过一个对外提供的方法Iterator();

其实就是说，在集合的内部，用一个内部类实现了一个取出元素的接口；以后可以尝试把这个方法自己写出来；

 

写法上：

要迭代所有的元素，用for循环比用while循环更加节约内存；

for（Iterator  it = al.iterator();it.hasNext();）

                   it.next();

 

 

三、Collection两个常见子接口List和Set的特点：

List接口：这个集合小体系的特点在于集合里面的元素是有序的，并且元素可以重复；因为该集合体系有索引；

Set接口：集合元素是无序的，元素不可以重复，集合当中没有索引；

（一）List接口特有的共性方法：

1、凡是可以操作脚标的方法都是该体系特有的方法；增、删、改、查；

增：

void add(int index, E element) 

boolean addAll(int index, Collection<?extends E> c) 

删

E remove(int index) 

改

E set(int index, E element)

查

E get(int index)

List<E> subList(int fromIndex, inttoIndex) （其实这个可以通过get方法循环即可；）

ListIterator<E> listIterator(intindex)

 

注意，但凡操作脚标的都是数组原理；

 

获取对象的index位置；

int indexOf(Object o) 

 

int lastIndexOf(Object o)

 

获取子列表：

List<E> subList(int fromIndex, inttoIndex)

 

列表迭代器

ListIterator<E> listIterator(intindex)

 

在迭代过程中，准备进行其他的操作，如添加或者删除元素；

Iterator it = al.iterator();

it.remove;移除迭代出来的动作；

 

List集合特有的迭代器，ListIterator是Iterator的子接口；

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

所以只能在迭代时，只能用迭代器方法操作元素，可是Iterator方法有限的，只能进行判断，取出和删除的操作；如果想要其他的操作如修改，添加等，就需要使用其子接口，ListIterator，

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

 

ListIteratorli = al.ListIterator（）；

voidadd(E e)  在迭代的后面的添加给定的元素；

voidset(E e)  把迭代的元素改为给定元素；

 

只有List集合中的迭代器才有这种在遍历过程中的增删改查功能；因为List是有脚标的；

 

booleanhasNext()  指针后面有没有元素；

booleanhasPrevious()  指针前面有没有元素；

E previous() 往前取元素；到这取，逆向遍历；

 

2、List常见的三个子类对象：是因为底层数据结构不一样，而单独封为实体的；

ArrayList    底层的数据结构使用的是数组结构；特点在于查询速度很快，因为有脚标；加入和删除元素时速度非常慢，元素越多越明显；

LinkedList                   底层使用的是链表数据结构；列表查询非常慢，因为只有相邻的元素才有关系；但是增删比较块；因为查询必须要从第一个开始查起；

   Vector     底层是数组数据结构，功能和ArrayList一模一样；它出现的时候集合框架还不存在呢？

         vector与ArrayList的区别是ArrayList线程是不同步的，Vector线程是同步的；一般用ArrayList，效率高，Vector增删查询都非常慢；替代了Vector，多线程中可以对ArrayList进行加锁；

         Java的集合框架中会有一个专门加锁的功能；

         ArrayList的默认容量是10的空列表，当元素增加后，他会new一个新的数组，长度增加百分之50的延长，然后把原来的数组复制过来即可

         Vector是百分之百的延长，比较浪费空间；基本淘汰了；

 

Vector里的唯一的特有取出数据方法——枚举，其他都被ArrayList取代了；

        

Enumerationen =  v.elements（）；

while（en.hasMoreElements()）

         en.nextElement();可以枚举所有的元素出来；

 

发现枚举和迭代器很像；其实枚举和迭代是一样的；因为枚举的名称以及方法的名称都过长，所以被迭代器取代了；枚举和Vector都是1.0版本的，以后版本的都是用迭代器了，不用枚举了；

 

LinkedList链表结构的List，所使用频率不是特别高；他的特有方法有：

 

addFirst();

addLast();

 

getFirst();

getLast();

获取元素，但不删除元素；如果集合中没有元素，会出现NoSuchElementException

removeFirst();——peekFirst

removeLast();——pollFirst

也可以获取元素，但是元素被删除；如果集合中没有元素，会出现NoSuchElementException

 

在JDK1.6版本中，出现了替代方法；以后就用这个，不用之前的方法了；

booleanofferFirst(E e)

         

 boolean offerLast(E e)

        

EpeekFirst()

          获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

 E peekLast()

          获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

EpollFirst()

          获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

 E pollLast()

                 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 

 

练习1：使用LiskedList模拟一个堆栈或者队列数据结构；

 

堆栈的数据结构的特点：先进后出；如同一个杯子；

队列的数据结构的特点：先进先出；如同一个水管；

        

要先封装起来，先把描述和功能封装起来，然后对外提供一个最简单的访问方式即可；

 

这个练习要求必须会；

 

练习2：去除ArrayList集合中的重复元素；

用it.next()在循环当中只能写一次，如果写多次就极有可能出现脚标异常；

即在迭代时循环中next调用一次，就要hasNext判断一次；

不能同时在一个语句中

 

练习3：将自定义对象作为元素存在ArrayList集合中，并去除重复元素；

比如，存人对象，同姓名，同年龄，视为同一个人，为重复元素；

（1）描述人，将数据封装进入对象；

（2）定义容器，存人；

（3）取出

 

List集合判断元素是否相同，依据的元素的equals方法；contains，removed底层都是依赖的这个方法，ArrayList和LinkedList集合底层的数据结构的方法依赖的都是这个；

其他的集合和这个不一样；

 

涉及的增删操作比较频繁用LinkedList集合

涉及的查询操作比较频繁用ArrayList集合

当然两者都可以用，一般实在不好找，就用ArrayList；

 

 

（二）Set集合

元素是无序的，即存入和取出的顺序不一定一致，元素不可以重复；

Set集合的功能和Collection集合功能是一致的，因为都没有脚标；

 

常见的子类：

HashSet集合：底层数据结构是哈希表； TreeSet集合

1、HashSet集合

 

哈希值，取出来的是按照集合里面的哈希值的顺序来的；

在哈希表里，如果哈希值重复的时候，他还有另外一个调取方式，即对象是否是同一个对象；如果哈希值相同，就比较两个是不是一个对象；如果不是就在此位置上顺延；

如果哈希值不同，就直接按哈希值直接保存；

 

演示：

往hashSet集合中存入自定义对象，姓名和年龄相同为同一个人，重复元素；

 

Set中取出元素就只有一种方式，即迭代器；

Set集合；可以保证唯一性；因为不可重复性；

 

按照条件来设定哈希值；来保证Hashcode的唯一；

 

HashSet是如何保证元素的唯一性的呢？

 

是通过元素的两个方法，hashcode和equals来完成的，如果元素的hashcode值相同，才会判断equals是否为true，如果元素的hashcode不同，则equals为false；

 

当我们要把对象存放在HashSet集合当中的时候，我们一般都要重写成我们需要的hashcode和equals方法；而且这些方法并不是我们自己调用的，而是底层内部调用的，集合把他的调用方法给封装了，我们不知道；

一般开发中，只要我们把数据往集合中保存，我们都最好都要重写上面两个函数；尽量保证hashcode的唯一性，这样才会主动进行比较是否相同；

 

如何查询是否包含，以及删除元素：

 

注意：对于判断元素是否存在以及删除等操作，依赖的方法都是元素的hashcode和equals方法；先判断hashcode，相等的情况再比较equals方法；

 

 

ArrayList集合里的方法操作只依赖equals方法；

 

2、TreeSet集合

set：无序，不可重复元素；

HashSet集合：底层数据结构是哈希表； 线程是非同步的；因为数据结构不一样，保证元素唯一性的方式也不一样；HashSet保证元素的唯一性的原理是：判断元素的hashcode是否相同，如果相同，还会继续判断元素的equals方法，是否为true；

 

TreeSet集合：特点是，可以对set集合中的元素进行排序；是按照自然顺序来排序的；

                            底层数据结构是二叉树；保证元素唯一性的依据是compareto 方法return 0；

                            其所有的操作也都是依赖这个方法进行操作，如判断包含，删除等；

 

演示：存自定义数据演示该集合

 

需求：往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序；

 

TreeSet集合往里面存放的元素必须要具有比较性才行；否则会抛出错误；

 

因为要排序，并且该集合不能重复，所以只要判断是相同对象，就不会进入集合；

 

注意：排序时，当主要条件相同时，一定要判断次要条件是否相同；

 

TreeSet底层的数据结构是：

 

排序无非就是互相比较，如果元素太多，就会导致效率非常慢；所以为了优化效率，TreeSet优化了数组的效率，TreeSet用了一个比较特殊的数据结构来做这个事情；

 

二叉树数据结构，可以减少比较次数；而且，如果元素比较多的情况，他比较到最后，会自动取折中值来进行比较；这样就可以提高效率；

 

取值都是按照默认顺序，从小到大来取；二叉树的数据结构都是从左边最小的数据往上开始取值；

 

如果要降序排列，可以把重写的compareTo中返回值中1改为-1等；

 

TreeSet排序只看compare的比较结果，不看你是用什么方法比的；

 

可以让TreeSet取出数据的方式按照存放顺序取，只需要重写比较方法，返回1即可，逆序也一样；

 

TreeSet排序的第一种方式，让元素自身具备比较性，元素需要实现comparable接口，覆盖comparato方法，这种方式也称为元素的自然排序，或者叫做默认排序；

 

元素一定义完，就具备了比较性了，具有默认顺序了；

 

TreeSet的的第二种排序方式：

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

 

当元素自身不具备比较性，或者具备的比较性不是所需要的，这是需要让容器自身具备比较性，定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数；

 

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

 

定义一个类，实现comparator接口，覆盖compare方法

 

二叉树都是以判断return是否为0，来比较是否相等；

 

一般，比较器的方法用的比较多；功能扩展就直接实现需要的接口即可；所以开发时候一定都把接口弄出来，以后直接升级实现接口就搞定了

 

练习：按照字符串长度排序

 

字符串本身具备比较性，但是他的比较方式不是所需要的，这时就只能使用比较器；

 

当然也可以把封装的比较器用匿名内部类做也行；