SE的学习1_____集合框架

标签：通过   map接口   mod   基于   需要   com   速度   remove   ble   

Collection接口：包含list 和set两个子接口。（注意map不是Collection下的接口）。

List：有序可重复 ArrayList，LinkedList，Vector

1.ArrayList：

1. 构造方法： 无参构造默认初始值大小为10，且每次扩容的大小为（原始容量*1.5+1）；

2. 遍历问题：foreach，转换成数组，iterator；

  //1
     public static void test1(List lists){
         for (Object list : lists) {
             System.out.println(list);
         }
     }
 ?
     //2
     public static void test2(List lists){
         Object[] objects = lists.toArray();
         for (int i = 0; i < lists.size(); i++) {
             System.out.println(objects[i]);
         }
     }
 ?
     //3
     public static void test3(List lists){
         Iterator<String> iterator=lists.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
         }
     }

3. 线程问题：ArrayList是线程不安全的，当要处理多线程时采用vector，vector通过使用加锁关键字保证了线程的安全性，vector的无参构造的默认初始值大小也是10，每次扩容为（原始容量*2）；

4. 常用方法：(CURD)

   1. trimToSize(); 去空格；

   2. iterator(); 获得遍历的迭代器；

   3. subList(int,int): 截；

   4. toArray(); 转换成数组；

   5. set(int,object) //改

   6. indexOf(object) //获得元素第一次出现的索引

   7. contains(object) //是否包含某个元素

   8. get(int) 获得具体下表的元素

5. 特点：底层是数组，适合按下标索引，不适合插入增加。

2.LinkedList：

1. 构造方法： 无参构造，有参构造；

2. 遍历问题：

    ?
        public static void t1(List lists){
            Object[] objects = lists.toArray();
            for (Object object : objects) {
                System.out.println(object);
            }
        }
    ?
        public static void t2(List lists){
    ?
            for (Object list : lists) {
                System.out.println(list);
            }
        }
    ?
        public static void t3(List lists){
            Iterator iterator = lists.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }

3. 线程不安全；

4. 经常被当做堆栈来用；

5. 底层 双向链表，适合随机插入元素，随机访问速度慢

3.Stack

1. 继承自Vector；

2. 只有一个无参构造方法 new Stack();

3. 特殊方法：

   1. push(object) //入栈

   2. pop() //出栈 并删除该元素

   3. peek() //查看栈顶元素，不会删除

   4. search(object) //查找元素出现的位置 下标从1开始

   5. empty() //判空

4.queue：（Collection的子接口）

1. 是一个接口，继承自Collection接口，实现类：LinkedList；

2. 常用的无参构造；

3. 常用的方法：

   1. offer(object):添加元素

   2. poll() ：删除

   3. remove():删除

   4. peek()：查看，返回一个object

   5. element(): 查看元素

Set接口：无序，不可重复 HashSet，TreeSet

set不重复因为 重写了：hashCode(),equals()，set无序是因为存放和取的顺序不一样

1.HashSet 无序，存放元素和获取元素的顺序是不一样的，也就是说set的本身是有序的

1. 无参构造：初始值大小为16，负载因子是0.75

2. 有参构造：new HashSet(int ,float) :可以手动设置初始大小和负载因子

3. 遍历方法：

 public class HashSetPrint {
 ?
     public static void main(String[] args) {
 ?
         Set<String> set = new HashSet<>();
         set.add("hello");
         set.add("world");
         set.add("hello");
         //1.
         for (String s : set) {
             System.out.println(s);
         }
 ?
         //2.
         Object[] objects = set.toArray();
         for (Object object : objects) {
             System.out.println(object);
         }
 ?
         //3.
         Iterator<String> iterator = set.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
         }
 ?
     }
 }
 ?

3. 非线程安全；

4. 常用方法：

add(object);

remove(object); //删除一个对象

iterator(); //进行遍历

size(); //获得集合的大小

5. 不重复规则底层的实现：

重写equals()和hashCode()方法；

6. 底层实现：

HashSet底层实现用HashMap，我们输入的HashSet值作为HashMap的键存入，所以HashSet是不可重复，且仅仅只可以存入一个null值；

7. 当我们想把自己定义的类型写进HashSet中需要实现Comparable接口，并实现compareTo()方法，因为HashSet中存放的数据都是可比较的；

2.LinkHashSet: 无序不重复 是HashSet的子类 底层是LinkedHashMap；

3.TreeSet： 无序不可重复

1. 无参构造；

2. 常用方法： add()，remove()，size()；

3. 底层实现用的排序二叉树，会按照值的大小进行相关的排序操作，比起HashSet更加有序；

4. 无序是指：输入和输出是无序的；

5. 唯一性是通过：实现Comparable接口重写compareTo()方法进行判断元素是否重复的；

 public class HashSetT1 {
 ?
     public static void main(String[] args) {
         Set<String> set=new HashSet<>();
         set.add("a");
         set.add("c");
         set.add("t");
         set.add("f");
         set.add("b");
 ?
         Iterator<String> iterator = set.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());
             //输出：a b c t f 
         }
     }
 ?
     @Test
     public void t(){
         Set<String> set=new TreeSet<>();
         set.add("a");
         set.add("c");
         set.add("t");
         set.add("f");
         set.add("b");
 ?
         Iterator<String> iterator = set.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());
             // 输出： a b c f t
         }
     }
 ?
 }
 ?

Map接口： 不直接继承于Collection接口 HashMap，TreeMap

set接口的底层就是基于map接口实现的，set中存放的值就是map的key是不允许重复的。

1.HashMap： 实现map接口，key和value均可为空，且只能存储一个null

2.HashMap的key不能为基本数据类型因为：HashMap的key是不能重复的，判断重复的依据就是：先采用HashCode()计算Hash值看是否相同，有必要时再采用equals()方法进行比较。如果想使用自己定义的对象作为key，就必须重写HashCode，equals方法。

1. 构造方法：

   1. 无参构造：默认大小为 16，负载因子 0.75

   2. 有参构造：可设置初始大小，以及负载因子；

2. 常用方法：CRUD

   1. put<key,value>: key不能重复，当存入相同key的键值对时会进行覆盖，不象set拒绝存入；

   2. replace<key,value> :改

   3. get(key) 返回value；

   4. containsKey(key): 是否包含某个key

   5. containsValue(value): 是否包含某个value；

   6. keySet() :返回key的集合；

3. 遍历：

     @Test
        public void t(){
            HashMap<Integer, String> map = new HashMap<>();
            map.put(7,"777777");
            map.put(1,"aaaaa");  //value被覆盖
            map.put(2,"bbbbb");
            map.put(4,"ddddd");
            map.put(3,"ccccc");
            map.put(1,"AAAAA");
            map.put(5,"555555");
            map.replace(7,"seven");
    ?
            //1.使用keySet
            Set<Integer> set = map.keySet();
            Iterator<Integer> iterator = set.iterator();
            while (iterator.hasNext()){
                Integer key = iterator.next();
                String value = map.get(key);
               // System.out.println(key+"  "+value);
            }
    ?
            //2.使用entryset
            Set<Map.Entry<Integer, String>> entries = map.entrySet();
            Iterator<Map.Entry<Integer, String>> iterator1 = entries.iterator();
            while (iterator1.hasNext()){
                System.out.println(iterator1.next());
            }
    //        for (Map.Entry<Integer, String> entry : entries) {
    //            System.out.println(entry);
    //        }
    ?
        }

4. 底层结构：

   散列表的形式(数组+列表)：查询快，插入和删除快；

   HashCode():不同的对象产生的hashcode码可能是相同的，但是不同的hashcode码一定对应不同的对象，在HashMap中，不同hashCode码对应于数组中不同的位置，相同hashCode的元素在同一数组位置后用列表连接起来； 数组后的链表中存储的是key+value的entry对象。

2.TreeMap：

1. 底层存储结构：红黑树；

2. 遵循Comparable接口的compareTo方法；

SE的学习1_____集合框架

标签：通过   map接口   mod   基于   需要   com   速度   remove   ble   

原文地址：https://www.cnblogs.com/xbfchder/p/11402755.html