package cn.itcast.p3.collection.demo;

import java.util.ArrayList;

import java.util.Collection;

public class CollectionDemo {

    /**

     * @param args

     */

    public static void main(String[] args) {

        /*Collection coll = new ArrayList();

        show(coll);

    */

        Collection c1 = new ArrayList();

        Collection c2 = new ArrayList();

        show(c1,c2);

    }

    public static void show(Collection c1,Collection c2){

        //给c1添加元素。

        c1.add("abc1");

        c1.add("abc2");

        c1.add("abc3");

        c1.add("abc4");

        //给c2添加元素。

        c2.add("abc2");

        c2.add("abc5");

        c2.add("abc6");

        System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3, abc4]

        System.out.println("c2:"+c2);//c2:[abc2, abc5, abc6]

        //将c2中的元素添加到c1集合中,添加一堆

        c1.addAll(c2);

        System.out.println(c1);//[abc1, abc2, abc3, abc4, abc2, abc5, abc6]

        //演示removeAll

        //将两个集合中的相同元素从调用removeAll的集合中删除,从c1中删除c1和c2相同的元素

    /*    boolean b = c1.removeAll(c2);

        System.out.println("removeAll:"+b);

        System.out.println("c1"+c1);//c1[abc1, abc3, abc4]

*/

        //演示containsAll，c1集合中是否包含C2中的所有元素，包含返回true

        boolean b1 = c1.containsAll(c2);

        System.out.println("containsAll:"+b1);

        //演示retainAll 取交集，保留和指定的集合相同的元素，而删除不同的元素。和removeAll功能相反 。
        //c2:[abc2, abc5, abc6],
        //addAll后的C1:[abc1, abc2, abc3, abc4, abc2, abc5, abc6]

//        boolean b = c1.retainAll(c2);

//        System.out.println("retainAll:"+b);

//        System.out.println("c1:"+c1);//c1:[abc2, abc2, abc5, abc6]

    }

    /**

     * 测试集合 Collection集合中的方法

     * @param coll

     */

    public static void show(Collection coll){

        //1,添加元素。add.

        coll.add("abc1");

        coll.add("abc2");

        coll.add("abc3");

        System.out.println(coll);

        //2，删除元素。remove

        if(coll.contains("abc2")){

            coll.remove("abc2");//会改变集合的长度

        }

        //清空集合

        //coll.clear();//清空集合中的元素，但是集合还在，集合为[]空

        System.out.println(coll.contains("abc3"));

        System.out.println(coll);

    }

}

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class IteratorDemo {

    /**

     * java.util.NoSuchElementException

     */

    public static void main(String[] args) {

        Collection coll = new ArrayList();

        coll.add("abc1");

        coll.add("abc2");

        coll.add("abc3");

        coll.add("abc4");

        System.out.println(coll);//[abc1, abc2, abc3, abc4]

        //使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。

        Iterator it = coll.iterator();

        while(it.hasNext()){

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

        }

    /*    for(Iterator it = coll.iterator(); it.hasNext(); ){

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

        }*/

    }

}

import java.util.ArrayList;

import java.util.List;

/**

 *

List:特有的常见方法：有一个共性特点就是都可以操作角标。

1，添加

    void add(index,element);

    void add(index,collection);

2，删除；

    Object remove(index):

3，修改：

    Object set(index,element);

4，获取：

    Object get(index);

    int indexOf(object);获取指定元素的索引

    int lastIndexOf(object);

    List subList(from,to);

 *

 *

 */

public class ListDemo {

    /**

     * @param args

     */

    public static void main(String[] args) {

        List list = new ArrayList();

        show(list);

    }

    public static void show(List list) {

        //添加元素

        list.add("abc1");

        list.add("abc2");

        list.add("abc3");

        System.out.println(list);//[abc1, abc2, abc3]

        //插入元素,在列表的指定位置插入元素

        list.add(1,"abc9");

        System.out.println(list);//[abc1, abc9, abc2, abc3]

        //删除元素。

        System.out.println("remove:"+list.remove(2));//remove:abc2

        //修改元素。

        System.out.println("set:"+list.set(1, "abc8"));//set:abc9

        //获取元素。

        System.out.println("get:"+list.get(0));//get:abc1

        System.out.println(list);//[abc1, abc8, abc3]

        //获取子列表。

        System.out.println("sublist:"+list.subList(1, 3));//sublist:[abc8, abc3]

        //根据对象获取位置

        System.out.println(list.indexOf("abc8"));//

        System.out.println(list.lastIndexOf("abc3"));//

        System.out.println(list);//[abc1, abc8, abc3]

    }

}

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

public class ListDemo2 {

    /**

     * @param args

     */

    public static void main(String[] args) {

        List list = new ArrayList();

        showListIterator(list);

    }

    /**

     * 可以使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查，不会抛出并发修改的异常

     * 线程只操作迭代对象，不修改集合，这就不是并发的操作，是迭代对象ListIterator中自己的增删改方法，而不是调用集合中的方法

     * @param list

     */

    public static void showListIterator(List list){

        list.add("abc1");

        list.add("abc2");

        list.add("abc3");

        list.add("abc4");

        list.add("abc5");

        System.out.println("list:"+list);

        ListIterator it = list.listIterator();

        while(it.hasNext()){

            Object obj = it.next();

            if(obj.equals("abc4")){

                //it.add("abc9");//不是list.add

                it.set("abc9");

            }

            else

                System.out.print(" "+obj);

        }

        System.out.print("\n");

        System.out.println("********************************");

        //System.out.println("hasnext:"+it.hasNext());

        //System.out.println("hasPrevious:"+it.hasPrevious());

        //System.out.println("previous:"+it.previous());

        //逆向遍历

        while(it.hasPrevious()){

            System.out.print(" "+it.previous());//输出 abc5 abc9 abc3 abc2 abc1

        }

        System.out.print("\n");

        System.out.println("********************************");

        System.out.println(list);

    }

    /**

     * java.util.ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常

     * 集合和迭代器同时对元素进行修改，就会产生异常，一个线程对collection集合迭代，另一个对Collection进行修改的时候，

     * 就会出现上面的异常

     * @param list

     */

    public static void showConcurrentModificationException(List list){

        list.add("abc1");

        list.add("abc2");

        list.add("abc3");

        System.out.println("list:"+list);

        Iterator it = list.iterator();

        while(it.hasNext()){

            Object obj = it.next();//java.util.ConcurrentModificationException

                            //在迭代器过程中，不要使用集合操作元素，容易出现异常。

                        //可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。

            if(obj.equals("abc2")){

                list.add("abc9");

            }

            else

                System.out.println("next:"+obj);

        }

        System.out.println(list);

    }

    /**

     * List集合的遍历，下面两种方法都可以

     * @param list

     */

    public static void show(List list) {

        list.add("abc1");

        list.add("abc2");

        list.add("abc3");

        list.add("abc4");

        //第一种使用iterator

        Iterator it = list.iterator();

        while(it.hasNext()){

            System.out.println("next:"+it.next());

        }

        //list特有的取出元素的方式之一。

        for(int x=0; x<list.size(); x++){

            System.out.println("get:"+list.get(x));

        }

    }

}

import java.util.Enumeration;

import java.util.Iterator;

import java.util.Vector;

public class VectorDemo {

    /**Enumeration枚举接口的功能和Iterator迭代器接口的功能是重复的，Iterator接口添加了一个可选的移除方法，并使用较短的方法名

     * java1.2开始，使用Iterator替代Enumeration

     * @param args

     */

    public static void main(String[] args) {

        Vector v = new Vector();

        v.addElement("abc1");

        v.addElement("abc2");

        v.addElement("abc3");

        v.addElement("abc4");

        Enumeration en = v.elements();

        while(en.hasMoreElements()){

            System.out.println("nextelment:"+en.nextElement());

        }

        Iterator it = v.iterator();

        while(it.hasNext()){

            System.out.println("next:"+it.next());

        }

    }

}

package cn.itcast.p.bean;

public class Person  {

    private String name;

    private int age;

    public Person() {

        super();

    }

    public Person(String name, int age) {

        super();

        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 String toString(){

        return name+":"+age;

    }

  }
}

import java.util.ArrayList;

import java.util.Iterator;

import cn.itcast.p.bean.Person;

public class ArrayListTest {

    /**

     * @param args

     */

    public static void main(String[] args) {

        ArrayList<Person> al = new ArrayList<Person>();

        al.add(new Person("listP1",21));

        al.add(new Person("listP1",22));

        al.add(new Person("listP2",23));

        al.add(new Person("listP3",24));

        System.out.println(al);//[listP1:21, listP1:22, listP2:23, listP3:24]

        Iterator it = al.iterator();

        while(it.hasNext()){

            Person p = (Person) it.next();

            System.out.println(p.getName()+"--"+p.getAge());

        }

    }

}

import java.util.Iterator;

import java.util.LinkedList;

public class LinkedListDemo {

    /**

     * @param args

     */

    public static void main(String[] args) {

        LinkedList link = new LinkedList();

        link.addFirst("abc1");

        link.addFirst("abc2");

        link.addFirst("abc3");

        link.addFirst("abc4");

        System.out.println(link);

        System.out.println("使用getFirst---"+link.getFirst());//获取第一个但不删除。当链表为空的时候会抛出抛出NoSuchElementException

        System.out.println("使用getLast---"+link.getLast());//获取最后一个元素，当链表为空的时候会抛出抛出NoSuchElementException

        System.out.println("使用peekFirst---"+link.peekFirst());//获取第一个元素，当链表为为空的时候不会报异常

        System.out.println("使用peekLast---"+link.peekLast());//获取最后一个元素

//        System.out.println("使用link.removeFirst---"+link.removeFirst());//获取第一个元素但是会删除。abc4，当链表为空的时候会抛出抛出NoSuchElementException

//        System.out.println("使用removeFirst---"+link.removeFirst());//abc3

//        System.out.println("使用removeLast---"+link.removeLast());//获取最后一个元素，并移除abc1

        System.out.println("使用pollFirst---"+link.pollFirst());//获取第一个元素并从集合中移除（1.6，出来的新方法，当链表为为空的时候不会报异常）

        System.out.println("使用pollFirst---"+link.pollFirst());

        System.out.println("使用pollLast---"+link.pollLast());//获取最后一个元素并从集合中移除

        System.out.println("使用pollLast---"+link.pollLast());

//        while(!link.isEmpty()){

//            System.out.println(link.removeLast());

//        }

        System.out.println(link);

//        Iterator it = link.iterator();

//        while(it.hasNext()){

//            System.out.println(it.next());

//        }

    }

}

package cn.itcast.p.bean;

public class Person /*extends Object*/ {

    private String name;

    private int age;

    public Person() {

        super();

    }

    public Person(String name, int age) {

        super();

        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 String toString(){

        return name+":"+age;

    }

    @Override

    public boolean equals(Object obj) {//判断人的内容是否相同

        System.out.println("调用了equals方法---------------");

        if(this == obj) //this只是否为Person对象

            return true;

        if(!(obj instanceof Person)){

            throw new ClassCastException("类型转化错误！");

        }

        Person p = (Person)obj;

        return this.name.equals(p.name) && this.age == p.age;//字符创name的内容相同吗

    }

    @Override

    public int hashCode() { //判断人的hash值是否相同

        System.out.println("调用了hashCode方法---------------");

        return name.hashCode()+ age;

    }

}

package cn.itcast.p4.hashset.test;

import java.util.HashSet;

import java.util.Iterator;

import cn.itcast.p.bean.Person;

/*

 * 往hashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人。视为相同元素。

 */

public class HashSetTest {

    /**

     * @param args

     */

    public static void main(String[] args) {

        HashSet hs = new HashSet();

        /*

         * HashSet集合数据结构是哈希表，所以存储元素的时候，我们需要覆盖hashCode方法和equal方法，来确保放入的对象的唯一性

         * 使用的元素的hashCode方法来确定位置，如果位置相同，

         * 在通过元素的equals来确定是否相同,如果相同的话，就不往set里面存

         */

        hs.add(new Person("lisi4",24));

        hs.add(new Person("lisi7",27));

        hs.add(new Person("lisi1",21));

        hs.add(new Person("lisi9",29));

        hs.add(new Person("lisi7",27));

        Iterator it = hs.iterator();

        while(it.hasNext()){

            Person p = (Person)it.next();

            //System.out.println(p);

            System.out.println(p.getName()+"...."+p.getAge());

        }

    }

}

public class Person /*extends Object*/ implements Comparable{

    private String name;

    private int age;

    public Person() {

        super();

    }

    public Person(String name, int age) {

        super();

        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 String toString(){

        return name+":"+age;

    }

    @Override

    public boolean equals(Object obj) {//判断人的内容是否相同

        System.out.println("调用了equals方法---------------");

        if(this == obj) //this只是否为Person对象

            return true;

        if(!(obj instanceof Person)){

            throw new ClassCastException("类型转化错误！");

        }

        Person p = (Person)obj;

        return this.name.equals(p.name) && this.age == p.age;//字符创name的内容相同吗

    }

    @Override

    public int hashCode() { //判断人的hash值是否相同

        System.out.println("调用了hashCode方法---------------");

        return name.hashCode()+ age;

    }

    @Override

    public int compareTo(Object o) {

        if(!(o instanceof Person))

            throw new ClassCastException("类型转化错误");

        Person p = (Person)o;

        int temp = this.age-p.age;

        return temp==0 ? (this.name.compareTo(p.name)) : temp;//temp等于0表示年龄相等。

    }

}

public class Person{

    private String name;

    private int age;

    public Person() {

        super();

    }

    public Person(String name, int age) {

        super();

        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 String toString(){

        return name+":"+age;

    }

}

import java.util.Comparator;

import cn.itcast.p.bean.Person;

/**

 * 创建了一个根据Person类的name进行排序的比较器。

 * 先按照姓名进行比较，如果姓名相同，再按照年龄进行比较

 */

public class ComparatorByName implements Comparator {

    @Override

    public int compare(Object o1, Object o2) {

        Person p1 = (Person)o1;

        Person p2 = (Person)o2;

        int temp = p1.getName().compareTo(p2.getName());

        //比较姓名相同，在比较年龄

        return temp==0?p1.getAge()-p2.getAge(): temp;

//        return 1;//有序。

    }

}

package cn.itcast.p5.treeset.demo;

import java.util.Iterator;

import java.util.TreeSet;

import cn.itcast.p.bean.Person;

import cn.itcast.p5.comparator.ComparatorByName;

public class TreeSetComparator {

    /**

     * @param args

     */

    public static void main(String[] args) {

        TreeSet ts = new TreeSet(new ComparatorByName());

        /*

         * 自定义对象，使用TreeSet，进行自然排序的时候，

         * 需要实现Comparable接口，添加元素的时候进行比较

         *

         * 以Person对象年龄进行排序，如果年龄相同，就按照姓名排序

         *

         */

        ts.add(new Person("zhangsan",28));

        ts.add(new Person("lisi",21));

        ts.add(new Person("zhouqi",29));

        ts.add(new Person("zhaoliu",25));

        ts.add(new Person("wangu",24));

        Iterator it = ts.iterator();

        while(it.hasNext()){

            Person p = (Person)it.next();

            System.out.println(p.getName()+":"+p.getAge());

        }

    }

}

package cn.itcast.p5.treeset.test;

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

import cn.itcast.p.bean.Person;

import cn.itcast.p5.comparator.ComparatorByLength;

/*

 * 对字符串进行长度排序，比较内容

 *

 * "20 18 -1 89 2 67"

 */

public class TreeSetTest {

    /**

     * @param args

     */

    public static void main(String[] args) {

        //接口内部类

        TreeSet ts = new TreeSet(new Comparator<String>() {

            @Override

            public int compare(String o1, String o2) {

                int temp = o1.length()-o2.length();

                return temp==0 ? o1.compareTo(o2):temp;

            }

        });

        ts.add("aaaaa");

        ts.add("zz");

        ts.add("nbaq");

        ts.add("cba");

        ts.add("abc");

        ts.add("abc");

        Iterator it = ts.iterator();

        while(it.hasNext()){

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

        }

    }

}

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

public class MapDemo {

    public static void main(String[] args) {

        Map<Integer,String> map = new HashMap<Integer,String>();

        method(map);

    }

    /**

     *

     * Set<Map.Entry<K,V>> entrySet()方法：返回一个set集合，里面装的是Map.Entry接口类型的键值对象

     *

     * 第二种遍历map的方式：通过看API:Set<Map.Entry<K,V>> entrySet()：Map.Entry<K,V>接口类型，

     * 里面有K getKey() 返回与此项对应的键。 V getValue()  返回与此项对应的值。 

     * 思路：通过把map转化为set，进行迭代

     * 通过使用entrySet方法吧键和值的映射关系作为对象，存储到set集合中，这个映射关系的类型为Map.Entry类型

     *

     *

     */

    public static void method_3(Map<Integer,String> map){

        map.put(8,"lisi");

        map.put(2,"zhaoliu");

        map.put(7,"wangwu");

        map.put(6,"wangwang");

        Set<Map.Entry<Integer, String>>entrySet = map.entrySet();

        System.out.println(entrySet);//[2=zhaoliu, 6=wangwang, 7=wangwu, 8=lisi]

        Iterator<Map.Entry<Integer, String>>it = entrySet.iterator();

        //System.out.println(it.next());

        while(it.hasNext()){

            Map.Entry<Integer, String> entryMap = it.next();

            Integer key = entryMap.getKey();//获取键

            String value = entryMap.getValue();//获取值

            System.out.println(key+":"+value);

        }

    }

    /*

     * 第一种遍历的方法

     * Set<K> keySet()：返回键的set集合

     * 取出map中的所有元素。

     * 原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，

             在对每一个键通过map集合的get方法获取其对应的值即可。  

     */

    public static void method_2(Map<Integer,String> map){

        map.put(8,"zhaoliu");

        map.put(2,"zhaoliu");

        map.put(7,"xiaoqiang");

        map.put(6,"wangcai");

        Set<Integer> keySet = map.keySet();

        System.out.println(keySet);//键的set集合[2, 6, 7, 8]

        Iterator<Integer> it = keySet.iterator();//迭代keySet

        while(it.hasNext()){

            Integer key = it.next();

            String value = map.get(key);

            System.out.println(key+":"+value);

        }

    }

    /**

     * 常用方法：

            1，添加。

                value put(key,value):返回前一个和key关联的值，如果没有返回null.

            2，删除。

                void  clear():清空map集合。

                value remove(key):根据指定的key翻出这个键值对。 

            3，判断。

                boolean containsKey(key):

                boolean containsValue(value):

                boolean isEmpty();

            4，获取。

                value get(key):通过键获取值，如果没有该键返回null。

                                当然可以通过返回null，来判断是否包含指定键。

                int size(): 获取键值对的个数。 

            5.特殊方法： Collection<V> values() 包含的值的 Collection 视图。

     * @param map

     */

    public static void method(Map<Integer,String> map){//学号和姓名

        // 添加元素。

        System.out.println(map.put(8, null));//null

        System.out.println(map.put(8, "xiaoqiang"));//wangcai 存相同键，值会覆盖。

        map.put(2,"zhangsan");

        map.put(7,"zhaoliu");

        /*System.out.println(map);

        //删除。

        System.out.println("remove:"+map.remove(2));

        //判断。

        System.out.println("containskey:"+map.containsKey(6));

        System.out.println("containsValue:"+map.containsValue("zhaoliu"));

        //获取。

        System.out.println("get:"+map.get(7));

        System.out.println(map);*/

        //返回key对应的所有value的集合

        Collection<String>values = map.values();

        System.out.println(values);

        Iterator<String>it = values.iterator();

        while(it.hasNext()){

            String value = it.next();

            System.out.println(value);

        }

    }

}

interface MyMap{

    public static interface MyEntry{//内部接口

        void get();

    }

}

class MyDemo implements MyMap.MyEntry{

    public void get(){}

}

class Outer{

    static class Inner{

        static void show(){}

    }

}

public class Person  {

    private String name;

    private int age;

    public Person() {

        super();

    }

    public Person(String name, int age) {

        super();

        this.name = name;

        this.age = age;

    }

    @Override

    public int hashCode() {

        final int prime = 31;

        int result = 1;

        result = prime * result + age;

        result = prime * result + ((name == null) ? 0 : name.hashCode());

        return result;

    }

    @Override

    public boolean equals(Object obj) {

        if (this == obj)

            return true;

        if (obj == null)

            return false;

        if (getClass() != obj.getClass())

            return false;

        Person other = (Person) obj;

        if (age != other.age)

            return false;

        if (name == null) {

            if (other.name != null)

                return false;

        } else if (!name.equals(other.name))

            return false;

        return true;

    }

    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;

    }

    @Override

    public String toString() {

        return "Person:"+getName()+":"+getAge();

    }

}

package cn.itcast.p2.bean;

public class Student extends Person {

    public Student() {

        super();

    }

    public Student(String name, int age) {

        super(name, age);

    }

    @Override

    public String toString() {

        return "Student:"+getName()+":"+getAge();

    }

}

package cn.itcast.p7.hashmap.demo;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Set;

import cn.itcast.p2.bean.Student;

public class HashMapDemo {

    /**

     * @param args

     */

    public static void main(String[] args) {

        /*

         * 将学生对象和学生的归属地通过键与值存储到map集合中。

         *

         */

        HashMap<Student,String> hm = new HashMap<Student,String>();

        hm.put(new Student("lisi",38),"北京");

        hm.put(new Student("zhaoliu",24),"上海");

        hm.put(new Student("xiaoqiang",31),"沈阳");

        hm.put(new Student("wangcai",28),"大连");

        hm.put(new Student("zhaoliu",24),"铁岭");

//        Set<Student> keySet = hm.keySet();

//        Iterator<Student> it = keySet.iterator();

        Iterator<Student> it = hm.keySet().iterator();

        while(it.hasNext()){

            Student key = it.next();

            String value = hm.get(key);

                System.out.println(key.getName()+":"+key.getAge()+"---"+value);

        }

    }

}
    

package cn.itcast.p3.comparator;

import java.util.Comparator;

import cn.itcast.p2.bean.Person;

public class ComparatorByName implements Comparator<Person> {

    @Override

    public int compare(Person o1, Person o2) {

        int temp = o1.getName().compareTo(o2.getName());

        return temp==0? o1.getAge()-o2.getAge(): temp;

    }

}

package cn.itcast.p8.treemap.demo;

import java.util.Iterator;

import java.util.Map;

import java.util.TreeMap;

import cn.itcast.p2.bean.Student;

import cn.itcast.p3.comparator.ComparatorByName;

public class TreeMapDemo {

    /**

     * @param args

     */

    public static void main(String[] args) {

        TreeMap<Student,String> tm = new TreeMap<Student,String>(new ComparatorByName());

        tm.put(new Student("lisi",38),"北京");

        tm.put(new Student("zhaoliu",24),"上海");

        tm.put(new Student("xiaoqiang",31),"沈阳");

        tm.put(new Student("wangcai",28),"大连");

        tm.put(new Student("zhaoliu",24),"铁岭");

        Iterator<Map.Entry<Student, String>> it = tm.entrySet().iterator();

        while(it.hasNext()){

            Map.Entry<Student,String> me = it.next();

            Student key = me.getKey();

            String value = me.getValue();

            System.out.println(key.getName()+":"+key.getAge()+"---"+value);

        }

    }

}

package cn.itcast.p1.map.demo;

import java.io.File;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

public class LinkedHashMapDemo {

    /**

     * LinkedHashMap 按顺序存入，按顺序取出

     */

    public static void main(String[] args) {

        File f= null;

        HashMap<Integer,String> hm = new LinkedHashMap<Integer,String>();

        hm.put(7, "zhouqi");

        hm.put(3, "zhangsan");

        hm.put(1, "qianyi");

        hm.put(5, "wangwu");

        Iterator<Map.Entry<Integer,String>> it = hm.entrySet().iterator();

        while(it.hasNext()){

            Map.Entry<Integer,String> me = it.next();

            Integer key = me.getKey();

            String value = me.getValue();

            System.out.println(key+":"+value);

        }

    }

}