集合之Collection接口（二）

一、Collection的常用方法

1.size():返回集合中元素的个数

System.out.println(coll.size());

2.add(Object obj)：向集合中添加一个元素

        coll.add("AA");
        coll.add(123);       //此时的123为Integer类型，因为添加时参数列表为对象类型
        coll.add("BB");
        coll.add(new Date());
        System.out.println(coll.size());

3.addAll(Collection coll):将形参coll中包含的所有元素添加到当前集合中

        Collection coll1 = Arrays.asList(1,2,3);     //将数组转化为集合
        coll.add(coll1);
        System.out.println(coll.size());

4.isEmpty():判断集合是否为空

        System.out.println(coll.isEmpty());

5.clear():清空集合元素

        coll.clear();
        System.out.println(coll.size());

6.contains(Object obj) :判断集合是否包含指定的obj元素。如果包含返回true，不包含返回false
//判断的依据：根据元素所在的类的equals()方法进行判断
//明确：如果存入集合中的元素是辣子自定义类的对象。要求：自定义类要重写equals方法

        boolean b1 = coll.contains(123);
        b1 = coll.contains("11");
        boolean b2 = coll.contains(new Person("mm",23));
        System.out.println(b1);
        System.out.println(b2);

7.containsAll(Collection coll):判断当前集合是否包含coll集合中的所有元素

        Collection coll1  = new ArrayList();
        coll1.add("AA");
        coll1.add(123);     
        System.out.println(coll.containsAll(coll1));

8.retainAll(Collection coll):求当前集合与coll的共有元素,并将共有的元素存进当前集合中

        coll.retainAll(coll1);
        System.out.println(coll);

9.remove(Object obj):删除集合中的obj元素，若删除成功返回true，若删除失败返回false

   coll.remove(123);

10.removeAll(Collection coll):从当前集合中删除包含在coll中的元素。删除公共元素

    coll.retainAll(coll1);

11.equals(Object obj):判断集合中的所有元素是否完全相等

        Collection coll2  = new ArrayList();
        coll1.add("AA");
        coll1.add(123); 
        System.out.println(coll1.equals(coll2));

12.hashCode():

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

13.toArray():将集合转化为数组

 Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

14.interator()：返回一个Interator接口实现的对象，进而实现数组的遍历

        Iterator iterator = coll.iterator();
        /*方式一：不用（next方法）
         * 
           System.out.println(iterator.next);
           System.out.println(iterator.next);
           System.out.println(iterator.next);
        */
        
        /*方式二：不用
        for (int i = 0; i < coll.size(); i++) {
            System.out.println(iterator.next());
        }*/
        
        //方式三：采用（一般next()和hasNext()方法搭配使用）
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

二、Collection中的list接口（equal方法一致）

List的主要实现类：ArrayList；

其他实现类：Vector（古老的实现类、线程安全的，但是效率低于ArrayList），LinkedList（适用于插入，删除操作）；

void add(int index,Object obj):在指定的索引位置index插入元素obj
boolean addAll(int index,Collection eles):在指定位置处插入一个集合
Object get(int index):获取指定索引的元素
Object remove(int index):删除指定集合位置的元素
Object set(int index,Object ele):设置指定索引位置的元素为ele
int indexof(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在集合中最后出现的位置
List subList(int fromIndex,int toIndex)
List常用的方法：增(add(Object obj))删(remove)改(set)查(get(int index))插(add(int index,Object obj))长度(size())

实例：

List list = new ArrayList();
1.add():向ArrayList集合中加入元素

注：在判断两个自定义类是否相等时需要在自定义类中加入equals（）方法进行判断，否则会出现运算无效（错误）现象。

        list.add(123);
        list.add(456);
        list.add(new Date());
        list.add(new String());
        list.add(new Person("MM",23));
        System.out.println(list);
        
        Collection coll = new ArrayList();
        coll.add(890);
        coll.add(7586);

2.addAll():想集合中指定位置加入一个集合

        list.addAll(0, coll);
        System.out.println(list);

3.get(int index):获取集合中特定位置的元素

 System.out.println(list.get(0));

4.set(int index, Object obj):向集合中特定位置插入元素

list.set(3, 3456677);
System.out.println(list);

5.remove(int index):删除指定位置的元素

 list.remove(0);
System.out.println(list);

6.set(int index,Object obj):修改指定位置的元素

 list.set(0, 66666);
 System.out.println(list);

三、Collection中的set接口（equals方法和HashCode方法一致）

Set的主要实现类：HashSet；

其他实现类：LinkedHashSet，TreeSet；

在加入时需要在Perosn方法中加入equls方法和HashCode方法判断两者是否重复，否则将会出现添加后重复元素现象
说明：要求添加进Set中的元素所在的类，一定要重写equals()方法和hashCode()方法，进而保证Set中元素的不可重复性

Set:存储的元素都是无序的，不可重复的
1、无序性：无序性 != 随机性（它是指在内存中的存储是无序的，如何判断在内存的的驯顺序就需要使用HashCode方法）
真正的无序性指的是元素在底层存储的位置的无序性
2、不可重复性：当向Set中添加进相同的元素时候，后面的元素不可再添加进集合中

3.Set是如何存储的呢？使用了哈希算法
当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算对象的哈希值，
此哈希值已经有独享在Set中存储位置。若再次位置没有对象存储，则这个对象直接存储到
此位置。若此位置已经有对象存储，再通过equals（）方法比较这两个对象是否相同，如
果相同，后一个对象就不能再添加进来。
》》hashCode（）方法与equals（）方法要一致

三种实现类

1）HashSet类

@Test
	public void testHashSet() {
		Set set = new HashSet();
		set.add(123);
		set.add(345);
		set.add(new String ("AA"));
		set.add("BB");
		set.add(null);
		//在加入时需要在Perosn方法中加入equls方法和HashCode方法判断两者是否重复，否则将会出现添加后重复元素现象
		//说明：要求添加进Set中的元素所在的类，一定要重写equals()方法和hashCode()方法，进而保证Set中元素的不可重复性
		Person p1 = new Person("GG",23);
		Person p2 = new Person("GG",23);
		set.add(p1);
		set.add(p2);
		System.out.println(set.size());
		System.out.println(set);
		
	}

2）LinkedHashSet类

LinkedHashSet是HashSet的子类
LinkedHashSet:使用链表维护了一个添加进集合中的顺序。导致当我们遍历LinkHashSet元素时，是按照添加进去的顺序遍历的！但是在内存中存储的元素顺序依然是无序的。
LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素有很好的性能
LinkedHashSet不允许集合元素重复

public void testLinkedHashSet() {
		Set set = new LinkedHashSet();
		set.add(123);
		set.add(345);
		set.add(new String ("AA"));
		set.add("BB");
		set.add(null);
		
		Iterator iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		
	}

3）TreeSet类（最麻烦的类）：除了euqals方法和HashCode方法以外还有compareTo（）方法（即comparable）一致，两种排序方法如下。

向TreeSet添加的必须是同一个类的
可以按照添加进集合中的元素的指定顺序遍历。像String，包装类等默认按照从小到大的顺序进行遍历
自然排序，当向TreeSet中添加自定义类的对象时有两种排序方法：①：自然排序 ②：定制排序
①自然排序（comparable）：要求自定义类实现java.lang.Conparable接口并重写compareTo（Object obj）方法在此方法中。指定按照那个属性今次那个排序。②定制排序（comparator）
向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅仅是两个对象的属性值相同但是程序会认为这俩个对象时相同的，进而后一个对象就不能添加进来
》》compareTo（）与hashCode（）以及equals（）三者保持一致！

1）自然排序（comparable）

Person实例中代码如下（Person implements Comparable）：当向TreeSet中添加Person类的对象时，一句此方法，确定按照那个属性来重复。为避免只按照一个属性进行排序出现一个数值重复使得此属性无法添加进集合的情况，所有需要定义多个属性的定义排序判断

@Override
	public int compareTo(Object o) {		
			if(o instanceof Person ) {
				Person p = (Person)o;
				//return this.name.compareTo(p.name);
				//return this.age.compareTo(p.age);
				int i = this.age.compareTo(p.age);
				if(i == 0) {
					return this.name.compareTo(p.name);
				}else
					return i;
			}
			return 0;
	}

主类中代码如下：

//当向TreeSet中添加Person类的对象时，一句此方法，确定按照那个属性来重复
		set.add(new Person("AA",21));
		set.add(new Person("pp",21));
		set.add(new Person("BB",25));
		set.add(new Person("CC",26));
		set.add(new Person("DD",23));
		set.add(new Person("EE",22));
		set.add(new Person("SS",28));
		
		
	
		Iterator iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}

2）定制排序

①常用直接定义：

//方式一：
		//1.创建一个实现Comparator接口的类对象
		Comparator comparator = new Comparator() {

			//向treeSet中添加Customer类的对象，再次compare（）方法中按照Customer的那个属性进行排序
			@Override
			public int compare(Object o1, Object o2) {
				if(o1 instanceof Customer && o2 instanceof Customer) {
					Customer c1 = (Customer)o1;
					Customer c2 = (Customer)o2;
					int i = c1.getId().compareTo(c2.getId());
					if(i == 0) {
						return c1.getName().compareTo(c2.getName());
					}else
						return i;
				}
				
				return 0;
			}
			
		};
		
		//2.将此对象作为形参传递给TreeSet的构造器中
		TreeSet set = new TreeSet(comparator);
		//3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象
		set.add(new Customer("AA", 23));
		set.add(new Customer("ww", 23));
		set.add(new Customer("CC", 25));
		set.add(new Customer("FF", 78));
		set.add(new Customer("II", 45));
		set.add(new Customer("PP", 47));
		
		for(Object str: set) {
			System.out.println(str);
		}

②匿名类定义：

Set set = new TreeSet(new Comparator() {

			@Override
			public int compare(Object o1, Object o2) {
				if (o1 instanceof Customer && o2 instanceof Customer) {
					Customer c1 = (Customer)o1;
					Customer c2 = (Customer)o2;
					if(c1.getId().compareTo(c2.getId()) == 0) {
						return c1.getName().compareTo(c2.getName());
					}else {
						return c1.getId().compareTo(c2.getId());
					}
				}
				return 0;
			}
		});
		set.add(new Customer("aa", 123));
		set.add(new Customer("ss", 123));
		set.add(new Customer("bb", 234));
		set.add(new Customer("cc", 345));
		set.add(new Customer("dd", 456));
		set.add(new Customer("rr", 678));
		for(Object str : set) {
			System.out.println(str);
		}
	}