一、java-集合

Starlahi

已于 2022-07-05 11:20:16 修改

阅读量373

点赞数

分类专栏： Java 文章标签： java基础

于 2019-07-03 17:07:50 首次发布

本文链接：https://blog.csdn.net/Starlahi/article/details/94562745

版权

Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

集合分类：以Collection为基类的线性表类，如数组，list，set，vector,queue和堆栈stack；以Map为基类的键值对类，如HashMap和HashTable。

1. Array和ArrayList的异同：

异：* array不可扩容，定义时就必须指定大小，arraylist可以动态扩容。

* array只能添加同构的数据（声明为object[]的数组除外），ArrayList可以添加异构数据，因为它里面存放的都是被装箱了的Object型对象，实际上ArrayList内部就是使用"object[] _items"这样一个私有字段来封装对象的；

* Array不能够随意添加和删除其中的项，而ArrayList可以在任意位置插入和删除项。

* Array是始终是连续存放的，而ArrayList的存放不一定连续。

同：都具有索引(index),即可以通过index来直接获取和修改任意项。

相互转换：利用ArrayList的toArray返回一个数组；Arrays.asList返回一个列表。

2. ArrayList和LinkedList的区别（都是线程不安全）：

线程安全解决办法：

方法1： Collections.synchronizedList(new LinkedList<String>())

方法2: LinkedList和ArrayList换成线程安全的集合，如CopyOnWriteArrayList，ConcurrentLinkedQueue

* arrayList基于数组实现，容易查找定位，不擅长添加和删除；而linkedList基于双向链表实现，擅长添加和删除元素，但不擅长定位。

3. 浅复制和深复制

由于集合中存放的是引用，需要分别处理集合中的对象时，需要通过clone来实现深复制。

浅复制：

（1）通过拷贝构造方法实现浅拷贝（指的是该类的构造方法参数为该类的对象）：

 public Person(Age age,String name) {
        this.age=age;
        this.name=name;
    }
    //拷贝构造方法
    public Person(Person p) {
        this.name=p.name;
        this.age=p.age;
    }

（2）通过重写clone()方法进行浅拷贝：

1、Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。

2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法。

//重写Object类的clone方法
    public Object clone() {
        Object obj=null;
        //调用Object类的clone方法，返回一个Object实例
        try {
            obj= super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

深复制：

（1）通过重写clone方法来实现深拷贝：

与通过重写clone方法实现浅拷贝的基本思路一样，只需要为对象图的每一层的每一个对象都实现Cloneable接口并重写clone方法，最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝。简单的说就是：每一层的每个对象都进行浅拷贝=深拷贝。

//重写Object类的clone方法
    public Object clone() {
        Object obj=null;
        //调用Object类的clone方法——浅拷贝
        try {
            obj= super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        //调用Age类的clone方法进行深拷贝
        //先将obj转化为学生类实例
        Student stu=(Student)obj;
        //学生类实例的Age对象属性，调用其clone方法进行拷贝
        stu.age=(Age)stu.getaAge().clone();
        return obj;
    }

（2）通过对象序列化实现深拷贝

将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。

        Age a=new Age(20);
        Student stu1=new Student("摇头耶稣",a,175);
        //通过序列化方法实现深拷贝
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(stu1);
        oos.flush();
        ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        Student stu2=(Student)ois.readObject();

4. HashMap、HashTable和ConcurrentHashMap：

HashTable

底层数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做了相关优化
初始size为11，扩容：newsize = oldsize*2+1

HashMap

底层数组+链表实现，可以存储null键和null值，这样的键只有一个，但可以有一个或多个键所对应的值为null；线程不安全；
初始size为16，扩容：newsize = oldsize*2，size一定为2的n次幂
扩容针对整个Map，每次扩容时，原来数组中的元素依次重新计算存放位置，并重新插入
插入元素后才判断该不该扩容，有可能无效扩容（插入后如果扩容，如果没有再次插入，就会产生无效扩容）
当Map中元素总数超过Entry数组的75%，触发扩容操作，为了减少链表长度，元素分配更均匀

HashMap的初始值还要考虑加载因子:

哈希冲突：若干Key的哈希值按数组大小取模后，如果落在同一个数组下标上，将组成一条Entry链，对Key的查找需要遍历Entry链上的每个元素执行equals()比较。
加载因子：为了降低哈希冲突的概率，默认当HashMap中的键值对达到数组大小的75%时，即会触发扩容。因此，如果预估容量是100，即需要设定100/0.75＝134的数组大小。
空间换时间：如果希望加快Key查找的时间，还可以进一步降低加载因子，加大初始大小，以降低哈希冲突的概率。
HashMap： JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间
LinkedHashMap: LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑

ConcurrentHashMap

底层采用分段的数组+链表实现，线程安全（ReentrantLock）
通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。(读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。)
Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术
有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁
扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容
JDK1.8的实现已经摒弃了Segment的概念，而是直接用Node数组+链表+红黑树的数据结构来实现，并发控制使用Synchronized和CAS来操作，整个看起来就像是优化过且线程安全的。Node是ConcurrentHashMap存储结构的基本单元，继承于HashMap中的Entry，用于存储数据

5.collection和collections的区别和作用

1、java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。

2、Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

1) 排序(Sort)：

使用sort方法可以根据元素的自然顺序对指定列表按升序进行排-----两种实现方式：（1）列表中的所有元素都必须实现 Comparable 接口（重写comoareTo方法）；（2）实现Collections.sort()方法，该方法有两个参数，通过第二个参数直接调用排序规则（通过Comparator自定义比较器）。

Comparable和Comparator区别比较

　　Comparable是排序接口，若一个类实现了Comparable接口，就意味着“该类支持排序”。而Comparator是比较器，我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。

　　Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。

　　两种方法各有优劣，用Comparable 简单，只要实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。用Comparator 的好处是不需要修改源代码，而是另外实现一个比较器，当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了，并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。

2）把线程不安全变成线程安全的方法：如list——Collections.synchronizedList（list）；set——Collections.synchronizedSet（set）等。