java第十五天_Map集合，
Map集合：
该集合存储键值对。一对一往里存。而且要保证键的唯一性。
当有映射关系的元素时，考虑建立Map集合。
方法摘要：
1.添加：如果添加时，出现相同的键。那么后添加的值会覆盖原有键对应值，并且put方法会返回被覆盖的值。
put(K key,V value)
putAll(Map< ? Extends k, ? extends V> m)
2.删除
clear( )
remove ( Object key)
3.判断
containValue ( Object value)
containsKey ( Object key)
isEmpty ( )
4.获取
get ( Object key )：可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
size ( )
values ( )
entrySet ( )
keySet ( )
Map体系：和Set很像。Set底层就是使用了Map集合。
Map
|——Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0。效率低。
|——HashMap：底层是哈希表数据结构，允许使用null键null值。该集合是不同步的。JDK1.2。效率高。
|——TreeMap：底层是二叉树数据结构，线程不同步。可以用于给map集合中的键进行排序。
Map集合的两种取出方式：
Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
1.Set<k> keySet：将Map中所有的键存入到Set集合。因为Set具备迭代器，所以可以迭代方式取出所有的键，在根据get方法获取每一个键对应的值。
图解：
2.Set<Map.Entry<k,v>>entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry。
entrySet()方法将map集合中的映射关系取出。这个关系就是Map.Entry类型。那么关系对象Map.Entry获取到后，就可以通过Map.Entry中getKey和getValue方法获取关系中的键和值
图解：
代码：
//import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo
{
/**
* @map方法的演示。
*/
public static void main(String[] args)
{
Map<String,String> map=new HashMap<String,String>();//Map不是一个具体的集合类。
//添加元素。
map.put("01","zhangsan1");
map.put("02", "zhangsan02");
map.put("03", "zhangsan03");
//System.out.println(map.put("03", "zhangsan033"));//map后添加的值会覆盖以前的值，并且会返回被覆盖的值。
map.put("04", null);
//删除元素。
//System.out.println(map.remove("02"));
//map.clear();//clear()没有返回值
//获取元素
//System.out.println(map.get("04"));//根据指定键获取值，如果没有这个键值对，返回null。
//Collection<String> coll=map.values(); //获取map中的值。将这些值存到Collection集合中。
//取出元素
//第一种方法，将map的键值存到set集合中。迭代取出key值，再根据键值取出值。
/*Set<String> keyset=map.keySet();
for(Iterator<String> it=keyset.iterator();it.hasNext();)//
{
String key=it.next();
String value=map.get(key);
System.out.println("key="+key+",value="+value);
}*/
//第二种方法。将Map的映射关系取出。存入到Set集合中。
Set<Map.Entry<String, String>> entry=map.entrySet();
for(Iterator<Map.Entry<String, String>> it=entry.iterator();it.hasNext();)
{
Map.Entry<String, String> me=it.next();
String key=me.getKey();
String value=me.getValue();
System.out.println(key+":"+value);
}
//System.out.println(coll);
}
}
package day16;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class StudentMap
{
/**
* @Map中装Student对象为key，相应地址为value。
*/
public static void main(String[] args)
{
HashMap<Student,String> hm=new HashMap<Student,String>();
hm.put(new Student("zhangsan01",20), "beijing");
hm.put(new Student("zhangsan01",20), "beijing");
hm.put(new Student("zhangsan02",22), "shanghai");
hm.put(new Student("zhangsan03",23), "tianjin");
Set<Map.Entry<Student,String>> hs=hm.entrySet();
for(Iterator<Map.Entry<Student,String>> it=hs.iterator();it.hasNext();)
{
Map.Entry<Student, String> me=it.next();
Student stu=me.getKey();
String add=me.getValue();
System.out.println(stu+"^"+add);
}
}
}
class Student implements Comparable<Student>
{
private String name;
private int 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;
}
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Student s)//排序根据。
{
int num=new Integer(this.age).compareTo (new Integer(this.age));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public int hashCode()//要重写hashCode方法。尽量让每个元素的返回值不同。
{
return name.hashCode()+age*10;
}
public boolean equals(Student s)//重写equals方法。
{
return this.name.equals(s.name)&&(this.age==s.age);
}
public String toString()//打印对象需要调用这个方法。
{
return name+":"+age;
}
}
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class CharCount
{
/**
* @统计字符串中字母出现的次数并存入集合 */
public static void main(String[] args)
{
String str="aldjflasdfoqwnieonvaospnfieo";
System.out.println(charCount(str));
}
public static String charCount(String str)
{
char[] chs=str.toCharArray();
TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
int count=0;
for(int x=0;x<chs.length;x++)
{
if(!(chs[x]>='a'&&chs[x]<='z'||chs[x]>='A'&&chs[x]>='Z'))
continue;
Integer value=tm.get(chs[x]);
if(!(value==null))
{
count=value;
}
count++;
tm.put(chs[x], count);
/*if(value==null)
{
tm.put(chs[x], 1);
}
else
{
value++;
tm.put(chs[x], value);
}*/
count=0;
}
StringBuffer sb=new StringBuffer();
Set<Map.Entry<Character,Integer>> entryset=tm.entrySet();
for(Iterator<Map.Entry<Character,Integer>> it=entryset.iterator();it.hasNext();)
{
Map.Entry<Character,Integer> me=it.next();
Character ch=me.getKey();
Integer in=me.getValue();
sb.append(ch+"("+in+")");
}
return sb.toString();
}
}
