集合

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

集合和数组都是存储对象的一种容器

区别：数组是固定长度的，固定类型的，集合长度是可变的，可以存储不同的数据类型。特别的是集合中存放的不是对象实体而是对象的地址值。

创建一个集合容器：

使用Collection接口的非抽象子类，如ArrayList

ArrayList al=new ArrayList();

1.添加元素
al.add()
add方法中的参数类型是Object，以便于接收任何类型的对象
2.获取个数，集合长度
al.size()
3.删除元素
al.remove("元素")
al.clear()//清空集合
4.判断元素
al.contains("元素")
al.isEmpty()//判断集合是否为空
取交集 al1.retainAll(al2),al1只保留交集

迭代器 ：就是集合取出元素的方式。

hasNext()正向遍历，hasPrevious()逆向遍历

 

import java.util.*;


public class CollectionDemo 
{

	public static void main(String[] args)
	{
		List list = new ArrayList();
		
		list.add(1);//将元素添加到集合中
		list.add(2);
		list.add(3);
		list.add(4);
		sop("集合长度:"+list.size());
		Iterator it = list.iterator();
		while(it.hasNext())//判断迭代器关联的集合是否为空
		{
			sop("集合元素:"+it.next());//取出集合元素
		}
	}
	public static void sop(Object obj)
		{
		System.out.println(obj);
		}

}

 

 

 

Collection
|--List 元素的有序的，元素可以重复，因为该集合体系有索引
|--ArrayList 底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢。线程不同步
|--LinkedList 底层使用的是链表数据结构，特点：增删速度很快，查询速度稍慢
|--Vector 底层是数据数据结构，线程同步，被ArrayList替代了
|--Set  元素是无序的(存入和取出的顺序不一致)，且元素不可重复，Set的功能和Collection的是一致的
|--HashSet 底层数据结构是哈希表，线程是非同步的
HashSet是如何保证唯一性的？
是通过元素的两个方法，hashCode和equals来完成。复写Object的两个方法
如果元素的HashCode相同才会判断equals是否为true。
如果HashCode不同，则不会调用equals。

 

import java.util.*;
public class CollectionDemo 
{
	public static void main(String[] args)
	{
		List list = new ArrayList();
		list.add(1);//将元素添加到集合中
		sop(list.size());//集合长度
		list.remove(0);//移除角标为0的元
		list.set(0, 2);//修改角标为0的元素
		list.get(0);//获取角标为0的元素	}
	public static void sop(Object obj)
		{
		System.out.println(obj);
		}

}

 

import java.util.*;
class PersonDemo 
{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}

	PersonDemo(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int hashCode()
	{
		return name.hashCode()*22;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof PersonDemo))
			return false;
		PersonDemo p = (PersonDemo)obj;
		
		return this.name.equals(p.name)&&this.age==p.age;
		
	}
	
}
public class CollectionDemo 
{

	public static void main(String[] args)
	{
		HashSet set = new HashSet();
		
		set.add(new PersonDemo("张三",18));
		set.add(new PersonDemo("李四",23));
		set.add(new PersonDemo("王五",23));
		set.add(new PersonDemo("张三",20));
		
		sop("集合长度:"+set.size());
		Iterator it = set.iterator();
		while(it.hasNext())//判断迭代器关联的集合是否为空
		{
			PersonDemo p = (PersonDemo)it.next();
			sop(p.getName()+"---"+p.getAge());//取出集合元素
		}
	}
	public static void sop(Object obj)
		{
		System.out.println(obj);
		}

}

Map集合：该集合存储键值对，一对一对往里存，而且要保证键的唯一性。

 

 

 

|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低
|--HashMap：底层是哈希表数据结构，允许使用null键和null值，该集合是非线程同步的。JDK1.2，效率高。
可以通过get方法的返回值来判断一个键是否为空。
|--TreeMap：底层是二叉树结构，线程不同步，可以用于给map集合中的键进行排序。其实Set集合底层就是使用了Map集合。

Map集合的取出方式：

 

import java.util.*;
class Student implements Comparable<Student>//定义泛型，实现Comparable接口让集合自身具备比较性
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public int compareTo(Student s)//复写compareTo()方法进行自然排序
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));

		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	//复写Object的hashCode()和equals()方法，保证元素的唯一性
	public int hashCode()
	{
		return name.hashCode()+age*34;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");

		Student s = (Student)obj;

		return this.name.equals(s.name) && this.age==s.age;
		

	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+":"+age;
	}
}



class  MapTest
{
	public static void main(String[] args) 
	{
		HashMap<Student,String> hm = new HashMap<Student,String>();

		hm.put(new Student("lisi1",21),"beijing");
		hm.put(new Student("lisi1",21),"tianjin");
		hm.put(new Student("lisi2",22),"shanghai");
		hm.put(new Student("lisi3",23),"nanjing");
		hm.put(new Student("lisi4",24),"wuhan");

		//第一种取出方式 keySet

		Set<Student> keySet = hm.keySet();//将Map集合的键作为Set集合元素

		Iterator<Student> it = keySet.iterator();//关联迭代器

		while(it.hasNext())
		{
			Student stu = it.next();//获取键
			String addr = hm.get(stu);//通过键获取值
			System.out.println(stu+".."+addr);
		}


		//第二种取出方式 entrySet
		Set<Map.Entry<Student,String>> entrySet = hm.entrySet();//将Map集合的键值关系作为Set集合的元素

		Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
		
		while(iter.hasNext())
		{
			Map.Entry<Student,String> me = iter.next();//将迭代获取的元素存入Map集合
			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu+"........."+addr);
		}
	}
}