黑马程序员_Java_Collection

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、集合概述

       集合是存储对象最常用的一种方式，方便操作对象，集合就是存储多个对象的一个容器。

       集合的特点：

       (1)只能存储对象；

       (2)长度可以发生改变；

       (3)可以存储多种类型对象。

       集合和数组的区别：

       (1)集合的长度是可变的；数组的长度是固定的。

       (2)集合只能存储对象；数组可以存储对象，也可以存储基本数据类型。

       (3)集合存储的数据类型是不固定的；数组存储的数据类型是固定的。

       集合的框架：不断向上抽取来的，是一个体系。

二、Collection

       Collection是层次结构中的根接口（顶层接口）。

Collection的常用子类：
    |--List:元素是有序的，元素可以重复。因为该集合体系有索引
    |--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但增删速度稍慢
    |--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢，线程不同步
    |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
    |--Set：元素是无序的，不可重复

1.方法

      添加元素：

               boolean add(E e)：此处的E可以当成Object去理解，将指定的元素添加到此列表的尾部。

               boolean addAll(Collection<? extends E> c)：将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

       删除元素：

        boolean remove(Object obj)：移除一个指定元素。

        boolean removeAll(Collection<?> c)：只在调用者中移除两集合中的共同元素。

        void clear()：清空集合

判断元素：

boolean contains(Objectobj)：如果此 collection 包含指定的元素，则返回true。

booleancontainsAll(Collection)：判断师傅含有指定集合中的元素，只有所有元素都包含才返回ture。

        booleanisEmpty()：判断是否为空。

获取：

int size()：获取集合长度，若为0，则为空。

int hasCode()：返回此Collection的哈希码值。

Iterator<E> iterator()：返回次元素上的迭代器，用于遍历集合中的元素。

取交集：

boolean retainAll()：只在调用者中爆裂共同的交集元素。

程序示例：

<span style="font-size:12px;">private static void base_method() {
		ArrayList al=new ArrayList();
		
		//1，添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		
		//2，获取个数
		sop(al.size());
		
		//3，删除元素
		al.remove("java03");
		
		//4，判断元素
		sop(al.contains("java02"));
		sop(al.isEmpty());
		sop(al);
	}</span>

2.Iterator

Iterator（迭代器），对 collection 进行迭代的迭代器，其实就是集合取出元素的方式，会直接访问集合中的元素。所以将迭代器通过内部类的形式来进行描述，通过容器的iterator()方法获得内部类的对象。迭代器取代了Enumeration。

迭代器的方法：

boolean hasNext()：用于判断集合中是否还存在元素，如果仍有元素可以迭代，则返回true。

E next()：返回迭代的下一个元素。

void remove()：移除迭代器中返回的元素。

迭代器使用程序示例：

<span style="font-size:12px;">private static void method_get() {
		
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		
		//第一种方式：获取迭代器，用于取出集合中的元素
//		Iterator it=al.iterator();
//		while(it.hasNext())
//		sop(it.next());
		
		//第二种方式：for循环回收迭代器内存
		for(Iterator it=al.iterator();it.hasNext();){
			sop(it.next());
		}
	}</span>

3、迭代注意事项

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。

迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object，所以要记得类型转换。

三、List

1.List概述

List组成：

List:元素是有序的，元素可以重复。因为该集合体系有索引
    |--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但增删速度稍慢
    |--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢，线程不同步
    |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

2.ArrayList

特有方法：凡是可操作角标的方法都是该体系特有的方法。
1.增
add(index,element)：在指定位置加入元素。
addAll(index,Conllection)：在指定位置添加指定集合中的所有元素；若省略位置参数，则默认在当前集合后面添加元素。

2.删
remove(index)：移除指定位置的元素。

3.改
set(index)：修改指定位置的元素。

4.查
get(index)：获取指定位置的元素。
subList(from,to)：截取部分元素。
ListIterator()：获取List特有的迭代器。

ListIteratro迭代器的特有方法：

add(obj)：增加

        set(obj)：修改为obj

        hasPrevious()：判断前面有没有元素

        previous()：取前一个元素

程序示例：

<span style="font-size:12px;">public class ListDemo {

	public static void main(String[] args) {
//		method();
		
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		sop(al);
		
		ListIterator lt=al.listIterator();
		while(lt.hasNext()){
			Object obj=lt.next();
			if(obj.equals("java02"))
				lt.add("java009");
		}
		sop(al);
		
		//在迭代过程中，添加或删除元素
		/*
		Iterator it=al.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			if(obj.equals("java02"))
				it.remove();
			sop(obj);
		}
		sop(al);
		*/
	}

	public static void method() {
		ArrayList al=new ArrayList();
		
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		sop(al);
		al.add(1,"java06");
		sop(al);
		
		//删除指定位置的元素
		al.remove(3);
		sop(al);
		
		//修改元素
		al.set(2, "java007");
		sop(al);
		
		//通过角标获取元素
//		sop(al.get(3));
		
		for(int i=0;i<al.size();i++){
			sop(al.get(i));
		}
		Iterator it=al.iterator();
		while(it.hasNext())
			sop(it.next());
		
		sop(al.indexOf("java007"));
		
		List sub=al.subList(1, 3);
		sop(sub);
	}

	public static  void sop(Object obj){
		System.out.println(obj);
	}
}</span>

3.LinkedList

LinkedList是List接口的链接列表实现，此实现不同步。

LinkedList特有方法:

addFirst()
addLast()
getFirst()：获取元素，但不删除元素
getLast()
  removeFirst()：获取元素，但元素被删除。如果集合中没有元素，会出现NoSuchElementException
removeLast()
  在JDK1.6后出现了替代方法
offerFirst()
offerLast()
  peekFirst()：获取元素，但不删除元素
peekLast()
pollFirst()：获取元素，但元素被删除。如果集合中没有元素，会返回null。
pollLast()

程序示例：

<span style="font-size:12px;">public class LinkedListDemo {

	public static void main(String[] args) {
		LinkedList  link=new LinkedList();
		link.addFirst("java01");
		link.addFirst("java02");
		link.addFirst("java03");
		link.addFirst("java04");
//		sop(link);
//		sop(link.getFirst());
//		sop(link.getLast());
//		sop(link.removeFirst());//取并删
		while(!link.isEmpty()){
			sop(link.removeLast());
		}
	}

	public static  void sop(Object obj){
		System.out.println(obj);
	}
}
</span>

四、Set

1.Set概述

Set组成：

Set:元素是无序（存入和取出的顺序不一定一致，元素不可重复。
|--HashSet:底层数据结构是哈希表
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成
如果元素的hashCode值相同，才会判断equals是否为true。
如果元素的hashCode值不同，不会调用equals。
注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
|--TreeSet:可以对Set集合中的元素进行排序
  底层数据结构是二叉树
  保证元素唯一性的依据：
   compareTo方法return 0
   TreeSet排序的第一种方式：让元素自身具备比较性。
  元素需要实现Comparable接口，覆盖compareTo方法
  这种方式也成为元素的自然顺序，或者叫默认顺序。
   TreeSet的第二种排序方式：
   当元素自身不具备比较性时，或者具备的比较性不是所需要的。
   这时就要让集合自身具备比较方式。

Set集合的功能和Collection是一致的

2.HashSet

HashSet：线程不安全，存取速度快。

      可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不

会调用equals。注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

程序示例：

<span style="font-size:12px;">class Demo{
	
}
public class HashSetDemo {

	public static void main(String[] args) {
//		Demo d1=new Demo();
//		Demo d2=new Demo();
//		sop(d1);
//		sop(d2);
		
		HashSet hs=new HashSet();
		sop(hs.add("java01"));
		sop(hs.add("java01"));
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");
		
		Iterator it=hs.iterator();
		while(it.hasNext()){
			sop(it.next());
		}
	}
	public static  void sop(Object obj){
		System.out.println(obj);
	}
}</span>

3.TreeSet

TreeSet：底层的数据结构是二叉树，可对Set集合中的元素进行排序。TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写com

pareTo方法，才能让对象按指定需求进行排序，并加入集合。通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。

TreeSet排序的第一种方式：

让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也叫元素的自然排序，或者叫做默认排序。

程序示例：

<span style="font-size:12px;">class Student implements Comparable{
	
	private String name;
	private int age;
	
	Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	
	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	public int compareTo(Object obj) {
		
//		return 1;
		
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s=(Student) obj;
		sop(this.name+"...compareto..."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age){
			return this.name.compareTo(s.name);
		}
		
			
		return -1;
		
	}
	public static  void sop(Object obj){
		System.out.println(obj);
	}
}</span>

TreeSet排序的第二种方式：

当元素自身不具备比较性时，或者具备的比较性不是所需要的，

这时就需要让集合自身具备比较性。定义比较器，将比较器对象作为参数传递给TreeSet构造函数。

比较器Comparator是一个接口，需定义一个类，实现Comparator接口，覆盖compare方法。

程序示例：

<span style="font-size:12px;">public class TreeSetDemo2 {
		public static void main(String[] args) {
			TreeSet ts=new TreeSet(new MyCompare());
			
			ts.add(new Student("lisi01",22));
			ts.add(new Student("lisi02",20));
			ts.add(new Student("lisi03",19));
			ts.add(new Student("lisi04",23));
			
			Iterator it =ts.iterator();
			while(it.hasNext()){
				Student stu=(Student) it.next();
				sop(stu.getName()+"..."+stu.getAge());
			}
		}

		public static  void sop(Object obj){
			System.out.println(obj);
		}
	}

class MyCompare implements Comparator{

	public int compare(Object o1, Object o2) {
		Student s1=(Student)o1;
		Student s2=(Student)o2;
		int num=s1.getName().compareTo(s2.getName());
		if(num==0)
			return s1.getAge()-s2.getAge();
		return num;
	}
	
}</span>