黑马程序员_java09_集合框架

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

集合对象可以用来持有其他对象，作为数据容器使用，与数组的功能类似。java API 中的集合框架都位于java.util包中，实现了很多常见数据结构，如hashSet等。

java的集合框架是由很多的接口，抽象类，具体类组成的，都位于java.util包中。集合接口定义了具体集合类的规范。

Collection 接口

Collection 是所有集合类的根接口，同时Collection接口是一个泛型接口。Collection对象可以持有任何类型的对象。其持有的对象被称为集合元素。Collection接口中定义add()方法等。

Collection中定义了框架的共性功能。
添加：
add(e)
addAll(collection);

删除
remove(e)
removeAll(collection)
clear();

判断
contains(e);
isEmpty();

获取
iterator();
size();

获取交集
retainAll()

集合变数组
toArray();

add()方法的参数类型是Object。以便于接收任意类型的对象。

集合中存储的都是对象的引用(地址)。

Iterator 迭代器

其实就是集合中取出元素的方式。所以迭代器通过内部类形式来进行描述。通过容器的iterator()方法获取内部类的对象。

boolean hasNext()
此方法用来判断被迭代的集合中是否存在元素，集合中存在至少一个元素，则返回true，否则返回false。该方法返回值往往用来作为while循环的条件来迭代集合。

E next()
此方法用来返回集合中的当前元素，E是泛型，具体类型根据集合的泛型类型决定。
要使用Iterator 接口迭代集合对象，首先必须把集合对象转换成Iterator对象，才能进一步使用Iterator的方法进行迭代。Collection接口中定义了生成Iterator对象的方法。
Collection对象都可以调用iterator()方法，生成对应泛型的Iterator对象，进一步使用Iterator中的方法，对集合进行迭代。

Iterator接口中有一个子接口ListIterator，增加了迭代List的方法。值得注意的是，增强for循环 的使用，比迭代器更直接简洁。

import java.util.*;
class ArrayListTest 
{
    public static void main(String[] args) 
    {
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java03");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        sop(al);
        al=singleElement(al);
        sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static ArrayList singleElement(ArrayList al)
    {
        ArrayList newAl=new ArrayList();
        Iterator it=al.iterator();
        while (it.hasNext())
        {
            Object obj=it.next();
            if (!newAl.contains(obj))
            {
                newAl.add(obj);
            }
        }
        return newAl;
    }
}

Collection的子类
List ：元素是有序的，元素可以重复。因为该集合体系有索引。
ArrayList : 底层的数据结构使用的是数据结构。特点：查询速度快。但是增删稍慢，线程不同步、
LinkedList:底层的数据结构使用的数组结构。特点：增删速度很快，查询稍慢，线程不同步。
Vector: 底层是数组数据结构线程同步，但是已经被ArrayList代替，因为效率低。枚举就是Vector特有的取出方式，
但是枚举的名称以及方法的名称过长。
Set : 元素是无序的，元素不能重复。

List 中特有的方法

添加：
add(index,element);
addAll(index .collection);

删除：
remove(index);

修改
set(index ,element)

查找
get(index);
subList(form,to);
listIterator();
int indexOf(Obj);
ListIterator listInterator();

import java.util.*;
class DuiLie
{
    private LinkedList link;
    DuiLie()
    {
        link=new LinkedList();
    }
    public void myAdd(Object obj)
    {
        link.offerFirst(obj);       
    }
    public Object myGet()
    {
        return link.pollLast();
    }

    public boolean isNull()
    {
        return link.isEmpty();
    }
}
class LinkedListTest 
{
    public static void main(String[] args) 
    {
        DuiLie dl=new DuiLie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");
        while (!dl.isNull())
        {
            System.out.println(dl.myGet());
        }

    }

}

Set集合

Set集合的子类hashSet:底层数据结构是哈希表。是线程不安全扥，不是同步的。

HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode() 和equals()来完成的。
如果元素的hashCode值是相同的，才会判断equals是否为true。
如果元素的hashCode值不同，不会调用equals
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

TreeSet：可以对set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一的依据。
TresSet排序的第一种方法：让元素自身具备比较性。元素需要Comparable接口，覆盖compareTo方法。默认是元素
元素的自然顺序。
TreeSet的第二种排序方式。当元素自身不具备比较性是，或者具备的比较性不是所需要的。这时就需要让集合自身具
备比较性。在集合初始化时，就有了比较性。

import java.util.*;
class TreeSetDemo2 
{
    public static void main(String[] args) 
    {
        TreeSet ts=new TreeSet(new MyComparator());
        ts.add(new Student("lisi01",30));
        ts.add(new Student("lisi02",41));
        ts.add(new Student("lisi03",29));
        ts.add(new Student("lisi004",78));
        Iterator it=ts.iterator();
        while (it.hasNext())
        {
            Student s=(Student)it.next();
            System.out.println(s.getName()+"\t"+s.getAge());
        }
    }
}
class Student implements Comparable
{
    private int age;
    private String name;
    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int getAge()
    {
        return age;
    }
    public String getName()
    {
        return name;
    }
    public int compareTo(Object obj)
    {
        if (!(obj instanceof Student))
        {
          throw new RuntimeException(" no Student");
        }
        Student s=(Student)obj;
        if (this.age>s.age)
        {
            return 1;
        }
        if (this.age<s.age)
        {
            return -1;
        }
        if (this.age==s.age)
        {
            return this.name.compareTo(s.name);
        }
        return -1;
    }
}
class MyComparator implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        Student s1=(Student)o1;
        Student s2=(Student)o2;
        int num=s1.getName().compareTo(s2.getName());
        if (num==0)
        {
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        }
        return num;
    }
}

Map集合

Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。从概念上而言，您可以将 List 看作是具有数值键的 Map。而实际上，除了 List 和 Map 都在定义 java.util 中外，两者并没有直接的联系。

Map接口中的方法：

新增：

V put(K key, Vvalue)
将指定的值与此映射中的指定键关联（可选操作）。

删除: void clear();

判断：

booleanisEmpty()
如果此映射未包含键-值映射关系，则返回 true。

map集合的两种取出方式：

Set < K > keySet 将map中所有的键存入到Set集合中。因为Set具备迭代器。

Set

import java.util.*;
class  MapTest3
{
    public static void main(String[] args) 
    {
        String s=CharCout("abfkabhubkace");
        System.out.println(s);
    }
    public static String CharCout(String str)
    {
        char[] chs=str.toCharArray();
        TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
        int count=0;
        for (int x=0;x<chs.length;x++ )
        {
            if (!(chs[x]>='a'&&chs[x]<='z'||chs[x]>='A'&&chs[x]<='Z'))
            {
                continue;
            }
            Integer value=tm.get(chs[x]);
            if (value!=null)
            {
                count=value;
            }
            count++;
            tm.put(chs[x],count);
        }
        System.out.println(tm);
        StringBuilder sb=new StringBuilder();
        Set<Map.Entry<Character,Integer>> mapEntry=tm.entrySet();
        Iterator<Map.Entry<Character,Integer>> it=mapEntry.iterator();
        while (it.hasNext())
        {
            Map.Entry<Character,Integer> map=it.next();
            Character ch=map.getKey();
            Integer value=map.getValue();
            //System.out.println(ch+"("+Value+"), ");
            sb.append(ch+"("+value+"), ");

        }
        return sb.toString();
    }   
}

Collction主要有3个子接口，分别是List,Set ,Queue，List实现了有序的集合，Set不允许有重复的元素。Queue实现了FIFO的存储结构；Map结构存储键值对，不允许key值重复。