黑马程序员_集合（一）_List、Set

　------- android培训、java培训、期待与您交流！ ----------

 

 

数组和集合类的区别：

 

 

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能

 

 

储对象。

 

集合类的特点：

 

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

 

Collection接口：

 

List接口：可存放重复元素，元素存取是有序的。

 

Set：不可以存放重复元素，元素存取是无序的。

 

 

 

add方法的参数类型是Object，以便于接受任意类型对象。

 

 

集合中存储的都是对象的引用（地址）。

 

 

什么是迭代器：

 

 

其实就是集合的取出元素的方式。

 

 

迭代器的内部实现：

 

 

把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了

 

 

内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都有共性内容判断和取出。那

 

 

么可以将共性抽取。

 

 

Collection：

 

 

List:元素是有序的，元素可以重复。因为该集合体系有索引。

 

 

ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。当元素

 

 

超过10个，则自动延长，50%延长。

 

 

LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。

 

 

Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。当元素超出10个，100%延长。

 

 

List集合：

 

 1、添加：

 add(index,element);

 addAll(index,Collection);

 

 

2、删除：

 remove(index);

 

 

3、修改：

 set(index,element);

 

4、查询：

 get(index)；

 subList(from,to);

 listIterator();

 int indexOf(obj):获取指定元素的位置。

 ListIterator listIterator();

 

List集合特有的迭代器。ListIterator是Iterator的子接口。 

 

 

在迭代时，不可以通过集合对象的方法操作集合中的元素。

 

因为会发生ConcurrentModificationException异常。

 

 

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取

 

 

出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

 

 

该接口只能通过List集合的listIterator方法获取。

 

 

在迭代过程中，准备添加或者删除元素。

 

 

Iterator it = al.iterator();

		while(it.hasNext())
		{
			Object obj = it.next();

			if(obj.equals("java02"))
				al.add("java008");
				
		}

此时将抛出ConcurrentModificationException异常

 

 

 枚举就是Vector的特殊取出方式。

 

public static void main(String[] args) 
	{
		Vector v = new Vector();

		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");

		Enumeration en = v.elements();

		while(en.hasMoreElements())
		{
			System.out.println(en.nextElement());
		}
	}

 

 

LinkedList:

 

 

LinkedList的特有方法：

 

 

addFirst();

 

addLast();

 

getFirst();

 

getLast();获取元素，但不删除元素。如果集合中没有元素，则抛出异常。

 

 

removeFirst();

 

removeLast();获取元素，但是元素被删除，如果集合中没有元素，则抛出异常。

 

 

在JDK 1.6出现了替代方法:

 

 

offerFirst();

 

offerLast();

 

 

peekFirst();

 

peekLast();获取元素，但不删除元素。如果集合中没有元素，返回null。

 

 

pollFirst();

 

pollLast();获取元素，但是元素被删除，如果集合中没有元素，则返回null。

 

 

 练习：使用LinkedList模拟一个堆栈或者队列数据结构。

 

 

class DuiLie
{
	private LinkedList link;

	DuiLie()
	{
		link = new LinkedList();
	}
	
	public void myAdd(Object obj)//添加元素进入队列
	{
		link.addFirst(obj);
	}
	public Object myGet()//拿出元素，并移除这个元素
	{
		return link.removeFirst();
	}
	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");
		dl.myAdd("java04");

		while(!dl.isNull())//如果队列不为空，则取出元素
		{
			System.out.println(dl.myGet());
		}
	}
}

 

 

 练习：去除ArrayList集合中的重复元素。

 

 

class ArrayListTest 
{

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();//初始化一个ArrayList对象

		al.add("java01");//并添加元素
		al.add("java02");
		al.add("java01");
		al.add("java02");
		al.add("java01");

		sop(al);//打印原集合
		
		al = singleElement(al);

		sop(al);//打印去掉重复元素的集合
		

	}

	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器。
		ArrayList newAl = new ArrayList();

		Iterator it = al.iterator();//遍历原集合

		while(it.hasNext())
		{
			Object obj = it.next();

			if(!newAl.contains(obj))//如果新集合不包含这个元素则存入新集合
				newAl.add(obj);

		}

		return newAl;
	}
}

 

 

 

Set集合：

 

 

Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。

 

HashSet:底层数据结构是哈希表。是线程不安全的。不同步。

 

   HashSet保证元素的唯一性：

 

 

   1、是通过元素的两个方法，hashCode和equals来完成。

 

   2、如果元素的HashCode值相同，才会判断equals是否为true。

 

   3、如果元素的hashcode值不同，不会调用equals。

 

 

对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

 

 

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

 

练习：往hashSet集合中存入自定对象姓名和年龄相同为同一个人，重复元素。

 

 

class HashSetTest 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();//定义一个HashSet
		
		//向这个集合中添加自定义元素
		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));		
		
		//遍历这个集合
		Iterator it = hs.iterator();

		//打印集合中的内容
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
}
class Person
{
	private String name;//人的属性
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	//覆盖hashCode值和equals方法
	public int hashCode()
	{
		System.out.println(this.name+"....hashCode");
		return name.hashCode()+age*37;
	}

	//如果姓名和年龄相同就为同一个人
	public boolean equals(Object obj)
	{

		if(!(obj instanceof Person))
			return false;

		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;
	}
}

 

 

 TreeSet集合：

 

 

 可以对Set集合中的元素进行排序。底层数据结构是二叉树。

 

 

保证元素唯一性的依据：compareTo方法return 0.

 

 

TreeSet排序的第一种方式：让元素自身具备比较性。

 

元素需要实现Comparable接口，覆盖compareTo方法。

 

也种方式也成为元素的自然顺序，或者叫做默认顺序。

 

 

TreeSet的第二种排序方式：

 

当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合

 

 

初始化时，就有了比较方式。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

 

 

 当两种排序都存在时，以比较器排序为主。

 

 

练习：按字符串长度排序

 

class  TreeSetTest
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new StrLenComparator());//创建一个TreeSet，并传入一个比较器

		ts.add("abcd");//添加元素
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");

		Iterator it = ts.iterator();//遍历打印这个集合，查看排序结果

		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

class StrLenComparator implements Comparator
{
	public int compare(Object o1,Object o2)//覆盖compare方法
	{
		String s1 = (String)o1;
		String s2 = (String)o2;
			
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));//字符串按长度从短到长排序
		if(num==0)
			return s1.compareTo(s2);

		return num;
	}
}

  

 

 

　------- android培训、java培训、期待与您交流！ ----------