java学习——集合

集合类的特点

提供一种存储空间 可变 的存储模型，存储的数据容量可以随时发生改变

 

Collection类

常用方法：

boolean add(E e) //添加元素
boolean remove(Object o) //从集合中移除指定的元素
void clear() //清空集合中的元素
boolean contains(Object o) //判断集合中是否存在指定的元素
boolean isEmpty() //判断集合是否为空
int size()// 集合的长度，也就是集合中元素的个数

Collection 集合的遍历:

Iterator<String> it = c.iterator();//c为集合对象
//用while循环改进元素的判断和获取
while (it.hasNext()) { 
    String s = it.next(); 
    System.out.println(s); 
}

List

ArrayList 

extends AbstractList

void add(int index,E element) //在此集合中的指定位置插入指定的元素
E remove(int index) //删除指定索引处的元素，返回被删除的元素
E set(int index,E element) //修改指定索引处的元素，返回被修改的元素
E get(int index) //返回指定索引处的元素

并发修改异常

迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际

修改值不一致，则会出现：ConcurrentModificationException。如下

Iterator<String> it = list.iterator();
 while (it.hasNext()) {
     String s = it.next();
    if(s.equals("world")) { 
        list.add("javaee");
    }
}

解决方法：

1.使用for循环

for(int i=0; i<list.size(); i++){ 
    String s = list.get(i); 
    if(s.equals("world")) { 
        list.add("javaee"); 
    }
}

2.ListIterator迭代器，通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器 ，用于允许程序员沿任一方向（向前或向后都可以）遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

ListIterator<String> lit = list.listIterator();
while (lit.hasNext()) { 
    String s = lit.next(); 
    if(s.equals("world")) { 
        lit.add("javaee"); 
    } 
}

LinkedList

public void addFirst(E e) //在该列表开头插入指定的元素
public void addLast(E e)// 将指定的元素追加到此列表的末尾
public E getFirst()// 返回此列表中的第一个元素
public E getLast() //返回此列表中的最后一个元素
public E removeFirst() //从此列表中删除并返回第一个元素
public E removeLast() //从此列表中删除并返回最后一个元素

对比：

数组结构 ：查询快、增删慢

队列结构 ：查询慢、增删快 

Set

Set集合的特点

元素存取无序

没有索引、只能通过迭代器或增强for循环【指for( String s : set )】遍历

不能存储重复元素

 

HashSet

HashSet集合的特点

底层数据结构是哈希表,

对集合的 迭代顺序不作任何保证 ，也就是说不保证存储和取出的元素顺序一致

没有带索引的方法，所以 不能使用普通for 循环遍历

由于是 Set集合，所以是不包含重复元素的集合，底层依赖于hashCode()和equals（）方法判断唯一性

如果需要生成类对象的hashSet集合，需要 重写实现Object类的hashCode（）和equals（）方法 ，用于判断两类对象是否相等

 

hashMap 通过数组+链表实现，元素为链表的数组：

为保证唯一性采取的判断操作;

LinkedHashSet集合

特点

哈希表和链表实现的 Set 接口，具有可预测的迭代次序

由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

由哈希表保证元素唯一，也就是说没有重复的元素

TreeSet集合

特点

元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法

没有带索引的方法，所以不能使用普通 for 循环遍历

由于是 Set 集合，所以不包含重复元素的集合

构造方法

TreeSet()//根据其元素的自然排序进行排序
TreeSet(Comparator comparator) //根据指定的比较器进行排序

排序：自然排序，比较器排序

自然排序，就是让元素所属的类实现 Comparable 接口，重写 compareTo(T o)方法 。重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写。
 

比较器排序，就是让集合构造方法接收 Comparator 的实现类对象，重写 compare(T o1,T o2) 方法

TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student> () { 
    @Override 
    public int compare(Student s1, Student s2) { 
        //this.age - s.age 
        int num = s1.getAge() - s2.getAge();
        int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; 
        return num2;
         } 
});

Map

V put(K key,V value)                  添加元素
V remove(Object key)                  根据键删除键值对元素
void clear()                          移除所有的键值对元素
boolean containsKey(Object key)       判断集合是否包含指定的键
boolean containsValue(Object value)   判断集合是否包含指定的值
boolean isEmpty()                     判断集合是否为空
int size()                            集合的长度，也就是集合中键值对的个数
V get(Object key)                     根据键获取值
Set keySet()                          获取所有键的集合
Collection values()                   获取所有值的集合
Set<Map.Entry<K,V>> entrySet()        获取所有键值对对象的集合

 

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

Set<String> keySet = map.keySet(); 
//遍历键的集合，获取到每一个键。用增强for实现 
for (String key : keySet) { 
    //根据键去找值。用get(Object key)方法实现 
    String value = map.get(key);
}
/** 遍历方法二*/
//获取所有键值对对象的集合 
Set<Map.Entry<String, String>> entrySet = map.entrySet(); 
//遍历键值对对象的集合，得到每一个键值对对象 
for (Map.Entry<String, String> me : entrySet) { 
    //根据键值对对象获取键和值 
    String key = me.getKey(); 
    String value = me.getValue(); 
}

Collection集合工具类

public static void sort(List list)         将指定的列表按升序排序
public static void reverse(List<?> list)   反转指定列表中元素的顺序
public static void shuffle(List<?> list)   使用默认的随机源随机排列指定的列表

Collections.sort(array, new Comparator<Student>() {
     @Override 
    public int compare(Student s1, Student s2) { 
    //按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序 
    int num = s1.getAge() - s2.getAge(); 
    int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; 
    return num2; 
    } 
});