黑马程序员—集合框架小结

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------

集合框架

----Collection集合

----List集合:元素有序的且可以重复

----Set集合：元素是无序的不可以重复

----Map集合

集合用于存储对象，长度不限，可以存储不同类型的对象

下面是是一些共性方法

1、添加（add()）add方法的参数类型是Object 集合存储的是对象的引用（地址）

2、取得集合的长度（size()）

3、删除指定对象(remove(ele)) 清空集合（clear()） 

4、判断 contains(对象)  isEmpty();

5、取得两个集合的交集(retainAll(另一个集合))

6、消除相同的对象(removeAll(另一个集合))

怎么取得集合中的元素

通过一个对外提供的方法：iterator()

一、List集合

----ArraryList：底层的数据结构是数组（查询速度快，增删慢）

----LinkedList:底层的数据结构是链表（增删速度快，查询速度慢）

下面是List的特有方法：凡是可以操作角标的方法都是List的特有方法

增：add(index,element) addAll(index,Collection)

删:remove(index)

改：set(index,element)

查:get(index)  subList(from ,to)  indexOf(str);

 

List集合特有的迭代器：ListIterator

在迭代的时候不可以通过集合的方法操作集合中的元素，Interator只能进行判断和删除，如果要进行添加修改的话就得使用ListIterator

LinkedList的特有方法：

增：AddFirst() addLast()

删：removeFirst();removeLast()

查：getFirst();getLast();

 

 

List 集合判断元素是否相同依据的是元素的equals方法 remove也是调用了equals方法。下面就是一个具体的例子说明

 

去除集合中的重复元素

import java.util.*;
class Person
{
	private String name;
	private int age;
	public  boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		Person p=(Person)obj;
		return this.name==p.name&&this.age==p.age;
			
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
}
public class ArraryListTest2 
{
	public static void main(String[] args)
	{
		ArrayList<Person> al=new ArrayList<Person>();
		al.add(new Person("zhangsan",21));
		al.add(new Person("zhangsan",22));//Object obj=new Person();
		al.add(new Person("zhangsan",23));
		al.add(new Person("zhangsan",21));
		al.add(new Person("zhangsan",22));
		al=method(al);
		
		sop(al.remove(new Person("zhangsan",23)));//remove也是调用了person中的equals方法
		Iterator it=al.iterator();
		while(it.hasNext())
		{	
			Person p=(Person)it.next();
			sop(p.getName()+"....."+p.getAge());
		}
		
		
		
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static ArrayList method(ArrayList al)
	{
		ArrayList<Object> newal=new ArrayList();
		Iterator<Object> it=al.iterator();
		while(it.hasNext())
		{
			Object obj=it.next();
			if(!newal.contains(obj))//调用的是equals方法。
				newal.add(obj);
		}
		return newal;
		
	}
	
}

二、Set集合

---HashSet：底层的数据结构是哈希表

---TreeSet：可以对Set集合的元素进行自然排序

Set的功能和List的方法是一样的

 

1、HashSet

HashSet是通过hashcode()和equals()的方法保证元素的唯一性

若hashcode的值相同才会调用equals方法，若hashcode值不同equals方法就不会被调用

下面的应用时去除重复元素：

import java.util.HashSet;
import java.util.Iterator;


public class HastSetDemo
{
	public static void main(String[] args)
	{
		HashSet sh=new HashSet();
		sh.add(new person("lishi",14));
		sh.add(new person("lishi",12));
		sh.add(new person("lishi",12));
		sh.add(new person("lishi",13));
		sh.add(new person("zhangsan",14));
		pri(sh);
		
	}
	public static void pri(HashSet sh)
	{
		Iterator it=sh.iterator();
		while(it.hasNext())
		{
			person p=(person)it.next();
			System.out.println(p.getName()+"....."+p.getAge());
		}
	}
	
}
class person
{
	private String name;
	private int age;
	public person(String name, int age) {
		this.name=name;
		this.age=age;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	public  boolean equals(Object obj )
	{
		if(!(obj instanceof person))
			return false;
		person p=(person)obj;
		return p.name.equals(this.name) && p.age==this.age;
		
	}
	public int hashCode()
	{
		return name.hashCode()+age;
	}
	

　　}

2、TreeSet

底层结构是二叉树 可以对集合中的元素进行排序（这就要求集合中的元素具备比较性）

排序的方式有两种：

第一种：实现comparable接口覆盖compareTo方法这是让元素自身具备比较性

第二种：在元素自身不具备比较性或者具备的比较性不是需要的，这样我们要让集合具备比较性，方法是实现comparator接口，复写compare方法

如果两种方式都存在的话，以比较器为主。

import java.util.*;

public class TreeSetDemo 
{
	public static void main(String[] args)
	{
		TreeSet ts=new TreeSet(new camp());//以比较器比较
		ts.add(new student("zhangsan",11));
		ts.add(new student("lishi3",14));
		ts.add(new student("lishi3",11));
		ts.add(new student("lishi2",11));
		ts.add(new student("lishi1",12));
		
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			student p=(student)it.next();
			System.out.println(p.getName()+"....."+p.getAge());
		}
	}
	
}
class student implements Comparable
{
	private String name;
	private int age;
	public student(String name, int age) {
		this.name=name;
		this.age=age;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}

	public int compareTo(Object obj)
	{
		//按年龄排序，弱年龄相同就按姓名的自然顺序排序。
		if(!(obj instanceof student))
			throw new RuntimeException("....");
		student p=(student)obj;
		if(this.age>p.age)
			return 1;
		if(this.age==p.age)
			{
				return this.name.compareTo(p.name);
			}
		return -1;
		//是怎么存进去就怎么取出来
		//return 1;
		
	}
}
class camp implements Comparator
{

	public int compare(Object o1, Object o2)
	{
		student s=(student)o1;
		student s1=(student)o2;
		int num=s.getName().compareTo(s1.getName());
		if(num==0)
		{
			return new Integer(s.getAge()).compareTo(new Integer(s1.getAge()));
			/*
			if(s.getAge()>s1.getAge())
				return 1;
			else if(s.getAge()==s1.getAge())
				return 0;
			return -1;*/
		}
		return num;
	}
　　}
　　

三、泛型

在jdk 1.5以后出现的新特性，用于解决安全问题

好处：将运行时期的问题转到编译时期

避免强制类型转换的麻烦

1、什么时候定义泛型？

当类中要操作的引用数据类型不确定的时候早期一般使用Object来完成扩展，现在通过泛型。

2、泛型格式：通过<>来定义要操作引用的数据类型

//泛型类跟泛型方法的应用

//静态方法不能引用类定义的泛型，可以将泛型定义在方法上

public class fanXinDemo 
{
	public static void main(String[] args)
	{
		Demo<String> d1=new Demo<String>();
		d1.show("ss");
		d1.print(4);
		Demo.method("dddd");
	}
}
 
class Demo<T>
{
	public void show(T t)
	{	
		System.out.println(t);
	}
	public<Q> void print(Q q)//泛型方法
	{
		System.out.println(q);
	}
	public static<X> void method(X x)
	{
		System.out.println(x);
	}
	
　　}

3、泛型的限定

? extends E:可以吸收E和E的子类型，上限

? Super E：可以吸收E和E的父类型，下限

　　public static void printl(TreeSet<? extends Person> ts)//上限
　　	{
　　		Iterator<? extends Person> it=ts.iterator();
　　		while(it.hasNext())
　　		{
　　			Person p=(Person)it.next();
　　			System.out.println(p.getName()+"....."+p.getAge());
　　		}
　　	}
　　}

四、Map集合

该集合在存储键值是成对的往里存而且要保证元素的唯一性

1、方法

i. 删除：clear();remove(Object key)

ii. 判断：containsValue(Object Value)

  containsKey(Object key)

 

iii. 

获取：get(Object key);size();

Values();entrySet();keySet()

iv. 添加：put(key,Value);putAll();

2、Map集合两种取出元素的方式

i. keySet

将Map集合中的所有键取出存入Set集合。通过迭代器取得Set集合中的键值，再通过get(key)取出每个键值所对应的Value；

ii. entrySet

将Map集合中的映射关系（Map.Entry<key,value>）存入Set集合中，再通过getKey(),getValue()方法取得对应的键和值。

下面就是Map集合方法的操作和取出元素的方法

import java.util.*;

public class hashMapDemo
{
	public static void main(String[] args)
	{
		HashMap<String, String> hm=new HashMap<String, String>();
		hm.put("java01", "xxx1");
		hm.put("java02", "xxx2");
		hm.put("java03", "xxx3");
		hm.put("java04", "xxx4");
		//System.out.println(hm);
		//sop(hm.containsValue("java01"));//false
		//sop(hm.containsKey("java01"));//true
		hm.remove("java01");
		//sop(hm);
		//sop(hm.get("java02"));
		//sop(hm.values());
		
		//下面是Map的种取出方式
		/*Set<String> ss=hm.keySet();
		Iterator<String> it=ss.iterator();
		while(it.hasNext())
		{
			String s=it.next();
			String s1=hm.get(s);
			sop(s+"..."+s1);
		}*/
		//第二种
	
		Set<Map.Entry<String,String>> ss=hm.entrySet();
		Iterator<Map.Entry<String,String>> it=ss.iterator();
		while(it.hasNext())
		{
			Map.Entry<String, String> s=it.next();
			String s1=s.getKey();
			String s2=s.getValue();
			sop(s1+"..."+s2);
		}
		//用高级for也可以取出
		/*for(String str:hm.keySet())
		{
			String value=hm.get(str);
			sop(str+"..."+value);
		}*/
		
		
		
		
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

五、集合工具类

一、Collections工具类：

给list集合排序。

下面是一些Collections的方法：

1、以比较器给集合排序

sort(List<T> list, Comparator<? super T> c)

2、使用二分搜索法搜索指定列表，以获得指定对象。

binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

3、根据元素的自然顺序，返回给定 collection 的最大元素。

max(Collection<? extends T> coll)

4、 返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

reverseOrder(Comparator<T> cmp)

5、使用默认随机源对指定列表进行置换。

shuffle(List<?> list)

二：Arrays

用于操作数组的工具类，里面都是静态

把数组变成集合

asList(T... a)
          返回一个受指定数组支持的固定大小的列表。

可以使用集合的思想和方法操作数组。但是不可以使用集合的增删方法。因为数组的长度是固定的。

如果数组中的元素都是对象，那么变成集合数组的元素直接转成集合元素。

如果数组中的元素都是基本数据类型，那么将该数组作为集合的元素。

 

 * 里面都是静态方法*/
public class ArrarysDemo {
	public static void main(String[] args) {
		// aslist_method();
		toArrary_method();
	}

	public static void toArrary_method() {
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		String[] arr = al.toArray(new String[al.size()]);// 调用的是Collections中的toArrary方法
		sop(Arrays.toString(arr));

	}

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

	public static void aslist_method() {
		int[] arr = { 2, 3, 4 };
		sop(Arrays.toString(arr));
		String[] str = { "aa", "bb", "dd" };
		List<String> ls = Arrays.asList(str);
		sop(ls);// 因为str里的是对象。所以输出的元素就是数组的元素。
		List lss = Arrays.asList(arr);
		sop(lss);// 是将arr作为集合的元素
		// 数据变集合可以通过集合的一些方法来判断数组但是不能使用集合的增删方法，因为数组的长度是固定的
		sop(ls.contains("aa"));
	}
}

三、高级for循环

for(数据类型 名称：集合或数组)

高级for循环只能获取，不能对集合操作，迭代器还可以进行remove集合中的元素的动作。如果是ListIterator还可以进行增改操作。

传统for和高级for的差别

高级for必须要有遍历的目标，在遍历数组的时候还是建议用传统for，因为对数组的操作有涉及到角标。

ArrayList<String> al = new ArrayList<String>();

for(String s :al) { sop(s); }

 */// 这个方法只能获取。不能对集合进行其他动作

 

------------------------ ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ 

----------------------详细请查看：http://edu.csdn.net