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遍历数组

 1 public static void main(String[] args) {
 2     // 遍历数组：
 3     String[] arr = new String[] { "xx", "yy", "zz" };
 4 
 5     // 1，增强的for循环
 6     for (String elt : arr) {
 7         System.out.println(elt);
 8     }
 9 
10     // 2，下标的方式
11     for (int i = 0; i < arr.length; i++) {
12         System.out.println(arr[i]);
13     }
14 }

1.2.3遍历List

 1 public static void main(String[] args) {
 2     // 遍历List：
 3     List<String> list = new ArrayList<String>();
 4     list.add("aa");
 5     list.add("bb");
 6     list.add("cc");
 7 
 8     // 1，增强的for循环
 9     for (String elt : list) {
10         System.out.println(elt);
11     }
12 
13     // 2，下标
14     for (int i = 0; i < list.size(); i++) {
15         System.out.println(list.get(i));
16     }
17 
18     // 3，迭代器
19     for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
20         String elt = iter.next();
21         System.out.println(elt);
22     }
23 }

1.2.4遍历Set

 1 public static void main(String[] args) {
 2     // 遍历Set：
 3     Set<String> set = new HashSet<String>();
 4     set.add("dd");
 5     set.add("ee");
 6     set.add("ff");
 7 
 8     // 1，增强的for循环
 9     for (String elt : set) {
10         System.out.println(elt);
11     }
12     
13     // 2，迭代器
14     for(Iterator<String> iter = set.iterator(); iter.hasNext() ; ){
15         String elt = iter.next();
16         System.out.println(elt);
17     }
18 }

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

1.2.5遍历Map

 1 public static void main(String[] args) {
 2     // 遍历Map：
 3     Map<String, String> map = new HashMap<String, String>();
 4     map.put("aa", "xx");
 5     map.put("bb", "yy");
 6     map.put("cc", "zz");
 7 
 8     // 1，增强的for循环（Entry集合）
 9     for (Entry<String, String> entry : map.entrySet()) {
10         System.out.println(entry);
11     }
12     
13     // 2，增强的for循环（Key集合）
14     for(String key : map.keySet()){
15         System.out.println(key + " = " + map.get(key));
16     }
17     
18     // 3，遍历值的集合
19     for(String value : map.values()){
20         System.out.println(value);
21     }
22 }

---|Collection: 单列集合

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

无序的。