集合(单列)

Iterable

　　Collection

　　　　List　　:1、元素有索引；2、允许重复；3、元素有序；

　　　　　　ArrayList　　：数组结构，所有元素都有索引，元素都是连续的内存空间；

　　　　　　　　　　　　：查询快；增删慢（增删一个元素将会影响所有元素索引）

　　　　　　LinkedList　  ：链表结构，由链子连接起来的一堆节点（上一个节点地址值、本节点值、下一个节点地址值）

　　　　　　　　　　　    ：查询慢；增删快。

　　　　　　Vector　　　 ：线程安全。

　　　　Set　　：1、元素无索引；2、不许重复；3、元素无序；

　　　　　　AbstractSet

　　　　　　　　TreeSet　　：实现排序

TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
自然排序
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0
定制排序
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法

　　　　　　HashSet　　：哈希表结构；1、不能保证元素的排列顺序，顺序有可能发生变化；2、 不是同步的；3、集合元素可以是null,但只能放入一个null；（底层基于HashMap实现）

　　　　　　　　　　　　　　HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相 等
　　　　　　　　　　　　　　注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。其规则是如果两个对 象通过equals方法比较返回                                                   true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。

　　　　　　　　LinkedHashSet　　：哈希表和链表结构的结合；底层基于LinkedHashMap实现；

　　　　　　　　　　　　　　LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起 来像是以插入顺序保存                                                       的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
                                                 LinkedHashSet在迭代访问Set中的全部元素时，性能比HashSet好，但是插入时性能稍微逊色于HashSet。

(接口、抽象类、实现类)

---

 

LinkedList 特有功能api：

　　

void	addFirst(E e)
void	addLast(E e)
E	getFirst()
E	getLast()
E	removeFirst()
E	removeLast()

 

---

 

ListIterator && Iterator &&Iterable的区别：

　　Iterator迭代器包含的方法有：

　　　　hasNext()：如果迭代器指向位置后面还有元素，则返回 true，否则返回false

　　　　next()：返回集合中Iterator指向位置后面的元素

　　　　remove()：删除集合中Iterator指向位置后面的元素

　　ListIterator迭代器包含的方法有：

   　　　add(E e): 将指定的元素插入列表，插入位置为迭代器当前位置之前

　　　　hasNext()：以正向遍历列表时，如果列表迭代器后面还有元素，则返回 true，否则返回false

　　　　hasPrevious():如果以逆向遍历列表，列表迭代器前面还有元素，则返回 true，否则返回false

　　　　next()：返回列表中ListIterator指向位置后面的元素

　　　　nextIndex():返回列表中ListIterator所需位置后面元素的索引

　　　　previous():返回列表中ListIterator指向位置前面的元素

　　　　previousIndex()：返回列表中ListIterator所需位置前面元素的索引

　　　　remove():从列表中删除next()或previous()返回的最后一个元素（有点拗口，意思就是对迭代器使用hasNext()方法时，删除ListIterator指向位置后面的元素；当对迭代器使用hasPrevious()方法时，删除ListIterator指向位置前面的元素）

　　　　set(E e)：从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e

　　Iterable ：故名思议，实现了这个接口的集合对象支持迭代，是可迭代的。able结尾的表示 能...样，可以做...。

　　Iterator:   在英语中or 结尾是都是表示 ...样的人 or ... 者。如creator就是创作者的意思。这里也是一样：iterator就是迭代者，我们一般叫迭代器，它就是提供迭代机制的对象，具体如何迭代，都是Iterator接口规范的。

一．相同点

都是迭代器，当需要对集合中元素进行遍历不需要干涉其遍历过程时，这两种迭代器都可以使用。

二．不同点

1.使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。

2.ListIterator有add方法，可以向List中添加对象，而Iterator不能。

3.ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator不可以。

4.ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

5.都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。

以上所述是小编给大家介绍的JAVA中ListIterator和Iterator详解与辨析(推荐)，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持！

---

 

当对集合进行迭代的时候如果要对集合进行删除或者修改，需要使用迭代器来删除或者修改，不能通过集合来删除或修改，会发生并发修改异常ConcurrentModificationException，这是 因为在底层基本上Collection采用size属性来维护自已的状态，而Iterator采用cursor来来维护自已的状态。

当size出现变化时，cursor并不一定能够得到同步，除非这种变化是Iterator主动导致的。

public static void main(String args[]) {
    List<String> famous = new ArrayList<String>();
    famous.add("liudehua");
    famous.add("madehua");
    famous.add("liushishi");
    famous.add("tangwei");
    for (String s : famous) {
        if (s.equals("madehua")) {
            famous.remove(s);
        }
    }
}

从上面的代码可以看到当Iterator.remove方法导致ArrayList列表发生变化时，他会更新cursor来同步这一变化。但其他方式导致的ArrayList变化，Iterator是无法感知的。ArrayList自然也不会主动通知Iterator们，那将是一个繁重的工作。Iterator到底还是做了努力：为了防止状态不一致可能引发的无法设想的后果，Iterator会经常做checkForComodification检查，以防有变。如果有变，则以异常抛出，所以就出现了上面的异常。

 如果对正在被迭代的集合进行结构上的改变（即对该集合使用add、remove或clear方法），那么迭代器就不再合法（并且在其后使用该迭代器将会有ConcurrentModificationException异常被抛出）.

如果使用迭代器自己的remove方法，那么这个迭代器就仍然是合法的。

---

 

Collections集合工具类常用api示例

public class CollectionsTest {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(34);
        list.add(55);
        list.add(56);
        list.add(89);
        list.add(12);
        list.add(23);
        list.add(126);
        System.out.println(list);

        //对集合进行排序
        Collections.sort(list);
        System.out.println(list);

        //对集合进行随机排序
        Collections.shuffle(list);
        System.out.println(list);

        //获取集合最大值、最小值
        int max = Collections.max(list);
        int min = Collections.min(list);
        System.out.println("Max:" + max + " Min: " + min);

        List<String> list2 = Arrays.asList("Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday".split(","));
        System.out.println(list2);

        //查找集合指定元素，返回元素所在索引
        //若元素不存在，n表示该元素最有可能存在的位置索引
        int index1 = Collections.binarySearch(list2, "Thursday");
        int index2 = Collections.binarySearch(list2, "TTTTTT");
        System.out.println(index1);
        int n = -index2 - 1;

        //查找子串在集合中首次出现的位置
        List<String> subList = Arrays.asList("Friday,Saturday".split(","));
        int index3 = Collections.indexOfSubList(list2, subList);
        System.out.println(index3);
        int index4 = Collections.lastIndexOfSubList(list2, subList);
        System.out.println(index4);

        //替换集合中指定的元素，若元素存在返回true，否则返回false
        boolean flag = Collections.replaceAll(list2, "Sunday", "tttttt");
        System.out.println(flag);
        System.out.println(list2);

        //反转集合中的元素的顺序
        Collections.reverse(list2);
        System.out.println(list2);

        //集合中的元素向后移动k位置，后面的元素出现在集合开始的位置
        Collections.rotate(list2, 3);
        System.out.println(list2);

        //将集合list3中的元素复制到list2中，并覆盖相应索引位置的元素
        List<String> list3 = Arrays.asList("copy1,copy2,copy3".split(","));
        Collections.copy(list2, list3);
        System.out.println(list2);

        //交换集合中指定元素的位置
        Collections.swap(list2, 0, 3);
        System.out.println(list2);

        //替换集合中的所有元素，用对象object
        Collections.fill(list2, "替换");
        System.out.println(list2);

        //生成一个指定大小与内容的集合
        List<String> list4 = Collections.nCopies(5, "哈哈");
        System.out.println(list4);

        //为集合生成一个Enumeration
        List<String> list5 = Arrays.asList("I love my country!".split(" "));
        System.out.println(list5);
        Enumeration<String> e = Collections.enumeration(list5);
        while (e.hasMoreElements()) {
            System.out.println(e.nextElement());
        }
    }
}

---

Comparable&& Comparetor　　比较器

Comparable 是给要排序的实体本身实现的接口，而 Comparator 则是第三方。

比如：类 A 实现了 Comparable 接口，表示它可以和另一个 A 比较来达到排序的目的。
但，假设用户想点击按钮“按名字排序”，之后他又想“按QQ号排序”，这样的需求我们用 Comparable 是无法同时满足两种情况的，那么我们就需要第三方 Comparator，当我们在使用 Collections.sort() 方法时传递这个 Comparator 让它来排序。因此 Comparable 里面的方法只需要 1 个参数，因为另一个参数就是这个 A 类实例自己，而 Comparator 需要 2 个参数，它是第三方比较器，接收 2 个参数。