java学习第16天,学习内容
/*
Map集合:public interface Map<K,V>
该集合存储键值对,一对一对往里存,而且要保证键的唯一性
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()
Map集合:
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的,jsk1.0,效率低
|--HashMap:底层是哈希表数据结构,允许使用null键和null值,该集合是不同步的,jdk1.2,效率高
|--TreeMap:底层是二叉树数据结构,线程不同步,可以用于给map集合中的键进行排序
和Set很像
其实Set底层就是使用了Map集合
*/
//map的共性方法
import java.util.*;
class MapDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//map集合添加元素,如果出现添加时,相同的键,那么后添加的值会覆盖原有键对应值,
//并put方法会返回被覆盖的值
sop("put:......"+map.put("01","spider01"));
sop("put:......"+map.put("01","spider007"));
map.put("02","spider02");
map.put("04","spider04");
map.put("03","spider03");
sop("原始值:"+map);
//判断
sop("containsKey:..."+map.containsKey("03"));
//删除
sop("remove..."+map.remove("02"));
//获取
sop("get:..."+map.get("01"));
//sop("get:..."+map.get("011"));返回null
map.put("05",null);
sop("get:..."+map.get("05"));//返回null
//可以通过get方法的返回值来判断一个键是否存在,通过返回null来判断
//获取map集合中所有的值
Collection<String> coll = map.values();
sop(coll);
sop("变化值:..."+map);
}
}
import java.util.*;
/*
map集合的两种取出方式
1.keySet: Set<k> keySet:将map中所有的键存入到Set集合,因为set具备迭代器
所以可以空过迭代方式取出所有的键,在根据get方法,获取每一个键对应的值
map集合取出原理:将map集合转成set集合,在通过迭代器取出
2,entrySet: Set<> entrySet: 获取map集合双类型元素的关系映射,存到Set集合中
3,Map.Entry知识
Map.Entry 其实Entry也是一个接口,他是Map接口中的一个内部接口
*/
interface Map
{
public static interface Entry //接口在成员位子上才能加静态
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map
{
class Hahs implements Map.Entry
{
public Object getKey(){}
public Object getValue(){}
}
}
class MapkeySetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("02","spider02");
map.put("04","spider04");
map.put("01","spider01");
map.put("03","spider03");
Set<Map.Entry<String,String>> entrySet = map.entrySet();//获取map集合双类型元素的关系映射,存到Set集合中
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();
sop("key="+key+"valur="+value);
}
/*
//因为map集合没有迭代器,所有不能通过迭代的方式获取map集合中元素的值,
//但可以使用keySet()方法获取map集合中键的集合(Set集合)
//因为获取的键的集合是Set集合,就可以使用Iterator迭代器方式获取元素值
//获取键的值
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while (it.hasNext())
{
String key = it.next(); //得到键的值,
String value = map.get(key); //在通过键的值获取对象的元素值
sop("key..."+key+",value:..."+value);
}*/
}
}
import java.util.*;
/*
对MapTest中学生对象的年龄进行升序排序
因为数据是以键值对形式存在的
所以要使用可以排序的Map集合,TreeMap
添加对象比较器:通过实现Comparable接口,复写compare方法
*/
class StuAgeCompare implements Comparator<Student> //实现按照学生年龄排序,年龄相同时,按照姓名排序
{
public int compare(Student stu1,Student stu2)
{
int num = new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
if(num==0)
return stu1.getName().compareTo(stu2.getName());
return num;
}
}
class TreeMapTest2
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuAgeCompare());
tm.put(new Student("Spider01",21),"jiangxi");
tm.put(new Student("Spider04",25),"shanghai");
tm.put(new Student("Spider02",22),"beijing");
tm.put(new Student("Spider00",22),"beijing");
tm.put(new Student("Spider03",23),"shenzhen");
//取出元素方式有两种,一种是keySet()通过获取键,取得值
//一种是通过获取元素的键值关系,entrySet(),再获取键值
Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<Student,String> em = it.next();
Student stu = em.getKey();
String addr = em.getValue();
sop(stu.getName()+"..."+stu.getAge()+"..."+addr);
}
}
}
import java.util.*;
/*
练习:
每一个学生都有对应的归属地。
学生Student,地址:String
学生属性:姓名,年龄;
注意:姓名和年龄相同的视为同一个学生,
保证学生的唯一性
思路:
1,描述学生
2,定义map容器,将学生作为键,地址作为值,存入
3,获取map集合中的元素
*/
class Student implements Comparable<Student> //Student实现Comparable接口,复写compareTo()方法
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Student stu)
{
int num = new Integer(this.age).compareTo(new Integer(stu.age));
if (num==0)
return this.name.compareTo(stu.name);
return num;
}
//因为Student 存放在HashMap集合中,所以需要覆盖hashCode方法和equals方法,用于保证HashMap键的唯一性
public int hashCode()
{
return name.hashCode()+age*34;
}
public boolean equals(Object obj)
{
if (!(obj instanceof Student))
throw new ClassCastException("数据类型不匹配");
Student stu = (Student)obj;
return this.name.equals(stu.name) && this.age==stu.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String print()
{
return name+"..."+age;
}
}
class MapTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("zzh01",23),"jiangxi");
hm.put(new Student("zzh03",25),"beijing");
hm.put(new Student("zzh01",23),"henan"); //键相同,不会打印出来
hm.put(new Student("zzh04",21),"shanghai");
hm.put(new Student("zzh02",20),"guangdong");
//第一中获取方式,通过keySet()方式获取键
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
while (it.hasNext())
{
Student stu = it.next();
String addr = hm.get(stu);
sop("name="+stu.getName()+"age="+stu.getAge()+",first method."+addr);
}
sop("-----------------------------------------------------");
//第二种获取方式,通过entrySet()获取映射关系获取键和值
Set<Map.Entry<Student,String>> entrySet = hm.entrySet(); //获取映射关系集合
Iterator<Map.Entry<Student,String>> itl = entrySet.iterator(); //获取映射关系集合的迭代器
while (itl.hasNext())
{
Map.Entry<Student,String> me = itl.next(); //获取元素的映射关系
Student stu = me.getKey();
String addr = me.getValue();
sop("name="+stu.getName()+"age="+stu.getAge()+",secode method."+addr);
}
}
}
import java.util.*;
/*
练习:
"sdajajznvkjhanvndvn" 获取该字符串中的字母出现的次数。
希望打印结果: a(1)c(2).....
通过结果发现,每一个字母都有对应的次数
说明字母和次数之间都有映射关系。
注意了,当发现有映射关系时,可以选择map集合
因为map集合中存放就是映射关系
什么时候使用map集合呢?
当数据之间存在这种映射关系时,就是先想map集合。
思路:
1,将字符串转换成字符数组,因为要对每一个字母进行操作。
2,定义一个map集合,因为打印结果的字母有顺序,所以使用treemap集合
3,遍历字符数组:
将每一个字母作为键取查map集合,
如果返回null,将该字母和1存入到map集合中。
如果返回不是null,说明该字母在map集合已经存在并有对应次数,
那么就获取该次数并进行自增,然后将该字母和自增后的次数存入到map集合中,覆盖掉原来键对应的值
4,将map集合中的数据变成指定的字符串形式返回。
*/
class MapTest2
{
public static void main(String[] args)
{
String s = charCount("a+ab=dcoooobd,skdslc");
System.out.println(s);
}
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);
count=0;
/*
if (value==null)
{
tm.put(chs[x],1);
}
else
{
value++;
tm.put(chs[x],value);
}*/
}
//System.out.println(tm);
StringBuilder sb = new StringBuilder(); //定义一个容器,用于存放tm集合
Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet(); //获取集合元素的映射关系
Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<Character,Integer> em = it.next();
Character key = em.getKey();
Integer value = em.getValue();
sb.append(key+"("+value+")");
//System.out.println("key="+key+"...value="+value);
}
return sb.toString();
}
}