Java基础——集合

存储对象可以考虑：数组，集合
　　数组存储对象特点：Student[] stu = new Student[23]; str[0] = new Student();...
　　　　弊端：1.一旦创建，其长度不可改变
　　　　　　　2.真实的数组存放的对象的个数是不可知的
Java集合可分为Collection和Map两种体系：
Collection接口：

　　List接口：有序的，可重复元素 相当于“动态”数组
　　　　添加进List集合中的元素（或对象）所在的类一定要重写equals()方法；
　　　　|---ArrayList(主要的实现类)
　　　　|---LinkedList（更适用于频繁的插入、删除）
　　　　|---Vector（古老的实现类，线程安全的，但效率低于ArrayList）
　　Set接口：存储无序，不可重复元素

　　　　1.无序性 ！= 随机性，是指元素在底层存储的位置是无序的
　　　　2.不可重复性 当想Set中添加进相同的元素时，后面的添加不进去
　　　　注：不可重复性中相同性的判断，根据添加进Set中的元素所在类中的equals()和hashCode()方法，所以一定要重写equals()和hashCode()方法。

　　　　|---HashSet:主要实现类
　　　　|---LinkedHashSet:HashSet的子类，当我们遍历集合元素时，是按照添加进集合的顺序进行的，频繁的遍历，较少的添加和插入操作
　　　　|---TreeSet:可以按照添加进集合中元素的指定属性进行排序

　　　　　　1.向TreeSet中添加的元素必须是同一个类的
　　　　　　2.可以按照添加进集合中的元素指定的顺序遍历。像String，包装类等默认按照从小到大顺序遍历
　　　　　　3.当向TreeSet中添加自定义类的对象时，有两种排序方法：1.自然排序 2.定制排序

　　　　　　　　自然排序：1.要求添加进TreeSet中的元素所在的类implements Comparable接口
　　　　　　　　　　　　2.重写其CompareTo(Object obj)的抽象方法，在此方法中指明是按照哪个属性进行排序
　　　　　　　　　　　　3.向TreeSet中添加元素即可，若不实现此接口，会报运行时异常
　　　　　　　　定制排序：1.创建一个实现了Comparator接口的类对象，在实现类中重写Comparator的Compare()方法
　　　　　　　　　　　　　2.指明是按照Customer的哪个属性排序
　　　　　　　　　　　　　3.将此实现Comparator接口的实现类对象作为形参传给TreeSet的构造器中
　　　　　　　　　　　　　4.向TreeSet中添加元素即可，若不实现此接口，会报运行时异常
　　　　　　　　　　要求重写的CompareTo()方法或Compare()方法与添加进的类的hashCode()和equals()方法保持一致

public void testTreeSet(){
    //1.创建一个实现了Comparator接口的类对象，重写Compare()方法
    Comparator com = new Comparator(){
    //向TreeSet中添加Customer类的对象，在此Compare()方法中，指明是按照Customer的哪个属性排序
        public int compare(Object o1, Object o2){
            if(o1 instanceof Customer && o2 instanceof Customer){
                Customer c1 = (Customer)o1;
                Customer c2 = (Customer)o2;
                int i = c1.getId().compareTo(c2.getId());
                if(i == 0){ //两个元素的ID相同
                     return c1.getName().compareTo(c2.getName());
                }
                return i;
            }
            return 0;
        }
    };
    //2.将此对象作为形参传递给TreeSet的构造器中
    TreeSet set = new TreeSet(com);
    //3.向TreeSet中添加Comparator接口中的compare()方法中涉及的类的对象
    set.add(new Customer("AA", 12));
    set.add(new Customer("DD", 23));
    set.add(new Customer("ee", 42));
    set.add(new Customer("gg", 25));
    set.add(new Customer("cc", 22));
    set.add(new Customer("DD", 55));

    for(Object str: set){
        System.out.println(str);
    }
}                

注：自然排序和定制排序如果两个都实现了的话，定制排序优先。

Map接口：“key-value”对的集合
　　key是不可重复的，用Set存放，value是可重复的，用Collection存放。
　　一个key-value是一个entry(Map.Entry)，entry使用Set存放。 

　　|---HashMap：Map的主要实现类

　　　　HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。
　　　　HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。
　　|---LinkedHashMap：HashMap的子类，使用链表维护添加进Map中的顺序。故遍历时，是按照添加的顺序遍历的
　　|---TreeMap：按照添加进Map中元素的Key的指定属性排序。要求：key必须是同一个类的对象（value就没有要求，类型可不同）
　　　　针对key:自然排序 vs 定制排序
　　|---HashTable:古老的实现类，线程安全，不可以添加null键，null值，不建议使用
　　　　子类：Properties：常用来处理属性文件，键和值都是String类型的

//使用Properties处理属性文件
public void test(){
    Properties pros = new Properties();
    pros.load(new FileInputStream(new File("jdbc.properties")));//jdbc.properties存放的 user=root,password=123abc
    String user = pros.getProperty("user");
    System.out.println(user);//root
    String password = pros.getProperty("password");
    System.out.println(password);//123abc
}

1.集合中常见的方法：
　　1.size();
　　2.add(Object obj);
　　3.addAll(Collection coll);
　　4.boolean isEmpty();
　　5.clear();
　　6.boolean contains(Object obj);//相等返回true，不等返回false；
　　　　判断依据：根据元素所在的类的equals()方法进行判断；（故一般要重写类的equals()方法）
　　　　明确：如果存入集合中的元素是自定义类的对象，要求：自定义类要重写equals()方法！
　　7.containsAll(Collection coll);//判断当前集合是否包含coll中所有的元素
　　8.coll1.retainAll(Collection coll2);//求集合coll1与coll2所共有的元素，返回给coll1
　　9.boolean remove(Object obj);
　　10.boolean coll1.removeAll(Collection coll2);//从coll1中删除coll2中的元素，返回给coll1
　　11.coll1.equals(Collection coll2);
　　12.hashCode();
　　13.Object obj = coll.toArray();//将集合转化为数组
　　14.iterator();//返回一个Iterator的接口实现类的对象,进行集合Collection的遍历（不能遍历map）
2.集合的遍历：

//1.使用Iterator迭代器实现：
Iterator ite = coll.iterator();
    while(ite.hasNext){
    System.out.println(ite.next());
}

//2.使用增强的for循环实现对集合和数组的遍历：
for(Object i : coll){
    System.out.println(i);
    i = 23;//此处的i是新定义的局部变量，其值得修改不会对coll本身造成影响（值传递）
}

3.List中相对于Collection新增加的方法：
　　void add(int index, Object ele)
　　boolean addAll(int index, Collection eles)
　　Object get(int index)
　　int indexOf(Object obj)
　　int lastIndexOf(Object obj)
　　Object remove(int index)
　　Object set(int index, Object ele)
　　List subList(int fromIndex, int toIndex)

　　Arrays.asList(…) 方法返回的 List 集合既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合

4.Map 常用方法：
　　4.1添加、删除操作：
　　　　Object put(Object key,Object value)
　　　　Object remove(Object key)
　　　　void putAll(Map t)
　　　　void clear()

　　4.2元素查询的操作：
　　　　Object get(Object key)
　　　　boolean containsKey(Object key)
　　　　boolean containsValue(Object value)
　　　　int size()
　　　　boolean isEmpty()
　　　　boolean equals(Object obj)


　　4.3元视图操作的方法：
　　　　Set keySet()
　　　　Collection values()
　　　　Set entrySet()

//遍历Key集
Set set = map.keySet();
for(Object obj: set){
    System.out.println(s);
}
//遍历Value集
Collection value = map.values();
Iterator i = value.iterator();
while(i.hasNext()){
    System.out.println(i.next());
}
//遍历key-value对
方式一：通过keySet()与get()方法组合
Set set = map.keySet();
for(Object obj : set){
　　System.out.println(map.get(obj));
}
方式二：利用entrySet()方法：
Set set = map.entrySet();
for(Object obj : set){
　　Map.Entry entry = (Map.Entry)obj;
　　System.out.println(entry.getKey() + " " + entry.getValue());
　　System.out.println(entry);//输出的是以等号连接的key-value对
}

操作集合的工具类：Collections
　　区别于Collection

　　排序操作：（均为static方法）
　　　　reverse(List)：反转 List 中元素的顺序
　　　　shuffle(List)：对 List 集合元素进行随机排序
　　　　sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
　　　　sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
　　　　swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
　　查找和替换
　　　　Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
　　　　Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
　　　　Object min(Collection)
　　　　Object min(Collection，Comparator)
　　　　int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
　　　　void copy(List dest,List src)：将src中的内容复制到dest中
　　　　boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

List list1 = new ArrayList();
list1.add(123);
list1.add(332);
list1.add(2332);
//list1向list2复制
List list2 = new ArrayList();//错误的方式，因为此时list2的长度为0
List list2 = ArrayList.asList(new Object[list1.size()]);
Collections.copy(list2, list1);

　　同步控制：解决多线程并发访问集合时的线程安全问题
　　　　Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合
　　List list1 = new ArrayList();//list1不是线程安全的
　　List list2 = Collections.synchronizedList(list1);//list2是线程安全的

原文：http://www.cnblogs.com/SkyeAngel/p/7808684.html