day1 java基础回顾-集合

1、集合

1.1 集合的类型与各自的特性

---|Collection: 单列集合
            ---|List: 有存储顺序, 可重复
                ---|ArrayList:    数组实现, 查找快, 增删慢
                                    由于是数组实现, 在增和删的时候会牵扯到数组
增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快
        ---|LinkedList:    链表实现, 增删快, 查找慢由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高但查询时需要一个一个的遍历, 所以效率较低
                ---|Vector:    和ArrayList原理相同, 但线程安全, 效率略低
 和ArrayList实现方式相同, 但考虑了线程安全问题, 所以效率略低
            ---|Set: 无存储顺序, 不可重复
                ---|HashSet   线程不安全，存取速度快。底层是以哈希表实现的。
        ---|TreeSet   红-黑树的数据结构，默认对元素进行自然排
                                序（String）。如果在比较的时候两个对象
                                返回值为0，那么元素重复。
---| Map: 键值对   键不可重复，键可以重复
        ---|HashMap    线程不安全，存取速度快。底层是以哈希表实现的.
---|TreeMap   红-黑树的数据结构，默认对元素进行自然排
                序（String）。如果在比较的时候两个对象
                 返回值为0，那么元素重复
        ---|HashTable  底层也是使用了哈希表 维护的，存取的读取快，存储元素是
                         无序的。

1.2遍历集合

1.2.1遍历集合的几种方式

1，使用迭代器Iterator的方式。

2，使用增强for循环的方式。

3，如果有下标，则可以使用下标的方式。

 　　1.2.2遍历数组

public static void main(String[] args) {
    // 遍历数组：
    String[] arr = new String[] { "xx", "yy", "zz" };

    // 1，增强的for循环
    for (String elt : arr) {
        System.out.println(elt);
    }

    // 2，下标的方式
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

1.2.3遍历List

public static void main(String[] args) {
    // 遍历List：
    List<String> list = new ArrayList<String>();
    list.add("aa");
    list.add("bb");
    list.add("cc");

    // 1，增强的for循环
    for (String elt : list) {
        System.out.println(elt);
    }

    // 2，下标
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }

    // 3，迭代器
    for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
        String elt = iter.next();
        System.out.println(elt);
    }
}

1.2.4遍历Set

public static void main(String[] args) {
    // 遍历Set：
    Set<String> set = new HashSet<String>();
    set.add("dd");
    set.add("ee");
    set.add("ff");

    // 1，增强的for循环
    for (String elt : set) {
        System.out.println(elt);
    }
    
    // 2，迭代器
    for(Iterator<String> iter = set.iterator(); iter.hasNext() ; ){
        String elt = iter.next();
        System.out.println(elt);
    }
}

注意：set类型是集合，是无序的，所以没有下标遍历方式

1.2.5遍历Map

public static void main(String[] args) {
    // 遍历Map：
    Map<String, String> map = new HashMap<String, String>();
    map.put("aa", "xx");
    map.put("bb", "yy");
    map.put("cc", "zz");

    // 1，增强的for循环（Entry集合）
    for (Entry<String, String> entry : map.entrySet()) {
        System.out.println(entry);
    }
    
    // 2，增强的for循环（Key集合）
    for(String key : map.keySet()){
        System.out.println(key + " = " + map.get(key));
    }
    
    // 3，遍历值的集合
    for(String value : map.values()){
        System.out.println(value);
    }
}

 

 

 

 

---|Collection: 单列集合

           ---|List: 有存储顺序, 可重复

              ---|ArrayList:    数组实现, 查找快, 增删慢

                                  由于是数组实现, 在增和删的时候会牵扯到数组

增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快

              ---|LinkedList:   链表实现, 增删快, 查找慢由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高但查询时需要一个一个的遍历, 所以效率较低

              ---|Vector:   和ArrayList原理相同, 但线程安全, 效率略低

 和ArrayList实现方式相同, 但考虑了线程安全问题, 所以效率略低

           ---|Set: 无存储顺序, 不可重复

              ---|HashSet   线程不安全，存取速度快。底层是以哈希表实现的。

       ---|TreeSet   红-黑树的数据结构，默认对元素进行自然排

                                序（String）。如果在比较的时候两个对象

                                返回值为0，那么元素重复。

---| Map: 键值对   键不可重复，键可以重复

       ---|HashMap    线程不安全，存取速度快。底层是以哈希表实现的.

---|TreeMap   红-黑树的数据结构，默认对元素进行自然排

                序（String）。如果在比较的时候两个对象

                 返回值为0，那么元素重复

       ---|HashTable  底层也是使用了哈希表维护的，存取的读取快，存储元素是

                         无序的。