JAVA基础知识之练习题——集合

练习一：

创建一个Set集合，保存用户输入的数据

具体代码实现如下面代码中的testSet()方法。

知识点：

1. Set集合的基本特征是元素不允许重复。HashSet不保存元素顺序，LinkedHashSet用链表保持元素的插入顺序，TreeSet可定制排序规则。
2. HashSet的底层是用HashMap实现的，即HashMap<key, value>中把所有value置为null，key就组成了一个Set
3. HashSet把元素的hashCode值作为地址索引来存储元素，可以实现类似根据数组下标索引查找元素的效果，这是HashSet访问速度快的原因
4. HashSet中如果两个元素通过equals比较结果为true,但是两个元素的hashCode不相等，即在两个地方存放了值相等的两个元素，HashSet将会出现各种奇怪问题，不能正常工作。
5. 基于上面第4点，HashSet元素判断两个元素相等的标准是，不仅需要equals比较的结果为true，而且需要元素hashCode值相等，即不允许equals比较为true但是hashCode不想等的两个元素存放在HashSet中。
6. HashSet中允许equals比较为false但是hashCode相等的两个元素同时存在，这两个元素将会被存放在同一个位置，并用链表维持两个元素顺序，但是这将严重影响HashSet的性能。
7. 基于上面4.5.6点，如果需要重写一个HashSet的equals方法，一定也要重写hashCode方法，原则是如果equals方法和equals方法使用共同的变量（成员变量）做计算，使得如果equals为true，hashCode结果值要相等。
8. LinkedHashSet底层多了一个链表结构用来保存元素的插入顺序（插入位置还是由hashCode决定的），遍历LinkedHashSet时会自动根据链表来遍历
9. TreeSet的元素是有序的，有两种排序规则，默认是按自然排序（在元素中写排序规则，元素必须实现了Comparable接口，且元素类型必须一样），另一种是定制排序（由集合实现排序规则，需要集合关联一个Comparator对象实现）
10. JAVA中接收键盘输入用System.in.read()， 这个方法接收的是byte[]字节，当输入结束（回车）时返回-1，但是这个方法会同时将 和 也接收。BufferedReader的readLine()方法可以读取一行，适应各种平台的断行规则(自动去除换行符 , 等)，但是BufferedReader只能读取stream类型，System.in只能返回byte类型，因此需要用InputStreamReader做转换。

练习二

 创建一个List集合，随意添加10个元素，然后通过索引为5处的元素，再取其中某个元素的索引，再删除索引为3的元素

实现代码如下面的testList()

知识点，

1. List集合的基本特征是元素有序，可重复，每个元素都有顺序索引。因此List集合可以像数组一样使用。
2. List集合有一个专用迭代器ListIterator，可以实现反向迭代。
3. ArrayList和Vector底层使用一个智能数组实现，可动态扩展（ensureCapacity(int i)重新分类空间)，
4. 在java.util.Arrays 的内部也定义了一个ArrayList (通过asList()方法返回)，但这是一个不可变定长数组，不能增加，删除数组元素，否则会抛出异常。
5. Vector是一个古老的集合实现类，Vector所拥有的功能ArrayList基本都有。但是Vector是一个线程安全类，性能上会比ArrayList稍低。另外Vector还有一个子类Stack，实现了栈结构。
6. LinkedList是List的实现类，同时又是Deque的实现类，因此LinkedList同时具有ArrayList（随机存取）和ArrayDeque(双端队列,栈)的功能。但是LinkedList的内部实现完全不同，LinkedList内部使用链表实现，虽然也LinkedList表面上使用的是index索引数组方式的随机访问，但是内部实现的时候使用index关联了链表的顺序，依然使用的是迭代访问，所以性能上比ArrayList差。不过插入和删除性能更好。

练习三

给定["a","b","a","b","c","a","b","c"]数组，使用Map的key保存字符串的元素，用value保存元素出现的次数

实现代码如下面的testMap()

知识点

1. Map 的基本特征是key不重复。key和set存在单向一对一关系。
2. Map接口中有两个重要的数据结构，一个是keySetp，用Set集合保存了所有key；一个是内部类Entry，用来封装key-value对，每个元素对应一个Entry对象，保存在Map的全局数组transient Entry table[];中。
3. Map的entrySet()方法可以返回一个Entry对象组成的的Set集合的视图。注意entrySet中并没有使用一个Set对象来保存所有Entry集合，而是定义一个EntrySet内部类，其中有个iterator()方法可以迭代访问map的所有Entry对象，调用EntrySet的iterator()方法就相当于得到了Entry集合的视图。
4. HashMap中，每次put进一个新元素时，都会在底层new一个Entry类来关联key-value，并将Entry对象保存在Map的全局数组transient Entry table[];中
5. 由上面可知遍历HashMap至少有四种方法。1)集合通用方法value = iterator.next。 2)map常规方法 value=map.get(key).  3)遍历entrySet集合。  value=map.entrySet.getValue(). 4)遍历values集合 value=map.values...
6. HashMap和Hashtable的关系，可以类比HashSet跟Vector.  Hashtable是一个古老的，线程安全的集合。
7. HashMap跟HashSet判断元素是否相等的标准一样，都是需要同时满足equals为true，且元素hashCode值相等才认为是相同元素。 equals为true但hashCode不相等的两个元素可以存入map中，但是不能正常工作；equals为false但hashCode相等会认为是不同元素，存放在同一个地方，用链表关联value，性能低。
8. LinkedHashMap跟linkedHashSet一样，也用（双向）链表维护元素的插入顺序(key顺序）。

以上三个练习题实现代码如下，

package test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

class A {
    public int count;
    public A(int count) {
        this.count = count;
    }
    
    public boolean equals(Object obj){
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == A.class) {
            A r = (A)obj;
            return r.count == this.count;
        }
        return false;
    }
    
    public int hashCode() {
        return this.count;
    }
    
    public String toString() {
        return this.count+"";
    }
    
}
public class TestCollection {
    //练习一：创建一个Set集合，保存用户输入的数据
    public static void testSet() throws Exception {
        /*
         * LinkdedHashSet可以保持插入顺序
         * Set set = new LinkedHashSet();
         */
        
        /*
         * TreeSet需要实现排序规则，自然排序的元素是要元素实现Comparable接口，定制排序是要集合关联Comparator对象
         * Set set = new TreeSet();
         */
        
        //HashSet无序，不重复
        Set set = new HashSet();
        int keyIn;
        int num = 0;
        
        while ( num++ < 2) {
            /*
             * Scanner可以方便将键盘输入转换成各种类型
             * Scanner sc = new Scanner(System.in);
             * keyIn = sc.nextInt();
             */
            
            /*
             * BufferedReader的readLine()方法可以读取一行，可以适应各种平台的断行规则
             * 但是BufferedReader只能读取stream类型，System.in只能返回byte类型，因此需要用InputStreamReader做转换
             */
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            keyIn = Integer.parseInt(br.readLine());
            set.add(new A(keyIn));
        }
        System.out.println(set);
    }
    //练习二
    public static void testList() {
        List list = new LinkedList();
        //List list = new ArrayList();
        for (int i=0; i<10; i++) {
            list.add(new A(i));
        }
        list.add(new A(5));
        System.out.println(list);
        System.out.println(list.get(5));
        //这里虽然用的是new A(6)，但是在list中仍然可以找到这个元素，原因是在上面的class A中重写了equal和hashCode方法
        System.out.println(list.indexOf(new A(6)));
        System.out.println(list.remove(3));
        System.out.println(list);
    }
    //练习三
    public static void testMap() {
        String[] str = new String[] {"a","b","a","b","c","a","b","c"};
        Map<String, Integer> map = new HashMap();
        Set<String> set = new LinkedHashSet();
        for (int i = 0; i < str.length; i++) {
            set.add(str[i]);
        }
        
        String key;
        Iterator it = set.iterator();
        while (it.hasNext()) {
            int val = 0;
            key = (String)it.next();
            for (int i = 0; i < str.length; i++) {
                if (str[i] == key) val++;
            }
            map.put(key, val);
        }

        System.out.println(map);
    }
    
    public static void main(String[] args) throws Exception {
        //TestCollection.testSet();
        TestCollection.testList();
        //TestCollection.testMap();
    }
}