黑马程序员_集合（2）

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

   |--->TreeMap(JDK1.0):

        底层是二叉树结构；

        允许使用null键和null值；

        线程不同步；

        可以给Map集合中的键进行排序.

        TreeMap排序的第一种方式:让元素自身具备比较性，比如八种基本数据类型或则字符串，实现Compareble接口,覆盖compareTo方法，此方式是元素的自然顺序         

        TreeMap排序的第二种方式:当元素自身不具备比较性(比如存储学生对象时)或者具备的比较性不是我们所需要的比较性时(比如想字符串的长度排序),此时就需要让集合自身具备自定义的比较性。

            那如何让集合自身具备比较性呢？可在集合初始化时，

            就让集合具备比较方式。即定义一个类，

            实现Comparator接口，覆盖compare方法。

        classStudent implements Comparable<Student>{

            privateString name;

            privateint age;

            publicStudent(String name, int age) {

                super();

                this.name= name;

                this.age= age;

            }

            publicint getAge() {

                returnage;

            }

            publicvoid setAge(int age) {

                this.age= age;

            }

            publicString getName() {

                returnname;

            }

            publicvoid setName(String name) {

                this.name= name;

            }

            @Override

            publicint compareTo(Student stu) {

                intnum = new   Integer(this.age).compareTo(newInteger(stu.age));

                if(num==0)

                    returnthis.name.compareTo(stu.name);

                returnnum;

            }          

        }

 

        publicclass HashMapDemo1 {

            publicstatic void main(String[] args) {

                           

                Map<Student, String> tmap = new TreeMap<Student , String>();

                tmap.put(newStudent("001",20), "beijing");

                tmap.put(newStudent("002",25), "hebei");

                tmap.put(newStudent("003",50), "hainan");

                tmap.put(newStudent("001",20), "beijing");

               

                System.out.println(tmap.size());

                Set<Student>keySet1 = tmap.keySet();

                Iterator<Student>it1 = keySet1.iterator();

                while(it1.hasNext()){

                    Studentstu = it1.next();

                    Stringaddr = tmap.get(stu);

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

                }

            }

        }

   

 

    **Iterator：对collection进行迭代的迭代器.迭代器取代了Enumeration。

        迭代器和枚举的区别：

        迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的collection移除元素方法名称得到了改进，简化书写

    **LisIterator：系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表    

    **Collections：此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。

 

泛型：

    (1)为什么会出现泛型？

        因为集合存放的数据类型不固定，故往集合里面存放元素时，存在安全隐患，

        如果在定义集合时，可以想定义数组一样指定数据类型，那么就可以解决该类安全问题。

        JDK1.5后出现了泛型，用于解决集合框架的安全问题。

        泛型是一个类型安全机制。

    (2)泛型定义格式：通过<>来定义要操作的引用数据类型

        ArrayList<String>al = new ArrayList<String>;

    (3)泛型的好处：

        **将运行时期出现的ClassCastException(类型转换异常)问题转移到编译时期；

        **避免了强制转换的麻烦

    (4)什么时候定义泛型？

        泛型在集合框架中很常见，只要见到<>就要定义泛型。其实<>就是用来接收类型的。

        当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

    (5)泛型的形式

        **泛型类：即自定义泛型类

            A：当类中要操作的引用数据类型不确定时，早起定义Object来完成扩展，现在定义泛型来完成

            B：局限性：泛型类定义的泛型，在整个类中有效，如果该泛型类的方法被调用，

               当泛型类的对象明确要操作的类型后，所有要操作的类型就被固定。

        **泛型方法：泛型放在返回值前面，修饰符的后面

            A:为了避免泛型类的局限性，让不同方法可以操作不同的类型，而且类型还不确定，

              则可以将泛型定义在方法上

            B:特殊之处：静态方法不可以反问类上定义的泛型

              如果静态方法操作的应用数据类型不确定，可以讲泛型定义在静态方法上

        **泛型接口：

            当泛型定义在接口上时，则子类中要指定实现接口类型，同时还可以子类也可以定义为泛型类

    (6)泛型的高级应用：？通配符

        **当指定两种泛型的集合，则迭代时也要定义两种泛型的迭代器，麻烦，此时可通过将迭代器的泛型

          改为？，如Iterator<?>it=al.iterator();

        **两种泛型限定

            向上限定：? extends E  ;E可以接收E类型或者E的子类

            向下限定：? super E  ;E可以接收E类型或者E的父类

泛型的限定：

? extends E: 接收E类型或者E的子类型对象。--------[上限]（用的多些）

一般存储对象的时候用。-----比如添加元素 addAll.

? super E: 接收E类型或者E的父类型对象。-----------[下限]（用的很少）

一般取出对象的时候用。-----比如比较器。【难点】

class WorkerComp implementsComparator<Worker>{

public int compare(Worker s1,Worker s2){

returns1.getName().compareTo(s2.getName());

}

}class StudentComp implementsComparator<Student>{

public int compare(Student s1,Student s2){

returns1.getName().compareTo(s2.getName());

}

}class Comp implementsComparator<Person>{

public int compare(Person p1,Person p2){

return p1.getName().compareTo(p2.getName());

}     //比较器的泛型，有扩展性；

}     //其中Person是Worker和Student的父类。

 

||  多态的弊端就是不能预先使用子类的特有方法。

||  泛型的弊端也是，不能使用类型特有的方法，但是tostring可以使用。

 

Runtime:

    (1)每个Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。

       可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。

    (2)该类没有构造函数，也就是它不能直接创建对象，但是它里里面的方法又不是静态的

       ，故它一定有一个方法返回本类对象

    (3)故该类是单例设计模式，保证在内存中只有一个对象

    (4)方法摘要：

        Processexec(String command) 在单独的进程中执行指定的字符串命令

        void gc()运行垃圾回收器。

        staticRuntime getRuntime() 返回与当前 Java 应用程序相关的运行时对象

        voidexit(int status) 通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机

 

Date:

    (1)Date接口表示特定的瞬间，精确到毫秒

    (2)构造方法

        Date() 分配Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

        Date(longdate) 分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，

             即1970年1月1日00:00:00GMT）以来的指定毫秒数。

    (3)方法摘要：

        intcompareTo(Date anotherDate) 比较两个日期的顺序。         

        booleanequals(Object obj) 比较两个日期的相等性。

 

Calendar：

    (1)直接已知子类： GregorianCalendar

    (2)构造方法：

        protected  Calendar() 构造一个带有默认时区和语言环境的 Calendar。        

        protected  Calendar(TimeZone zone, Locale aLocale)  构造一个带有指定时区和语言环境的 Calendar。        

    (3)方法摘要：

        staticCalendar getInstance() 使用默认时区和语言环境获得一个日历。

Math：

包含用于执行基本数学运算的方法。

abs()///返回绝对值

double d = Math.ceil(12.34);///特点ceil 返回大于指定数据的最小整数；

double d1 = Math.floor(12.34);//特点ceil 返回小于指定数据的最小整数；

Long l = Math.round(12.34);//四舍五入

Double d2 = Math.pow(2,3);//次幂运算

Public static double random() 返回代正号的double值，[该值>=0&<1]伪随机数，借助了随机数生成器。

double d = Math.random();数字之间转换，(int)。

Random r = new Random(); int d =r.nextInt(10)+1;Random类的使用。