Java语法基础——集合的使用

Collection接口

Collection接口介绍

1、Collection接口是集合层次结构中的根界面 。 集合表示一组被称为其元素的对象。 一些集合允许重复元素，而其他集合不允许。JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List接口 。 该界面通常用于传递集合，并在需要最大的通用性的情况下对其进行操作。
2、 Collection接口提供l了一些集合通用方法。常用的一些方法有add(E e)、clear()、contains(Object o)、isEmpty()、iterator()、remove(Object o)、size()等。
（1）add(E e)方法用于判断集合中是否存在某一元素。如果不存在，则向集合添加指定元素，返回true；如果存在，则不再添加，返回false。
（2）clear()方法用于清除集合中所有元素。使用时需谨慎。
（3）contains()方法用于判断结合是否包含某一元素。如果包含，返回true；如果不包含，返回false。
（4）isEmpty()方法用于判断集合中是否存在元素。如果集合为空，返回true；如果集合不为空，返回false。
（5）iterator()方法返回集合迭代器对象。常用于集合的遍历。
（6）remove(Object o)方法用于删除集合中某一指定元素。如果删除元素存在，返回true；如果删除元素不存在，返回false。
Notes：
① addAll(Collection<? extends E> c) ，containsAll(Collection<? extends E> c) ，removeAll(Collection<? extends E> c) 三个方法都是以集合为单位操作结合对象。
② 需要使用Collection接口，通常需要实例其实现类。为了操作方便，在对集合对象进行实例化时最好指定其存储的数据类型。
如：Collection collection=new ArrayList();

Collection接口的实现类

前面已经提到，Collection接口需要使用，需要通过构造其实现类来实现。接下来介绍Collection接口比较常用到的几个实现类。ArrayList类，LinkedList类,HashSet类。

ArrayList类 和LinkedList类

1、ArrayList类和LinkedList类都实现了Collection接口的子接口List接口。它们除了要实现Collection接口的一些方法，还需要实现List接口的一些常用方法。
（1）add(int index, E element) ——在指定位置插入指定元素，返回执行结果，这里添加的元素可以重复。
（2）get(int index) ——返回列表中指定位置元素。
（3）set(int index, E element) ——用指定元素去替代指定位置元素，返回被替代元素。
（4）indexOf(Object o) ——返回列表中元素第一次出现位置的索引，如果列表中不包含此元素，返回-1。
（5）lastIndexOf(Object o) ——返回列表中元素最后一次出现位置的索引，如果列表中不包含此元素，返回-1。
（6）sort(Comparator<? super E> c) ——使用随附的 Comparator排序此列表来比较元素，根据给定规则进行排序 ，默认字母表顺序。
2、ArrayList类没有对List接口做很大的变动，常用的方法基本上就是对List接口的实现。常用的构造方法有ArrayList()——构造一个初始容量为十的列表； ArrayList(Collection<? extends E> c) ——构造一个包含特定集合的列表。

实例 创建一个集合对象，对List接口的一些方法进行实现（以ArrayList实现类为例），打码如下：

	public static void main(String[] args) {
		//构造一个初始容量为十的列表
		ArrayList<String> arrayList=new ArrayList<String>();
		//向列表中添加元素 可以重复
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("hello");
		//返回指定索引处元素
		System.out.println(arrayList.get(1));
		System.out.println("---------------------");
		//返回指定元素第一次出现的索引
		System.out.println(arrayList.indexOf("hello"));
		System.out.println("---------------------");
		//返回指定元素最后一次出现的索引
		System.out.println(arrayList.lastIndexOf("hello"));
		System.out.println("---------------------");
		//for循环对集合进行遍历
		for (String s:arrayList) {
			System.out.println(s);
		}
		System.out.println("---------------------");
		//构造一个包含指定集合的集合
		ArrayList<String> list=new ArrayList<String>(arrayList);
		//对集合指定索引处元素进行修改
		list.set(2, "java");
		//for循环对集合进行遍历
		for (String s:list) {
			System.out.println(s);
		}
		System.out.println("---------------------");
		//按指定规则对集合排序 默认字母表顺序
		list.sort(null);
		//for循环对集合进行遍历
		for (String s:list) {
			System.out.println(s);
		}
	}

3、LinkedList类由于除了实现List接口外，还实现了Deque接口。所以LinkedList类除了能够实现对列表的一些基本操作，还可以操作列表的两端元素。同样的，也有两个常用的构造方法LinkedList() ——构造一个空列表；LinkedList(Collection<? extends E> c) ——构造一个包含特定集合的列表。
①addFirst(E e) ，addLast(E e)
②offerFirst(E e) ，offerLast(E e)
③getFirst() ，getLast()
④peekFirst() ，peekLast()
⑤removeFirst() ，removeLast()
⑥pollFirst() ，pollLast()
⑦pop() ，push(E e)
notes:
（1）①和②两组方法都是在列表首部或尾部添加指定元素，返回执行结果。在使用时两组方法可以替换
（2）③和④两组方法都是获取列表首部或尾部元素。当列表不为空的时候，两组方法可以替换使用。但当列表为空时，③中方法会抛出异常，④中方法会返回null。
（3）⑤和⑥两组方法都是删除列表首部或尾部元素，返回删除的元素。同（2）所述，当列表不为空的时候，两组方法可以替换使用。但当列表为空时，⑤中方法会抛出异常，⑥中方法会返回null。
（4）pop()方法，弹出列表中第一个元素，与removeFirst和pollFirst方法有点相似，当列表为空时，会抛出异常；push(E e)方法，在列表首部添加指定元素，与addFirst(E e)和offerFirst(E e)方法有点相似。

实例 测试LinkedList类对列表首尾元素的操作，代码如下：

	public static void main(String[] args) {
		LinkedList<String> linkedList=new LinkedList<String>();
		//添加元素
		linkedList.add("hello");
		linkedList.add("world");
		//在索引为0的位置添加元素
		linkedList.addFirst("java");
		//在末尾添加元素
		linkedList.offerLast("android");
		//遍历元素
		for(String str:linkedList) {
			System.out.println(str);
		}
		System.out.println("---------------");
		//返回索引为0的元素
		System.out.println(linkedList.getFirst());
		//检索末尾元素 存在返回该元素
		System.out.println(linkedList.peekLast());
		System.out.println("---------------");
		//删除索引为0的元素 返回该元素
		System.out.println(linkedList.removeFirst());
		//检索末尾元素 存在将其删除并返回
		System.out.println(linkedList.pollLast());
		System.out.println("---------------");
		//遍历元素
		for(String str:linkedList) {
			System.out.println(str);
		}
	}

HashSet类

1、HashSet类与ArrayList类和LinkedList类不同。它实现的是Collection接口的子接口Set接口。它与继承list类接口的类相比最大的区别就是HashSet中添加的元素是不能够重复的且HashSet是按照特定的算法进行存储数据的（有兴趣可以看看数据结构中哈希表的内容）。在外人看来是无次序的。主要的构造方法有new HashSet()。
如：HashSet hashSet=new HashSet();
2、如1中所述，HashSet不允许存储重复元素。如果存储的对象是自己定义的一个类，为了排序相同的数据，注意需要重写类的hashCode()方法和equals(Object obj)方法。（具体的原因会在后续文章中进行详细说明）。这里重写的方法可以右键–>Source–>Generate hashCode() and equals()…

实例 利用HashSet类存储几个Person对象，代码如下：

Person类代码

public class Person {
	private String name;
	private int age;
	//有参构造方法
	public Person(String name,int age) {
		this.name=name;
		this.age=age;
	}
	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;
	}
	//重写toString方法
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	//重写hashCode方法
	@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;
	}
	//重写equals方法
	@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;
	}	
}

main函数代码

	public static void main(String[] args) {
	    //构造HashSet对象
		HashSet<Person> hashSet=new HashSet<Person>();
		//构造Person对象
		Person p1=new Person("test",20);
		Person p2=new Person("test",20);
		//向HashSet添加Person对象
		hashSet.add(p1);
		hashSet.add(p2);
		//遍历HashSet
		for(Person p:hashSet) {
			System.out.println(p);
		}	
	}

Collection接口的遍历

1、上面的例题中也可以看出Collection接口的实现类都可以通过for循环遍历。此外，Collection接口也可以通过iterator迭代器进行遍历。使用迭代器分为三个步骤：
①创建迭代器对象。通过集合类的iterator()方法返回该集合的迭代器。
②判断集合中是否存在元素。通过hasNext()方法返回一个boolean值。
③获取集合元素。通过Next()方法返回集合元素。

实例 分别用for循环和iterator迭代器对列表进行遍历（以ArrayList为例），代码如下：

	public static void main(String[] args) {
		//创建集合对象
		Collection<String> collection=new ArrayList<String>();
		//向集合添加数据
		collection.add("hello");
		collection.add("world");
		collection.add("java");
		//强制转型
		((ArrayList<String>) collection).sort(null);
		//iterator迭代器
		Iterator<String> it=collection.iterator();
		//判断是否有元素 进行遍历
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		System.out.println("---------------------");
		//for循环遍历
		for (String str : collection) {
			System.out.println(str);
		}
	}

Collections类

1、Collections类是Collection接口的一个工具类。Collections类是一个全部由静态方法组成的类，其中包括了很多对集合复杂操作的封装，该类在使用时不需要实例化，可以直接使用。
2、Collections类提供了非常多对集合进行操作的方法。一些比较常用的有binarySearch(List list,Object key)，copy(List dest,List src)，reverse(List list)，shuffle(List list)，swap(List<?> list, int i, int j) 等。
（1）binarySearch(List list,Object key)。二分查找法（数据结构中的一个查找算法，有兴趣可以了解一下），传入参数列表对象和需要查找的元素，返回指定元素索引。优点在于比传统的查找方法速度快了很多。
（2）copy(List dest,List src)。将一个列表复制到另一个列表，目标列表的长度一定要大于或等于源列表长度。传入参数目标列表对象和原列表对象。
（3）reverse(List list)。反转列表中所有元素。传入列表对象。
（4）shuffle(List list)。将列表中元素进行无次序排列，每次执行的结果都会不同。传入列表对象。
（5）swap(List<?> list, int i, int j) 。将列表中指定索引处的两个元素地址进行交换。传入列表对象和需要交换位置元素的索引。

实例 实现上述方法（以ArrayList类为例），代码如下：

	public static void main(String[] args) {
		extracted();
		System.out.println("---------------");
		extracted_2();
		System.out.println("---------------");
		extracted_3();
		System.out.println("---------------");
		extracted_4();
		System.out.println("---------------");
		extracted_5();
	}
	
	//将列表指定位置索引进行置换
	private static void extracted_5() {
		List<Integer> list=new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		Collections.swap(list,0,3);
		System.out.println(list);
	}
	
	//随机置换列表元素
	private static void extracted_4() {
		List<Integer> list=new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		Collections.shuffle(list);
		System.out.println(list);
	}
	//反转列表元素
	private static void extracted_3() {
		List<Integer> list=new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		Collections.reverse(list);
		System.out.println(list);
	}
	
	//static void copy(List dest,List src)
	//目标列表的长度要大于或等于源列表长度
	private static void extracted_2() {
		List<String> src=new ArrayList<String>();
		List<String> dest=new ArrayList<String>();
		src.add("hello");
		src.add("world");
		dest.add("");
		dest.add("");
		dest.add("");
		Collections.copy(dest, src);
		System.out.println(dest);
	}
	
	//static int binarySearch(List list,Object key)
	//二分法查找
	private static void extracted() {		
		List<Integer> list=new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		int index=Collections.binarySearch(list, 4);
		System.out.println(index);
	}