总结——JAVA集合框架

最新推荐文章于 2021-11-15 20:26:49 发布

疯狂的魔王

最新推荐文章于 2021-11-15 20:26:49 发布

阅读量279

点赞数 1

分类专栏：总结文章标签： JAVA集合框架

本文链接：https://blog.csdn.net/qq_40936909/article/details/86516549

版权

总结专栏收录该内容

1 篇文章 0 订阅

订阅专栏

前言：JAVA集合框架是JAVA编程中一个很重要的框架，在面试和开发中也会经常接触到，为了增强对集合框架的理解，特地在空余时间进行了总结。

一、集合框架的大体结构

二、详解主要类及接口

1.Collection接口

集合框架的顶级框架（不是Iterator）
是List和Set的父接口（List和Set一些公共的属性和方法放到了父类接口中）
但不是Map的父类

2.List接口

特点：有序，对象可以重复
遍历方式：

List<String> list = new ArrayList<String>();
       list.add("a");
       list.add("b");
       list.add("a");
       list.add("c");

//1.下标（for循环）
       for (int i = 0; i < list.size(); i++) {
           System.out.println(list.get(i));
       }

//2.foreach jdk>=1.5才有的for循环增强版foreach
       for (String s : list) {
           System.out.println(s);
       }

//3.Iterator迭代器(hasNext/next/remove) it拿到迭代器对象，拿到对象要new,new 就需要调构造方法，构造方法也是方法
       //.iterator()方法是从List父亲Collection继承来的，既然是从父类继承，那么父类的方法返回一个迭代器
       //那么就意味一件事，在父类Collection的iterator()方法中，实例化了一个迭代器对象，所以说父类依赖于Iterator
       Iterator<String> it = list.iterator();
       Object v = null;
       //把it想象成从-1开始，实际上没有-1位置
       while(it.hasNext()) {//有没有下一个
           v = it.next();//移动下一个
           System.out.println(v);
           /**如果遍历List集合时又想删除其中的元素，请使用迭代器
           it.remove();//删除当前的元素v
           */
       }

//4.forEach jdk>=1.8
       list.forEach(cc -> System.out.println(cc));//Lambda表达式(jdk>=1.8)，表达式由三部分组成：参数列表，箭头（→），一个表达式或语句块。

/*其所有遍历的结果都是
       a
       b
       a
       c    */

新增内容：

       ListIterator listIterator = list.listIterator();//迭代器，继承Iterator
       while (listIterator.hasNext()) {//向前遍历
           Object object = (Object) listIterator.next();
           System.out.println(object);
       }
       System.out.println("xxxxxxxxxxxxx");
       while (listIterator.hasPrevious()) {//向后遍历
           Object object = (Object) listIterator.previous();
           System.out.println(object);
       }

/*其遍历的结果是
       a
b
c
d
e
xxxxxxxxxxxxx
e
d
c
b
a    */

如果直接使用向后遍历：

       ListIterator listIterator = list.listIterator();
       System.out.println("xxxxxxxxxxxxx");
       while (listIterator.hasPrevious()) {
           Object object = (Object) listIterator.previous();
           System.out.println(object);
       }

/*其遍历的结果是
xxxxxxxxxxxxx */

<ListIterator可向前向后遍历，list依赖于ListIterator，所以可向前向后遍历>

ArrayList、Vector、LinkedList区别

	ArrayList	Vector	LinkedList
结构	数组结构	数组结构	链表结构
线程是否同步	不同步	同步	不同步
线程是否安全	线程不安全	线程安全	线程不安全

⑴ArrayList 与Vector的区别

相同点：ArrayList 与Vector都实现了Collection接口，它们都是有序集合，并且数据是可重复的

不同点：

①同步性：Vector线程同步、安全，ArrayList 线程不同步、不安全；由于Vector使用了synchronized方法（加锁，线程安全），通常性能比ArrayList 差。

②数据增长：Vector默认增长为原来的两倍，ArrayList默认增长为原来的1.5倍（依据jdk）。Vector 和ArrayList可以设置初始容量，即初始空间大小，Vector可以设置负载因子，即增长的空间大小，而ArrayList则没有提供可以设置负载因子的方法。

⑵ArrayList和LinkedList的区别

相同点：ArrayList和LinkedList都是线程不同步和线程不安全

不同点：ArrayList使用数组方式存储数据，此数组可存储的元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按下标查找元素，但是插入元素要涉及数组元素移动等内存操作，所以查询数据快而插入数据和删除数据慢；而LinkedList使用双向链表实现存储,按下标查找数据需要进行前向或后向遍历，但是插入数据和删除数据只需要记录本项的前后项即可，所以插入和删除速度快，而查询慢。

或者可以这样说，ArrayList查询快，写数据慢；LinkedList查询慢，写数据快。ArrayList查询快是因为底层是由数组实现，通过下标定位数据快。写数据慢是因为复制数组耗时。LinkedList底层是双向链表，查询数据依次遍历慢。写数据只需修改指针引用。

（但是如果详细去探索在不同场景下ArrayList和LinkedList的读写速度的话，那么LinkedList写入的速度不一定比ArrayList写入的速度，详细情况请看【https://blog.csdn.net/luzhenyu111/article/details/79111534】）

应用场景：平时项目中的查询所有操作使用的都是ArrayList；LinkedList ——贪食蛇游戏

package p2;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 *测试ArrayList和LinkedList的读写速度
 * 在集合中装5万条数据
 * @author Min.Z
 *
 */
public class Demo1 {
	static final int N=50000;
    static long timeList(List list){//增加消耗的时长
        long start=System.currentTimeMillis();
        Object o = new Object();
        for(int i=0;i<N;i++) {
            list.add(0, o);
        }
        return System.currentTimeMillis()-start;
    }
    static long readList(List list){//读取的时长
        long start=System.currentTimeMillis();
        for(int i=0,j=list.size();i<j;i++){
        	list.get(i);
        }
        return System.currentTimeMillis()-start;
    }

    static List addList(List list){
        Object o = new Object();
        for(int i=0;i<N;i++) {
            list.add(0, o);
        }
        return list;
    }
    public static void main(String[] args) {
        System.out.println("ArrayList添加"+N+"条耗时："+timeList(new ArrayList()));
        System.out.println("LinkedList添加"+N+"条耗时："+timeList(new LinkedList()));

        List list1=addList(new ArrayList<>());
        List list2=addList(new LinkedList<>());
        System.out.println("ArrayList查找"+N+"条耗时："+readList(list1));
        System.out.println("LinkedList查找"+N+"条耗时："+readList(list2));
    }
}

3.Set接口

特点：无序，对象不可重复
遍历方式：

Set<Integer> set = new HashSet<Integer>();
       set.add(1);
       set.add(21);
       set.add(5);
       set.add(3);
       set.add(6);
       set.add(3);

       //1.foreach
       for (Integer n : set) {
           System.out.println(n);
       }

       //2.Iterator
       Iterator<Integer> it = set.iterator();
       while(it.hasNext()) {
           System.out.println(it.next());
       }

       //3.forEach
       set.forEach(cc -> System.out.println(cc));

       /**
       * 其结果都是1 3 21 5 6
       * Set无序并不代表没有规律。无论遍历多少遍或者用其它的方法遍历，打印的结果都是一样的。
       * 其原因是：因为里面的算法是一样的，都是哈希算法。对于这个我会有一篇博客专门讲解。
       */

HashSet、TreeSet、LinkedHashSet区别

①.需要速度快的集合，使用HashSet

②.需要集合有排序功能，使用TreeSet

③.需要按照插入的顺序存储集合（插入数据的顺序和输出顺序是一样的），使用LinkedHashSet

4.Map接口

特点：无序，以键值对的形式添加元素，键不能重复，值可以重复，键相同，值会覆盖
遍历方式：

Map<String, String> map = new HashMap<String,String>();
       map.put("zs", "张三");
       map.put("ls", "李四");
       map.put("ww", "王五");
       map.put("zs", "王哈");
       map.put("hh", "哈哈");

//1.map.keySet()获得Map所有的键，返回一个Set集合并保存，再根据键去查找值
       Set<String> keySet = map.keySet();//map集合的key
       //①foreach
       for (String key : keySet) {
           System.out.println("键："+key+" 值："+map.get(key));
       }

       //②Iterator
       Iterator<String> it = keySet.iterator();
       String k = null;
       while(it.hasNext()) {
           k=it.next();
           System.out.println("键："+k+" 值："+map.get(k));
       }

//2.通过entrySet()方法将map集合中的映射关系取出（这个关系就是Map.Entry类型)，再遍历此Set
       Set<Map.Entry<String, String>> entrySet = map.entrySet();//因为键不重复，所以取出的整体（Map.Entry）绝对不重复
       //①foreach
       for (Entry<String, String> entry : entrySet) {
           System.out.println("键："+entry.getKey()+" 值："+entry.getValue());

       }
       //②Iterator
       Iterator<String> it2 = keySet.iterator();
       String k2 = null;
       while(it2.hasNext()) {
           k2=it2.next();
           System.out.println("键："+k2+" 值："+map.get(k2));
       }

/**
       * 虽然使用keySet及entrySet来进行遍历能取得相同的结果，但两者的遍历速度是有差别的。
       * keySet():迭代后只能通过keySet()取key
       * entrySet()：迭代后可以entry.getKey()，entry.getValue()取key和value。返回的是Entry接口 (整体，映射关系)
       * 说明：keySet()的速度比entrySet()慢了很多，也就是keySet方式遍历Map的性能不如entrySet性能好
       * 所以当我们数据是海量的时候，使用entrySet遍历可优化程序性能
       */

/**
       * 思考：在Map中keySet()遍历中，我们获得的键都是Set集合，所以决定了Map集合的键是无序且不能重复的
       * 且Map的打印顺序都是根据键找值，就说明，即Map打印的顺序也与哈希算法有关。
       */

HashMap、TreeMap、LinkedHashMap区别

①.在Map中插入、删除和定位元素，HashMap是最好的选择

②.需要集合有排序功能，使用TreeMap更好

③.需要按照插入的顺序存储集合，使用LinkedHashMap

HashMap的实现原理

通过put和get存储和获取对象。

存储对象时，我们将K/V传给put方法时，它调用hashcode计算hash从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量。

获取对象时，我们将K传递给get，他调用hashcode计算hash从而得到bucket位置，并进一步调用equals()方法确认键值对。

疯狂的魔王

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
总结——JAVA集合框架

前言：JAVA集合框架是JAVA编程中一个很重要的框架，在面试和开发中也会经常接触到，为了增强对集合框架的理解，特地在空余时间进行了总结。一、集合框架的大体结构二、详解主要类及接口1.Collection接口集合框架的顶级框架（不是Iterator）是List和Set的父接口（List和Set一些公共的属性和方法放到了父类接口中）但不是Map的父类2.List...
复制链接

扫一扫