11、集合类各种容器的使用注意细节：

        (1)迭代器：

                **迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

                  也就是在迭代循环中调用一次next方法一次就要hasNext判断一次，比如语句

                  sop(it.next()+"..."+it.next())会发生上述异常。

                **迭代器的next方法返回值类型是Object，所以要记得类型转换,应用泛型后就不用强转

        (2)List集合：

                **List集合里面的元素因为是带角标，所以List集合里面的元素都是有序的，

                  另外List集合可以包含重复元素，也可以包含null。  

                **List集合有迭代器Iterator，还有一个特有迭代器列表ListIterator

                **List集合中判断元素是否相同都是用equals方法，无论contains、remove都依赖equals方法

                  比如往ArrayList集合里面存放学生，同名同年龄视为同一个人，此时就需要在学生类复写Object类

                  里面的equals方法(非常重要！！！要注意！！)

        (3)Set集合：

                **Set接口里面存放的是元素是无序的，不可以有重复元素，可以包含null

                **Set集合只有一种取出方式，就是迭代器Iterator

                **Set集合功能和Collection是一致的，没有特殊方法

            |--->HashSet:

                **集合里面存放的元素是无序的，唯一的

                **底层数据结构是哈希表，哈希表结构的数据都是无序的，哈希表结构的操作效率都高效

                **线程不同步

                **保证元素唯一性的原理是：通过复写hashCode和equals方法

                        ****如果两元素的hashCode值相同，则继续判断两元素equals是否为真

                        ****如果两元素的hashCode值不同，则不会调用equals方法。

                **当我们往HashSet集合存放自定义的元素时(比如学生对象)，通常都要复写hashCode和equals方法，

                  而且hashCode和equals方法不通过我们调用，HashSet集合底层内部自己调用，自己拿元素去比较

            |--->TreeSet

                **TreeSet集合可以对存放的元素进行排序，弥补了Set集合元素无序的缺点，且元素是唯一的

                **底层数据结构是二叉树，二叉树结构都是有序的

                **线程不同步

                **TreeSet集合要求往集合里存放的元素自身具备比较性，否则会报错

                **TreeSet集合保证元素唯一性的依据是：通过compareTo或者compare方法中的来保证元素的唯一性。

                        TreeSet排序的第一种方式:让元素自身具备比较性，

                                                定义元素类实现Compareble接口，覆盖compare方法，

                                                此方式是元素的自然顺序。

                        TreeSet排序的第二种方式:让集合具备比较性

                                                当元素自身不具备比较性或者具备的比较性不是

                                                我们所需要的比较性时，此时就需要让集合具备自定义的比较性。

                                                那如何让集合自身具备比较性呢？

                                                可在集合初始化时，就让集合具备比较方式。

                                                即定义一个类，实现Comparator接口，覆盖compare方法。

                        注：

                        **判断元素唯一时，当主要条件一样时，判断次要条件

                        **两种排序方式都在时，以比较器为主！！！

        (4)Map集合：

                |--Hashtable

                        底层是哈希表结构

                        线程安全的，并且键和值不能为null。

                |--HashMap

                        底层是哈希表结构

                        线程不安全的，键和值可以为null。

                        |--LinkedHashMap

                                底层是链表和哈希表

                                线程不安全

                |--TreeMap

                        底层是二叉树

                        线程不安全的

12、如果你想将一组对象按一定顺序存取，在不考虑并发访问的情况下会使用____C_____ ,

        反之则会使用____A_____；如果你想存储一组无序但唯一的对象，你会使用___B______ ;

        如果你想按关键字对对象进行存取，在不考虑并发访问的情况下会使用___D______ ,反之则会使用_____E____。

A. Vector

B. HashSet

C. ArrayList

D. HashMap

E. Hashtable

13、泛型：

(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的父类

14、高级for循环

(1)JDK1.5新特性，代替迭代器使用时的不爽，简化书写，底层原理是迭代器凡是支持迭代器的都支持高级for循环

   高级for循环，只用于集合和数组的遍历，集合只能用Collection不能用Map集合

   只能把Map集合转化成Set集合，才能用for循环。

(2)格式

        for(数据类型 变量名:被遍历的集合(Collection)或者数组)

        {

               

        }

        (3)局限性：

        必须要有遍历的目标

        对集合或者数组进行遍历时，只能获取集合元素，不能对集合元素进行操作

        迭代器除了遍历，还可以进行remove操作集合中的元素

        列表迭代器还可以在遍历过程中进行增删改查的操作

(4)传统for循环和高级for循环的区别

        高级for循环有一个局限性，就是必须要有遍历的目标(集合或者数组)

        遍历数组时建议使用传统for循环，因为可以定义角标，比如打印100次helloworld时用传统for循环方便

15、可变参数

(1)数组的可变参数

        格式：

                int... arr

(3)方法的可变参数

        格式：

                public static void show(String str，int... arr)

                {

                }

        注意：可变参数一定要放在参数列表的最后面

16、静态导入：

**import static java.util.Arrays.*  导入的是Arrays这个类中所有的静态方法

**当类名重名时，需要制定具体的报名

**当方法重名时，需要制定具体所属的对象或者类

17、Collections类：
        (1)此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
        (2)静态方法摘要：
                static <T> boolean addAll(Collection<? super T> c, T... elements)
                        将所有指定元素添加到指定 collection 中。
                static <T> void fill(List<? super T> list, T obj)
                        使用指定元素替换指定列表中的所有元素。
                static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
                        使用另一个值替换列表中出现的所有某一指定值。
                static void reverse(List<?> list)
                        反转指定列表中元素的顺序。
                static <T> Comparator<T>  reverseOrder()
                        返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
                static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
                        返回一个比较器，它强行逆转指定比较器的顺序。
        (3)Collections类特牛的方法：
                集合有一个共同的缺点，那就是线程不安全，被多线程操作时，容易出现问题，虽然可以自己加锁
                但是麻烦。Collections提供特牛的方法，就是给它一个不同步的集合，它返回一个同步的安全的集合

                static <T> Collection<T> synchronizedCollection(Collection<T> c)
                        返回指定 collection 支持的同步（线程安全的）collection。
                static <T> List<T>  synchronizedList(List<T> list)
                        返回指定列表支持的同步（线程安全的）列表。
                static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
                        返回由指定映射支持的同步（线程安全的）映射。
                static <T> Set<T> synchronizedSet(Set<T> s)
                        返回指定 set 支持的同步（线程安全的）set。
                static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
                        返回指定有序映射支持的同步（线程安全的）有序映射。
                static <T> SortedSet<T>  synchronizedSortedSet(SortedSet<T> s)
                        返回指定有序 set 支持的同步（线程安全的）有序 set。
18、Arrays类：
        此类包含用来操作数组（比如排序和搜索）的各种方法。里面都是静态方法。
        如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。
        (1)静态方法摘要：
                static <T> List<T> asList(T... a)
                        返回一个受指定数组支持的固定大小的列表。
                注意：
                        A:该方法将一个数组变成集合后，不可以使用集合的增删方法，因为数组的长度是固定的！
                          如果增删，则发生UnsupportedOprationException(不支持操作异常)
                        B:如果数组中的元素都是基本数据类型，则该数组变成集合时，会将该数组作为集合的一个
                          元素出入集合
                        C:如果数组中的元素都是对象，如String，那么数组变成集合后，数组中的元素就直接转成
                          集合中的元素
19、数组变集合以及集合变数组的对比：
        (1)数组变集合：
                方法：static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。
                好处：可以使用集合的思想和方法操作数组中的元素，数组是一个对象，但是数组中的功能很少
        (2)集合变数组：
                方法：Collction中的toArray方法
                好处：可以限定对集合元素的操作，防止对集合的元素进行增删，因为数组长度是固定的。

20、Collections类和Arrays类的使用。(重点)
        A:Collections
                排序
                二分查找
                发转
        B:Arrays
                把数组变成字符串输出
                排序
                二分查找
21、System：
        (1)描述系统信息的类
        (2)该类没有构造方法，该类的方法和属性都是静态的
        (3)字段摘要：
                static InputStream in  “标准”输入流。   
                static PrintStream out  “标准”输出流。         
        (4)方法摘要：
                static void exit(int status) 终止当前正在运行的 Java 虚拟机。
                static void gc() 运行垃圾回收器。
                static Properties getProperties()  确定当前的系统属性         
                static String getProperty(String key) 获取指定键指示的系统属性。     
                static String getProperty(String key, String def) 获取用指定键描述的系统属性。
                static void setIn(InputStream in) 重新分配“标准”输入流。           
                static void setOut(PrintStream out) 重新分配“标准”输出流。
                static void setProperties(Properties props) 将系统属性设置为 Properties 参数。           
                static String setProperty(String key, String value) 设置指定键指示的系统属性。
22、Runtime:
        (1)每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
           可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。
        (2)该类没有构造函数，也就是它不能直接创建对象，但是它里里面的方法又不是静态的
           ，故它一定有一个方法返回本类对象
        (3)故该类是单例设计模式，保证在内存中只有一个对象
        (4)方法摘要：
                Process exec(String command) 在单独的进程中执行指定的字符串命令
                void gc() 运行垃圾回收器。
                static Runtime getRuntime() 返回与当前 Java 应用程序相关的运行时对象
                void exit(int status) 通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机
23、Date:
        (1)Date接口表示特定的瞬间，精确到毫秒
        (2)构造方法
                Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
                Date(long date) 分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，
                         即1970年1月1日00:00:00GMT）以来的指定毫秒数。
        (3)方法摘要：
                int compareTo(Date anotherDate) 比较两个日期的顺序。         
                boolean equals(Object obj) 比较两个日期的相等性。
24、Calendar：
        (1)直接已知子类： GregorianCalendar
        (2)构造方法：
                protected  Calendar() 构造一个带有默认时区和语言环境的 Calendar。         
                protected  Calendar(TimeZone zone, Locale aLocale)  构造一个带有指定时区和语言环境的 Calendar。         
        (3)方法摘要：
                static Calendar getInstance() 使用默认时区和语言环境获得一个日历。