集合框架

集合

l  为什么出现集合类？

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

l  数组和集合类同是容器，有何不同？

•    数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

特点：

1：对象封装数据，对象多了也需要存储。集合只用于存储对象，集合可以存储不同类型的对象。

2：对象的个数确定可以使用数组，但是不确定怎么办？可以用集合。因为集合是可变长度的。

 

集合和数组的区别：

1：数组是固定长度的；集合可变长度的。

2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。

3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。

 

数据结构：就是容器中存储数据的方式。

 

对于集合容器，有很多种。因为每一个容器的自身特点不同，其实原理在于每个容器的内部数据结构不同。

集合容器在不断向上抽取过程中。出现了集合体系。

在使用一个体系时，原则：参阅顶层内容。建立底层对象。

attention：集合中存储的都是对象的引用(地址) 而不是对象本身

Collection接口有两个子接口：  List（列表），Set（集）

|--List：可存放重复元素，元素存取是有序的。该集合体系有索引

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

 

Collection及其子类称为集合框架

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

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

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

Collection中的方法有

boolean	equals(Object o)   比较此 collection 与指定对象是否相等。
int	hashCode()        返回此 collection 的哈希码值。

增

boolean	add(E e)     确保此 collection 包含指定的元素（可选操作）。
boolean	addAll(Collection<? extendsE> c) 将指定 collection 中的所有元素都添加到此 collection 中

删

boolean	remove(Object o)   从此 collection 中移除指定元素的单个实例，如果存在的话
boolean	removeAll(Collection<?> c)   移除此 collection 中那些也包含在指定 collection 中的所有元素
void	clear()      移除此 collection 中的所有元素

改

查

boolean	contains(Object o)      如果此 collection 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)     如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	isEmpty()    如果此 collection 不包含元素，则返回 true。
boolean	retainAll(Collection<?> c)    仅保留此 collection 中那些也包含在指定 collection 的元素
int	size()     返回此 collection 中的元素数。

迭代器   其实就是集合的元素取出方式

Iterator<E>

iterator()  返回在此 collection 的元素上进行迭代的迭代器。

If(Iterator it = 集合对象.iterator();it.hasNext();  )

{

    Object ob =It.next();

}

 

List接口

l —— Vector：底层使用的是数组结构 线程安全，但速度慢，已被ArrayList替代。

l  ——ArrayList：底层使用的是数组结构  特点：线程不安全，查询速度快但增删慢。

l —— LinkedList：底层使用的是链表结构  特点：增删速度快，查询稍慢。

 

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

 

List集合判断元素是否相同 底层调用的是equals()方法

 

类ArryList集合的方法除了继承collection的方法外 其特有方法包括

l  增

void	add(index , element)        在指定下标添加元素
boolean	add(index , Collection)     在指定下标添加某个集合所有元素

    删

protected  void	removeRange(int fromIndex, int toIndex)    移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
E	remove(int index)  移除此列表中指定位置上的元素。

l  改

E	set(int index,E element)         用指定的元素替代此列表中指定位置上的元素。

l 查

int	indexOf(Object o)   返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
E	get(int index)   返回此列表中指定位置上的元素。
集合	SubList(from, to)   获取子集合包含from不包含to

retainAll()取两集合的交集 有交集则返回true 交集存入调用者集合 无交集返回false

        //sop("a和b是否有交集："+a.retainAll(b));

        //sop("这些交集的元素是："+a);

a和b均为list集合

        //  a.removeAll(b);移除与指定集合中相同的元素

        //a.removeAll(b);

        //sop("a.removeAll(b);  "+a);

 

 

类LinkedList集合的方法除了继承collection的方法外 其特有方法包括

增

void	addFirst(E e)  将指定元素插入此列表的开头。
void	addLast(E e)  将指定元素添加到此列表的结尾。

删

E	poll()        获取并移除此列表的头（第一个元素）
E	pollFirst()   获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E	pollLast()  获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	remove()       获取并移除此列表的头（第一个元素）。
boolean	remove(Object o)      从此列表中移除首次出现的指定元素
E	remove(int index)     移除此列表中指定位置处的元素。
E	removeFirst()          移除并返回此列表的第一个元素。
E	removeLast()           移除并返回此列表的最后一个元素。

改

E	set(int index,E element)         将此列表中指定位置的元素替换为指定的元素。

 

查

boolean	offer(E e)       将指定元素添加到此列表的末尾（最后一个元素）。
boolean	offerFirst(E e)      在此列表的开头插入指定的元素。
boolean	offerLast(E e)       在此列表末尾插入指定的元素。
E	element()          获取但不移除此列表的头（第一个元素）。
E	peek()              获取但不移除此列表的头（第一个元素）。
E	peekFirst()  获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E	peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	pop()             从此列表所表示的堆栈处弹出一个元素。
void	push(E e)         将元素推入此列表所表示的堆栈。
E	getFirst()              返回此列表的第一个元素。
E	getLast()                返回此列表的最后一个元素。
int	indexOf(Object o)  返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
int	lastIndexOf(Object o)   返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
boolean	contains(Object o)  如果此列表包含指定元素，则返回 true。

// LinkedList中利用removeFirst()遍历输出元素

        while(!a1.isEmpty())

        {

            sop(a1.removeFirst());

        }

 

LinkedList中利特有方法

addFrst()

addLast()

 

获取元素但不删除元素

getFirst()

getLast()

 

特殊：获取元素同时删除元素

removeFirst()   获取并移除此列表的第一个元素；如果此列表为空，则抛异常。noSuchElementException

removeLast()    获取并移除此列表的最后一个元素；如果此列表为空，则抛异常。

    1.6开始

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

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

 

List集合判断元素是否相同底层调用的是元素的equals()方法 remove(Object o)contains(Object o)等需要通过判断对象是否相同的方法都需要调用对象的equals()方法

所以List集合中 自定义对象要注意复写equals()方法

 

List 接口提供了特殊的迭代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该列表迭代器接口具备了对元素的增、删、改、查的动作，以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表迭代器。

ListIterator<E>	listIterator()   返回此列表元素的列表迭代器（按适当顺序）
ListIterator<E>	listIterator(int index)    返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。

 

ListIterator<E>的相比较Iterator<E>特有方法

int	nextIndex()     返回对 next 的后续调用所返回元素的索引。
boolean	hasPrevious()   如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E	previous()      返回列表中的前一个元素。
int	previousIndex()     返回对 previous 的后续调用所返回元素的索引。
void	remove()    Iterator也有此方法      从列表中移除由 next 或 previous 返回的最后一个元素
void	add(E e)           将指定的元素插入列表（可选操作）。
void	set(E e)       用指定元素替换 next 或 previous 返回的最后一个元素

List集合特有的迭代器,ListIterator<E>是Iterator<E>的子类接口

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

所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的只能对集合元素进行判断，取出，删除操作

如果想要进行修改等操作，就需要使用其子接口Listiterator来实现

If(ListIterator it = 集合对象. listIterator (); it.hasNext()或者it.hasPrevious();  )

{
    Object ob = it.next();//it.previous()
    it.set(element);
    it.remove();
}

ListIterator<E>内存放的是集合中的元素<E>

 

List集合因为角标有了自己的获取元素的方式： 遍历。

for(intx=0; x<list.size(); x++){

  sop("get:"+list.get(x));

}

Set接口  元素是无序的(存入和取出的顺序不一定一致)元素不可以重复

    |--——HashSet：底层数据结构是哈希表

    |--——TreeSet：可以对set集合中的元素进行自然排序

                 底层数据结构是二叉树

                 保证集合中元素的唯一性：compareTo()方法return 0

 

HashSet集合是没有重复元素的，那是怎样保证集合中元素的唯一性呢？这就得依靠两个方法，hashCode() 和 equals() 方法。

        如果元素的HashCode值相同，才会判断equals是否为true

        如果元素的HashCode值不相同，则不会调用equals方法

 

类 HashSet：不同步

HashSet集合的数据(元素)存储原理

1， 当HashSet集合调用add()方法添加元素过程中，会调用元素自身的hashCode()方法算出哈希值，(元素(地址,集合中存储的是元素的地址)的存储位置是由哈希值进过一定运算决定的)与之前add()方法添加的所有元素的哈希值进行比较，如果不同则根据哈希值找存储到相应的位置上

2， 当这两元素的哈希值相同，那么就会调用元素自身的equals()方法，进行比较，如果两元素相同equals()返回true，则当前要存储的对象(元素)不进行存储操作。如果不相同equals()返回false，那么就在同一个位置继续存放当前要存储的对象

当存储自定义对象时  需要复写hashCode()和equals() 方法。

public int hashCode()

public boolean equals(Object obj)

HashSet类集合的主要方法

boolean add(E e)

void clear()

boolean contains(Object o)

Iterator iterator() 

boolean isEmpty() 

boolean remove(Object o)   

int size() 

迭代器遍历集合元素

HashSet集合中  对于判断元素是否存在，以及删除等操作，调用的方法是hashCode() 和 equals() 方法  hashCode()不同直接存   相同则比较equals() 相同则直接删

对于ArrayList集合，判断元素是否存在，或者删元素底层依据都是equals方法。

对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。

类 TreeSet

类 HashSet：不同步

保证集合中元素的唯一性：一中compareTo()方法(二中比较器中的compare ())return 0

当存储自定义对象时  需要复写compareTo()方法。返回0时表示两元素相等则调用者元素不存储  同时根据返回的值进行元素排序

TreeSet集合中  对于判断元素是否存在，以及删除等操作，调用的方法是compareTo()方法return 0

 

TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo()方法    这种方式叫做元素的自然顺序或者默认顺序

TreeSet排序的第二种方式：让容器自身具备比较性。当元素自身不具备比较性时，或者具备的比较性不是所需要的。。。这时就需要让集合自身具备比较性：在集合初始化时就有了比较方式

1， 创建myCompare类实现Comparator接口  覆盖compare()方法 创建比较器

2， 创建TreeSet集合对象时通过构造函数调用myCompare对象使用其比较方法

当两种排序都存在，TreeSet构造函数调用比较器时  以比较器为主

当TreeSet集合中元素自身不具备比较性 同时没有创建或调用比较器时  编译不出错运行出错

TreeSet集合排序有两种方式，Comparable和Comparator区别：

1：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。

2：让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。

第二种方式较为灵活。

注意：在进行比较时，如果判断元素不唯一，比如，同姓名，同年龄，才视为同一个人。

  在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。

========================================================

Map集合：

|-——-Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。

|——--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

|-——-TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

 

Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：要保证map集合中键的唯一性。  

 

1，添加。

 put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

  voidputAll(Map);

2，删除。

  voidclear()：清空

  valueremove(key) ：删除指定键。

3，判断。

  booleanisEmpty()：

  booleancontainsKey(key)：是否包含key

  booleancontainsValue(value) ：是否包含value

4，取出。

  intsize()：返回长度

  valueget(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

  Collection values()：获取map集合中的所有的值。

5，想要获取map中的所有元素：

  原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

Set keySet();

Set entrySet();//取的是键和值的映射关系。

取出map集合中所有元素的方式一：keySet()方法。

可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。

      

Set keySet = map.keySet();
      Iterator it = keySet.iterator();
     while(it.hasNext()) {
         Object key = it.next();
         Object value = map.get(key);
         System.out.println(key+":"+value);
     }

--------------------------------------------------------

取出map集合中所有元素的方式二：entrySet()方法。

Set entrySet =map.entrySet();
        Iterator it =entrySet.iterator();
        while(it.hasNext()) {
            Map.Entry  me = (Map.Entry)it.next();
            System.out.println(me.getKey()+"::::"+me.getValue());
        }

集合什么时候用？

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

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

===========================================================================

Collections：它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

静态方法：

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

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

Collections.max(list); //返回list中字典顺序最大的元素。

int index = Collections.binarySearch(list,"zz");//二分查找，返回角标。当元素不存在时 返回值为-（插入点+1）

Collections.reverseOrder();//逆向反转排序。  reverseOrder(比较器对象)   反转比较器  返回翻转后的比较器

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

将非同步集合转成同步集合的方法：Collections中的  XXX synchronizedXXX(XXX);

List synchronizedList(list);

Map synchronizedMap(map);

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

 

Collection和 Collections的区别：

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

Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

----------------------------------------------------------

Arrays：

用于操作数组对象的工具类，里面都是静态方法。

asList方法：将数组转换成list集合。

String[] arr ={"abc","kk","qq"};

List<String> list =Arrays.asList(arr);//将arr数组转成list集合。

将数组转换成集合，有什么好处呢？用aslist方法，将数组变成集合；

可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；

注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；

如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。

如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。

 

集合变数组：用的是Collection接口中的方法：toArray();

如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。

    如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。

    所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只允许获取这些元素即可。

增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。

  for(Object obj : map.entrySet()) {
  Map.Entry entry = (Entry) obj; // obj 依次表示Entry
  System.out.println(entry.getKey() + "=" +entry.getValue());

增强for循环 只能够遍历元素 无法修改集合元素