黑马程序员------集合

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

概述：
1、集合就是一个容器
2、集合中存储的对象不是实体对象，而是地址值
3、集合在jdk1.5之后可以存入基本数据类型（实际上数据会自动装箱，存入的还是对象）
为什么有不同的容器:
因为他们的数据结构不同（数据结构=存储方式）

集合框架：

Collection：所有容器的父类（接口）

Collection中方法：
1、a.add();添加元素 | addAll()；添加一组元素（把另一个容器添加进来）
2、a.retainAll(b);添加一组元素，取a集合和b集合中元素的交集（没有交集则为空，不是Null）
3、a.toArray()：把集合a变为数组
4、a.contains()：a集合中是否包含某元素
5、a1.iterator()：iterator()方法放回一个Iterator对象，因为iterator()方法在集合内部能更好的操作集合的元素
所有的容器都可以使用迭代器来对集合中的数据进行存取
6、a.size()：获取集合长度
7、a.remove();删除一个元素 | a.removeAll();删除一组元素
8、a.clear();：清空集合
9、a.isEmpty()；判断集合是否为空
实例：

        ArrayList<String> a1 = new ArrayList<String>();        ArrayList<String> a2 = new ArrayList<String>();        a1.add("1");        a1.add("2");        a1.add("3");        a2.add("1");        a2.add("3");        a2.add("4");        a2.add("5");        a1.retainAll(a2);        for (Iterator<String> it = a1.iterator(); it.hasNext();) {            System.out.println(it.next());        }        System.out.println(a1.size());"获取长度"        System.out.println(a1.contains("1"));"包含"        System.out.println(a1.remove("1"));"删除元素"        a1.removeAll(a2);"删除a2和a1中交集元素"        System.out.println(a1);        System.out.println(a1.clear());"清空集合"

Iterator （集合中元素取出的通用方式）：

    "Iterator获取对象的方法定义在集合的内部(内部类)，这样可以直接访问集合中内部元素，由于每个集合数据结构不同    取出细节也不同，但他们都有共性内容，这些共性内容定义为一个类，并符合相同的规则就是iterator    通过iterator获取元素并操作元素，不是简单的打印元素    接口的引用指向子类对象，a1.iterator()返回一个子类对象，这个对象是通过方法获取，而不是new 出来"for (Iterator<String> it = a1.iterator(); it.hasNext();) {"获取下一个元素，一般循环中只有一个next，有几个next(),就会获取几次元素，循环中多个next()会造成安全隐患"    System.out.println(it.next());    it.remove();"删除元素"}

ListIterator：
由于iterator中只有hasNext();next();remove()方法，无法在集合取出元素的同时对集合中元素进行添加和修改
注意：
不可以在使用iterator操作元素的同时使用集合的方法操作集合中的元素（比如使用add()方法添加数据），会出现异常
原因：
主要是List集合，他有get()和set()集合方法
使用listierator可以对数据进行添加修改等操作

for (Iterator<String> it = a1.iterator(); it.hasNext();) {    "发生并发异常，由于现在是用iterator来操作元素，这时候使用集合方法来操作元素就会产生异常"    a1.add("9");    System.out.println(it.next());}for (ListIterator<String> it = a1.listIterator(); it.hasNext();) {            it.next();"获取下一个元素"            it.add("1");"添加元素"            "是否有上一个元素，默认为false，当使用了一次next()之后，指针向下移动，此时判断变为true"            it.hasPrevious();            it.previous();"获取上一个元素"            it.set("0");"修改元素"}

List：
特点：
1、元素有序（什么顺序存入，什么顺序取出）
2、元素可以重复
3、可以通过角标索引元素
4、有set(index),get(index);通过角标获取数据的方法
|–List ：
1、–ArrayList：数组数据结构（有索引，利用角标来存取值），查询修改速度快。添加删除速度快，线程不同步
2、–LinkedList：链表数据结构（一个元素只是记住前一位和后一位的元素），查询修改速度慢，线程不同步，添加删除速度快
3、–Vector：数组数据结构（和ArrayList功能一样，被ArrayList取代）（线程同步），取出方式为枚举
实例：

使用LinkedList模拟堆栈和队列堆栈：先进后出，队列，先进先出"把LinkedList相关方法封装到LinkedTest类中"public class ListSetDemo {    public static void main(String[] args) {        LinkedTest<String> a = new LinkedTest<String>();        a.add("1");        a.add("2");        a.add("3");        a.add("4");        a.getDL();"获取队列输出"        a.getDZ();"获取堆栈输出"    }import java.util.LinkedList;public class LinkedTest<E> {"E 采用泛型，因为不确定传入的类型，而且方法中的类型全部一致，所以泛型写在类上，采用泛型后不用进行类型转换，把运行时问题变为编译时问题，提高安全性"    private LinkedList<E> list;    public LinkedTest() {        this.list = new LinkedList<E>();    }    public void add(E e) {        list.addFirst(e);"添加元素"    }    public void getDL() {        int size = list.size();"获取元素长度"        "由于这里对元素进行取出（删除），导致元素长度改变，所以不能再这里写i<list.size()"        for (int i = 0; i < size; i++) {            "先输出最后一个"            System.out.println(list.removeLast());        }    }    public void getDZ() {        int size = list.size();        for (int i = 0; i < size; i++) {            "先输出第一个"            System.out.println(list.removeFirst());        }    }}

List集合中判断重复元素：
采用集合中元素的equals()方法来判断元素是否相同

import java.util.ArrayList;public class ListSetDemo {    public static void main(String[] args) {        "contains()和remove()方法会进行判断元素是否相同"        ArrayList<Persion> list = new ArrayList<Persion>();        list.add(new Persion("lisi", 10));        System.out.println(list.contains(new Persion("lisi", 10)));"结果：true"        System.out.println(list.contains(new Persion("lisi", 11)));"结果：false"        System.out.println(list.remove(new Persion("lisi", 11)));"结果：false"    }}public class Persion {    private String name;    private int age;    public Persion(String name, int age) {        super();        this.name = name;        this.age = age;    }    public int getAge() {        return age;    }    @Override    public boolean equals(Object obj) {        "重写equals()方法，通过判断姓名和年龄是否相同来判断是不是相同数据,        equals()方法不能使用泛型，因为这个方法是重写了Object中的方法,若是加上泛型就不是重写了"        Persion p = (Persion) obj;"类型强制转换"        return this.name.equals(p.name) && this.age == p.age;    }}

Set
特点：
1、无序（元素存入和取出顺序不一致）
2、元素不重复（通过元素的hashCode()和equals()判断元素是否相同）
3、set集合和Collection集合中的功能相同，没有像List集合有特殊方法(get()，set()，Listiterator)
Set
1、–HashSet：哈希表数据结构，根据哈希值来对数据进行排列，若哈希值相同则用equals()方法来判断是否是同一个对象，
若同一个对象就不存入，否则存入，线程不同步
(结构：若两个元素的哈希值都是3c，则它们会并排排列，而不会前后排列)
3c – 3d
|
3c
LinkedHashSet：可以对hashset集合进行排序

2、–TreeSet：二叉树数据结构（数据小的左边，大的右边），可以对元素进行排序（默认进行自然排序），线程不同步

Set集合判断元素是否相同：
首先判断元素的hashCode() 方法返回值是否相同，若相同就使用equals()方法判断是否是同一个对象
若两个都相同，则认为是同一个元素（集合会自动调用元素的相关方法进行判断，不需要手工调用）
Set集合中实例

"需求：根据姓名和年龄是否相同来判断是否为同一个数据"import java.util.HashSet;import java.util.Iterator;public class ListSetDemo {    public static void main(String[] args) {        HashSet<Persion> h = new HashSet<Persion>();        h.add(new Persion("zhangsan", 10));        h.add(new Persion("zhangsan", 20));        h.add(new Persion("zhangsan", 30));        h.add(new Persion("zhangsan", 40));        h.add(new Persion("zhangsan", 50));        "取出元素"        for (Iterator<Persion> it = h.iterator(); it.hasNext();) {            Persion p = it.next();            System.out.println(p.getAge() + "..." + p.getName());        }        "contains()和remove()方法判断元素是否相同，判断自定义数据中年龄和姓名相同来判断元素是否相同"        h.contains(new Persion("zhangsan", 50));        h.remove(new Persion("zhangsan", 50));    }}public class Persion {    private String name;    private int age;    public Persion(String name, int age) {        super();        this.name = name;        this.age = age;    }    public int getAge() {        return age;    }    public String getName() {        return name;    }    @Override    public int hashCode() {        "修改hashCode()方法修改返回值"        System.out.println(this.name + "...hash..." + this.age);        "这里乘20是为了确保返回值的唯一性"        return name.hashCode() + age * 20;    }    @Override    public boolean equals(Object obj) {        Persion p = (Persion) obj;        "判断姓名和年龄是否相同"        return this.name.equals(p.name) && this.age == p.age;    }}

TreeSet实例

import java.util.Iterator;import java.util.TreeSet;public class ListSetDemo {    public static void main(String[] args) {        "TreeSet中的元素必须要有排序，元素必须要实现Comparable<T> (T是需要比较的数据类型)，实现其中的compareTo(T o)方法""TreeSet排序的方法有两种：1、元素实现实现Comparable<T> (T是比较的数据类型)，实现其中的compareTo(T o)2、当元素中的排序不是我们想要的时候，通过创建一个类(A)实现Comparator<T>,重写compare(T o1, T o2)方法并在new TreeSet(new A())时把类(A)作为参数传入例如:String类的数据，由于String类是final类型，不能有子类，但是他的比较方式是采用自然排序(根据ASCII码排序)，这时候就不能通过第一种,修改元素的比较方法来修改排序，只能使用第二种方法采用比较器来比较当地一种方法和第二种方法同时存在时候，采用第二种方法来进行比较"        "使用元素自带的比较方式Comparable"        TreeSet<Persion> t = new TreeSet<Persion>();        "使用自定义的比较方式Comparator"        TreeSet<Persion> t = new TreeSet<Persion>(new ComTest());        t.add(new Persion("lizi0", 10));        t.add(new Persion("lizi0", 20));        t.add(new Persion("lizi2", 10));        t.add(new Persion("lizi3", 60));        t.add(new Persion("lizi4", 70));        for (Iterator<Persion> it = t.iterator(); it.hasNext();) {            Persion p = it.next();            System.out.println(p.getAge() + "..." + p.getName());        }        "TreeSet确定元素是否唯一也是依据hashCode()方法和equals()方法来判断"        t.contains(new Persion("lizi3", 10));        t.remove(new Persion("lizi4", 70));    }}public class Persion implements Comparable<Persion> {    private String name;    private int age;    public Persion(String name, int age) {        super();        this.name = name;        this.age = age;    }    public int getAge() {        return age;    }    public String getName() {        return name;    }    @Override    public int hashCode() {        System.out.println(this.name + "...hash..." + this.age);        return name.hashCode() + age * 20;    }    @Override    public boolean equals(Object obj) {        Persion p = (Persion) obj;        "判断元素的姓名和年龄是否相同"        return this.name.equals(p.name) && this.age == p.age;    }    "重写方法定义比较方式"    @Override    public int compareTo(Persion o) {        if (this.age != o.age) {            return this.age - o.age;        } else {            return this.name.compareTo(o.name);        }    }}import java.util.Comparator;"这里使用泛型来确定比较的数据类型，避免强转"public class ComTest implements Comparator<Persion> {    "重写方法定义比较方式"    @Override    public int compare(Persion o1, Persion o2) {        "比较两个数是否相同"        if (o1.getAge() != o2.getAge()) {            return o1.getAge() - o2.getAge();        } else {            return o1.getName().compareTo(o2.getName());        }    }}

泛型
特点：
1、用于解决安全问题，把运行时问题变成编译时问题，提前解决
2、运行过程中避免强制转换

格式：通过< > 来定义存储的类型
例如：TreeSet t = new TreeSet(); T并没有实际意义，它是用来确定TreeSet集合中接收元素的数据类型
TreeSet t ：T是声明的类型；new TreeSet();T 是实际创建的时候存入的类型，两个必须相同

自定义泛型：

"//泛型定义在类上，整个类都可以确定这种类型"class A<E> {    private E e;    "方法中使用类定义的泛型"    public A(E e) {        this.e = e;    }    public void show(E e) {    }    "不确定传入类型的时候可以使用 ? ，"    public void show4(Collection<? 或 T> t) {    "如果参数是?，不能进行这样操作，因为不明确?类型"     ？ a = it.next();     "如果参数是T，可以进行这样的操作，已经明确了类型"     T t = it.next();    }    "//方法自定义泛型类型，不使用和类相同类型，泛型定义在返回值的前面"    public <T> void show2(T t){    }    "静态方法自定义泛型"    public static <T> void show1(T t) {    }    "静态方法不能使用类定义的泛型，因为要确定类的泛型要先有对象，而静态不需要对象就能调用，导致冲突"     //public static void show2(E e) {     }    "接收的参数类型是Collection或其子类，集合中接收的类型是Persion类或他的子类，不确定，上限"    public void show2(Collection<? extends Persion> t) {    }    "接收的参数类型是Collection或其子类，集合中接收的类型是Persion类或他的父类，下限"    public void show3(Collection<? super Persion> t) {    }interface B<T> {"泛型定义在接口上"    void show(T t);}}

Map：
Map ：
1、HashMap：哈希表结构，可以存入键null和值null，线程不同步，无序
2、LinkedHashMap：LinkedHashMap是Map接口的哈希表和链接列表实现，元素顺序存入，元素顺序取出，允许使用null值和null键
3、TreeMap：二叉树结构，可以存入键null和值null，线程不同步，可以排序
4、HashTable：哈希表结构，不可以存入键null和值null，线程同步，无序（被HashMap取代）

Map

import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.TreeSet;public final class ListSetDemo {    public static void main(String[] args) {        Map<String, String> map1 = new HashMap<String, String>();        Map<String, String> map2 = new HashMap<String, String>();        map1.put("1", "a");"添加"        map1.put("2", "b");        map1.put("3", "c");        map1.put("4", "d");        "当键已经存在，又使用相同的键存入数据时，此时值:e会覆盖值:d，同时返回被覆盖的值:d"        String s = map1.put("4", "e");        map1.putAll(map2);"添加map容器"        map1.clear();"清空map集合"        map1.remove("1");"根据键删除对应的值，同时返回对应的值"        map1.containsKey("1");"是否存在键"        map1.containsValue("a");"是否存在对应的值"        map1.isEmpty();"判断是否为空"        map1.get("1");"根据键获取值"        Collection<String> coll = map1.values();"返回集合中所有的值，返回对象是一个Collection集合"        map1.size();"集合长度"    }}

Map的取出方式
keySet();返回一个Set集合，集合中的元素是map中键
entrySet();返回一个Set集合，集合中的元素是map中键值对的对应关系(Map.Entry)

import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;public final class ListSetDemo {    public static void main(String[] args) {        Map<String, String> map1 = new HashMap<String, String>();        Map<String, String> map2 = new HashMap<String, String>();        map1.put("1", "a");        map1.put("2", "b");        map1.put("3", "c");        map1.put("4", "d");        "返回map集合中键，并存入Set集合中"        Set<String> keyset = map1.keySet();        "对Set集合进行遍历"        for (Iterator<String> it = keyset.iterator(); it.hasNext();) {            "获取键的信息"            String key = it.next();            "通过键使用map的get()方法获取对应的值"            String value = map1.get(key);            System.out.println(key + "..." + value);        }        System.out.println("------------------------");        "返回map中键值对的对应关系，并存入Set集合中，键值对的数据类型就是:Map.Entry"        Set<Map.Entry<String, String>> entryset = map1.entrySet();        for (Iterator<Map.Entry<String, String>> it = entryset.iterator(); it.hasNext();) {            "获取Map.Entry对象"            Map.Entry<String, String> map = it.next();            "使用Map.Entry对象调用方法获取 键 信息"            String key = map.getKey();            "使用Map.Entry对象调用方法获取 值 信息"            String value = map.getValue();            System.out.println(key + "..." + value);        }    }}

LinkedHashMap是HashMap的一个子类，它保留元素存入的顺序，当需要元素输出时顺序和输入时顺序的相同，那么就选用LinkedHashMap。
LinkedHashMap是Map接口的哈希表和链接列表实现，具有迭代顺序，并允许使用null值和null键，线程不同步

实例：
使用HashMap< Integer,Persion> 对集合中的元素进行排序，Persion中有年龄（age）和姓名（name）
在不破坏键-值的情况下，根据用户的年龄进行排序，并且返回HashMap< Integer,Persion>
难点：HashMap不支持排序
LinkedHashMap 是HashMap的子类，并且保留插入顺序
扩展：通过Collections.sort(list,comparator)可以实现ArrayList，LinkedList，HashSet，HashMap的排序

public class Demo {    public static void main(String[] args) {        HashMap<Integer, Persion> map = new LinkedHashMap<Integer, Persion>();        map.put(1, new Persion(10, "a10"));        map.put(3, new Persion(17, "b11"));        map.put(2, new Persion(12, "c12"));        map.put(4, new Persion(14, "d13"));        System.out.println(demo(map));    }    public static HashMap<Integer, Persion> demo(HashMap<Integer, Persion> map) {        "1、获取键值对的关系集合，并返回set集合"        Set<Map.Entry<Integer, Persion>> set = map.entrySet();        "2、创建一个List集合，在构造函数中把set集合作为参数传入，获得一个list集合"        List<Map.Entry<Integer, Persion>> list = new ArrayList<Map.Entry<Integer, Persion>>(                set);        "3、通过Collections.sort(list,comparator)对一个list集合进行排序"        Collections.sort(list, new Comparator<Map.Entry<Integer, Persion>>() {            @Override            public int compare(Entry<Integer, Persion> o1, Entry<Integer, Persion> o2) {                return o2.getValue().getAge() - o1.getValue().getAge();            }        });        "4、创建一个LinkedHashMap对象"        LinkedHashMap<Integer, Persion> lhm = new LinkedHashMap<Integer, Persion>();        "5、遍历集合，把排序完的值存入LinkedHashMap集合中"        for (Map.Entry<Integer, Persion> en : list) {            lhm.put(en.getKey(), en.getValue());        }        return lhm;    }}

Map 实例
需求：有学生类，学生属性有姓名年龄，每个学生都有一个归属地，学生使用Student，归属地使用String,当姓名年龄相同时认为是同一个学生，不进行存储，存储时候使用年龄进行排序，使用map集合实现

import java.util.Iterator;import java.util.Map;import java.util.Set;import java.util.TreeMap;public final class ListSetDemo {    public static void main(String[] args) {        Map<Student, String> map1 = new TreeMap<Student, String>();        map1.put(new Student("zhangsan1", 10), "beijing");        map1.put(new Student("zhangsan2", 20), "shanghai");        map1.put(new Student("zhangsan3", 60), "shenzhen");        map1.put(new Student("zhangsan4", 30), "guangzhou");        map1.put(new Student("zhangsan5", 12), "tianjing");        map1.put(new Student("zhangsan5", 12), "chognqing");        Set<Map.Entry<Student, String>> entryset = map1.entrySet();        for (Iterator<Map.Entry<Student, String>> it = entryset.iterator(); it.hasNext();) {            Map.Entry<Student, String> map = it.next();            Student key = map.getKey();            String value = map.getValue();            System.out.println(key.getName() + "...." + key.getAge() + "..." + value);        }    }}"Student类实现Comparable接口，因为有可能使用TreeSet来进行存储，提前准备"public class Student implements Comparable<Student> {    private String name;    private int age;    public Student(String name, int age) {        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;    }    "Map集合采用元素的hashCode()和equals()方法来判断元素是否相同"    @Override    public int hashCode() {        return this.name.hashCode() + this.age * 12;    }    @Override    public boolean equals(Object obj) {        if (!(obj instanceof Student)) {            throw new ClassCastException("类型错误");        }        Student s = (Student) obj;        if (this.age == s.age) {            return this.name.equals(s.name);        }        return false;    }    "排序实现Comparable接口"    @Override    public int compareTo(Student o) {        int num = this.age - o.age;        if (num == 0) {            return this.name.compareTo(o.name);        }        return num;    }}

工具类–Collections，Arrays，System，Runtime

import java.io.IOException;import java.io.ObjectInputStream.GetField;import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.Properties;import java.util.TreeSet;"/** * 静态导入 * 默认导入是导入包中所有的类，静态导入是导入类中的所有静态方法，此时在函数中书写时不用加上类名，而是可以直接使用方法 */"import static java.util.Arrays.*;public final class ListSetDemo {    public static void main(String[] args) {        ArrayList<Student> list = new ArrayList<Student>();        "/**         * Collections.reverseOrder() 空参数时反转元素排序         * Collections.reverseOrder(new ComTest())//new ComTest()中默认是按照年龄从小到大排序         * 强行反转成从大到小,有参数时反转Comparator接口的排序方式         */"        TreeSet<Student> tset = new TreeSet<Student>(Collections.reverseOrder(new ComTest()));        list.add(new Student("zhangsan1", 10));        list.add(new Student("zhangsan4", 40));        list.add(new Student("zhangsan9", 90));        list.add(new Student("zhangsan6", 60));        list.add(new Student("zhangsan3", 30));        tset.add(new Student("zhangsan1", 10));        tset.add(new Student("zhangsan4", 40));        tset.add(new Student("zhangsan9", 90));        tset.add(new Student("zhangsan6", 60));        tset.add(new Student("zhangsan3", 30));        "/**         * 增强for循环：必须要有对象遍历，传统for循环功能更强，这个是传统for简写格式         * 在操作集合时候不能对集合进行添加和删除元素         */"        for (Student s : tset) {            System.out.println(s.getAge() + "..." + s.getName());        }        "/** 对List集合中的元素进行排序,List集合中元素必须具备比较性         *  1、元素实现Comparable 接口，重写compareTo()方法         *  2、创建类实现Comparator接口，定义比较方法         */"        Collections.sort(list);        "// 获取list集合中按照自然顺序（根据ASCII码表）最大的"        System.out.println(Collections.max(list));        "// 二分查找法查找集合中的元素，首先内部元素要重写方法定义唯一性的判断方法"        int index = Collections.binarySearch(list, new Student("zhangsan1", 10));        System.out.println(index);        "// 把集合中所有元素替换成指定元素"        Collections.fill(list, new Student("wangwu", 80));        "// 反转集合中的元素"        Collections.reverse(list);        "/**         * Arrays 用于操作数组的工具类         */"        int[] arr = { 2, 3, 5, 6, 9, 10 };        "// 二分法查找"        System.out.println(Arrays.binarySearch(arr, 2));        "// 复制数组中的一部分元素，也可以全部元素"        int[] brr = Arrays.copyOfRange(arr, 2, 3);        for (int a : brr) {            System.out.println(a);        }        "// 比较数组中元素是否相同"        Arrays.equals(arr, brr);        "// 数组中元素全部替换"        Arrays.fill(arr, 9);        "// 数组进行排序, 可以执行局部排序"        Arrays.sort(arr);        "// 把数组转换成字符串"        Arrays.toString(arr);        "/** 把数组转换成List集合         * 当数组中的元素都是基本数据类型时候，数组转换成集合，此时集合中存入的元素是数组对象的地址值         * int[] a = {2, 3, 5, 6, 9, 10 };         * List<int[]> list = Arrays.asList(a);         * 当数组中的元素都是对象时，数组转换成集合，此时集合中存入的元素是数组中的元素         * Integer[] i = {2, 3, 5, 6, 9, 10}         * List<Integer> list = Arrays.asList(i);         */"        Arrays.asList(arr);        "/**         * System:不能被实例化，内部方法都是静态         * System.in：获取键盘录入         * System.out：输出打印到控制台         */"        System.gc();"// 运行垃圾回收器"        Properties pro = System.getProperties();"// 获取当前系统的信息,返回Properties类型"        System.setProperty("a", "b");"//添加信息"        "/**         * Runtime：java程序都有一个Runtime实例，使程序和系统环境相连         */"        Runtime r = Runtime.getRuntime();"//获取实例对象"        try {            r.exec("c://a.exe");"//使用独立线程执行exec内容，可以执行系统的.exe文件等"        } catch (IOException e) {            e.printStackTrace();        }    }    "/**     * 可变参数类型     * 可以存入T类型的参数多个，虚拟机会自动把参数封装进相对应的数组中，不用手动操作     * 若方法中传入多个不同的参数类型，可变参数类型必须放在最后     */"    public <T> void show(String s, T... a) {    }        "/**         * Date 时间类（已经被Calendar取代）         * 有util包和sql包，不同情况导入不同包         */"        Date date = new Date(System.currentTimeMillis());        "// 默认输出格式：Tue Sep 22 10:59:39 CST 2015"        System.out.println(date);        "/**         * 对date的输出格式进行格式化         * y:年,M:月,d:月份的天数,D:年中的天数,E:星期的天数,h:小时,m:分钟,s:秒         */"        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-ddED");        String s = sdf.format(date);        System.out.println(s);        "/**         * Calendar 日历         */"        Calendar c = Calendar.getInstance();"// 获取calendar对象"        System.out.println("年：" + c.get(Calendar.YEAR));"// 年"        System.out.println("月中的天：" + c.get(Calendar.DAY_OF_MONTH));"// 月中的天"        System.out.println("星期的天：" + c.get(Calendar.DAY_OF_WEEK));"// 星期的天"        System.out.println("月：" + c.get(Calendar.MONTH));"// 月"        System.out.println("分钟：" + c.get(Calendar.MINUTE));"// 分钟"        System.out.println("秒：" + c.get(Calendar.SECOND));"// 秒"        System.out.println("小时：" + c.get(Calendar.HOUR));"// 小时"        System.out.println("天中的小时：" + c.get(Calendar.HOUR_OF_DAY));"// 天中的小时"        "/**         * 如何获取任意一年的2月份天数         */"        c.set(2017, 2, 1);"// 2013 年 3月 1日 ：月默认是从0 开始计算，要注意"        c.add(Calendar.DATE, -1);"// 对日期进行减1"        "//Math工具类"        System.out.println(Math.abs(-1));"// 绝对值"        System.out.println(Math.max(2, 5));"// 2 和 5 两个值的最大值"        System.out.println(Math.ceil(12.34));"// 返回大于指定数值的最小整数13.0"        System.out.println(Math.floor(12.34));"// 返回小于指定数值的最大数值12.0"        System.out.println(Math.round(12.35));"// 四舍五入12"        System.out.println(Math.random());"// 随机数0-1包含0 不包含1"        System.out.println(Math.pow(2, 5));"// 2的5次方32.0"        System.out.println(new Random().nextInt(10));"//返回0-9之间的整数"}

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-