黑马程序员--集合（一）

黑马程序员--集合（一）

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

集合类

一、概述

1、集合类：储存对象最常用的方式的方式之一。数据多了用对象存，对象多了用集合存。
集合类的特点：只用于存储对象，长度可变，可存储不同类型的对象。
PS：
集合类和数组都是容器，有何不同？
数组长度固定，且只能存相同类型的对象。
集合长度可变；数组可储存基本数据类型，集合只能储存对象。

2、集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。
任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。
集合框架的优点：
简化程序设计；提高程序效率；提高API的使用效率；提高代码复用性。
集合框架的构成和分类：

二、Collection接口

框架的顶层-->Collection接口：
1、常见方法：
1.1添加：
boolean add(Object obj);
boolean addAll(Collection coll);
1.2删除
boolean remove(Object obj);
boolean removeAll(Collection coll);
void clear();
1.3判断
boolean contains(Object obj);
boolean containsAll(Collection coll);
boolean isEmpty();判读集合中是否有元素。
1.4获取
int size();
Iterator iterator()：返回迭代器接口。
迭代器接口：对所有Collection容器进行元素取出的公共接口。
具体方法：
hasNext():若仍有元素可迭代，则返回true。
next():返回迭代的下一个元素。

remove():从迭代器指向的collection中移除迭代器返回的最后一个元素。

PS：
由于不同集合数据结构不同，造成每一个集合存取的方式可能不同。一般当我们需要多个动作（判断、取出）
才能完成一个动作的取出时，我们就将取出动作封装成一个对象。同时，因为其操作元素在集合中，
通过定义内部类，取出方式就可以直接访问集合内容元素。同时，我们将内部类都符合的取出方式规则定义在Iterator接口中，
通过iterator()方法获取。
1.5其他
boolean retainAll(Collection coll)：取交集
Object toArray()：将集合转成数组

import java.util.*;
/*
1.add方法的参数类型是Object.以便于接收任意类型对象。
2.集合中存储的都是对象的引用（地址）。
3.集合变数组。
Collection接口中的toArray方法。
3.1指定类型的数组到底要定义多长？
当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组。
当指定类型的数组长度大于集合的size，就不会创建一个新的数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组内存处置最优。
3.2为什么要将集合变数组？
当不需要对集合元素增删时，可限定对元素的操作。因为数组长度固定。
*/
class CollectionDemo
{
	public static void main(String[] args)
	{
		base_method();
		other_method();
	}
	public static void base_method()
	{
		Collection col1 = new ArrayList();

		//添加元素
		col1.add("java01");
		col1.add("java02");
		col1.add("java03");
		sop("col1添加："+col1);

		Collection col2 = new ArrayList();
		col2.addAll(col1);
		sop("col2添加："+col2);		

		//删除元素
		sop("删除java02："+col1.remove("java02"));
		col1.clear();
		sop("清空后集合"+col1);

		//判断元素
		sop("java03是否存在："+col1.contains("java03"));
		sop("col2是否为空？"+col2.isEmpty());
		
		//获取
		sop("获取col2中元素个数:"+col2.size());
		//获取迭代器，取出集合中的元素。接口性引用只能指向自己的子对象。it随for循环结束而释放，更节省内存。
		for(Iterator it = col2.iterator();it.hasNext();)
		{
			System.out.print(it.next()+" ");
		}
		System.out.println();

		Collection col3 = new ArrayList();

		col3.add("java02");
		col3.add("java05");

		sop("col2:"+col2);
		
		//取交集，去除交集
		col3.retainAll(col2);
		sop("取交集:"+col3);

		col3.removeAll(col2);
		sop("移除相同元素:"+col3);
	}
	public static void other_method()
	{
		Collection<String> col4 = new ArrayList<String>();

		col4.add("abc1");
		col4.add("abc2");
		col4.add("abc3");

		//将集合转成数组
		String[] arr = col4.toArray(new String[col4.size()]);
		
		sop("集合转数组："+Arrays.toString(arr));
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

运行结果：

2、List、Set接口

2.1 List接口
2.1.1 List常见方法：
这些方法有一个共性特点：都可以操作角标。
2.1.1.1 添加
void add(index,element);
void addAll(index,Collection);
2.1.1.2 删除
Object remove(index);
2.1.1.3 修改
Object set(index,element);
2.1.1.4 获取
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(form,to);//展现列表

import java.util.*;
class ListDemo
{
	public static void main(String[] args)
	{
		base_method();
	}
	public static void base_method()
	{
		List li = new ArrayList();

		//添加元素
		li.add("java01");
		li.add("java03");
		li.add("java03");
		
		sop("添加元素："+li);

		//删除指定位置的元素
		li.remove(2);
		sop("被删除后的集合："+li);	

		//修改元素
		li.set(1,"java02");
		sop("被修改后的集合"+li);

		li.add(2,"java02");
		sop("定点添加："+li);

		//通过角标获取元素
		sop("get(1):"+li.get(1));

		//获取所有元素
		for(int x=0;x<li.size();x++)
		{
			System.out.print("li("+x+")="+li.get(x)+" ");
		}
		System.out.println();

		for(Iterator it = li.iterator();it.hasNext();)
		{
			System.out.print("next:"+it.next()+" ");
		}
		System.out.println();

		//通过indexOf获取对象的位置
		sop("index="+li.indexOf("java02"));
		sop("lastIndexOf:"+li.lastIndexOf("java02"));

		List sub = li.subList(0,3);
		sop("sub"+sub);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);		
	}
}

运行结果：

2.1.1.5 ListIterator接口
ListIterator接口是Iterator的子接口。它是List集合特有的迭代器。它只能通过listIterator()方法获取。
Iterator方法只能对元素进行判断、取出、删除的操作，当迭代器需要增加元素等操作时，必须通过集合的方法，
这是会出现并发访问异常，存在安全隐患。ListIterator接口扩展了Iterator接口功能。避免了混合使用集合问题。
ListIterator接口常见方法：
add();
hasNext():正向遍历； 
hasPrevious():逆向遍历； 
next()：返回列表中下一个元素；
previous():返回列表中的前一个元素；
remove()：移除元素；
set():替换。

//获取数据的方法有两种：迭代器和集合，当两种方式混合使用时，会发生-->并发访问异常。
import java.util.*;
class ListDemo2
{
	public static void main(String[] args) 
	{
		iterator_method();
	}
	public static void iterator_method()
	{
		//演示列表迭代器
		List li = new ArrayList();
		//添加元素
		li.add("java01");
		li.add("java02");	
		li.add("java03"); 
		sop("li="+li);
		
		//本例中，li是集合；it是迭代器。当两种方式访问同一数据时，会存在安全隐患。
		for(Iterator it = li.iterator();it.hasNext();)
		{
			//因为要判断的it.next()要==java02,所以obj（即it）为java01。
			Object obj = it.next();
			if(obj.equals("java02"))
				//因为迭代器只有移除方法，没有添加，所以需要借助集合的add()方法。
				li.add("java008"); 
				it.remove();
			//会输出java01，因为remove只移除了引用，对象还存在。
			sop("obj="+obj);
			sop("li="+li);
		}	
		sop(li);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

运行结果：

/*
List定义了自己的迭代器接口：ListIterator()。避免Itetator接口中可使用方法较少，混合使用集合和迭代器的问题。
ListIterator是Iterator的子接口。该接口只能通过List集合的listIterator方法获取。
*/
import java.util.*;
class ListDemo3
{
	public static void main(String[] args) 
	{
		iterator_method();
	}
	public static void iterator_method()
	{
		//演示列表迭代器
		List li = new ArrayList();
		//添加元素
		li.add("java01");
		li.add("java03"); 
		li.add(1,"java02");	
		sop("li="+li);

		//其可以增、改、查的原因是它带角标。
		ListIterator lit = li.listIterator();
		
		//判断迭代前有没有元素	
		sop("hasPrevious():"+lit.hasPrevious());
		while(lit.hasNext())
		{
			Object obj = lit.next();
			
			//替换元素
			if(obj.equals("java02"))
				lit.set("java007");
		}
		//判断迭代后有没有元素
		sop("hasNext():"+lit.hasNext());
		sop("hasPrevious():"+lit.hasPrevious());	
		sop("li="+li);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

运行结果：

2.1.2List分类：
List:元素是有序的，元素可以重复。因为该集合体系有索引。
  |--Vector:底层是数组数据结构。线程同步。Vector生成20容量的数组，但是较浪费空间。被ArrayList替代。
  |--ArrayList:底层是数组数据结构。线程不同步。特点：查询块；增删慢。可变长度数组：超过10后，生成15容量的数组。
  |--LinkedList:底层使用的链表数据结构。特点：增删快；查询慢。

import java.util.*;
class LinkedListDemo
{
	public static void main(String[] args)
	{
		LinkedList link = new LinkedList();
	
		//先存的为尾
		link.addFirst("java01");
		link.addFirst("java02");
		link.addFirst("java03");

		sop("link="+link);

		sop("获取尾元素:"+link.getFirst());
		
		sop("获取头元素:"+link.getLast());

		sop("移除尾元素:"+link.removeFirst());

		sop("link="+link);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

运行结果：

JDK1.6后方法：

/*
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出  如同杯子。
队列：先进先出  如同水管。
*/

import java.util.*;
class DuiLie
{
	private LinkedList link;
	DuiLie()
	{
		link = new LinkedList();
	}
	//先入的为尾
	public void myAdd(Object obj)
	{
		link.offerFirst(obj);
	}
	//获取并删除先存入的元素
	public Object myGet()
	{
		return link.pollLast();
	}
	public boolean isNull()
	{
		return link.isEmpty();
	}
}
class LinkedListTest
{
	public static void main(String[] args)
	{
		DuiLie dl = new DuiLie();

		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		
		while(!dl.isNull())
		{
			System.out.print(dl.myGet()+" ");
		}
		System.out.println();
	}
}

运行结果：

PS：
Enumeration（枚举）：是Vector特有的取出方式。枚举和迭代功能一样。

2.2 Set接口
Set接口中元素不可以重复，无序（存入和输出顺序不一定一致）。它的方法和Collection一致。

HashSet保证元素唯一性原理：判断元素的hashCode值是否相同。
如果元素的哈希值相同，才会判断对象内容是否相同。

PS：
1、判断元素是否存在，以及删除等操作，HashSet依赖的方法是元素的hashCode和equals方法；
而ArrayList只依赖equals方法。TreeSet保证元素唯一性的依据compareTo方法。
原因：数据结构不同，所依赖方法也不一样。
2、让HashSet无序变有序，可使用LinkedHashSet。 

import java.util.*;
/*
通过hashSet集合判断Person对象是否相同。姓名和年龄相同视为重复元素。
*/
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	//复写hashCode()
	public int hashCode()
	{
		//看hashCode的调用记录
		System.out.println(this.name+"....hashCode()");
		//字符串name有自己的hashCode值，排除和相同的情况
		return name.hashCode()+age*37;
	}	
	//复写equals	
	public boolean equals(Object obj)
	{		
		if(!(obj instanceof Person))
			return false;

		//向下转型。因为要使用Person自己的方法。
		Person p = (Person)obj;
		System.out.println(this.name+"...equals.."+p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class HashSetTest
{
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();

		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a4",13));

		for(Iterator it = hs.iterator();it.hasNext();)
		{
			Person p = (Person)it.next();
			sop(p.getName()+"...."+p.getAge());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

运行结果：

2.2.1TreeSet排序
a 元素的自然顺序（默认顺序）。让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。

/*
需求：往TreeSet集合中存储自定义对象学生。按照学生的年龄进行排序。

注意：排序时，当主要条件相同时，一定判断一下次要条件。
Comparable是一个接口，用于强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。
compareTo():比较此对象与指定对象的顺序。返回负数、零、整数。
ClassCastException:类型转换异常。
*/
import java.util.*;
//Comparable接口强制让学生具备比较性
class Student implements Comparable
{
	private String name;
	private int age;

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	//复写compareTo()
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;
		
		System.out.println(this.name+"...compareto..."+s.name);

		int temp = this.age-s.age;

		//有具体返回值可以用三元运算符，年龄相同，再按名字排。
		return temp==0?this.name.compareTo(s.name):temp;
	}

	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class TreeSetDemo
{
	public static void main(String[] args)
	{
		TreeSet ts = new TreeSet();

		//所存元素必须具备比较性， TreeSet()才能排序。
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi04",20));
		ts.add(new Student("lisi02",19));
		ts.add(new Student("lisi01",20));
	
		for(Iterator it = ts.iterator();it.hasNext();)
		{
			Student stu = (Student)it.next();//向下转型。
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}

运行结果：

b 自定义比较器。让集合自身具备比较性：定义一个类，实现Comparator接口，覆盖compare方法。将该类对象
作为参数传递给TreeSet集合的构造函数。这种方法适用于：元素自身不具备比较性或不具备自己所需的比较性。
当两种方式都存在时，以比较器为主。

/*
练习：按照字符串长度排序。
自定义比较器：元素自身不具备比较性或不具备自己所需的比较性。
*/
import java.util.*;
class TreeSetTest
{	
	public static void main(String[] args)
	{
		TreeSet ts = new TreeSet(new StrLenComparator());

		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("z");
		ts.add("hahhaha");
	
		for(Iterator it = ts.iterator();it.hasNext();)
		{
			System.out.println(it.next());
		}
	}
}
//实现Comparator接口，覆盖compare方法。
class StrLenComparator implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		String s1 = (String)o1;	
		String s2 = (String)o2;	
		
		//String类的compareTo方法
		int num =new Integer(s1.length()).compareTo(new Integer(s2.length()));

		if(num==0)
			//主要条件符合，判断次要条件
			return s1.compareTo(s2);
		return num;
	}

}

运行结果：