Java学习第15-16天：集合框架之Map和泛型（半壁江山了）

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

Until15

集合框架

1、Treeset

2、Treeset存储自定义对象

3、二叉树

4、实现comparator方法排序

5、Treeset练习

6、泛型概念

7、泛型使用

8、泛型类

9、泛型方法

10、静态方法泛型

11、泛型接口

12、泛型限定·

 

注意：compareTo 和 compare的返回值都是Int类型

Treeset

Treeset 弥补了hashset无序的不足

（可以对set集合进行自然排序）

保证元素的唯一性方法

 

Treeset存储自定义对象

往treeset存的对象要有比较性（其中会涉及classCastException异常）

要实现comparable接口---对应要覆盖compareTo方法

 

提一点！String类自身implements comparable接口了！所以有compareTo方法！

 

二叉树

Treeset的底层数据结构就是二叉树！

二叉树的好处是！减少比较次数、提高效率（自动取折中值））

实现comparator方法排序

Treeset排序的第一种方法：让元素自身具有比较行！实现comparable接口，覆写其中compareTo()方法！（Integer也具备compareTo比较方法）

Treeset排序的第二种方法：当元素自身不具备比较性的时候，则让集合自身具备比较性！（集合一初始化就具备比较方法），使容器具备比较性之后，传给treeset！该方法是实现comparator方法，覆写compare（s1,s2）方法！

 

Treeset练习

public class Demo_TreeSet_01 {

public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<Person>();
ts.add(new Person("张三",20));
ts.add(new Person("老胡",23));
ts.add(new Person("张三",21));
ts.add(new Person("贝贝",20));
ts.add(new Person("涵妮",44));
Iterator<Person> it = ts.iterator();
while(it.hasNext()){
Person p =it.next();
System.out.println(p.getName()+"...."+p.getAge());
}
}

}
/**
//第一种比较方法
class Person implements Comparable
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Person))
throw new RuntimeException("该类不是Person类");
Person p = (Person)obj;
System.out.println(this.name+"....."+p.name);
if(this.age != p.age)
return 1;
if(this.age == p.age)
{
return this.name.compareTo(p.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
*/

 public class Demo_TreeSet_02 {

public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<Person>(new MyComparator());
ts.add(new Person("张三",21));
ts.add(new Person("老胡",23));
ts.add(new Person("张三",20));
ts.add(new Person("贝贝",20));
ts.add(new Person("涵妮",44));
Iterator<Person> it = ts.iterator();
while(it.hasNext()){
Person p =it.next();
System.out.println(p.getName()+"...."+p.getAge());

}
}
}
//方法二
class MyComparator implements Comparator
{
public int compare(Object s1,Object s2)
{
Person p1 = (Person)s1;
Person p2 = (Person)s2;
int num = p1.getName().compareTo(p2.getName());
if(num == 0)
{
if(p1.getAge()>p2.getAge())
return 1;
if(p1.getAge()==p2.getAge())
return 0;
return -1;
}
return num;
}
}
class Person implements Comparable
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Person))
throw new RuntimeException("该类不是Person类");
Person p = (Person)obj;
System.out.println(this.name+"....."+p.name);
if(this.age != p.age)
return 1;
if(this.age == p.age)
{
return this.name.compareTo(p.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
 

public class Collection_TreeSet {

/**
* 按字符串的长度进行比较！
* 而元素本身具备这种比较性是不需要的！所以需要定义一个类来让类实现comparator接口！让容器具备比较性
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet<String> ts = new TreeSet<String>(new MyPe());
ts.add("jasbdjk");
ts.add("akdjha");
ts.add("uuuwooopqpknm");
ts.add("asd");
ts.add("a");
System.out.println(ts);
}

}
class MyPe 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;
}
}

泛型概念

泛型是JDK1.5之后出现的新特性！

它解决了安全问题！

（类型安全机制！）

[ ]	用于数组
{ }	用于代码
< >	用于泛型
( )	用于参数

 

优点：将运行时期可能遇到的问题转移到编译时期了！

     避免了强制转换的麻烦

public class Demo_泛型 {
public static void main(String[] args) {
// TODO Auto-generated method stub

}

}
//泛型类
//当类要操作的数据引用类型不确定的时候可以使用泛型类
class Utt<qq>
{
private qq q;
public void setQ(qq q)
{
this.q = q;
}
public qq getQ()
{
return q;
}
public <T> void print(T t)//泛型方法
{
System.out.println(t);
}
/**
* 静态泛型类！
* 静态方法不可以访问类上定义的泛型！
* 如果静态方法要操作的数据类型不确定，可以在方法上定义泛型
*/
public static <w> void printt(w t)//泛型方法
{
System.out.println(t);
}
}
//泛型接口
interface bb<T>
{
void show(T t);
}
class dd<T> implements bb<T>
{
public void show(T t)
{
System.out.println(t);
}
}
/**
泛型限定：
<? extends E>可以接受E类型或其子类。上限 ？---》E
|--子类

|---父类
<? super E>可以接受E类型或E的父类 下限 ？-- E
？ --》可以是通配符！
*/



Until16

1、map概述

2、Map子类对象特点

3、Map共性方法

4、Map-keyset

5、Map-entryset

6、Map练习

7、Treemap练习

8、Treemap练习-字母出现的次数

9、Map扩展

 

map概述

Map集合存储键值对。一对一对往里面存的!key的唯一性一定要保证
需求	方法	注解
添加	Put(K key,V value); putAll(Map<? Extends k,? Extends v>,m>
删除	Clear(); Remove(Object key)
判断	contaisValue(Object value); contaisKey(Object Key); isEmpty
获取	Get(Object key); Size(); Values(); 【entrySet()和keySet()】

 

和collection同属顶层位置！但无必要联系！

collection	map
单身汉	夫妻对

 

 

 

Map< key,value> 该集合是一种映射关系来的！

该集合存储键值对的时候，要保证key的唯一性

它的存入方法是put()! 比较特殊~不是add~要记着！而且集合中查看集合长度用的是size（）方法！

该集合获取value的方式有两种！一种是entrySet()  一种是keySet()

 

Map子类对象特点

 

Map子类	特点	注解
HashTable	底层用的是哈希表！不能传Null~线程是同步的	这个是1.0版本的方法
HashMap	底层同样是用哈希表！~语序使用Null!线程是不同步的	这个是1.2版本之后的方法
TreeMap	二叉树数据结构！线程同步，可对key进行排序	其实set底层就是调用map的集合

 

 

Map-keyset和Map-entryset

 

public class Demo_Map_keySet {

public static void main(String[] args) {
// 演示keySet方法
/*
* keyset：将map中所有的键存入到set集合中！因为set具备迭代器
* 所有可以使用迭代方式取出所有的key，在根据get方法，获取每一个键对应的值
*/
Map<Integer,String> mm = new HashMap<Integer,String>();
mm.put(1, "张三");
mm.put(2, "小光");
mm.put(3, "啊喷");
mm.put(4, "无奈");
mm.put(5, "肖晓明");
Set<Integer> ss = mm.keySet();
Iterator<Integer> it = ss.iterator();
while(it.hasNext()){
int key = it.next();
String value = mm.get(key);
System.out.println(key+"=="+value);
}
}

}
public class Demo_Map_entrySet {

public static void main(String[] args) {
// 演示entrySet方法
/*
* Set<Map.Entry<k,v>> entrySet:
* 将map集合中的映射关系存入到set集合中！而这个关系的数据类型是Map.Entry
*/
Map<Integer,String> mm = new HashMap<Integer,String>();
mm.put(1, "张三");
mm.put(2, "小光");
mm.put(3, "啊喷");
mm.put(4, "无奈");
mm.put(5, "肖晓明");
Set<Map.Entry<Integer,String>> ss = mm.entrySet();
Iterator<Map.Entry<Integer,String>> it = ss.iterator();
while(it.hasNext())
{
Map.Entry<Integer,String> mp = it.next();
int key = mp.getKey();
String value = mp.getValue();
System.out.println(key+"......"+value);
}
}

}
 

Map练习

package until_16;
import java.util.*;
public class Demo_Map {

/*(写的真乱！没点耐心自己都不想看自己的代码！)
* 每个学生都有对应的归属地
* 学生Student 地址String
* 学生属性包括-姓名和年龄！同名同年的为同一个人!保证学生的唯一性
* 思路！第一描述学生~
* 第二定义map容器~将学生作为key传入~地址作为值！
* 第三获取map集合中的元素（用第二种！练习）
*/
public static void main(String[] args) {
Map<Student,String> mm = new HashMap<Student,String>();
mm.put(new Student("张三",12),"深圳" );
mm.put(new Student("张三",12),"上海" );
mm.put(new Student("凑名",20),"北京" );
mm.put(new Student("欲走",21),"广州" );
//!方法一!方法一!以下是自己的错误思路和正确思路的一些做法！文本注释的基本为自己的错误想法
//调用的是EntrySte方法
//Set<Map.Entry<Student,String>> entrySet = mm.entrySet();
Set<Student> keySet = mm.keySet();//使用keySet方法
//调用的是EntrySte方法
//Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
/**
* 完全没有必要
Set<Student> stu = new TreeSet<Student>(new MyComp());//建立另一个容器用来存student对象
*/
Iterator<Student> it = keySet.iterator();
while(it.hasNext())
{
/*
调用的是EntrySte方法
Map.Entry<Student, String> mp = it.next();
Student key = mp.getKey();
String keyy = getKey(key);
String value = mp.getValue();
System.out.println(keyy+"=="+value);
*/
Student stu = it.next();
String value = mm.get(stu);
System.out.println(stu.getName()+"..."+stu.getAge()+"..."+value);
}
/**
* 错误的思路
System.out.println(stu);
Iterator<Student> itt = stu.iterator();
while(itt.hasNext())
{
Student stud = itt.next();
System.out.println(stud.getName()+"=="+stud.getAge());
}
*/
//！方法二！二！
Set<Map.Entry<Student,String>> entrySet = mm.entrySet();
Iterator<Map.Entry<Student,String>> itt = entrySet.iterator();
while(itt.hasNext())
{
Map.Entry<Student, String> me = itt.next();
Student stu = me.getKey();
String ss = me.getValue();
System.out.println(stu+"..."+ss);
}
}
public static String getKey(Student st)
{
Set<Student> stu = new TreeSet<Student>(new MyComp());
stu.add(st);
Iterator<Student> it = stu.iterator();
String nameage = null;
while(it.hasNext())
{
Student s = it.next();
String name = s.getName();
int age = s.getAge();
nameage = "名字："+name+"=="+"年龄"+age;
}
return nameage;
}

}
class MyComp implements Comparator //让类具备了比较性
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
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 //学生类！~自定了hashCode、equals方法！还有让元素具备了比较性
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
return -1;
Student s = (Student)obj;
int num = new Integer(this.age).compareTo(new Integer(s.age));
if(num == 0)
{
return this.name.compareTo(s.name);
}
return num;
}
public int hashCode()
{
return name.hashCode()+age;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student s = (Student)obj;
if(this.age>s.age)
return true;
if(this.age == s.age){
return this.name.equals(s.name);
}
return false;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+":"+age;
}
}


Treemap练习
package until_16;
import java.util.*;
public class Demo_Map_1 {

/**
* 对学生对象的年龄进行升序排序
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<Studenw,String> mm = new TreeMap<Studenw,String>();
mm.put(new Studenw("张三",12),"深圳" );
mm.put(new Studenw("张三",12),"上海" );
mm.put(new Studenw("凑名",20),"北京" );
mm.put(new Studenw("欲走",21),"广州" );
Set<Studenw> s = mm.keySet();
Iterator<Studenw> it = s.iterator();
while(it.hasNext())
{
Studenw t = it.next();
String value = mm.get(t);
System.out.println(t+"....."+value);
}
}
}
class Studenw implements Comparable<Studenw>
{
private String name;
private int age;
Studenw(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Studenw w)
{
int num = new Integer(this.age).compareTo(new Integer(w.age));
if(num==0)
return this.name.compareTo(w.name);
return num;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+age;
}
}



Treemap练习-字母出现的次数

 package until_16;
import java.util.*;
public class Demo_Map_2 {

/**
* 获取字符串字母出现的次数
* 分析：根据字母的出现和次数---形成映射关系！如果key为字母，而字母出现的次数为value!
* 如果是这样的话~我们就可以考虑map集合！~然后因为想要abcd的排序方式~使用的集合对象就可以是TreeMap!~
*
* 思路：1、将字符串转换成字符数组
* 2、定义TreeMap集合
* 3、遍历的方式！：让字母作为key和集合中的key进行比较
* 如果返回的是Null的话~就将字母和1存入
* 如果返回的不是null~取出集合中的key对应value~自增
* 4、将map集合中的键值对根据我们需要的方式变成字符串打印输出
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "akjdh12nbiuhehirkndKJRH";
getMap(s);
}
public static void getMap(String s)
{
char[] ch = s.toCharArray();
int port = 0;
Map<Character,Integer> m = new TreeMap<Character,Integer>();
for(int x = 0;x<ch.length;x++)
{
//System.out.println(m.containsKey(ch[port]));
if(!m.containsKey(ch[port]))
{
//System.out.println("p");
m.put(ch[port], 1);
}
else
{
int value = m.get(ch[port]);
m.put(ch[port], ++value);
}
port++;
}
Set<Map.Entry<Character, Integer>> ss = m.entrySet();
Iterator<Map.Entry<Character, Integer>> it = ss.iterator();
while(it.hasNext())
{
Map.Entry<Character, Integer> me = it.next();
char key = me.getKey();
int value = me.getValue();
System.out.print(key+"("+value+")");
}
}
}

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