Java基础——集合

1、总述
集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定就使用集合容器进行存储。

集合特点：
1、用于存储对象的容器
2、集合的长度是可变的
3、集合中不可以存储基本数据类型值

集合容器因为内部的数据结构不同，有多种具体容器，不断向上抽取，就形成了集合框架。

2、框架的顶层Collection接口（其他继承Collection集合类都具有以下方法）：

1、添加
boolean add(Object obj);
boolean addAll(Collection coll);

2、删除
boolean remove(Object obj);
boolean removeAll(Collection coll);
void clear();

3、判断：
boolean contains(Object obj);
boolean containsAll(Collection coll);
boolean isEmpty();判断集合中是否有元素

4、获取
int size();
Iterator iterator():取出元素的方式：迭代器
该对象必须依赖于具体容器，因为每一个容器的数据结构不同，所以该迭代器对象是在容器内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就是iterator方法。
iterator接口就是对所有的Collection容器进行元素取出的公共接口。

5、其他：
boolean retainAll(Collection coll);取交集
Object[] toArray():将集合转成数组

3、继承Collection的子类有List和Set

collection
|—list:有序（存入与取出的顺序一致），元素都有索引，元素可以重复。
|—set:元素不能重复，无序。

3.1List
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)
list集合是可以对元素的增删改查

List又分为:
|–Vector:内部是数组数据结构，是同步的。增删查询都很慢
|–ArrayList:内部是数组数据结构，是不同步的。替代了Vector(效率高)。查询速度非常快
|–LinkedList:内部是链表数据结构，是不同步的。增删元素的速度非常快。

LinkedList:
addFirst()
addLast()
jdk1.6
offerFirst()
offerLast()

getFirst()//获取但不移除，如果链表为空，抛出NoSuchElementException异常
getLast()
jdk1.6
peekFirst()//获取但不移除，如果链表为空，返回null
peekLast()

removeFirst()//获取并移除，如果链表为空，抛出NoSuchElementException异常
removeLast()
jdk1.6
pollFirst()//获取并移除，如果链表为空，返回null
pollLast()

3.2 Set
Set:元素不可以重复，是无序的。
Set接口中的方法和Collection方法是一致的
Set
|—HashSet:内部数据结构是哈希表，是不同步的
哈希表确定元素是否相同：
1、判断的是两个元素的哈希值是否相同
如果相同，再判断两个对象的内容是否相同
2、判断哈希值相同，其实判断的是对象的hashCode的方法。
判断内容相同用的是equals方法
注意：如果哈希值不同，是不需要判断equals。
|—TreeSet:可以对Set集合中的元素进行排序，不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元素需要实现Comparable接口。覆盖compareTo方法。

如果不要按照对象中具备的自然顺序进行排序，如果对象中不具备自然顺序。
可以使用TreeeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖Compare方法
将该类对象作为参数传递给TreeSet集合中的构造函数 比较器常用些。

4、泛型
泛型：
jdk1.5出现的安全机制
好处：
1、将运行时期的问题ClassCastException转到了编译时期
2、避免了强制转换的麻烦
<>:什么时候用？
当操作的引用数据类型不确定的时候，就使用<>.将要操作的引用数据类型传入即可。
其实<>就是一个用于接收具体引用数据类型的参数范围。

在程序中，只要用到了带有<>的类或接口，就要明确传入的具体引用数据类型（不能是基本数据类型），如果没有<>默认就是Object类型，也就是在后面需要强转。

泛型技术是给编译器使用的技术，用于编译时期，确保了类型的安全。
运行时会将泛型去掉，生成的class文件中是不带泛型的这个称为泛型的擦除。
为什么擦除呢？因为为了兼容运行的类加载器。

泛型的补偿：在运行时，通过获取元素的类型进行转换动作，不用使用者再强制转换了。

泛型的通配符格式：？未知类型

5、集合总结
集合的一些技巧：
需要唯一吗？
需要：Set
需要制定顺序：
需要：TreeSet
不需要：HashSet
但是想要一个和存储一致的顺序（有序）：LinkedHashSet
不需要：List
需要频繁增删吗？
需要：LinkedList
不需要：ArrayList

前缀名就是该集合的数据结构,后缀名就是该集合所属的体系。
看到array:就要想到数组，就要想到查询快，有角标。
看到link：就要想到链表，就要想到增删快，就要想到add get remove+first last的方法。
看到hash：就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashCode方法和equals方法。
看到tree:就要想到二叉树，就想要排序，就要想到两个接口Comparable,Comparator。
而且通常这些常用的集合容器都是不同步的。

6、Map
Map:一次添加一对元素。Collection一次添加一个元素。
Map也称为双列集合，Collection称为单列集合。
其实Map集合中存储的就是键值对。
map集合必须保证键的唯一性。

6.1Map常用的方法
常用方法：
1、添加
value put(key,value):返回前一个和key关联的值，如果没有返回null

2、删除
value remove():根据指定的key翻出这个键值对
value clear():清空map集合
3、判断
boolean containsKey(key)
boolean containsValue(value)
boolean isEmpty()
4、获取
value get(key):通过键获取值，如果没有该键返回null
当然可以通过返回null,来判断是否包含指定键
int size():获取键值对的个数

6.2 Map子类
Map常用的子类：
|—Hashtable:内部结构是哈希表，是同步的。不允许null作为键，null作为值
|—Properties:用来存储键值对型的配置文件的信息，可以和IO技术相结合
|—HashMap:内部结构是哈希表，不是同步的。允许null作为键，null作为值
|—TreeMap:内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序

7.代码示例

7.1基本数据类型对象

package cn.itcast.p2.wrapper.demo;

public class WrapperDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * 
         * 基本数据类型对象包装类
         * 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了
         * 属性和行为丰富了该数据的操作。
         * 用于描述该对象的类就称为基本数据类型对象包装类
         * 
         * 
         * byte     Byte
         * short    Short
         * int      Integer
         * long     Long
         * float    Float
         * double   Double
         * char     Character
         * boolean  Boolean
         * 
         * 
         * 该包装对象主要用基本类型和字符串之间的转换
         * 
         * 基本类型---》字符串
         *      1、基本类型数值+""
         *      2、用String类中的静态方法valueOf（基本类型数值）
         *      3、用Integer中的静态方法valueOf(基本类型数值)
         * 
         * 字符串---》基本类型
         *      1、使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");其中xxx代表8中具体类型
         *          例如：Long.parseLong("longstring"),只有Character没有parse方法
         *      2、如果字符串被Integer进行对象的封装
         *          可使用另一个非静态的方法，intValue();将一个Integer对象转成基本数据类型值
         * 
        * */
        int num=4;
        System.out.println(Integer.MAX_VALUE);//获取int类型的最大值
        System.out.println(Integer.toBinaryString(6));//进制转换

        Integer i=new Integer(num);//将基本数据类型转换成对象
        System.out.println(Integer.parseInt("123")+1);//将字符串转成数字

        Integer dig =new Integer("123");
        System.out.println(dig.intValue());//非静态方法将字符串转成

        /*
         * 整数具备不同的进制体现：
         * 
         * 十进制-->其他进制
         * 
         * 其他进制-->十进制
         * 
         * 
         * */
//      十进制-->其他进制
        System.out.println(Integer.toBinaryString(60));//将10进制转成2进制
        System.out.println(Integer.toOctalString(60));//将10进制转成8进制
        System.out.println(Integer.toHexString(60));//将10进制转成16进制

        System.out.println(Integer.toString(60,2));//将2进制转成10进制
        System.out.println(Integer.toString(60,8));//将8进制转成10进制
        System.out.println(Integer.toString(60,16));//将16进制转成10进制
//      十进制-->其他进制
        System.out.println(Integer.parseInt("110",2));//将字符串从2进制转成10进制
//      自动拆箱
        Integer a=new Integer("3");
        Integer b=new Integer(3);

        System.out.println(a==b);//结果为:false
        System.out.println(a.equals(b));//结果为:true 自动拆箱
        System.out.println(a.compareTo(b));//相等返回结果0

    }

}

package cn.itcast.p2.wrapper.demo;

public class WrapperDemo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int num=4;
        Integer i=4;//i=new Integer(4);自动装箱，简化书写
        i=i+6;//i=new Integer(i.intValue()+6);//i.intValue()自动拆箱

        Integer a=new Integer(127);
        Integer b=new Integer(127);

        System.out.println(a==b);//false
        System.out.println(a.equals(b));//true

        Integer x=129;//jdk1.5以后，自动装箱，如果装箱的是一个字节（即127及小于127的数x==y），那么该数据会被共享，不会重新开辟新的空间
        Integer y=129;
        System.out.println(x==y);//false
        System.out.println(x.equals(y));//true
    }

}

综合案例

package cn.itcase.p2.wrapper.test;

import java.util.Arrays;

public class WrapperTest {

    private static final String SPACE_SEPARATOR=" ";
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * 对一个字符串中的数值进行从小到大的顺序排序
         * 
         * "20 78 9 -7 88 36 29"
         * 
         * 思路：
         * 1、排序很熟
         * 2、如何获取到这个字符串中的这些需要排序的数值？
         * 发现这些字符串中其实都是空格来对数值进行分隔的
         * 所以就想到用字符串对象的切割方法将大串变成多个小串
         * 3、最终变成小字符串，怎么变成一个int数呢？
         * 字符串变成基本类型使用包装类
         * 
         * */
        String numStr="20 78 9 -7 88 36 29";
        System.out.println(numStr);
        numStr=sortStringNumber(numStr);
        System.out.println(numStr);
    }

    private static String sortStringNumber(String numStr) {
        // TODO Auto-generated method stub
        //1、将字符串变成字符串数组
        String[] str_arr=stringToArray(numStr);
        //2、将字符串数组变成int数组
        int [] num_arr=toIntArray(str_arr);
        //3、对int数组排序
        mySortArray(num_arr);
        //4、将排序后的int数组变成字符串
        String temp=arrayToString(num_arr);
        return temp;
    }

    private static String arrayToString(int[] num_arr) {
        // TODO Auto-generated method stub
        StringBuilder sb=new StringBuilder();
        for(int x=0;x<num_arr.length;x++)
        {
            if(x!=num_arr.length-1)
                sb.append(num_arr[x]+SPACE_SEPARATOR);
            else
                sb.append(num_arr[x]);
        }
        return sb.toString();
    }

    private static void mySortArray(int[] num_arr) {
        // TODO Auto-generated method stub
        Arrays.sort(num_arr);
    }

    /**
     * @param str_arr
     */
    public static int[] toIntArray(String[] str_arr) {
        int[] arr=new int[str_arr.length];
        for(int i=0;i<arr.length;i++)
        {
            arr[i]=Integer.parseInt(str_arr[i]);
        }

        return arr;
    }

    /**
     * @param numStr
     */
    public static String[] stringToArray(String numStr) {
        String[] str_arr=numStr.split(SPACE_SEPARATOR);

        return str_arr;
    }

}

7.2 Collection方法代码示例

package cn.itcast.p3.collection.demo;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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("abc6");
        c2.add("abc7");


        System.out.println("c1:"+c1);
        System.out.println("c2:"+c2);
        //演示addAll
        c1.addAll(c2);//将c2中的元素添加到c1中
        System.out.println("c1:"+c1); 
        /*
        //演示removeAll
        boolean b=c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除
        System.out.println("removeAll:"+b);
        System.out.println("c1:"+c1);
        */
        /*
        //演示containsAll
        boolean b=c1.containsAll(c2);
        System.out.println("containsAll:"+b);
        */
        //演示retainsAll
        boolean b=c1.retainAll(c2);//取两个集合中的交集
        System.out.println("c1:"+c1);



    }
    public static void show(Collection coll)
    {
        //1、添加元素，add
        coll.add("abc1");
        coll.add("abc2");
        coll.add("abc3");
        System.out.println(coll);
        //2、删除元素，remove
        coll.remove("abc2");//会改变集合的长度
        System.out.println(coll);
        //清空集合
        coll.clear();
        System.out.println(coll);
    }
}

package cn.itcast.p3.collection.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Collection coll=new ArrayList();

        coll.add("abc1");
        coll.add("abc2");
        coll.add("abc3");
        coll.add("abc4");
        //使用了Collection中的iteratior()方法.调用集合中的迭代器方法，是为了获取集合中的迭代器对象
        /*第一种方法
        Iterator it=coll.iterator();
//      System.out.println(it.next());
//      System.out.println(it.next());
//      System.out.println(it.next());
//      System.out.println(it.next());

        while(it.hasNext())
        {
            System.out.println(it.next());
        }
        */
        //第二种方式，推荐使用这种方式
        for(Iterator it=coll.iterator();it.hasNext();)
        {
            System.out.println(it.next());
        }
    }

}

7.3 List代码示例

7.3.1 List共同方法代码示例

package cn.itcast.p4.list.demo;

import java.util.ArrayList;
import java.util.List;

public class ListDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        show(list);
    }

    private static void show(List list) {
        // TODO Auto-generated method stub
        //添加元素
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        list.add("abc5");
        System.out.println(list);
        //插入元素
        list.add(1, "abc9");
        System.out.println(list);
        //删除元素
        System.out.println("remove:"+list.remove(2));
        System.out.println(list);
        //修改元素
        System.out.println("set:"+list.set(1, "abc8"));
        System.out.println(list);
        //获取元素
        System.out.println("get:"+list.get(0));
        System.out.println(list);
        //获取子列表
        System.out.println("sublist:"+list.subList(1, 2));
        System.out.println(list);
    }

}

package cn.itcast.p4.list.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        show(list);
    }

    public static void show(List list) {
        // TODO Auto-generated method stub
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        list.add("abc5");

        Iterator it=list.iterator();
        while(it.hasNext())
        {
            System.out.println("迭代器取出方式："+it.next());
        }
        //list特有的取出元素的方式之一
        for(int x=0;x<list.size();x++)
        {
            System.out.println("list的取出方式："+list.get(x));
        }

    }

}

package cn.itcast.p4.list.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListDemo3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        list.add("abc5");
        System.out.println(list);
        ListIterator it=list.listIterator();//获取列表迭代对象
        //它可以实现迭代过程中完成对元素的增删改查
        //只有list集合中具备该迭代功能

        while(it.hasNext())
        {
            Object obj=it.next();
            if(obj.equals("abc2"))
            {
                it.add("abc9");
            }   
        }
        while(it.hasPrevious()) {
            System.out.println("previous:"+it.previous());//从后往前遍历
        }
        System.out.println("list:"+list);
        /*
        Iterator it=list.iterator();
        while(it.hasNext())
        {
            Object obj=it.next();//java.util.ConcurrentModificationException
                            //在迭代器过程中，不要使用集合操作元素，容易出现异常  因为添加了“abc9”之后迭代器对象中并没有这个“abc9”,所以在判断的时候会报错
                            //可以使用Iterator接口的子接口ListIterator来完成在迭代过程中对元素进行更多的操作
            if(obj.equals("abc2")) {
                list.add("abc9");
            }
            else
                System.out.println("next:"+obj);
        }
        System.out.println(list);
        */

    }

}

7.3.2 Vector

package cn.itcast.p4.Vector.demo;

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Vector v=new Vector();
        v.addElement("abc1");
        v.addElement("abc2");
        v.addElement("abc3");
        v.addElement("abc4");
        v.addElement("abc5");
        Enumeration en=v.elements();
        while(en.hasMoreElements()) {
            System.out.println("nextelement:"+en.nextElement());
        }
        Iterator it=v.iterator();
        while(it.hasNext()) {
            System.out.println("next:"+it.next());
        }
    }

}

7.3.3 ArrayList代码示例

Person类

package cn.itcast.p.bean;

public class Person implements Comparable {
    private String name;
    private int age;

    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }


    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        if(this==obj)//用于判定加入集合的是不是同一个对象，如果是则不让其加入集合
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");
        Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;//当姓名和年龄相同的时候才是同一个元素
    }
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()+age;//用于返回对象的hash值
    }
    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 int compareTo(Object o) {
        // TODO Auto-generated method stub
        Person p=(Person)o;
        /*
         * 第二种方法
         * */
        int temp=this.age-p.age;
        return temp==0?this.name.compareTo(p.name):temp;

        /*第一种方法，以年龄排序，如果年龄相等就按姓名排序
        if(this.age>p.age)
            return 1;
        if(this.age<p.age)
            return -1;
        else {
            return this.name.compareTo(p.name);
        }
        */
    }
}

package cn.itcast.p3.ArrayList.test;

import java.util.ArrayList;
import java.util.Iterator;

import cn.itcast.p.bean.Person;

public class ArrayListTestDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList al=new ArrayList();
        al.add(new Person("lisil",21));
        al.add(new Person("lisi2",22));
        al.add(new Person("lisi3",23));
        al.add(new Person("lisi4",24));

        Iterator it=al.iterator();
        while(it.hasNext())
        {
            /*
             * 这样写结果为：
                     * lisil:22
                       lisi3:24
             * 
             * 因为it.next()它是迭代器，会自动往下走，当取到第一个的名字后，又it.next()则跑到下一个即lisil2了，所以取出的是lisil2的年龄
             * 
            System.out.println(((Person) it.next()).getName()+":"+((Person) it.next()).getAge());//((Person) it.next())之所以这样写是因为，ArrayList中存储的是一个对象而且是Object类型的
                                                        //因为ArrayList中能存储任意对象，所以只能默认是Object对象，自然而然返回的也是Object对象，而Object对象没有getName()方法，所以必须强转
             */
            Person p=(Person) it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }

    }

}

7.3.4 LinkedList代码示例

package cn.itcast.p4.Linklist.demo;
import cn.itcast.p4.Linklist.test.DuiLie;
public class LinklistDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
        LinkedList link=new LinkedList();
        link.addFirst("abc1");//作为第一个存储
        link.addFirst("abc2");
        link.addFirst("abc3");
        link.addFirst("abc4");
        System.out.println(link);
        System.out.println(link.getFirst());//获取第一个元素但不删除

        System.out.println(link.removeLast());//删除最后一个
        System.out.println(link);
        Iterator it=link.iterator();
        while(it.hasNext()) {
            System.out.println("iterator:"+it.next());
        }
        */
        DuiLie dl=new DuiLie();
        dl.myAdd("abc1");
        dl.myAdd("abc2");
        dl.myAdd("abc3");
        dl.myAdd("abc4");
        dl.myAdd("abc5");
        while(!dl.isNull())
        {
            System.out.println(dl.myGet());
        }

    }

}

LinkedList模拟队列结构

package cn.itcast.p4.Linklist.test;

import java.util.LinkedList;

public class DuiLie{
    private LinkedList link;
    public DuiLie(){
        link=new LinkedList();
    }
    /*
     * 队列的添加元素的功能
     * */
    public void myAdd(Object obj) {
        link.addLast(obj);
    }
    public Object myGet() {
        return link.removeFirst();
    }
    public boolean isNull() {
        return link.isEmpty();
    }
};

7.4 Set
7.4.1 HashSet代码示例

package cn.itcast.p3.hashset.demo;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashSet hs=new HashSet();

        hs.add("abc1");
        hs.add("abc2");
        hs.add("abc3");
        hs.add("abc4");
        hs.add("abc5");

        Iterator it=hs.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

}

7.4.2HashSet存储对象,覆盖对象中的HashCode和equals方法

Person类

package cn.itcast.p.bean;

public class Person implements Comparable {
    private String name;
    private int age;

    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }


    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        if(this==obj)//用于判定加入集合的是不是同一个对象，如果是则不让其加入集合
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");
        Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;//当姓名和年龄相同的时候才是同一个元素
    }
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()+age;//用于返回对象的hash值
    }
    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 int compareTo(Object o) {
        // TODO Auto-generated method stub
        Person p=(Person)o;
        /*
         * 第二种方法
         * */
        int temp=this.age-p.age;
        return temp==0?this.name.compareTo(p.name):temp;

        /*第一种方法，以年龄排序，如果年龄相等就按姓名排序
        if(this.age>p.age)
            return 1;
        if(this.age<p.age)
            return -1;
        else {
            return this.name.compareTo(p.name);
        }
        */
    }



}

package cn.itcast.p3.hashset.demo;

import java.util.HashSet;
import java.util.Iterator;

import cn.itcast.p.bean.Person;

/*
 * 往hashSet集合中存储Person对象，如果姓名和年龄相同，则视为同一个元素
 * */
public class HashSetTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashSet hs=new HashSet();
        /*HashSet集合数据结构是哈希表，所以存储元素的时候
         * 使用的元素的hashCode方法来确定位置，如果位置相同，再通过元素的equals来去顶是否相同
         * */
        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));//如果没有重写Person中的hashCode以及 equals方法，则能被加入到集合中，因为原Person中
                                        //调用的是Object对象的hashCode方法，new一个对象它的hashCode就不同，所以能通过

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

    }

}

7.4.3 LinkedHashSet代码示例

package cn.itcast.p3.hashset.demo;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class LinkedHashSetDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashSet hs=new LinkedHashSet();//不重复且有序

        hs.add("abc1");
        hs.add("abc2");
        hs.add("abc3");
        hs.add("abc3");
        hs.add("abc5");

        Iterator it=hs.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

}

7.4.4 TreeSet代码示例

TreeSet存储对象Person时，第一种方法：Person类完成Comparable接口的实现

package cn.itcast.p.bean;

public class Person implements Comparable {
    private String name;
    private int age;

    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }


    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        if(this==obj)//用于判定加入集合的是不是同一个对象，如果是则不让其加入集合
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");
        Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;//当姓名和年龄相同的时候才是同一个元素
    }
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()+age;//用于返回对象的hash值
    }
    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 int compareTo(Object o) {
        // TODO Auto-generated method stub
        Person p=(Person)o;
        /*
         * 第二种方法
         * */
        int temp=this.age-p.age;
        return temp==0?this.name.compareTo(p.name):temp;

        /*第一种方法，以年龄排序，如果年龄相等就按姓名排序
        if(this.age>p.age)
            return 1;
        if(this.age<p.age)
            return -1;
        else {
            return this.name.compareTo(p.name);
        }
        */
    }



}

第二种方法是通过构造函数实现构造器的实现

package cn.itcast.p5.treeset.demo;

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) {
        // TODO Auto-generated method stub
        Person p1=(Person)o1;
        Person p2=(Person)o2;

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

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

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

    }

}

package cn.itcast.p5.treeset.demo;

import java.util.Iterator;
import java.util.TreeSet;

import cn.itcast.p.bean.Person;

public class TreeSetDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        demo1();
        /*
         * 以Person年龄按从小到大的顺序排序
         * */
        TreeSet ts=new TreeSet(new ComparatorByName());//通过比较器进行指定排序，优选比较器进行排序，它是在构造过程中完成的
        ts.add(new Person("zhangsan",28));
        ts.add(new Person("wangu",23));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("lisi",23));

        Iterator it=ts.iterator();
        while(it.hasNext()) {
            Person p=(Person)it.next();
            System.out.println(p.getName()+"---"+p.getAge());
        }
    }

    /**
     * 
     */
    public static void demo1() {
        TreeSet ts=new TreeSet();

        ts.add("abc");
        ts.add("aa");
        ts.add("nba");
        ts.add("cba");

        Iterator it=ts.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

}

7.5 泛型
7.5.1 泛型代码示例

基本数据类型对象泛型

package cn.itcast.p1.generic.demo;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<String> al=new ArrayList<String>();//public boolean add(Object obj)
        al.add("abc1");
        al.add("abc2");
//      al.add(4);//al.add(new Integer(4))

        Iterator<String> it=al.iterator();//通过上面的泛型<String>保证了返回的是String类型的，因此迭代器返回的也应该是String类型的，所以在此处需要加上泛型
                                            //有了上面的泛型限制，下面就不需要强转了，同时添加al.add(4)再编译的时候就会报错
        while(it.hasNext())
        {
            String str=it.next();//由于al.add(4)添加的是Integer类型的，不能强转成String类型，所以会报错
            System.out.println(str);
        }
    }

}

自定义对象泛型

Person类

package cn.itcast.p2.bean;

public class Person implements Comparable<Person>{

    private String name;
    private int age;

    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public int compareTo(Person obj) {
        Person p=(Person)obj;
        int temp=this.age-p.age;
        return temp==0?this.name.compareTo(p.name):temp;
    }

    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 Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person:"+getName()+":"+getAge();
    }
    @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;
    }



}

ComparatorByName构造器的实现

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) {
        // TODO Auto-generated method stub
        int temp=o1.getName().compareTo(o2.getName());
        return temp==0?o1.getAge()-o2.getAge():temp;
    }

}

自定义对象泛型的代码示例

package cn.itcast.p1.generic.demo;


import java.util.Iterator;
import java.util.TreeSet;

import cn.itcast.p2.bean.Person;
import cn.itcast.p3.comparator.ComparatorByName;

public class GenericDemo2 {

    public static void main(String[] args) {
        //TreeSet<E>uto-generated method stub
//      TreeSet<Person>ts=new TreeSet<Person>();//第一种方式通过覆写Comparable接口
        TreeSet<Person>ts=new TreeSet<Person>(new ComparatorByName());//第二种方法通过实现比较器实现的
        ts.add(new Person("lisi",21));
        ts.add(new Person("lisi3",23));
        ts.add(new Person("lisi",21));
        ts.add(new Person("lisi",21));
        ts.add(new Person("lisi0",20));

        Iterator<Person>it=ts.iterator();
        while(it.hasNext()) {
            Person p=it.next();
            System.out.println(p.getName()+"---"+p.getAge());
        }
    }

}

7.5.2 泛型通配符

package cn.itcast.p4.generic.define.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericAdvanceDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<String>al=new ArrayList<String>();
        al.add("abc");
        al.add("hehe");

        ArrayList<Integer>al2=new ArrayList<Integer>();
        al2.add(5);
        al2.add(67);

        printCollection(al);
        printCollection(al2);


    }
    /*
     * 迭代并打印集合中的元素
     * */
    private static void printCollection(Collection<?> al) {//通配符的使用，就是里面不管什么类型的都行
                                                    //之所以用Collection是因为这样可以兼容ArrayList、HashSet等都行
        // TODO Auto-generated method stub
        Iterator<?>it=al.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

}

7.5.3 泛型上限

Person类

package cn.itcast.p2.bean;

public class Person implements Comparable<Person>{

    private String name;
    private int age;

    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public int compareTo(Person obj) {
        Person p=(Person)obj;
        int temp=this.age-p.age;
        return temp==0?this.name.compareTo(p.name):temp;
    }

    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 Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person:"+getName()+":"+getAge();
    }
    @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;
    }



}

Student类

package cn.itcast.p2.bean;

public class Student extends Person {

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }


    @Override
    public String toString() {
        return "Student:"+getName()+":"+getAge();
    }

}

Worker类

package cn.itcast.p2.bean;

public class Worker extends Person {

    public Worker() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Worker(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }

    @Override
    public String toString() {
        return "Woker:"+getName()+":"+getAge();
    }

}

泛型上限代码示例：

package cn.itcast.p4.generic.define.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;

public class GenericAdvanceDemo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Worker>al=new ArrayList<Worker>();
        al.add(new Worker("abc",30));
        al.add(new Worker("abc4",34));

        ArrayList<Student>al2=new ArrayList<Student>();
        al2.add(new Student("stu1",11));
        al2.add(new Student("stu2",22));

        /*ArrayList<String>al3=new ArrayList<String>();
        al2.add("stu1dsfa");
        al2.add("fandks");*///不能，因为它不是Person类型也不是它的子类

        printCollection(al);
        printCollection(al2);


    }
    /*
     * 迭代并打印集合中的元素
     * 可以对类型进行限定
     * ? extends E:接收E类型或者E的子类型对象。上限！ 
     * ? super E:接收E类型或者E的父类型。下限！
     * 
     * */
    private static void printCollection(Collection<? extends Person> al) {//? extends Person泛型的限定，只能是Person类型或其子类型
                                                    //之所以用Collection是因为这样可以兼容ArrayList、HashSet等都行
        // TODO Auto-generated method stub
        Iterator<? extends Person>it=al.iterator();
        while(it.hasNext()) {
            Person p=it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }

}

package cn.itcast.p4.generic.define.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;

public class GenericAdvanceDemo3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Person>al1=new ArrayList<Person>();
        al1.add(new Person("abc",30));
        al1.add(new Person("abc4",34));

        ArrayList<Student>al2=new ArrayList<Student>();
        al2.add(new Student("stu1",11));
        al2.add(new Student("stu2",22));

        ArrayList<Worker>al3=new ArrayList<Worker>();
        al3.add(new Worker("abc",30));
        al3.add(new Worker("abc4",34));

        ArrayList<String>al4=new ArrayList<String>();
        al4.add("abcedf");
//      al1.addAll(al4);//错误，类型不匹配


        /*ArrayList<String>al3=new ArrayList<String>();
        al2.add("stu1dsfa");
        al2.add("fandks");*///不能，因为它不是Person类型也不是它的子类

//      printCollection(al);
//      printCollection(al2);


    }
}
/*一般在存储元素的时候都是用上限，因为这样取出来都是按照上限类型来运算的，不会出现类型隐患
 * */
class MyCollection<E>{
    public void add(E e) {

    }
    public void addAll(MyCollection<E>e) {

    }
}   

7.5.4 泛型定义在方法和接口上

泛型定义在方法上（泛型类）

泛型类

package cn.itcast.p4.generic.define.demo;

/*public class Tool {
    private Object Object;

    public void setObject(Object Object) {
        this.Object = Object;
    }
    public Tool(Object Object) {
        super();
        this.Object = Object;
    }

}*/
//在jdk1.5后，使用泛型类来接受类中要操作的引用数据类型
//泛型类，什么时候用？当类中的操作的引用数据类型不确定的时候，就使用泛型类来表示
public class Tool<T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    /*
     * 将泛型定义在方法上
     * */
    public <W>void show(W str){
        System.out.println("show:"+str.toString());
    }
    public void print(T str) {
        System.out.println("print:"+str);
    }
    /*
     * 当方法静态时，不能访问类上定义的泛型，如果静态方法使用泛型
     * 只能将泛型定义在方法上
     * */
    public static<Y> void method(Y obj) {
        System.out.println("method:"+obj);
    }

}

泛型类的使用

package cn.itcast.p4.generic.define.demo;

import cn.itcast.p2.bean.Student;

public class GenericDefineDemo3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Tool<Student>tool=new Tool<Student>();
        tool.setT(new Student());
        Student stu=tool.getT();

    }

}

package cn.itcast.p4.generic.define.demo;

public class GenericDemo4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Tool<String>tool=new Tool<String>();

        tool.show(new Integer(4));//数据类型是Integer
        tool.show("abc");//数据类型是String
        tool.print("abc");
        Tool.method("haha");
        Tool.method(new Integer(9));
    }

}

泛型接口的使用

package cn.itcast.p4.generic.define.demo;

public class GenericDefineDemo5 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        InterImpl in=new InterImpl();
        InterImpl in2=new InterImpl();
        in.show("abc");
        in2.show("abc");
    }

}
//泛型接口,将泛型定义在接口上
interface Inter<T>{
    public void show(T t);
}
//第一种实现方法
class InterImpl implements Inter<String>{
    public void show(String str) {
        System.out.println("show:"+str);
    }
}
//第二种实现方法
class InterImpl2<Q> implements Inter<Q>{
    public void show(Q q) {
        System.out.println("show:"+q);
    }
}

7.6 Map
7.6.1 Map代码示例

package cn.itcast.p6.map.demo;

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) {
        // TODO Auto-generated method stub
        Map<Integer,String>map=new HashMap<Integer,String>();
        //method(map);
        method_2(map);
    }
    public static void method_2(Map<Integer,String>map) {
        map.put(8,"wangwu");
        map.put(2, "zhaoliu");
        map.put(7,"xiaoqiang");
        map.put(6, "wangcai");

        //取出map中的所有元素
        //原理，通过keySet方法获取map中所有的键所在的Set集合，再通过Set迭代器获取到每一个键
        //再对每一个键获取其对应的值即可

        Set<Integer>keySet=map.keySet();
        Iterator<Integer>it=keySet.iterator();
        while(it.hasNext()) {
            Integer key=it.next();
            String value=map.get(key);
            System.out.println(key+":"+value);
        }
    }
    public static void method(Map<Integer,String>map)//学号、姓名
    {
        //添加元素
        System.out.println(map.put(8,"wangcai"));//null
        System.out.println(map.put(8, "xiaoqiang"));//wangcai,存相同键，值会覆盖
        map.put(2,"zhangsan");
        map.put(7,"zhaoliu");
        //删除
        System.out.println("remove:"+map.remove(2));
        //判断
        System.out.println("containskey:"+map.containsKey(7));
        //获取
        System.out.println("get:"+map.get(8));

    }
}

package cn.itcast.p6.map.demo;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo_2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<Integer,String>map=new HashMap<Integer,String>();
        //method(map);
        method_2(map);
    }
    public static void method_2(Map<Integer,String>map) {
        map.put(8,"wangwu");
        map.put(2, "zhaoliu");
        map.put(7,"xiaoqiang");
        map.put(6, "wangcai");

        /*
         * 通过Map转成set就可以迭代
         * 找到了另一个方法：entrySet
         * 该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map、Entry类型
         * 
         * */
        Collection<String>values=map.values();
        Iterator<String>it2=values.iterator();
        while(it2.hasNext()) {
            System.out.println(it2.next());
        }

        Set<Map.Entry<Integer,String>>entrySet=map.entrySet();
        Iterator<Map.Entry<Integer, String>>it=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);
        }
    }
    public static void method(Map<Integer,String>map)//学号、姓名
    {
        //添加元素
        System.out.println(map.put(8,"wangcai"));//null
        System.out.println(map.put(8, "xiaoqiang"));//wangcai,存相同键，值会覆盖
        map.put(2,"zhangsan");
        map.put(7,"zhaoliu");
        //删除
        System.out.println("remove:"+map.remove(2));
        //判断
        System.out.println("containskey:"+map.containsKey(7));
        //获取
        System.out.println("get:"+map.get(8));

    }
}

Map案例

package cn.itcast.p7map.test;

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

/*
 * 练习：
 * “fsdfasdfafda”获取该字符串中，每一个字母出现的次数
 * 要求打印结果是：a(2)b(1)....;
 * 思路：
 * 对于结果的分析发现，字母和数字之间存在着映射的关系，而且这种关系很多
 * 很多就需要存储，能存储映射关系的容器有数组和Map集合
 * 关系一方是有序集合吗？没有
 * 那就是使用Map集合，又发现可以保证唯一性的一方具备着顺序如a b c...
 * 所以使用TreeMap集合
 * 
 * 这个集合最终应该存储的是字母和次数的对应关系
 * 1、因为操作是字符中的字母，所以先将字符串变成字符数组
 * 2、遍历字符数组，用每一个字母作为键去查Map集合中这个表
 * 如果该字母键不存在，就将该字母作为键1作为值存储到map集合中
 * 如果该字母键存在，就将该字母键对应值取出并+1,再将该字母和+1后的值存储到map集合中
 * 键相同值会覆盖。这样就记录了该字母表的次数
 * 3、遍历结束，map集合就记录所有字母的出现的次数
 * */
public class MapTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="fs dfa + sdfafda";
        String s=getCharCount(str);
        System.out.println(s);
    }

    private static String getCharCount(String str) {
        // TODO Auto-generated method stub
        //将字符串变成字符数组
        char[] chs=str.toCharArray();
        //定义map集合表
        Map<Character,Integer>map=new TreeMap<Character,Integer>();
        for(int i=0;i<chs.length;i++) {
            if(!(chs[i]>='a'&&chs[i]<='z'||chs[i]>='A'&&chs[i]<='Z'))
                continue;
            //将数组中的字母作为键去查map表
            Integer value=map.get(chs[i]);
            //判断值是否为null
            //第一种写法
/*          if(value==null) {
                map.put(chs[i], 1);
            }else {
                map.put(chs[i],value+1);
            }*/
            //第二种写法
            int count=1;
            if(value!=null) {
                count=value+1;
            }
            map.put(chs[i], count);

        }
        return mapToString(map);
    }

    private static String mapToString(Map<Character, Integer> map) {
        // TODO Auto-generated method stub
        StringBuilder sb=new StringBuilder();
        Iterator<Character>it=map.keySet().iterator();
        while(it.hasNext()) {
            Character key=it.next();
            Integer value=map.get(key);
            sb.append(key+"("+value+")");
        }
        return sb.toString();
    }

}

package cn.itcast.p7map.test;

import java.util.HashMap;
import java.util.Map;

public class MapTest2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * Map在有映射关系时，可以优先考虑
         * 在查表中的应用较为多见
         * */
        String week=getWeek(1);
        System.out.println(week);
        System.out.println(getWeekByMap(week));
    }
    public static String getWeekByMap(String week) {
        Map<String,String>map=new HashMap<String,String>();
        map.put("星期一", "Mon");
        map.put("星期二", "Tus");
        map.put("星期三", "Wes");
        map.put("星期四", "Thr");
        map.put("星期五", "Fri");
        map.put("星期六", "Sat");
        map.put("星期日", "Sun");
        return map.get(week);
    }
    private static String getWeek(int i) {
        // TODO Auto-generated method stub
        if(i<1||i>7)
            throw new RuntimeException("没有对应的星期，请重新输入");
        String[]weeks= {"","星期一","星期二"};
        return weeks[i];
    }

}

7.6.2 Map子类

HashMap

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 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * 将学生对象和学生的归属地通过键和值存储到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();
        while(it.hasNext())
        {
            Student key=it.next();
            String value=hm.get(key);
            System.out.println(key.getName()+":"+key.getAge()+"----"+value);
        }
    }

}

LinkedHashMap

package cn.itcast.p7.hashmap.demo;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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);

        }

    }

}

TreeMap

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 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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();
            String value=me.getValue();
            Student key=me.getKey();

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

}

7.7 工具类
7.7.1 排序工具

package cn.itcast.p1.toolclass.collections.demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsDemoSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * Collections:集合框架的工具类
         * 里面的方法都是静态的
         * 
         * */
        demo_1();
    }
    public static void demo_1(){
        List<String>list=new ArrayList<String>();
        list.add("abcde");
        list.add("cba");
        list.add("aa");
        list.add("zzz");
        list.add("nbaa");
        list.add("zzz");
        System.out.println(list);
        //对list集合进行指定顺序的排序,因为list实现了Collection的接口
        Collections.sort(list);
        System.out.println(list);
    }

}

ComparatorByLength类

package cn.itcast.p1.toolclass.collections.demo;

import java.util.Comparator;

public class ComparatorByLength implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        // TODO Auto-generated method stub
        int temp=o1.length()-o2.length();
        return temp==0?o1.compareTo(o2):temp;
    }

}

自定义排序

package cn.itcast.p1.toolclass.collections.demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

public class CollectionsDemoSortByLength {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * Collections:集合框架的工具类
         * 里面的方法都是静态的
         * 
         * */
        demo_1();
        demo_2();
        demo_3();
        demo_4();
        demo_5();
    }
    public static void demo_1(){
        List<String>list=new ArrayList<String>();
        list.add("abcde");
        list.add("cba");
        list.add("aa");
        list.add("zzz");
        list.add("nbaa");
        list.add("zzz");
        System.out.println(list);
        //对list集合进行指定顺序的排序,因为list实现了Collection的接口
        mySort(list,new ComparatorByLength());
//      Collections.sort(list,new ComparatorByLength());//按长度排序（指定顺序）
        System.out.println(list);
    }

    public static void demo_2() {//折半查找
        List<String>list=new ArrayList<String>();
        list.add("abcde");
        list.add("cba");
        list.add("aa");
        list.add("zzz");
        list.add("nbaa");
        list.add("zzz");
        Collections.sort(list);
        System.out.println(list);

        int index=Collections.binarySearch(list, "cba");
        System.out.println("index="+index);

    }
    public static void demo_3() {
        List<String>list=new ArrayList<String>();
        list.add("abcde");
        list.add("cba");
        list.add("aa");
        list.add("zzz");
        list.add("nbaa");
        System.out.println(list);
        //获取最大值
        String max=Collections.max(list);
        String maxLen=Collections.max(list,new ComparatorByLength());
        System.out.println("max="+max);
    }
    public static void demo_4() {
        /*倒序
         * TreeSet<String>ts=new TreeSet<String>(new Comparator<String>(){

            @Override
            public int compare(String o1, String o2) {
                // TODO Auto-generated method stub
                    int temp=o2.compareTo(o1);
                    return temp;
            }

        });*/
        TreeSet<String>ts=new TreeSet<String>(Collections.reverseOrder());//将自然排序逆转
        ts.add("abc");
        ts.add("hahaha");
        ts.add("zzz");
        ts.add("aa");
        ts.add("cba");

        System.out.println(ts);
    }
    public static void demo_5() {
        List<String>list=new ArrayList<String>();
        list.add("abcde");
        list.add("cba");
        list.add("aa");
        System.out.println(list);
        Collections.replaceAll(list,"cba","nba");//用"nba"替换列表中的所有"cba"
//      Collections.fill(list, "cc");//将列表中的所有元素替换成"cc"
//      Collections.shuffle(list);//将列表中的元素随机打乱顺序
        System.out.println(list);
    }
    public static<T>void mySort(List<T>list,Comparator<? super T>comp){
        for(int i=0;i<list.size()-1;i++) {
            for(int j=i+1;j<list.size();j++) {
                if(comp.compare(list.get(i),list.get(j))<0) {
                    Collections.swap(list, i, j);
                }
            }
        }
    }
}

7.7.2 Arrays

package cn.itcast.p2.toolclass.collections.demo;

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        demo_1();
        demo_2();
    }

    private static void demo_2() {
        // TODO Auto-generated method stub
        /*
         * 如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储
         * 如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储
         * */
        int[] arr= {31,11,51,61};
        List<int[]> list=Arrays.asList(arr);//int[]存储的是什么类型泛型就是什么样的
        System.out.println(list.size());//因为存储的是基本类型，所以此处打印的是1,如果是Integer类型则打印的是4
    }

    /**
     * 
     */
    public static void demo_1() {
        /*
         * Arrays:集合框架的工具类，里面的方法都是静态的
         * 
         * */
        /*int[]arr= {3,1,5,6,3,6};
        System.out.println(Arrays.toString(arr));*/
        /*
         * 重点：List asList(数组)将数组转成集合
         * 好处：可以使用集合的方法操作数组中的元素
         * 注意：数组的长度是固定的，所以对集合的增删方法是不可以使用的
         * 否则会发生UnsupportedOperationException异常
         * 
         * */
        String[] arr= {"abc","haha","xixi"};
        List<String>list=Arrays.asList(arr);
        boolean b=list.contains("xixi");
        System.out.println("b="+b);
    }

}

package cn.itcast.p2.toolclass.collections.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ToArray {
    public static void main(String[]args) {
        /*
         * 集合转成数组
         * 使用的就是Collection接口中的toArray方法
         * 集合转成数组：可以对集合中的元素操作的方法进行限定，不允许对其进行增删
         * 
         * */
        List<String>list=new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        /*
         * toArray方法需要传入一个指定类型的数组
         * 如果长度小于集合的size,那么该方法会创建一个同类型并和集合相同size的数组
         * 如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认为null，
         * 所以建议最好长度就指定为集合的size
         * 
         * */
        String[]arr=list.toArray(new String[list.size()]);
        System.out.println(Arrays.toString(arr));
    }
}

7.8 新特性
7.8.1 高级for语句

package cn.itcast.p4.news.demo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ForEachDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * foreach语句：
         * 格式：
         * for(类型 变量：Collection集合|数组)
         * {
         * }
         * 传统for和高级for的区别：
         * 传统for可以完成对语句执行很多次，因为可以定义控制循环的增量和条件
         * 高级for是一种简化形式
         * 它必须有被遍历的目标，该目标要么是数组，要么是Collection单列集合
         * 对数组的遍历如果仅仅是获取数组中的元素，可以使用高级for
         * 如果要对数组的角标进行操作建议使用传统for
         * */
        List<String>list=new ArrayList<String>();
        list.add("abnc");
        list.add("abdnc");
        list.add("abnsc");
        list.add("ab1c");
        for(String s:list) {
            System.out.println(s);
        }

        //上面的是新式写法，一般只用与迭代，取出，不会对元素进行过多的操作
        /*Iterator<String>it=list.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }*/
        /*不能直接使用高级for遍历map集合，但是可以将它先转换成单列的set，就可以用了
         * */
        Map<Integer,String>map=new HashMap<Integer,String>();
        map.put(3, "zhjang");
        map.put(1, "wangyi");
        map.put(4, "wangwu");
        map.put(5, "zhangsan");
        for(Integer key:map.keySet()) {
            String value=map.get(key);
            System.out.println(key+":"+value);
        }
        for(Map.Entry<Integer, String>me:map.entrySet())
        {
            Integer key=me.getKey();
            String value=me.getValue();
            System.out.println(key+":"+value);
        }
    }

}

7.8.2 可变参数

package cn.itcast.p4.news.demo;

public class ParamterDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr= {5,1,4,7,3};
        int sum=add(arr);//可变参数
        System.out.println("sum="+sum);

//      新特性，函数的可变参数，其实就是一个数组，但是接收的是数组的元素
//      自动将这些元素封装成数组，简化了调用者的书写
//      注意：可变参数类型，必须定义在参数列表的结尾
//      例如：public static int newAdd(int a,int... arr)
        int sum2=newAdd(5,1,4,7,3);
        System.out.println("sum="+sum2);
        int sum1=newAdd(5,1,4,7,3,5,6,7);
        System.out.println("sum1="+sum1);
    }
    public static int newAdd(int... arr) {
        int sum=0;
        for(int i=0;i<arr.length;i++)
        {
            sum+=arr[i];
        }
        return sum;
//      System.out.println(arr);
//      return 0;
    }
    public static int add(int[] arr) {
        int sum=0;
        for(int i=0;i<arr.length;i++)
        {
            sum+=arr[i];
        }
        return sum;
    }

}

7.8.3 静态导入

package cn.itcast.p4.news.demo;

import java.util.ArrayList;
import java.util.List;
import static java.util.Collections.*;//静态导入，其实导入的是类中的静态成员

public class StaticImportDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<String>list=new ArrayList<String>();
        list.add("abc3");
        list.add("abc1");
        list.add("abc7");
        System.out.println(list);
        sort(list);//以前是Collections.sort
        System.out.println(list);

        String max=max(list);//以前是Collections.max
        System.out.println("max="+max);
    }

}