集合

集合类概述

  java.util包中提供了一些集合类，这些集合类又被称为容器。数组也是一种容器，但集合类与数组的不同之处在于数组的长度是固定的，而集合的长度是可变的；数组用来存放基本类型的数据，集合用来存放对象的引用。常用的集合有List集合、Set集合和Map集合，其中List与Set继承了Collections接口。各接口还提供了不同的实现类。

一、List集合（有序的，可重复的）

               <1>ArrayList

                            底层的数据结构使用的是数组数据结构，查询快（一般用于查询），增删改慢。下面我们就看看代码以及打印出来的结果

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

                                        public class TestList {
                                                   public static void main(String[] args) {
                                                        // 实例化一个集合
                                                       List<String> list=new ArrayList<String>();

                                                       //给集合添加值

                                                       list.add("A");

                                                       list.add("B");
                                                       list.add("C");
                                                       list.add("A");

                                                        //获得集合的长度

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

                                                        //遍历集合，循环输出集合中所有值
                                                     for (String string : list) {
                                                               System.out.println(string);

                                                  }

                                                           }

                                          打印出来的结果是：

                                                                          4

                                                                          A

                                                                          B

                                                                          C

                                                                          A

                                                                    

              <2>LinkedList(特有方法)

                            底层的数据河沟使用的是链表结构，查询慢（一般不用于查询），增删改快，下面我们就看看代码以及打印出来的结果

                                          import java.util.LinkedList;
                                           import java.util.List;

                                        public class TestList {
                                                   public static void main(String[] args) {

                                                     //实例化一个集合

                                                    LinkedList<String> list=new LinkedList<String>();

                                                    //给集合添加值

                                                     list.add("A");
                                                     list.add("B");
                                                     list.add("C");
                                                     list.add("A");

                                                     //分别在头部与尾部添加值

                                                     list.addFirst("头");
                                                     list.addLast("尾");

                                                     //移除集合中第一个值
                                                     list.removeFirst();

                                                     //遍历集合，循环输出集合中所有值
                                                     for (String string : list) {
                                                               System.out.println(string);

                                                           }

                                                                }

                                              打印出来的结果是：

                                                                                A

                                                                                B

                                                                                C

                                                                                A

                                                                                尾

              <3>Vector                           

        底层是数据结构使用的是数组数据结构，线程同步，现被ArrayList替代了，不常用。

                          因为不是很常用，所以在这里也不列举了。感兴趣的可以 点击打开链接了解Vector  也可以复制这个网址：http://baike.baidu.com/link?url=Czdp-LEFDxAHIACle_9Uns4D-v9TFzYtHg2nVpoQuv2gBOs0DBmmaFOU3BkSgWLtY1XczU-D4Dl7eRs8rKvf3a

二、Set集合（不能添加重复，无序但却会排序）

   <1>HashSet

     可以加空值， HashSet通过元素的两个方法，hashCode和equals来保证元素的唯一性。如果元素的hasnCode相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

     mport java.util.HashSet;
       public class TestSet {
       public static void main(String[] args) {

     //实例化集合HashSet

        HashSet<String> hashSet=new HashSet<String>();

       //给集合HashSet中添加值

         hashSet.add("A");

        hashSet.add("C");

        hashSet.add("B");

        hashSet.add(null);

        //遍历HashSet集合，循环输出集合中的值

        for (String string : hashSet) {

            System.out.println(string);

        }

         }

       打印出来的结果为：

                  null

                 A

                 B

                  C

   <2>TreeSet

        不可以加空值,可以对Set集合中的元素进行排序。排序时，当主要条件相同，一定要比较次要条件。

              import java.util.TreeSet;
            public class TestSet {
            public static void main(String[] args) {

               //实例化TreeSet集合

               TreeSet<String> treeSet=new TreeSet<String>();

               //给TreeSet集合添加值

                  treeSet.add("A");
                  treeSet.add("C");
                  treeSet.add("B");
                treeSet.add(null);

               //遍历TreeSet集合，循环输出集合中的值

                for (String string : treeSet) {
                      System.out.println(string);
                   }

                }

                  }

            打印的结果为：

                 空指针异常（TreeSet不可以添加空值，若把treeSet.add(null)删掉，则打印出来的是A,B,C）

三、Map集合（该集合存储键值对，一对一对往里存，而且要保证键的唯一性。如果添加元素时有相同的键，那么后添加的值会覆盖并返回原有键对应值，可以通过get方法的返回值来判断一个键是否存在。通过返回null判断。）

     Map集合的三种取值方式：

              Set<k> keySet：根据键获取值

              Set<Map.Entry<k,v>> entrySet：获取所有的键跟值

              Collection<V> collection:获取所有的值

      <1>HashMap

        可以添加空值，无序。底层是哈希表数据结构，不可以存入null键和null值，该集合是线程同步的

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

           public class TestMap {
              public static void main(String[] args)

            //实例化Map集合

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

            //给集合添加值

              map.put("A", "AAAA");
             map.put("2", "2222");
             map.put("3", "3333");
             map.put("王", "大小王");
        
              //遍历输出
        //01.获取所有的键，再根据键获取值
               Set<String> strings=map.keySet();
               for (String string : strings) {
              System.out.println(string+":"+map.get(string));
                 }
        
        //02.获取所有的值
//              Collection<Object> collection=map.values();
//              for (Object object : collection) {
//                  System.out.println(object);
//                 }
        
        //03.获取键和值（一个一个）
//        Set<Entry<String, Object>> entries=map.entrySet();
//        for (Entry<String, Object> entry : entries) {
//            System.out.println(entry.getKey() + " " + entry.getValue());
//        }
    }
}

          打印的结果为：

             

     <2>HashTable

        不能添加空值，无序。底层是哈希表数据结构，允许使用null键和null值，该集合是不同步的。

          详情可以点击打开链接了解 或者复制网址：http://www.cnblogs.com/yangleiWPF/archive/2010/11/16/1878494.html

     <3>TreeMap

           可以添加空值，有序。底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。

          详情可以 点击打开链接了解 或者复制网址：http://blog.csdn.net/chenssy/article/details/26668941

四、泛型（JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。）

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

            在使用Java提供的对象时，什么时候写泛型：通常在集合框架中很常见，只要见到<>就要定义泛型。

          其实<>就是用来接受类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>即可。

     泛型类：

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

     泛型方法：

          泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象要明确要操作的具体的类型后，所有要操作的类型就一定固定了。为了让不同的方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

     静态方法泛型：

          特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。

      泛型定义方法时，要放在返回类型前面。

      泛型限定：用于泛型扩展。

      ？：通配符，也可以理解为占位符。

     <? extends E>：可以接受E类型或者E类型的子类型。上限

     <? super E>：可以接受E类型或者E类型的父类型。下限