1-Collection接口

1. 集合概述

面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。

数组在内存存储方面的特点：

数组初始化以后，长度就确定了。

数组声明的类型，就决定了进行元素初始化时的类型

数组在存储数据方面的弊端：

数组初始化以后，长度就不可变了，不便于扩展

数组中提供的属性和方法少，不便于进行添加、删除、插入等操作， 且效率不高。同时无法直接获取存储元素的个数

数组存储的数据是有序的（顺序存储的）、可以重复的。存储数据的类型单一

Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。

 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中）

2.1 数组在存储多个数据方面的特点：

     > 一旦初始化以后，其长度是确定的。

     > 数组一旦定义好，其元素的类型也是确定的，只能操作指定类型的数据，比如：String[] arr;int[] arr1;Object[] arr2;

2.2 数组在存储多个数据方面的缺点：

     > 一旦初始化以后，其长度就不可修改

     > 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。

     > 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用

     > 数组存储数据的特点：顺序存储的、可重复。对于无序存储、不可重复的需求，不能满足，而如果使用容器中的Map可解决。

Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组，并提供了丰富的方法用于操作容器中的数据。

2. 集合中的重要结构

二、集合框架

     |----Collection接口：单列集合，用来存储一个一个的对象

         |----List接口：存储有序的、可重复的数据，“动态”数组，可动态扩容

             |----ArrayList、LinkedList、Vector

         |----Set接口：存储无序的、不可重复的数据，类比于高中学的“集合”（有限性、确定性、互异性、无序性）

             |----HashSet、LinkedHashSet、TreeSet

     |----Map接口：双列集合，用来存储一对(key - value)一对的数据，类比高中学习的函数：y = f(x)

             |----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

3. Collection接口方法的使用

3.1 add() 、 size() 、 addAll()、  clear()、 isEmpty() 方法的使用

1. @Test

2. public void testColl(){

3.     Collection coll = new ArrayList();

5.     // boolean add(E e);

6.     coll.add(123);

7.     coll.add('a');

8.     coll.add("ylaihui");

10.     // size() 返回元素的个数

11.     System.out.println(coll.size()); // 3

13.     Collection coll2 = new ArrayList();

14.     coll2.add(new java.lang.String("ylaihui"));

15.     coll2.add(new java.lang.StringBuffer("ylaihui"));

17.     //addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中

18.     coll.addAll(coll2);

20.     System.out.println(coll.size());  // 5

21.     // 调用 ArrayList的 toString方法 [123, a, ylaihui, ylaihui, ylaihui]

22.     System.out.println(coll);

24.     // 判断集合是否为空 （集合中是否有元素） return size() == 0

25.     Collection coll3 = new ArrayList();

26.     System.out.println(coll3.isEmpty());  // true

27.     System.out.println(coll.isEmpty());   // false

29.     // 清空集合元素

30.     coll.clear();

31.     System.out.println(coll.isEmpty());  // true

32. }

代码输出：

3

5

[123, a, ylaihui, ylaihui, ylaihui]

true

false

true

3.2 contains()、 containsAll()、 remove()、removeAll()方法的使用

order类

1. class Order {

2.     private int id;

3.     private double price;

5.     public Order() {

6.     }

8.     public Order(int id, double price) {

9.         this.id = id;

10.         this.price = price;

11.     }

13.     @Override

14.     public boolean equals(Object o) {

15.         if (this == o) return true;

16.         if (o == null || getClass() != o.getClass()) return false;

17.         Order order = (Order) o;

18.         return id == order.id &&

19.                 Double.compare(order.price, price) == 0;

20.     }

22.     @Override

23.     public String toString() {

24.         return "Order{" +

25.                 "id=" + id +

26.                 ", price=" + price +

27.                 '}';

28.     }

29. }

1. @Test

2. public void testMethod() {

3.     Collection objects = new ArrayList();

4.     objects.add(123);

5.     objects.add(false);

6.     objects.add(new String("ylaihui"));

8.     // contains(Object obj):判断当前集合中是否包含obj

9.     // 会调用obj对象所在类的equals(),并非比较的对象的地址，而是比较的对象的内容

10.     System.out.println(objects.contains(123));  // 自动装箱 true

11.     System.out.println(objects.contains("ylaihui")); // true

12.     System.out.println(objects.contains(new String("ylaihui")));  // true

14.     Order order = new Order(111, 100.00);

15.     objects.add(order);

16.     // 不管有没有重写equals，结果都为true，因为是同一个对象 调用== 或 equals都是true

17.     System.out.println(objects.contains(order));  // true

19.     // true， 如果Order类没有重写equals方法，结果为 false

20.     System.out.println(objects.contains(new Order(111, 100.00))); // true

22.     Collection coll1 = Arrays.asList(123, false);

23.     // 判断 objects 集合中是否包含集合 coll1, 子集的关系

24.     System.out.println(objects.containsAll(coll1)); // true

26.     // remove(Object obj):从当前集合中移除obj元素。

27.     objects.remove(new Order(111, 100.00));

28.     System.out.println(objects);  // [123, false, ylaihui]

30.     //removeAll():移除两个部分的交集(coll2和objects的交集被移除)

31.     Collection coll2 = Arrays.asList(123, false, 1111);

32.     objects.removeAll(coll2);

33.     System.out.println(objects);  // [ylaihui]

34. }

3.3 retainAll() 方法的使用

1. @Test

2. public void test3() {

3.     Collection coll = new ArrayList();

4.     coll.add(123);

5.     coll.add(456);

6.     coll.add(new Order(1111, 100.00));

7.     coll.add(new String("ylaihui"));

8.     coll.add(false);

10.     //retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合

11.     Collection coll1 = Arrays.asList(123, 456, 789);

12.     coll.retainAll(coll1);

13.     System.out.println(coll);  // [123, 456]

14. }

3.4 equals() 方法的使用

1. @Test

2. public void test4() {

3.     Collection coll = new ArrayList();

4.     coll.add(123);

5.     coll.add(456);

6.     coll.add(new Order(1111, 100.00));

7.     coll.add(new String("ylaihui"));

8.     coll.add(false);

10.     Collection coll2 = new ArrayList();

11.     coll2.add(123);

12.     coll2.add(456);

13.     coll2.add(new Order(1111, 100.00));

14.     coll2.add(new String("ylaihui"));

15.     coll2.add(false);

17.     //equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。

18.     System.out.println(coll.equals(coll2));  // true

19. }

3.5 toArray()、hashCode()、 Arrays.asList()

1. @Test

2. public void test5() {

3.     Collection coll = new ArrayList();

5.     coll.add(123);

6.     coll.add(456);

7.     coll.add(new Order(1111, 100.00));

8.     coll.add(new String("ylaihui"));

9.     coll.add(false);

11.     //hashCode():返回当前对象的哈希值

12.     System.out.println(coll.hashCode());

14.     //集合 -> 数组：toArray()

15.     Object[] objects = coll.toArray();

16.     for (int i = 0; i < objects.length; i++) {

17.         System.out.println(objects[i]);

18.     }

20.     //数组 -> 集合:调用Arrays类的静态方法asList(),基本数据类型的数组无法转换为多元素的集合

21.     Collection coll2 = Arrays.asList(objects);

22.     System.out.println(coll2);  // [[123, 456, Order{id=1111, price=100.0}, ylaihui, false]]

23.     System.out.println("coll2.size() = " + coll2.size());  // 5

25.     Collection coll3 = Arrays.asList(new String[]{"y", "lai", "hui"});

26.     System.out.println(coll3);  // [y, lai, hui]

27.     System.out.println(coll3.size()); // 3

29.     Collection coll4 = Arrays.asList(new int[]{1, 2, 3});

30.     System.out.println(coll4);  // [[I@22927a81]

31.     System.out.println(coll4.size()); // 1

33.     Collection coll5 = Arrays.asList(new Integer[]{1, 2, 3});

34.     System.out.println(coll5);  // [1, 2, 3]

35.     System.out.println(coll5.size()); // 3

36. }

3.6 iterator() 方法的使用

 Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。

 GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。 迭代器模式，就是为容器而生。 类似于“公交车上的售票员”、“火车上的乘务员”、 “空姐” 。

 Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了

Iterator接口的对象。

 Iterator 仅用于遍历集合， Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象，则必须有一个被迭代的集合。

 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且

下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。

1. @Test

2. public void testIterator(){

3.     Collection coll = new ArrayList();

4.     coll.add(123);

5.     coll.add(234);

6.     coll.add("ylaihui");

8.     Iterator iterator = coll.iterator();

10.     while(iterator.hasNext()){

11.         System.out.println(iterator.next());

12.     }

14.     // 迭代器遍历结束后，需要重新初始化 否则报异常 NoSuchElementException

15.     // 可以这样实现，但是不推荐这么使用

16.     iterator = coll.iterator();

17.     for (int i = 0; i < coll.size(); i++) {

18.         System.out.println(iterator.next());

19.     }

20. }

3.7 iterator() 方法的原理

调用 next() 时指针下移

每次调用 Iterator() 方法都会返回一个  Iterator 对象

System.out.println(iterator.getClass());   对于ArrayList集合的迭代器， 是其内部类的类型， class java.util.ArrayList$Itr，该内部类实现了 Iterator接口

4. 迭代器的remove()方法

如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，

再调用remove都会报IllegalStateException。

1. public class IteratorRemove {

2.     @Test

3.     public void testremove(){

4.         Collection coll = new ArrayList();

5.         coll.add(111);

6.         coll.add(222);

7.         coll.add("ylaihui");

9.         Iterator it = coll.iterator();

10.         while(it.hasNext()){

11.             Object next = it.next();

12.             if(next.equals(111)){

13.                 it.remove();

14.             }

15.         }

16.         it = coll.iterator();

17.         while (it.hasNext())

18.             System.out.println(it.next());

19.     }

20. }

代码运行结果

222

ylaihui

5. foreatch 增强for循环

jdk 5.0 新增了foreach循环，用于遍历集合、数组

for(集合元素的类型 局部变量 : 集合对象)

内部仍然调用了迭代器。

1. //ForeatchTest.java

2. package com.ylaihui.collectionitf;

4. import org.junit.Test;

6. import java.util.ArrayList;

7. import java.util.Collection;

9. public class ForeatchTest {

10.     @Test

11.     public void testremove() {

12.         Collection coll = new ArrayList();

13.         coll.add(111);

14.         coll.add(222);

15.         coll.add("ylaihui");

17.         for(Object obj : coll){

18.             System.out.println(obj);

19.         }

20.     }

22.     @Test

23.     public void testArray(){

24.         int[] ints = {1, 2, 3, 4, 5};

26.         for(int i : ints){

27.             System.out.println(i);

28.         }

29.     }

30. }