黑马程序员_java集合(1) Collection & List & Set & Map

本文链接：https://blog.csdn.net/johese/article/details/8677191

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

一.Collection

集合与数组的区别

他们都是容器，都可以存储对象，他们的区别是：数组的长度是固定的，而集合的长度的可变的；数组既能存储基本数据类型也能存储引用数据类型，而集合只能存储引用数据类型，如果给集合添加基本数据类型的元素，这些基本数据类型会自动装箱成对应的引用数据类型；数组存储的元素都是同一类型，而集合可以存储不同类型的元素

集合的特点

集合只用于存储对象，它的长度可变，能够存储不同类型的对象

因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构

Collection是一个接口，它定义了一些共性的方法，包括添加、移除、清空元素，是否为空、是否包括某一元素，获取元素个数等操作。

注意：

1.它里边有一个Iterator方法，专门用于取出元素。

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

3.集合中存放的都是对象的引用（地址）

eg:

import java.util.*;
		
class  CollectionDemo
{
	public static void main(String[] args) 
	{
		method_get();
		//method_1();
				
	}
	public static void method_get()
	{
		ArrayList al = new ArrayList();

		//1.添加元素
		al.add("java01");//add的参数是Object类型的。
		al.add("java02");
		al.add("java03");
		al.add("java04");
		
		Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
		sop(it.hasNext());
		sop(it.next());
		sop(it.hasNext());
		
		while(it.hasNext())
		{
			sop(it.next());
		}
		/*
		for(Itera tor it = al.iterator();it.hasNext();)
		{
			sop(it.next());
		}
		*/
	}
	
	//取交集
	public static void method_1()
	{
		ArrayList al1 = new ArrayList();		
		al1.add("java01");		
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");

		ArrayList al2 = new ArrayList();		
		al2.add("java02");		
		al2.add("java05");
		al2.add("java07");
		al2.add("java08");
		
		//al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素。
		al1.removeAll(al2);

		sop("al1:"+al1);
		sop("al2:"+al2);		

	}

	public static void base_method()
	{
		//创建一个集合容器，使用Collection接口的子类，ArrayList
		ArrayList al = new ArrayList();

		//1.添加元素
		al.add("java01");//add的参数是Object类型的。
		al.add("java02");
		al.add("java03");
		al.add("java04");

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

		//3.删除元素
		al.remove("java02");
		
		//4.判断元素。
		sop("java03是否存在："+al.contains("java03"));
		sop("结合是否为零："+al.isEmpty());

		//2，获取个数，集合长度
		sop("size="+al.size());
		
		//打印改变后的集合
		sop(al);
				

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

Collection按元素是否允许重复，分为List和Set两类。List是允许元素重复，每个元素都有索引。Set不允许重复，元素没有索引。Collection体系结构如下：

Collection

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

|--ArrarList：底层数据使用的是数据结构。JDK1.2才出现的。特点：查询修改速度很快，但添加删除很慢。线程不同步。

|--LinkedList：底层数据用的是链表数据结构。特点：增删速度很快，查询稍慢。

|--Vector:底层是数组数据结构。JDK1.0出现的，线程同步。被ArrayList替代了，增删查询都很慢。

|--Set：元素是无序的（存入和取出的顺序不一定一致），元素不可重复，没有索引。

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

|---TreeSet：底层数据是二叉树结构。

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

-------------------------------------------------------------------------------------------------------------------------------

二.List

list 特有方法

增：

add(index,element);

addAll(index,Collection);

删：

remove(index);

改：

set(index,element);

查：

get(index);

subList(from,to);

ListIterator();

list特有的迭代器

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

实现该接口的子类对象只能通过List集合的ListIterator方法获取

eg：

class ListDemo 
{
	public static void main(String[] args) 
	{
		//演示列表迭代器
		ArrayList al = new ArrayList();

		//1.添加元素
		al.add("java01");//add的参数是Object类型的。
		al.add("java02");
		al.add("java03");

		
		//在迭代过程中，准备添加或者删除元素。
		ListIterator it = al.listIterator();

		sop("hasPrevious:"+it.hasPrevious());
		while(it.hasNext())
		{
			Object obj = it.next();
			if(obj.equals("java02"))
				it.set("java08");
			sop(obj);
		}
		while(it.hasPrevious())
		{
			sop("hasPrevious:"+it.previous());
		}
		sop("hasNext:"+it.hasNext());
		sop("hasPrevious:"+it.hasPrevious());
		sop(al);
		/*
		for(Iterator it = al.iterator();it.hasNext();)
		{
			Object obj = it.next();
			if(obj.equals("java02"))
				//al.add("java07");//迭代器和集合同时操作元素，会出现ConcurrentModificationException异常。
				it.remove();//将java02的引用从集合中删除了。
			sop("obj="+obj);
		}
		sop(al);
		*/
		

		//method();

		
				
	}
	public static void method()
	{
		ArrayList al = new ArrayList();

		//1.添加元素
		al.add("java01");//add的参数是Object类型的。
		al.add("java02");
		al.add("java03");
		
		sop("原集合："+al);
		//在指定位置添加元素。
		al.add(1,"java09");
		sop(al);

		//删除指定位置的元素。
		//al.remove(2);

		//修改元素
		//al.set(2,"java07");

		//通过角标获取元素
		sop("a1.get(1):"+al.get(1));
		sop(al);
		//获取所有元素
		for(int x = 0;x<al.size();x++)
		{
			sop("al("+x+"):"+al.get(x));
		}
		
		for(Iterator it = al.iterator();it.hasNext();)
		{
			sop("next:"+it.next());
		}

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


		List sub = al.subList(1,3);
		sop("sub:"+sub);

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

ArrayList ，底层是数据结构，适用于查询，线程不同步

eg:

/*
练习：将自定义对象作为元素存到ArrayList集合中，并去除重复元素，比如：存入对象，同姓名同年龄，视为同一个人，为重复元素。

思路：
1.对人描述，将数据封装进人对象。
2.定义容器，将人存入。
3.取出。
List集合判断元素是否相同，依据的是元素的equals方法。
*/
import java.util.*;
class Person1
{
	private String name;
	private int age;
	Person1(String name,int age)
	{
		this.name =name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//复写equals方法，其实是为集合做判（包含）断服务的。
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person1))
			return false;
		Person1 p = (Person1)(obj);
		return this.name.equals(p.name) && this.age==p.age;
	}
}
class ArrayListTest2 
{
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();
		Person1 p1=new Person1("mama",23);
		al.add(new Person1("lisi",20));
		al.add(new Person1("zhangsna",23));
		al.add(new Person1("wangwu",40));
		al.add(new Person1("wangwu",40));
		al.add(new Person1("loosi",20));
		al.add(p1);
		al.add(p1);
		
		
		
		al=singleList(al);
//		sop("remove 03:"+al.remove(new Person1("zhangsna",23)));

		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Person1 p = (Person1)it.next();

			sop(p.getName()+"::"+p.getAge());
		}

	}
	//去除ArrayList中的重复的元素
	public static ArrayList singleList(ArrayList al)
	{
		ArrayList newAl = new ArrayList();
		
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();
			if(!(newAl.contains(obj)))
				//contains判断是否相同，用的是equals方法，集合中的元素如果没有重写equals方法，那么传入引用没有问题，
				//但如果传入的是匿名对象，那么就会出现重复元素，该函数的实现就出现了bug
				newAl.add(obj);
		}
		return newAl;

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

vector

Vector底层也是数组结构，它是线程同步的，但效率低，它有自己特有的枚举Enumeration，用来取出集合元素。后来ArrayList取代了Vector，Iterator取代了Enumeration

eg:

mport java.util.*;

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())
		{
			sop(en.nextElement());
		}
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

LinkedList

LinkedList的特有方法：

addFirst(); addLast();

getFirst();getLast();

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

removeFirst();removeLast();

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

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

offerFirst();offerLast();

peekFirst();peekLast();

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

poolFirst();poolLast();

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

eg:

/*
需求：使用LinkedList模拟一个堆栈或者队列数据结构
为什么要模拟？
LinkedList名称是固定的，在现实开发中，我们希望制作一个跟项目有关的容器，针对特定的数据结构提供更为简便的方法。
堆栈：先进后出。如同一个杯子。
队列：先进先出。如同一个水管。First In First Out
*/
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.removeLast();
	}
	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");		

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

-------------------------------------------------------------------------------------------------------------------------------

三.Set

与List不同，Set中的元素不允许重复，但这里的“不允许”是建立在你正确运用其实现原理的基础上，否则仍可能出现重复的情况。

Set常用的子类为HashSet和TreeSet，这两个子类实现元素唯一性的原理不同：HashSet是通过依次调用元素的hashCode和equals方法，而TreeSet是通过让元素或集合具备比较性（分别对应Comparable和Comparator两个接口）来实现的。

TreeSet还有一个特点，它是元素是有序的。这里的有序，跟其存入顺序无关，是指其自然顺序或比较器指定的顺序

HashSet 元素唯一性

是通过依次调用hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals方法。（开发时，往集合存对象时，一般要重写对象所属类的hashCode和equals方法）

HashSet对于判断元素是否存在，已经删除等操作，依赖的方法也是元素的hashCode和equals方法。

eg:

package bxd.day14;
/*
往HashSet集合中存入自定义对象。
姓名和年龄相同为同一个人，重复元素。

*/
import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name =name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public int hashCode()
	{
		System.out.println(this.name+"之前的hashCode值："+super.hashCode());
		return name.hashCode()+age*37;//所有的目的都是为了让HashSet判断的hashCode值只跟你要保证唯一的那些值有关，
		//age*37,是为了尽量保证hashCode值的唯一。比如（40+20）和（20+40）的情况。
		
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)(obj);
		System.out.println(this.name+"...equals..."+p.name);//该句没有被打印说明没有调用equals()方法。
		return this.name.equals(p.name) && this.age==p.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("a2",12));
		// hs.add(new Person("a4",14));

		//sop("a1存在:"+hs.contains(new Person("a1",11)));
		sop("a4 exists?"+hs.remove(new Person("a4",14)));

		 Iterator it = hs.iterator();
		 while(it.hasNext())
		 {
			 Person p = (Person)it.next();
			 sop(p.getName()+"::"+p.getAge());
		 }
	}


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

TreeSet

TreeSet中元素的取出顺序跟存入顺序无关，不可以有重复元素。

TreeSet实现排序的方式有两种

让元素具备比较性，实现Comparable接口

TreeSet存入的元素，如果没有实现Comparable接口，往TreeSet中add第一个元素的时候，不会出问题，但add第二个元素时，会出现类型转换异常，因为TreeSet集合是通过Comparable接口的compareTo方法来完成排序的，它默认其中的元素都实现了Comparable接口。

同时，在compareTo方法中，当主要条件判断相等后，一定要再判断下次要条件。

TreeSet对于判断元素是否存在，已经删除等操作，依赖的方法也是元素的compareTo方法

让集合具备比较器集合传入Comparator接口

当集合元素没有比较性或具备的比较性不是所需要的时，可以让集合自己具备比较性，即集合初始化时，把一个比较器Comparator作为参数传入集合的构造函数。

Comparator接口里边有个compare（obj，obj）方法

eg:

import java.util.*;
class TreeSetDemo2  
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new MyCompare());

		ts.add(new Student2("a1",15));
		ts.add(new Student2("a2",12));
		ts.add(new Student2("a2",13));
		ts.add(new Student2("a4",16));
		ts.add(new Student2("a4",17));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student2 stu = (Student2)it.next();
			System.out.println(stu.getName()+"::"+stu.getAge());
		}
	}
}
//第二种排序方式：实现比较器，现在姓名再按年龄排序。
class MyCompare implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		Student2 s1 = (Student2)o1;
		Student2 s2 = (Student2)o2;


		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
		{
			/*if(s1.getAge()>s2.getAge())
				return 1;
			if(s1.getAge()==s2.getAge())
				return 0;
			return -1;*/
			num=new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
}

//第一种排序方式：让集合元素具备比较性，先按年龄再按姓名比较。
class Student2 implements Comparable//该接口让学生具备比较性。
{
	private String name;
	private int age=100;
	Student2(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student2))
			throw new RuntimeException(obj.toString()+"不是学生对象");
		Student2 s = (Student2)obj;
		//System.out.println(this.name+"...compareTo..."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}		
		return -1;	

	}
	/*
	public int compareTo(Object obj){
		
		return 1;//这样做会导致按存入顺序取出元素；改为-1，则逆序；改为0，则永远只能存一个元素。		
	}*/
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	
}

-------------------------------------------------------------------------------------------------------------------------------

四.Map

Map集合:它存储的是键值对，其中键必须保证唯一性，值允许重复。Map集合没有自身特有的迭代器，它的元素取出是通过将键或键值对放入Set集合中，利用Set集合中的迭代器取出的。Map是双列集合，Collection是单列集合

1.添加

V put(K key, V value)

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

不同之处：

put时，如果key已经存在，则新存入的值覆盖原来的值，并把原来的值作为方法的返回值；add时，如果该元素已经存在，则不能存入集合，方法返回值为false，如果不存在，则存入集合，方法返回值为true

2.删除

clear()

V remove(Object key)

3.判断

boolean containsKey(Object key)

boolean containsValue(Object value)

boolean isEmpty()

4.获取

V get(Object key)

int size()

Collection<V> values()

Set<Map.Entry<K,V>>entrySet()

Set<K> keySet()

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
class  MapDemo
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap <String,String>();
		System.out.println("put:"+map.put("01","zhangsan01"));//结果为null
		System.out.println("put:"+map.put("01","wangwu"));//结果我zhangsan01
		/*
		put如果存入了已经存在的键，则新键值会覆盖旧键值，并将旧键值返回；put存入一个未存在的键时，会返回null。
		*/
		map.put("02","zhangsan02");
		map.put("03","zhangsan02");
		map.put(null,null);

		System.out.println("containsKey:"+map.containsKey("022"));
		//System.out.println("remove:"+map.remove("02"));
		System.out.println("get:"+map.get("023"));
		map.put("04","null");
		System.out.println("get:"+map.get("04"));
		//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。（毕老师这点讲的是不是有问题？）

		
		//获取map集合中的值
		Collection <String> coll =map.values();

		System.out.println(coll);
		System.out.println(map);
	}
}
/*
既然hashMap可以存放null键null值，那么通过get方法返回null，应该不能判断该键是不是存在，因为可能出现有键值为空的情况;这时就要用containsKey()方法来判断了
*/

体系结构

|---Hashtable<K,V>：底层是哈希表数据结构，不可以存入null键null值，该集合是同步的。JDK1.0，效率低。，

|---HashMap<K,V>：底层是哈希表数据结构，允许存入null键null值，该集合是不同步的。JDK1.2，效率高。

|---TreeMap<K,V>：底层是二叉树结构，线程不同步，可以用于给Map集合中键进行排序。

和Set很像，其实Set底层就是使用了Map集合

eg:

/*

map集合的两种取出方式：
1.Set<K> keySet;将map中的所有的键存入到Set集合，因为set具有迭代器。
	所以可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。
	Map集合的取出原理:将Map集合转成Set集合，再通过迭代器取出。
2.Set<Map.Entry<K,V>> entrySet:将Map集合中的映射关系存入到了Set集合中，
	而这个关系的数据类型就是：Map.Entry.
*/
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Map;

class MapDemo2 
{
	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");
		System.out.println(map);
		System.out.println("-------------");

		
		//Map元素取出的方式一（EntrySet）：将Map集合中的映射关系取出，存入到Set集合中。
		Set<Map.Entry<String , String>> entrySet = map.entrySet();
		System.out.println(entrySet);
		System.out.println("-------------");

		Iterator<Map.Entry<String , String>> it = entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(me);
			System.out.println("key:"+key+",value="+value);

		}
		
		//元素取出的方式二（KeySet)
		/*
		//先获取map集合的所有键的Set集合。
		Set<String> keySet = map.keySet();
		//有了Set集合，就可以获取机迭代器。
		Iterator<String> it = keySet.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			String value = map.get(key);
			System.out.println("key:"+key+",value="+value);

		}
		*/
	}
}

/*
Map.Entry 其实Entry也是一个接口，他是Map接口中的一个内部接口。如下：

interface Map
{
	public static interface Entry
	{
		public abstract Object getKey();
		public abstract Object getValue();
	}
}
class  HashMap implements Map
{
	class Haha implements Map.Entry
	{
		public  Object getKey(){}
		public  Object getValue(){}
	}
	
}
*/

练习题:

/*
每一个学生都有对应的归属地
学生Student，地址String
学生属性：姓名，年龄
注意：姓名和年龄相同视为同一个学生
保证学生的唯一性。

1.描述学生
2.定义Map容器，将学生作为键，地址作为值，存入。
3.获取Map集合中的元素。
*/

import java.util.*;
class MapTest 
{
	public static void main(String[] args) 
	{
		HashMap<Student,String> hm = new HashMap<Student,String>();
		hm.put(new Student("lisi1",22),"beijing");
		hm.put(new Student("lisi1",22),"shanghai");
		hm.put(new Student("lisi3",24),"wuhan");  
		hm.put(new Student("lisi4",25),"nanjing");

		//第一种取出方式：keySet()
		Iterator<Student> it = hm.keySet().iterator();
		while(it.hasNext())
		{
			Student stu = it.next();
			String addr = hm.get(stu);
			System.out.println(stu+".."+addr);
		}
		System.out.println("-------------");

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

	}
}

/*
 为什么将复写equals、hashCode方法，并实现comparable接口？
 因为，Sutdent有可能存入HashMap中，也有可能存入TreeMap中。
 
 */
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public int getAge()
	{
		return age;
	}
	public void setAge(int age)
	{
		this.age = age;
	}
	public int hashCode()
	{
		return name.hashCode()+37*age;//这点要注意
	}
	public boolean equals(Object obj)
	{
		if( !(obj instanceof Student))
			throw new ClassCastException("类型不匹配"); 
		Student s = (Student) obj;
		return this.name.equals(s.getName())&&this.age==s.getAge();
	}
	public int compareTo(Student s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.getAge()));
		if(num == 0)
			this.name.equals(s.name);
		return num;
	}
	public String toString()
	{
		return name+","+age;
	}
}

eg2：

/*
练习：
”stdafasdffadf“获取该字符串中的字母出现的次数。
希望打印结果:a(1)c(2)。。。。

通过结果发现，每个字母都有对应的次数
说明字母和次数之间都有映射关系。

注意了，当发现有映射关系时，可以选择Map集合
因为Map集合中存放的就是映射关系。

什么时候使用Map集合呢？
当数据之间存在这个映射关系时，就要先想到Map集合。
我的思路：
1.建立字母为键，类型为char，次数为值，类型为int，的Map，因为字母按顺序打印，所以选用TreeMap
2.将字符串遍历，重复的字符，值++；
3.使用迭代器打印TreeMap集合。

毕老师思路：
1.将字符串转换成字符数组，因为要对每一个字母进行操作。

2.定义一个map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。

3.遍历字符数组。
	将每一个字符作为键去查map集合。
	如果返回null，将该字母和1存入到map集合。
	如果返回不是null，说明该字母在map集合已经存在，并有对应的次数。
	那么就获取该次数进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖调用原键所对应的值。
4.将map集合中的数据变成指定的字符串形式返回。


*/
import java.util.*;
class MapTest3 
{
	public static void main(String[] args) 
	{
		//String str = myCharCount("adfasdf!!!!!sssasdfas");
		String str =charCount("dsadfadfasdf");
		System.out.println(str);
	}
	//毕老师的方法
	public static String charCount(String str)
	{
		char [] chs = str.toCharArray();
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();			
		for(int x =0;x<chs.length;x++)
		{
			int count =0;
			char ch = str.charAt(x);
			if(!(ch>='a'&&ch<='z'|| ch>='A'&&ch<='Z'))
				continue ;

			Integer value = tm.get(chs[x]);
			
			/*
			if(value == null)
				tm.put(chs[x],1);
			else
			{
				value = value+1;
				tm.put(chs[x],value);
			}
			*/
			if(value!=null)
				count = value;
			count++;
			tm.put(chs[x],count);				
		}

		StringBuilder sb = new StringBuilder();
		Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
		Iterator<Map.Entry<Character,Integer>>it = entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<Character,Integer> me = it.next();
			Character ch = me.getKey();
			Integer value = me.getValue();
			sb.append(ch+"("+value+")");
		}
		return sb.toString();

	}
	//我的方法
	public static String myCharCount(String str)
	{	
		
		String resault="";
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();

		int count = 0;				
		for(int x =0;x<str.length();x++)
		{
			char ch = str.charAt(x);
			if(!(ch>='a'&&ch<='z'|| ch>='A'&&ch<='Z'))
				continue ;
			if(!tm.containsKey(ch))
				tm.put(ch,1);
			else
			{
				int num =tm.get(ch)+1;
				tm.put(ch,num);
			}				
		}

		
		Iterator<Map.Entry<Character,Integer>> it = tm.entrySet().iterator();
		while(it.hasNext())
		{
			Map.Entry<Character,Integer> me = it.next();
			char letter = me.getKey();
			int num = me.getValue();
			resault += letter+"("+num+")";
		}

		return resault;
		
	}
}

eg3:

/*
需求:对学生对象的年龄进行升序排序。

因为数据是以键值对形式存在的,所以要使用可以排序的Map集合，TreeMap。
*/
import java.util.*;

class StuNameComparator implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(num == 0)
			return new Integer(s1.getAge()).compareTo(s2.getAge());
		return num;
	}
}
class MapTest2 
{
	public static void main(String[] args) 
	{
		TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
		tm.put(new Student("lisi1",22),"beijing");
		tm.put(new Student("alisi1",23),"shanghai");
		tm.put(new Student("alisi1",24),"shanghai");
		tm.put(new Student("xlisi3",24),"wuhan");  
		tm.put(new Student("lisi4",25),"nanjing");

		Iterator<Map.Entry<Student,String>> it = tm.entrySet().iterator();
		while(it.hasNext())
		{
			Map.Entry<Student,String> me = it.next();
			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu+","+addr);
		}
		
	}
}

Map扩展

map 集合嵌套

eg:

/*
map扩展知识

map集合使用是因为具备映射关系。

“yureban” “01” “zhangsan”
“yureban” “02” "lisi"
"jiuyeban" "01" "zhousi"
"jiuyeban" "02" "liuwu"

一个学校有多个教室，每个教室都有自己的名字，而一个教室对应多个学生。

*/
import java.util.*;
class Student1
{
	private static String id;
	private String name;
	Student1(String id,String name)
	{
		this.id = id;
		this.name = name;
	}
	public String toString()
	{
		return id+":::"+name;
	}
	public static void main(String[] args) 
	{
		Student1  s1 =new Student1("id","name");
		id = "1212";
		Integer a = Integer.parseInt(id,10);		
		System.out.println(s1.id);
		System.out.println(a);
		
		
	}
	
}
class MapDemo3 
{
	public static void demo()
	{
		HashMap<String,List<Student1>> czbk = new HashMap<String,List<Student1>>();
		List<Student1> yure = new ArrayList<Student1>();
		List<Student1> jiuye = new ArrayList<Student1>();

		czbk.put("yuer:",yure);
		czbk.put("jiuye:",jiuye);

		yure.add(new Student1("01","zhangsan"));
		yure.add(new Student1("02","wagnwu"));

		jiuye.add(new Student1("01","liuqiang"));
		jiuye.add(new Student1("02","limeng"));

		Iterator<String> it = czbk.keySet().iterator();
		while(it.hasNext())
		{
			String roomName = it.next();
			List<Student1> room = czbk.get(roomName);
			System.out.println(roomName);
			getInfos(room);
		}
	}
	public static void getInfos(List<Student1> room)
	{
		Iterator<Student1> it = room.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	
	public static void main(String[] args) 
	{
		demo();
	}

	public static void getStudentInfo(HashMap<String,String> hm)
	{
		Iterator<Map.Entry<String,String>> it = hm.entrySet().iterator();
		while(it.hasNext())
		{
			Map.Entry<String,String> me = it.next();
			String num =me.getKey();
			String name = me.getValue();
			System.out.println(num+":"+name);
		}
		System.out.println(hm);
	}
}

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