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  底层也是使用了哈希表维护的，存取的读取快，存储元素是

无序的。