黑马程序员——java基础： 集合

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

一为什么出现集合类？

       面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种

数组和集合类同事容器，有何不同？

       数组虽然也可以存储对象，但长度是固定的；集合长度是可变的，数组中可以存储基本数据类型。

二  迭代器

迭代：就是取出集合中元素的一种方式

把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。那么取出方式就被定义成了内部类。而每个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容，判断和取出，那么可以将共性内容进行抽取那么这些内部类都符合一个规则：该规则是Iterator.

如何获取集合的取出对象呢？

通过一个对外提供的方法：iterator();

三 集合框架-List集合共性方法

Collection

       |--List:元素是有序的，元素可以重复，因为该集合体系有索引；

              |--ArrayList:底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢，线程不同步。

              |--LinkedList:底层使用的是链表数据结构，特点：增删速度很快，查询稍慢。

              |--Vector:底层是数组数据结构，线程同步。被ArrayList替代了。

       |--Set:元素是无序的，元素不可以重复，因为该集合体系没有

List：

       特有方法：凡是可以操作角标的方法都是该体系特有的方法。

增

       add(index,element);

       addAll(index,Collection);

删

       remove(index);

改

       set(index,element);

查

       get(index);

       subList(from,to);

       listIterator：列表迭代器

List集合特有的迭代器。ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。

所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除等操作。如果要想其他的操作如添加，修改等，就需要使用其子接口：ListIterator该接口只能通过List集合的ListIterator方法获取。

四、集合框架-Vector中的枚举

枚举就是Vector特有的取出方式。发现枚举和迭代器很像，其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长，所以被迭代器取代了

五 LinkedList

LinkedList:特有方法：

addFirst();

addLast();

getFirst();

getLast();

获取元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

获取元素，但元素被删除，如果集合中没有元素，会出现

在JDK1.6出现了替代方法。

offerFirst();

offerLast();

peekFirst();

peekLast();

获取元素，但不删除元素，如果集合中没有元素，会返回null.

pollFirst();

pollLast();

获取元素，但是元素被删除，如果集合中没有元素，会返回null

import java.util.*;
class LinkedListDemo
{
       public static void main(String[] args)
       {
              LinkedList link = new LinkedList();
              link.addFirst("java01");
              link.addFirst("java02");
              link.addFirst("java03");
              link.addFirst("java04");
 
              sop(link);
              while(!link.isEmpty())
              {
                     sop(link.removeLast());
              }
       }
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}

使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出  如同一个杯子

队列：先进先出    First in First out FIFO   如同一个水管。

六集合框架-HashSet

|--Set:元素是无序（存入和取出的顺序不一定一致），元素不可以重复。

       |--HashSet：底层数据结构是哈希表。

                     HashSet是如何保证元素唯一性的呢？

                     是通过元素的两个方法，hashCode和equals来完成。

                     如果元素的HashCode值相同，才会判断equals是否为true。

                     如果元素的hashcode值不同，不会调用equals。

 

                     注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

       |--TreeSet：

Set集合的功能和Collection是一致的。

七 集合框架—TreeSet

Set无序，不可以重复元素。

       |--HashSet：数据结构式哈希表，县城市非同步的。

                            保证元素唯一性的原理：判断怨毒的hashcode值是否相同。

                            如果相同，还会继续判断元素的equals方法，是否为true

       |--TreeSet：可以对Set集合中的元素进行排序。

                            底层数据机构是二叉树，保证元素唯一性的依据：

                            compareTo方法return 0；

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

                            元素需要实现Comparable接口，覆盖compareTo方法。

                            这种方式也称为元素的自然顺序，或者叫做默认顺序。

                            TreeSet的第二种排序方式。

                            当元素自身不具备比较性时，或者具备的比较性不是所需要的，

                            这时就需要让集合自身具备比较性

                            在集合初始化时，就有了比较方式。

需求：

往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序。

记住，排序时，当主要条件相同时，一定要判断一下次要条件。

<span style="font-size:14px;">import java.util.*;
class TreeSetDemo
{
       public static void main(String[] args)
       {
              TreeSet ts = new TreeSet();
              ts.add(new Student("lisi001",20));
              ts.add(new Student("lisi009",22));
              ts.add(new Student("lisi004",23));
              ts.add(new Student("lisi003",23));
              ts.add(new Student("lisi007",25));
 
              Iterator it = ts.iterator();
              while(it.hasNext())
              {
                     //System.out.println(it.next());
                     Studentstu = (Student)it.next();
                     System.out.println(stu.getName()+"..."+stu.getAge());
              }
       }
}
 
class Student implements Comparable//该接口强制让学生具备比较性
{
       private String name;
       private int age;
       Student(String name,int age)
       {
              this.name = name;
              this.age = age;
       }
       public int compareTo(Object obj)
       {
              if(!(obj instanceof Student))
                     thrownew RuntimeException("不是学生对象");
              Student s = (Student)obj;
 
              System.out.println(this.name+"..compareTo..."+s.name);
              if(this.age > s.age)
                     return1;
              if(this.age==s.age)
              {
                     returnthis.name.compareTo(s.name);
              }
              return -1;
       }
       public String getName()
       {
              return name;
       }
       public int getAge()
       {
              return age;
       }
}</span>

八 Map集合

1，map是一个接口 Map<K,V>

类型参数：

K：此映射所维护的键的类型

V：映射值的类型

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。

       1.添加

              put(K key, V value)

              putAll(Map<? extends K,? extends V>m)

       2.删除

              clear()

              remove(Object key)

       3.判断

              containsValue(Object value)

              containsKey(Object key)

              isEmpty()

       4.获取

              get(Object key)

              size()

              value()

 

2、Map子类对象特点

Map

       |--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的，jdk1.0效率低

       |--HashMap：底层是哈希表数据结构，允许存入null键null值。该集合线程不同步的，jdk1.2效率高。

       |--TreeMap：底层是二叉树数据结构，线程不同步，可以用于各map集合中的键进行排序。

map和Set很像，其实Set底层就是使用了Map集合。

Hashtable用作键的对象必须实现hashCode方法和equals方法。

import java.util.*;
class MapDemo
{
       public static void main(String[] args)
       {
              Map<String,String> map = new HashMap<String,String>();
              //添加元素,如果出现相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
              System.out.println("put:"+map.put("01","zhangsan01"));
              System.out.println("put:"+map.put("01","wangwu"));
              map.put("02","zhangsan02");
              map.put("03","zhangsan03");
 
              System.out.println("containsKey:"+map.containsKey("02"));
              //System.out.println("remove:"+map.remove("02"));
              map.put("04",null);
              System.out.println("get:"+map.get("04"));
              //可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断。
             
              //获取Map集合中所有的值
              Collection<String> coll =map.values();
              System.out.println(coll);
              System.out.println(map);
       }
}

3 、 map集合的两种取出方式：

Map-keySetSet<k> keySet：将map中所有的键存入到Set集合，因为set具备迭代器，所以可以用迭代的方式取出所有的键，再根据get方法，获取每一个键所对应的值。

Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。

 Map-Entry

Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到set集合中，而这个关系的数据类型就是：Map.Entry

九集合框架的工具类

1、Collections-sort

Collections:此类完全由在collection上进行操作或返回collection的静态方法组成。它包含collection上操作的多态算法，即“包装器”，包装器返回由指定collection支持的心collection，以及少数其他内容。

如果为此类的方法锁提供的collection或类对象为null，则这些方法都抛出NullPointerException。

Collections-sort

Collections-max

         根据指定比较器产生的顺序，返回给定collection 的最大元素。

2、Collections-替换反转

fill：将集合中的元素全部替换成指定元素

3、Collections-SynchronizedList

static<T> List<T>synchronizedList(List<T> list):返回指定列表支持的同步（线程安全）列表。

static void shuffle(List<?< list):使用默认随机源对指定列表进行置换。

4、Arrays

Arrays:用于操作数据的工具类，里面都是静态方法。

asList:将数组变成list集合。

把数组编程list集合有什么好处？

       可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。否者会发生UnsupportedOperationException异常。

5、集合变数组

Collection接口中的toArray方法。

6、高级for循环

格式：

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

对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。

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

如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别？

高级for有一个局限性，必须有被遍历的目标。

建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义角标。

<span style="font-size:14px;">import java.util.*;
class ForEachDemo
{
       public static void main(String[] args)
       {
              ArrayList<String> al = new ArrayList<String>();
              al.add("abc1");
              al.add("abc2");
              al.add("abc3");
 
              for(String s : al)
              {
                     System.out.println(s);
              }
              /*
              Iterator it = al.iterator();
              while(it.hasNext())
              {
                     System.out.println(it.next());
              }
              */
 
              int[] arr = {3,4,5};
              for(int i:arr)
              {
                     System.out.println("i:"+i);
              }
 
<SPAN style="WHITE-SPACE: pre"> </SPAN>//由于Map集合不支持Collection集合中的方法，因此这里需要先将其转换成Set集合后，才能使用相关方法
              HashMap<Integer,String> hm = newHashMap<Integer,String>();
              hm.put(1,"a");
              hm.put(2,"b");
              hm.put(3,"c");
 
<SPAN style="WHITE-SPACE: pre"> </SPAN>//取出元素的第一种方法
              Set<Integer> keySet = hm.keySet();
              for(Integer i : keySet)
              {
                     System.out.println(i+"::"+hm.get(i));
              }
 
              //Set<Map.Entry<Integer,String>>entrySet = hm.entrySet();
              //for(Map.Entry<Integer,String> me: entrySet)
 
<SPAN style="WHITE-SPACE: pre"> </SPAN>//取出元素的第二种方法
              for(Map.Entry<Integer,String> me:hm.entrySet())
              {
                     System.out.println(me.getKey()+"-----"+me.getValue());
              }
       }
}</span>