黑马_blog4_集合框架

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

 

1集合框架（体系概述）

为什么会出现这么多的容器呢？

因为每一个容器对数据的存储方式都有不同，这个存储方式可以称之为：数据结构--数据在内存中的存储方式。

2集合框架（共性方法）

引入的包：import java.util.*;

创建一个集合容器，使用Collection接口的子类ArrayList

ArrayList aL=new ArrayList();

添加元素：aL.add(“java01”);

获取集合长度：aL.size();

打印集合：System.out.println(aL);

删除元素：aL.remove(“java02”);

  aL.clear();

判断元素：aL.contains(“java03”);//是否包含

          aL.isEmpty();//集合是否为空

取交集：aL1.retainAll(aL2);

取差集：aL1.removeAll(aL2);

注：add方法的参数类型是Object，以便于接收任意类型对象，集合中存储的都是对象的引用。

3集合框架（迭代器）

什么是迭代器？

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

把取出方式定义在了集合的内部，这样取出方式就可以直接访问每个集合内容的元素，那么取出方式就被定义成了内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容：判断和取出，那么可以将这些共性抽取。那么这些内部类都符合一个规则Iterator，如何获取集合的取出对象呢？通过一个对外提供的方法iterator()；

代码：

import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		ArrayList<String> aL=new ArrayList<String>();
		aL.add("java01");
		aL.add("java02");
		aL.add("java03");
		Iterator it=aL.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

4集合框架（List结合共性方法）

Collection

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

   |---Set:元素是无序的，元素不可以重复，没有索引

List集合特有方法：凡是可以操作角标的方法都是该体系特有的方法。

增加元素：add(index,element)

          addAll(index,Collection)

删除元素：remove(index);

修改元素：set（indext,element)

查找元素：get(index)

          subList(from,to)

          ListIterator();

获取所有元素

方式1：for(int i=0;i<aL.size();i++)

{System.out.println(aL.get(i));}

方式2：

Iterator it=aL.iterator();

while(it.hasNext())

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

获取对象的位置：aL.indexOf(“java02”);

5集合框架（ListIterator)

代码：

		//在迭代过程中，准备添加或者删除元素
		ArrayList aL=new ArrayList();
		aL.add("java02");
		aL.add("java03");
		Iterator it=aL.iterator();
		while(it.hasNext())
		{
			Object obj=it.next();
			if(obj.equals("java02"))
				it.remove();
		}
		System.out.println(obj);

List集合特有的迭代器，ListIterator是Iterator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生并发修改异常，所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作，如添加，修改等就需要使用其子接口，ListIterator，该接口只能通过List集合的ListIterator方法获取。

代码：

ArrayList aL=new ArrayList();
		aL.add("java02");
		aL.add("java03");
		ListIterator it=aL.listIterator();
		Object obj=null;
		while(it.hasNext())
		{
			obj=it.next();
			if(obj.equals("java02"))
				it.add("java009");
			
		}
		System.out.println(aL);

判断有没有前一个元素：it.hasPrevious();

判断有没有后一个元素：it.hasNext();

获取前一个元素：it.previous();

6集合框架（List集合具体对象的特点)

Collection

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

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

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

|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

ArrayList 默认长度为10，超过10，再添加，就会new一个新的数组，50%延长，把原来的添加到新数组中来，再向后添加。

Vector 默认长度为10，超过10,100%延长。

一般使用ArrayList，Vector的效率低。

7集合框架（Vector中的枚举）

枚举就是Vector特有的取出方式。发现枚举和迭代器很像。其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。枚举郁郁而终了。

代码：

class VectorDemo 
{
	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());
		}
	}
}

8集合框架(LinkedList)

LinkedList:特有方法：

addFirst();

addLast();

 

getFirst();

getLast();

获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法。

offerFirst();

offerLast();

 

peekFirst();

peekLast();

获取元素，但不删除元素。如果集合中没有元素，会返回null。不抛出异常

pollFirst();

pollLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null。不抛出异常

9集合框架（LinkedList练习）

使用LinkedList模拟堆栈或者队列数据结构：

堆栈：先进后出，如同杯子

队列：先进先出，如同水管

代码：

import java.util.*;
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();
	}
}

10集合框架（ArrayList练习1）

代码：

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

注：迭代时，it.next()取一次，就用it.hasNext()判断一次。

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		ArrayList aL=new ArrayList();
		aL.add("java01");
		aL.add("java01");
		System.out.println(singleElement(aL));
	}
	public static List singleElement(ArrayList aL)
	{
		ArrayList temp=new ArrayList();
		Iterator it=aL.iterator();
		while(it.hasNext())
		{
			Object obj=it.next();
			if(!temp.contains(obj))
				temp.add(obj);
			
		}
		return temp;
	}
}

11集合框架（ArrayList练习2）

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。

思路：

1，对人描述，将数据封装进人对象。

2，定义容器，将人存入。

3，取出。

注：List集合判断元素是否相同，依据是元素的equals方法。equals方法默认比较的是地址值，我们要让它按照我们的方式比较，需要重写equals方法。

代码：

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		ArrayList aL=new ArrayList();
		aL.add(new Person("zhangsan",34));
		aL.add(new Person("lisi",34));
		aL.add(new Person("wangwu",33));
		aL.add(new Person("wangwu",33));
		aL.add(new Person("wangwu",33));
		aL.add(new Person("wangwu",33));
		aL=singleElement(aL);
		Iterator it=aL.iterator();
		while(it.hasNext())
		{
			Person p=(Person)it.next();
			System.out.println(p.getName()+"   "+p.getAge());
		}
        System.out.println(aL.remove(new Person("wangwu",33)));
	}
	public static ArrayList singleElement(ArrayList aL)
	{
		ArrayList temp=new ArrayList();
		Iterator it=aL.iterator();
		while(it.hasNext())
		{
			Object obj=it.next();
			if(!temp.contains(obj))
				temp.add(obj);
			
		}
		return temp;
	}
}
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}

注意：调用contains(),contais()调用的是equals（）；

remove底层也调用了equals();

12集合框架（HashSet）

set：元素无序，不可重复。

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

Set集合的功能和Collection功能一致。
代码：

import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();
		hs.add("java01");
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");
		hs.add("java03");
		Iterator it=hs.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

13集合框架（HashSet存储自定义对象）

往HashSet集合中存入自定义的对象，姓名和年龄相同为同一个人。

代码：

import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();
		hs.add(new Person("java01",22));
		hs.add(new Person("java02",22));
		hs.add(new Person("java02",22));
		Iterator it=hs.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
class Person
{
	private String name;
	private int age;
	public Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public int hashCode()
	{
		return this.name.hashCode()+age*17;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
		{
			return false;
		}
		Person p=(Person)obj;
		return this.name.equals(p.name)&&(this.age==p.age);
	}	
}

HashSet是如何保证元素唯一性的呢？

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

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

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

13集合框架（HashSet判断和删除的依据）

hs.contains(new Person("java01",22))；

hs.remove(new Person("java01",22))

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

14集合框架（TreeSet）

Set:无序，不可以重复元素。

|--HashSet：数据结构是哈希表。线程是非同步的。

保证元素唯一性的原理：判断元素的hashCode值是否相同。

如果相同，还会继续判断元素的equals方法，是否为true。

|--TreeSet：可以对Set集合中的元素进行排序。

底层数据结构是二叉树。

保证元素唯一性的依据：

compareTo方法return 0.

代码：

import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		TreeSet ts=new TreeSet();
		ts.add("java01");
		ts.add("java06");
		ts.add("java02");
		ts.add("java08");
		ts.add("java00");
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

15集合框架（TreeSet存储自定义对象）

往TreeSet集合中存储自定义对象，学生，想按照学生的年龄进行排序。

记住：排序时，当主要条件相同时，一定要判断一下次要条件。

代码：

import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		TreeSet ts=new TreeSet();
		ts.add(new Student("zhangsan",23));
		ts.add(new Student("zhangsan",19));
		ts.add(new Student("zhangsan",33));
		ts.add(new Student("zhangsan",11));
		ts.add(new Student("zhangsan1",11));

		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			Student s=(Student)it.next();
			System.out.println(s.getName()+"  "+s.getAge());
		}
	}
}
class Student implements Comparable
{
	private String name;
	private int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s=(Student)obj;
		if(this.age>s.age)
			return 1;
		else if(this.age<s.age)
			return -1;
		else return this.name.compareTo(s.getName());
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
}

实现Comparable接口，并复写CompareTo（Object obj)方法，Student类才具有比较性。

16集合框架（二叉树）

元素怎么存进去就怎么取出来

public int compareTo(Object obj)

{return 1;}

注：|--TreeSet：可以对Set集合中的元素进行排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0.

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

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

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

17集合框架（实现comparator方式排序）

TreeSet的第二种排序方式。

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

这时就需要让集合自身具备比较性。

在集合初始化时，就有了比较方式。

代码：

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		TreeSet ts=new TreeSet(new MyCompare());
		ts.add(new Student("java04",22));
		ts.add(new Student("java02",25));
		ts.add(new Student("java01",21));
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			Student s=(Student)it.next();
			System.out.println(s.getName()+" "+s.getAge());
		}

	}
}
class Student implements Comparable
{
	private String name;
	private int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public int compareTo(Object obj)
	{
		Student s=(Student)obj;
		int num=new Integer(this.getAge()).compareTo(new Integer(s.getAge()));
		if(num==0)
		{
			return this.getName().compareTo(s.getName());
		}
		return num;
	}
}

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 new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
}

18集合框架（TreeSet练习）

按照字符串的长度排序：使用比较器

import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		TreeSet ts=new TreeSet(new StringLengthComparator());
		ts.add("aaaa");
		ts.add("cbaa");
		ts.add("e9");
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
class StringLengthComparator implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		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;
	}
}

19集合框架（泛型概述）

泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

好处

1.将运行时期出现问题ClassCastException，转移到了编译时期。，

方便于程序员解决问题。让运行时问题减少，安全。，

2，避免了强制转换麻烦。

代码：

ArrayList<String> aL=new ArrayList<String>();
	aL.add("java01");
	aL.add("java02");
	Iterator<String> it=aL.iterator();
	while(it.hasNext())
		{
		String s=it.next();
		System.out.println(s);
	}

20集合框架（泛型使用）

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

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，

只要见到<>就要定义泛型。

其实<> 就是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

泛型比较器代码：

import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts=new TreeSet<String>(new StringLengthComparator());
		ts.add("java02");
		ts.add("java01");
		ts.add("java001");
		Iterator<String> it=ts.iterator();
		while(it.hasNext())
		{
			String s=it.next();
			System.out.println(s);
		}
	}
}
class StringLengthComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0)
			return s1.compareTo(s2);
		return num;
	}
}

21集合框架（泛型类）

泛型类代码：

class Test 
{
	public static void main(String[] args) 
	{
		Tool<Student> tL=new Tool<Student>();
		tL.setObject(new Student());
		Student s=tL.getObject();

	}
}
class Student
{
}
class Worker
{
}
class Tool<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q=q;
	}
	public QQ getObject()
	{
		return this.q;
	}
}

当类中要操作的引用数据类型不确定的时候，使用泛型类，早期使用的是Object来完成扩展，容易在运行时期强制类型转换出错。

22集合框架（泛型方法）

泛型类定义的泛型，在整个类中有效。如果被方法使用，

那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定。

那么可以将泛型定义在方法上。

代码：

class Test 
{
	public static void main(String[] args) 
	{
		Demo d=new Demo ();
		d.show(4);
		d.print("haha");
	}
}

class Demo
{
	public<T> void show(T t)
	{
		System.out.println("show"+t);
	}
	public<T> void print(T t)
	{
		System.out.println("print"+t);
	}
}

23集合框架(静态方法泛型）

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

public static <W> method(W w)

24集合框架(泛型接口）

在实现接口的时候知道操作的是什么类型：

class Test 
{
	public static void main(String[] args) 
	{
		InterImple in=new InterImple();
		in.show("hello");
	}
}
interface Inter<T>
{
	public void show(T t);
}
class InterImple implements Inter<String>
{
	public void show(String str)
	{
		System.out.println(str);
	}
}

在实现接口的时候不知道操作什么类型，在实例化的时候才知道。

class Test 
{
	public static void main(String[] args) 
	{
		InterImple<Integer> in=new InterImple<Integer>();
		in.show(5);
	}
}
interface Inter<T>
{
	public void show(T t);
}
class InterImple<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println(t);
	}
}

25集合框架(泛型限定）

? 通配符。也可以理解为占位符。

泛型的限定；

？ extends E: 可以接收E类型或者E的子类型。上限。

？ super E: 可以接收E类型或者E的父类型。下限

？ extends E示例代码：

import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		ArrayList<Person> aL=new ArrayList<Person>();
		aL.add(new Person("aaa1"));
		aL.add(new Person("aaa2"));
		aL.add(new Person("aaa3"));
		print(aL);
		ArrayList<Student> aL1=new ArrayList<Student>();
		aL1.add(new Student("aaa-01"));
		aL1.add(new Student("aaa_02"));
		aL1.add(new Student("aaa-03"));
		print(aL1);
	}
	public static void print(ArrayList<? extends Person> aL)
	{
		Iterator<? extends Person> it=aL.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}
class Person
{
	private String name;
	public Person(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return this.name;
	}
}
class Student extends Person
{
	public Student(String name)
	{
		super(name);
	}
}
？ super E示例代码：
import java.util.*;
class Test 
{
	public static void main(String[] args) 
	{
		TreeSet<Student> ts=new TreeSet<Student>(new Comp());
		ts.add(new Student("abc04"));
		ts.add(new Student("abc01"));
		ts.add(new Student("abc03"));
		Iterator<Student> sit=ts.iterator();
		while(sit.hasNext())
		{
			System.out.println(sit.next().getName());
		}

		TreeSet<Worker> tss=new TreeSet<Worker>(new Comp());
		tss.add(new Worker("wabc-03"));
		tss.add(new Worker("wabc-01"));
		tss.add(new Worker("wabc-04"));

		Iterator<Worker> wit=tss.iterator();
		while(wit.hasNext())
		{
			System.out.println(wit.next().getName());
		}
	}
}
class Comp implements Comparator<Person>
{
	public int compare(Person p1,Person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}
class Person
{
	private String name;
	public Person(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return this.name;
	}
}
class Student extends Person
{
	public Student(String name)
	{
		super(name);
	}
}
class Worker extends Person
{
	public Worker(String name)
	{
		super(name);
	}
}

26集合框架（Map概述）

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

1，添加。

put(K key, V value) 

putAll(Map<? extends K,? extends V> m) 

2，删除。

clear() 

remove(Object key) 

3，判断。

containsValue(Object value) 

containsKey(Object key) 

isEmpty() 

4，获取。

get(Object key) 

size() 

values() 

entrySet() 

keySet() 

27集合框架（Map子类对象的特点）

Map

|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。

|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。

|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

和Set很像。

其实大家，Set底层就是使用了Map集合。

注意：添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。

System.out.println("put:"+map.put("01","zhangsan1"));

System.out.println("put:"+map.put("01","wnagwu"));

28集合框架（Map_keySet)

map集合的两种取出方式：

Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

代码：

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		Map<String,String> map=new HashMap<String,String>();
		map.put("01","zhangsan01");
		map.put("02","zhangsan02");
		map.put("03","zhangsan03");
		map.put("04","zhangsan04");
		Set<String> keys=map.keySet();
		Iterator<String> it=keys.iterator();
		while(it.hasNext())
		{
			String key=it.next();
			String value=map.get(key);
			System.out.println(key+"="+value);
		}
	}
}

注意：Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

29集合框架（Map-entrySet)

Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry

Entry其实就是Map中的一个static内部接口。

为什么要定义在内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。

代码：

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		Map<String,String> map=new HashMap<String,String>();
		map.put("01","zhangsan01");
		map.put("02","zhangsan02");
		map.put("03","zhangsan03");
		map.put("04","zhangsan04");
		Set<Map.Entry<String,String>> entry=map.entrySet();
		Iterator<Map.Entry<String,String>> it=entry.iterator();
		while(it.hasNext())
		{
			Map.Entry<String,String> me=it.next();
			String key=me.getKey();
			String value=me.getValue();
			System.out.println(key+"="+value);
		}
	}
}

30集合框架（Map练习）

练习要求：

每一个学生都有对应的归属地。学生Student，地址String。学生属性：姓名，年龄。

注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。

1，描述学生。

2，定义map容器。将学生作为键，地址作为值。存入。

3，获取map集合中的元素。

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		HashMap<Student,String> hm=new HashMap<Student,String>();
		hm.put(new Student("lisi1",22),"tianjing");
		hm.put(new Student("lisi1",22),"beijing");
		hm.put(new Student("lisi2",26),"shanghai");
		hm.put(new Student("lisi3",23),"nanjing");
		hm.put(new Student("lisi4",26),"wuhan");
		//第一种取出方式
		Set<Student> keys=hm.keySet();
		Iterator<Student> it=keys.iterator();
		while(it.hasNext())
		{
			Student stu=it.next();
			String address=hm.get(stu);
			System.out.println(stu+"  "+address);
		}

		//第二种取出方式
		Set<Map.Entry<Student,String>> entry=hm.entrySet();
		Iterator<Map.Entry<Student,String>> iter=entry.iterator();
		while(iter.hasNext())
		{
			Map.Entry<Student,String> me=iter.next();	
			Student stu=me.getKey();
			String address=me.getValue();
			System.out.println(stu+"-------"+address);
		}

	}
}
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int hashCode()
	{
		return this.name.hashCode()+this.age*37;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("类型不匹配");
		Student s=(Student)obj;
		return this.name.equals(s.name)&&this.age==s.getAge();
	}
	public int compareTo(Student s)
	{
		int num=this.name.compareTo(s.getName());
		if(num==0)
		{
			return new Integer(this.age).compareTo(new Integer(s.getAge()));
		}
		return num;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public String toString()
	{
		return this.name+" "+this.age;
	}
}

31集合框架（TreeMap练习）

利用treeMap存入学生对象：

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		TreeMap<Student,String> hm=new TreeMap<Student,String>(new StuCom());
		hm.put(new Student("lisi1",22),"tianjing");
		hm.put(new Student("lisi1",22),"beijing");
		hm.put(new Student("lisi2",26),"shanghai");
		hm.put(new Student("lisi3",23),"nanjing");
		hm.put(new Student("lisi4",26),"wuhan");

		Set<Map.Entry<Student,String>> entry=hm.entrySet();
		Iterator<Map.Entry<Student,String>> iter=entry.iterator();
		while(iter.hasNext())
		{
			Map.Entry<Student,String> me=iter.next();	
			Student stu=me.getKey();
			String address=me.getValue();
			System.out.println(stu+"-------"+address);
		}

	}
}
class StuCom implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		int num=new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		if(num==0)
			return s1.getName().compareTo(s2.getName());
		return num;
	}
}
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int hashCode()
	{
		return this.name.hashCode()+this.age*37;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("类型不匹配");
		Student s=(Student)obj;
		return this.name.equals(s.name)&&this.age==s.getAge();
	}
	public int compareTo(Student s)
	{
		int num=this.name.compareTo(s.getName());
		if(num==0)
		{
			return new Integer(this.age).compareTo(new Integer(s.getAge()));
		}
		return num;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public String toString()
	{
		return this.name+" "+this.age;
	}
}

32集合框架（TreeMap练习-字母出现的次数）

根据给定的字符串，统计各个字母出现的次数。

代码：

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		System.out.println(charCount("rrrrdldlk"));
	}
	public static String charCount(String str)
	{
		char[] chs=str.toCharArray();
		TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
		for(int i=0;i<chs.length;i++)
		{
			Integer value=tm.get(chs[i]);
			if(value==null)
			{
				value=0;
			}
			tm.put(chs[i],value+1);
		}
		StringBuilder sb=new StringBuilder();
		Set<Map.Entry<Character,Integer>> entry=tm.entrySet();
		Iterator<Map.Entry<Character,Integer>> it=entry.iterator();
		while(it.hasNext())
		{
			Map.Entry<Character,Integer> me=it.next();
			Character c=me.getKey();
			Integer count=me.getValue();
			sb.append(c+"("+count+")");
		}
		return sb.toString();
	}
}

33集合框架（Map扩展）

代码示例1：

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		HashMap<String,String> yure=new HashMap<String,String>();
		HashMap<String,String> jiuye=new HashMap<String,String>();
		HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();
		yure.put("01","zhangsan1");
		yure.put("02","zhangsan2");
		jiuye.put("01","lisi1");
		jiuye.put("02","lisi2");
		czbk.put("jiuye",jiuye);
		czbk.put("yure",yure);
		Set<String> keys=czbk.keySet();
		Iterator<String> it=keys.iterator();
		while(it.hasNext())
		{
			String key1=it.next();
			HashMap<String,String> hs=czbk.get(key1);
			System.out.println(key1);
			Set<String> ks=hs.keySet();
			Iterator<String> iter=ks.iterator();
			while(iter.hasNext())
			{
				String key=iter.next();
				String value=hs.get(key);
				System.out.println(key+" "+value);
			}
		}
	}
}

代码示例2：

 import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
	ArrayList<Student> list=new ArrayList<Student>();
	list.add(new Student("01",23));
	list.add(new Student("02",22));
	list.add(new Student("03",33));
	list.add(new Student("04",33));
	HashMap<String,ArrayList<Student>> czbk=new HashMap<String,ArrayList<Student>>();
	czbk.put("jiuye",list);
	czbk.put("yure",list);
	Set<String> keys=czbk.keySet();
	Iterator<String> it=keys.iterator();
	while(it.hasNext())
	{
		String key=it.next();
		System.out.println(key);
		ArrayList<Student> value=czbk.get(key);
		for(int i=0;i<list.size();i++)
		{
			System.out.println(list.get(i).getName()+" "+list.get(i).getAge());
		}
	}
}
}
class Student
{
	private String name;
	private int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
}

34 集合（Collections工具类）

  排序：Collections.sort(list,new StrLenCom());

最大值：Collections.max(list,new StrLenCom());

这版查找：Collections.binarySearch（list,”aaa”,new StrLenCom());

将集合中的元素全都替换成它：Collections.fill(list,”pp”)；

集合中元素替换：Collections.replaceAll(list,”oldValue”,”newValue”)

集合中元素反转：Collections.reverse(list)

强行逆转指定比较器顺序：Collections.reverseOrder(new StrLenCom());

强行逆转实现Comparable接口的对象collection的自然顺序：Collections.reverseOrder();

把元素随机排放：Collections.shuffle(list)

元素换位置：Collections.swap(list,1,2)

将非同步的变成同步的：Collections.synchronizedList（list）

示例代码：

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		ArrayList<String> list=new ArrayList<String>();
		list.add("sddd");
		list.add("dkjld");
		list.add("dkdk");
		Collections.sort(list,new StrLenCom());
		String max=Collections.max(list,new StrLenCom());
		System.out.println(list);
		System.out.println(max);
}
}

class StrLenCom implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		int num= new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0)
			return s1.compareTo(s2);
		return num;
	}
}      

35 集合（Arrays工具类）

Arrays：用于操作数组的工具类。

将数组变成字符串：Arrays.toString（arr)

将数组变成List集合：Arrays.asList(arr);（不可以使用集合的增删方法）

*高级for循环

格式：

for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)

{

}

对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。

如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须有被遍历的目标。

建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

*可变参数。

例如：

 public static void show(String str,int... arr)

{System.out.println(arr.length);}

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------