Java常用集合泛型

2016-06-21

复习了常用的集合泛型，ArrayList,HashSet,HashMap

有C++STL经验上手很快

Collection

Collection接口

List接口
Queue接口
Set接口

List 接口

List类接口通过ArrayList类实现
添加方法： Arraylist.add 添加单个元素
添加数组元素： Arraylist.addAll(Arrays.aslist(Arrays));

遍历方法：

for(int i = 0;i<Arraylist.size();i++){
    CurrentType = (CurrentType)Arraylist.get(i);
}

迭代遍历
public void TestIterator(){
    Iterator it = CoursesToSelect.iterator();
    while(it.hasNext()){
        Course cr = (Course)it.next();
        System.out.println("课程："+cr.getId()+":"+cr.getName());
    }
}

For each遍历

for(Object obj:CoursesToSelect){
    Course cr = (Course)obj;

}


更改元素

Set
CourseToSelect.set(index,Course);

删除元素

 remove
 CorsesToSelect.remove(index);

 同样的 remove可以以数组的方式删除
 CoursesToSlect.remove(ArrayOfCourses.aslist(Course));

泛型

给集合框架规定元素类型

public List<Course> CoursesToSelect;
CoursesToSelect = new ArrayList<Course>();

注意：泛型元素的子类同样可以增加到泛型中

HashSet

构造方法摘要

HashSet() 
          构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 
HashSet(Collection<? extends E> c) 
          构造一个包含指定 collection 中的元素的新 set。 
HashSet(int initialCapacity) 
          构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。 
HashSet(int initialCapacity, float loadFactor) 
          构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子。

方法摘要

boolean add(E e) 
         如果此 set 中尚未包含指定元素，则添加指定元素。 
void clear() 
         从此 set 中移除所有元素。 
Object clone() 
         返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。 
boolean contains(Object o) 
         如果此 set 包含指定元素，则返回 true。 
boolean isEmpty() 
         如果此 set 不包含任何元素，则返回 true。 
Iterator<E> iterator() 
         返回对此 set 中元素进行迭代的迭代器。 
boolean remove(Object o) 
         如果指定元素存在于此 set 中，则将其移除。 
int size() 
         返回此 set 中的元素的数量（set 的容量）。

Map - HashMap

HashMap 键值对

构造方法摘要

HashMap() 
          构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 
HashMap(int initialCapacity) 
          构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。 
HashMap(int initialCapacity, float loadFactor) 
          构造一个带指定初始容量和加载因子的空 HashMap。 
HashMap(Map<? extends K,? extends V> m) 
          构造一个映射关系与指定 Map 相同的新 HashMap。

方法摘要

void clear() 
         从此映射中移除所有映射关系。 
Object clone() 
         返回此 HashMap 实例的浅表副本：并不复制键和值本身。 
boolean containsKey(Object key) 
         如果此映射包含对于指定键的映射关系，则返回 true。 
boolean containsValue(Object value) 
         如果此映射将一个或多个键映射到指定值，则返回 true。 
Set<Map.Entry<K,V>> entrySet() 
         返回此映射所包含的映射关系的 Set 视图。 
V get(Object key) 
         返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。 
boolean isEmpty() 
         如果此映射不包含键-值映射关系，则返回 true。 
Set<K> keySet() 
         返回此映射中所包含的键的 Set 视图。 
V put(K key, V value) 
         在此映射中关联指定值与指定键。 
void putAll(Map<? extends K,? extends V> m) 
         将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。 
V remove(Object key) 
         从此映射中移除指定键的映射关系（如果存在）。 
int size() 
         返回此映射中的键-值映射关系数。 
Collection<V> values() 
         返回此映射所包含的值的 Collection 视图

注意点1：在泛型元素中，判断泛型内是否包含该元素需要元素类重载equals方法
注意点2：在Set集合中，调用contains方法时需要将泛型元素类重载hashcode和equals方法

Sort方法

应用Collections.sort将集合排序，对于泛型集合，需要将泛型元素类实现Comparable接口

实例：

课程类

package TEST1;

/**
 * 课程类
 * @author Administrator
 *
 */
public class Course implements Comparable {
    private     String id;
    private  String name;
    public Course(String id, String name)  {
        super();
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int compareTo(Object obj) {
        // TODO Auto-generated method stub
        Course cr = (Course)obj;
        if(Integer.parseInt(this.id)>=Integer.parseInt(cr.id)){
            return 1;
        }
        else{
            return  -1;
        }
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "课程号："+id+" 课程名："+name;
    }
}

Main方法类

package TEST1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Course> CL = new ArrayList<Course>();
        Scanner in = new Scanner(System.in);
        int num;
        num = in.nextInt();
        for(int i=0;i<num;i++){
            String id,name;
            id = in.next();
            name = in.next();
            CL.add(new Course(id,name));
        }
        Collections.sort(CL);
        Iterator<Course> it =CL.iterator();
        while(it.hasNext()){
            Course cr = it.next();
            System.out.println(cr.toString());
        }    
    }
}

Comparator接口类

Comparator接口类同样也是用于Collection.sort的排序方法，其使用方法与C++中的sort里的cmp函数类似，Comparator接口的实现类需要实现compara方法，其实现与C++的cmp函数类似

实例

public class CourseCmp implements Comparator<Course> {

    @Override
    public int compare(Course o1, Course o2) {
        // TODO Auto-generated method stub
        return Integer.parseInt(o1.getId())>
               Integer.parseInt(o2.getId())?
               1:-1; 
    }
}

然后在主方法里我们将Sort方法更改为

Collections.sort(CL,new CourseCmp());