Collection集合

集合和数组的主要区别在于，集合的大小不受限制，而数组的大小是限制的，这就是数组的致命缺陷，一旦数组的大小确定，则其大小不能改变。集合可以认为是一种可变的数组，大小可以随着元素的增加而增加。在使用集合增加数据是又常和泛型联系在一起。

1.集合与数组的区别

-数组是一个线性的序列，所以可以快速访问其他元素，当用户创建了一个数组时，其容量是不变的，而且生命周期也是不能改变的，而且Java数组会做边界检查，如果发现有 越界现象，会报RuntingException异常作物，所有不用担心和C、C++一样不做边界检查会出问题，当然检查边界会以降低效率为代价。

-集合的容量是可变的，扩展性比较好。

-集合的内部实现就是基于数组的，所有，数组的效率要高于集合。

小面是集合位于java.util包下面的结构图：

2. collection集合

Collection是最基本的集合接口，有两个子接口List和Set，这些接口主要用于操作结合，如结合增删查改等。List和Set下面有几个比较重要的实现类，分别是：ArrayList、LinkedList、HashSet、SortedSet。

2.1.ArrayList数组列表

ArrayList是List接口的子接口，它允许集合存储的元素可以重复，并且可以将null存储到集合中。ArrayList是线程不安全的，如果多个线程同时访问一个ArrayList实例，可能会访问数据出现不一致的情况。

//初始化list集合
		List<String> list = new ArrayList<String>();
		//添加数据
		list.add("王小二");
		list.add("王小二");
		list.add("张三");
		System.out.println(list);
//		结果：[王小二, 王小二, 张三]
//	    由结果可以看出List集合是可以重复的，而且是按照顺序执行的

        

2.2.LinkedList链表

ArrayList只能在尾部增加，并不能向前增加，但是LinkedList类可以在集合的前面后面增加元素，灵活性比较强。LinkedList类的iterator和listIterator方法可以很方便的遍历集合元素。

		LinkedList<String> list = new LinkedList<String>();
		list.add("王小二");
		list.add("王小二");
		list.add("张三丰");
		//增加到第一个
		list.addFirst("刘德华");
		//增加到最后一个
		list.addLast("黄XX");
		System.out.println(list);
		//结果：[刘德华, 王小二, 王小二, 张三丰, 黄XX]


2.3HashSet

    
    

     
     此类实现Set接口，并且HashSet的顺序是不确定的，此类运行使用null元素。HashSet接口不允许集合添加重复元素，如果添加重复元素将会覆盖之前的元素。HashSet的线程是不同步的。
    
    

    
    

     
     
		Set<String> set = new HashSet<String>();
		set.add("王小二");
		set.add("王小二");
		set.add("刘德华");
		set.add("张学友");
		System.out.println(set);
		//结果：[王小二, 张学友, 刘德华]
		//由结果可以看出Set集合是可以重复，并且无序的。

     
     
2.4.TreeSet

    
    

    
    

     
     TreeSet集合是用来集合元素内部进行排序使用的，TreeSet集合是线程不同步的。
     
     


     
     
Set<String> set2 = new TreeSet<String>(new Comparator<String>() {
			int i =1;
			@Override
			public int compare(String o1, String o2) {
				// TODO 自动生成的方法存根
				return o1.compareTo(o2);
			}
		});
		set2.add("9999");
		set2.add("8888");
		set2.add("2222");
		set2.add("1111");
		set2.add("我们");
		set2.add("5555");
		System.out.println(set2);
		//由结果可以看出是进行过排序的
    
    

3.Comparable/comparable接口

Comparable接口主要用来对对象排序使用，这种排序被称为类的自然排序，类的compareTo方法可以由用户自己定义排序规则。

实现此接口的对象列表可以通过Collection.sort(或Arrays.sort)进行自动排序。为了更好的实现此功能，建议比较排序的类实现方法hashCode和equals方法。

Comparable接口只有一个方法compareTo，该方法定义如下：

int  compareTo(to):比较次对象与制定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

package com.song.collection;

public class Person implements Comparable
    
    
     
      {
	private String name;
	private int age;

	public Person(String _name, int _age) {
		this.name = _name;
		this.age = _age;
	}
	@Override
	public String toString() {
		// TODO 自动生成的方法存根
		return name+","+age;
	}
	@Override
	public int compareTo(Person o) {
		int c = age-o.getAge();
//		System.out.println("age:"+age+"--o.getAge:"+o.getAge());
		if(age!=0){
			return c;
		}
		return name.compareTo(o.getName());
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}

package com.song.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CompareDome {
	public static void main(String[] args) {
		List
     
     
      
       list = new ArrayList
      
      
       
       ();
		list.add(new Person("王小二", 20));
		list.add(new Person("刘德华", 30));
		list.add(new Person("张学友", 21));
		list.add(new Person("刘德华", 20));
		list.add(new Person("张学友", 25));
		list.add(new Person("张xx", 15));
		list.add(new Person("王xx", 18));
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
		
	}
	//[王小二,20, 刘德华,30, 张学友,21, 刘德华,20, 张学友,25, 张xx,15, 王xx,18]
    //[张xx,15, 王xx,18, 王小二,20, 刘德华,20, 张学友,21, 张学友,25, 刘德华,30]
}

      
      
     
     
    
    

4.增强for循环

增强for循环主要是用来打印集合的，并且增强for循环只能打印数组和带泛型的集合。增强for循环的局限性就在于它只能打印集合中的内容，不能对集合本身进行修改，因为修改后会出现意想不到ed情况。

增强for循环的语法如下：

	for(集合中泛型的数据类型  对象名：集合变量名){

	}

5.Iterator接口

Iterator接口就是用来遍历结合。

package com.song.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Interator1 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("王小二");
		list.add("王小二");
		list.add("张学友");
		list.add("张学友");
		list.add("刘德华");
		list.add("张学友");
		Iterator<String> ite = list.iterator();
		while (ite.hasNext()) {// 如果还有下一个
			String s = ite.next();// 把下一个取出来
			if (s.equals("张学友")) {
				ite.remove();// 移除
			}
		}
		System.out.println(list);
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i).equals("王小二")) {
				list.remove(i);
				i--;// 因为集合元素进行删除时，内部指针的位置会发生相应变化，所以进行for循环删除，
				//要将指针进行相应变化才能删除干净
			}
		}
		System.out.println(list);
	}
}