Java集合

最新推荐文章于 2023-03-08 09:44:17 发布

我走后的夜与昼

最新推荐文章于 2023-03-08 09:44:17 发布

阅读量47

点赞数

分类专栏： java学习文章标签： java 集合

本文链接：https://blog.csdn.net/wyb0218_0308/article/details/118071707

版权

java学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

集合

什么是集合

概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
和数组的区别
1. 数组长度固定，集合长度不固定
2. 数组可以存储基本类型和引用类型，集合只能存储引用类型
位置：java.util

Collection体系集合

Java的集合类主要由Map接口和Collection接口派生而来
Collection接口有两个常用的子接口，即List接口和Set接口
通常说的Java三大类接口构成(Map接口、List接口和Set接口)
List接口的特点：有序、有下标、元素可重复
Set接口的特点：无序、无下标、元素不能重复

Collection接口

特点：代表一组任意类型的对象，无序、无下标、不能重复。
方法：
1. add:添加单个元素
2. remove:删除指定元素
3. clear:清空
4. contains:查找元素是否存在
5. addAll:添加多个元素
6. isEmpty:判断是否为空
7. size:获取元素个数
8. containsAll:查找多个元素是否都存在
9. removeAll:删除多个元素

 public static void main(String[] args) {
    //创建Collection对象
        Collection co=new ArrayList();
    // add:添加单个元素
        co.add("awei");
        co.add(10);//co.add(new Integer(10))
        co.add(true);
        System.out.println("co="+co);
    // remove:删除指定元素
        //co.remove(0);删除第一个元素
        co.remove(true);//指定删除某个元素
        System.out.println("co="+co);
    // contains:查找元素是否存在
        System.out.println(co.contains("awei"));//T
    // size:获取元素个数
        System.out.println(co.size());//2
    // isEmpty:判断是否为空
        System.out.println(co.isEmpty());//F
    // clear:清空
        co.clear();
    // ddAll:添加多个元素
        ArrayList arr = new ArrayList();
        arr.add("苹果");
        arr.add("橘子");
        co.addAll(arr);
        System.out.println("co="+co);
    //containsAll:查找多个元素是否都存在
        System.out.println(co.containsAll(arr));//T
    // removeAll:删除多个元素
        co.add("蓝莓");
        co.removeAll(arr);
        System.out.println("co="+co);
    }

Collection遍历

Iterator

Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
所有实现了Collection接口的集合类都有一个Iterator()方法，用于返回一个实现了Iterator接口的对象，即可以返回一个迭代器
Iterator仅用于遍历集合，Iterator本身并不存放对象。

//创建迭代器
Iterator it=arr.Iterator();
//hasNext():判断是否还有下一个元素
while(it.hasNext()){
    //next()作用:1.指针下移 2.将下移以后集合位置上的元素返回
    System.out.println(in.next());
    //remove();删除当前元素
}
//快捷键，快速生成while=> itit
//显示所有的快捷键的快捷键ctrl+j
//当退出while循环后，这时iterator迭代器，指向最后的元素
//it.next();//NoSuchElementException
//如果希望再次遍历，需要重置我们的迭代器
it=arr.Iterator();

注：在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next会抛出NoSuchElementException异常。

增强for循环

增强for循环，可以代替iterator迭代器
特点：增强for就是简化版的iterator，本质一样。只能遍历集合或数组。
基本语法

for(元素类型 元素名：集合名或数组名){
    访问元素
}

List接口

List接口是Collection接口的子接口
List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
List集合中的每个元素都有其对应的顺序索引，即支持索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
常用的实现类有：ArrayList、LinkedList、Vector。
方法：
1. add(index,o):在index位置插入o元素
2. addAll(index,c):将一个集合中的元素添加到此集合中的index位置
3. get(index)//获取指定index位置的元素
4. indexOf:返回元素在集合中首次出现的位置
5. LastIndexOf:返回元素在集合中末次出现的位置
6. remove(index):移除指定index位置的元素，并返回此元素
7. set(index,e)把指定位置的index元素为e，相当于替换
8. subList(fromIndex,toIndex)//返回fromIndex和toIndex之间的集合元素

//创建对象
        List list=new ArrayList();
        list.add("杨过");
        list.add("郭靖");
        //add(index,o):在index位置插入o元素
        //在index=1的位置插入一个元素
        list.add(1,"张无忌");
        System.out.println("list="+list);
        //addAll(index,c):将一个集合中的元素添加到此集合中的index位置
        List list2=new ArrayList();
        list2.add("李白");
        list2.add("杜甫");
        list.addAll(1,list2);
        System.out.println("list="+list);
        //get(index)//获取指定index位置的元素
        //获取index==1位置的元素
        System.out.println(list.get(1));
        //indexOf:返回元素在集合中首次出现的位置
        System.out.println(list.indexOf("李白"));//1
        //LastIndexOf:返回元素在集合中末次出现的位置
        System.out.println(list.lastIndexOf("郭靖"));//4
		//remove(index):移除指定index位置的元素，并返回此元素
		list.remove(0);
		System.out.println("list="+list)
        //set(index,e)把指定位置的index元素为e，相当于替换
        list.set(2,"王维");
        System.out.println("list="+list);
        //subList(fromIndex,toIndex)//返回fromIndex和toIndex之间的集合元素
        //注意返回的子集合fromIndex<=subList<toIndex
        List li = list.subList(0, 2);
        System.out.println("li="+li);
    }

List遍历

//1.使用iterator
Iterator it=list.iterator();
while(it.hasNext()){
    Object o=it.next();
}
//2.使用增强for
for(Object o:list){
}
//3.使用普通for
for(int i=0;i<list.size();i++){
    Object o=list.get(i);
    System.out.println(o);
}

ArrayList

注意事项：
1. permits all elements,including null,ArrayList可以加入null，并且多个
2. ArrayList是由数组来实现数据存储的
3. ArrayList基本等同于Vector，除了ArrayList是线程不安全(执行效率高)，在多线程情况下，不建议使用。
底层操作机制源码分析(重点、难点)：
1. ArrayList中维护了一个Object类型的数组elementData
  
  transient Object[] elementData;
2. 当创建对象时，如果使用的是无参构造器，则初始elementData容量为0(JDK7是10)
3. 当添加元素时：先判断是否需要扩容，如果需要扩容，则调用grow方法，否则直接添加元素到合适位置
4. 如果使用的是无参构造器，如果第一次添加，需要扩容的话，则扩容elementData为10，如果需要再次扩容的话，则扩容elementData为1.5倍
5. 如果使用的指定容量capacity的构造器，则初始elementData容量为capacity
6. 如果使用的指定容量capacity的构造器，如果需要扩容，则直接扩容elementData为1.5倍

Vector

Vector底层也是一个对象数组，protected Object[] elementData;
Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized

public synchronized E get(int index){
    if(index>=elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    return elementData(index);
}

在开发中，需要线程同步安全时，考虑使用Vector

类型	底层结构	版本	线程安全(同步)效率	扩容倍数
ArrayList	可变数组	jdk1.0	不安全，效率高	如果有参构造1.5倍，如果无参第一次10，从第二次开始按1.5扩容
Vector	可变数组	jdk1.2	安全，效率不高	如果无参，默认10，满后2倍扩容，如果指定大小，则每次直接按2倍扩容

LinkedList

LinkedList实现了双向链表和双端队列特点
可以添加任何元素(元素可以重复)，包括null
线程不安全，没有实现同步

LinkedList的底层操作机制
1. LinkedList底层维护了一个双向链表
2. LinkedList中维护了两个属性first和last分别指向首节点和尾节点
3. 每个节点(Node对象)，里面有=又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个。最终实现双向链表。
4. 所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高

//双向链表模拟
public class   LinkedList {
    public static void main(String[] args) {
        //创建三个节点
        Node lufly = new Node("路飞");
        Node naluduo = new Node("鸣人");
        Node nazi = new Node("纳兹");
        //连接三个节点，形成双向链表
        //lufei->naluduo->nazi
        lufly.next=naluduo;
        naluduo.next=nazi;
        //nazi->naluduo->lufly
        nazi.pre=naluduo;
        naluduo.pre=lufly;
        //让first引用指向lufly，就是双向链表的头节点
        Node first=lufly;
        //让last引用指向nazi，就是双向链表的尾节点
        Node last=nazi;
        //遍历，从头到尾
        while (true){
            if (first==null){
                break;
            }
            System.out.println(first);
            first=first.next;
        }
        //添加对象tong
        Node tong = new Node("桐人");
        //把tong加入双向链表
        naluduo.next=tong;
        tong.next=nazi;
        nazi.pre=tong;
        tong.pre=naluduo;
        //让first再次指向lufly
        first=lufly;
        last=nazi;
        //再次遍历
        while (true){
            if (first==null){
                break;
            }
            System.out.println(first);
            first=first.next;
        }
    }
}
//定义一个Node类，表示双向链表的一个节点
class Node{
    public Object item;//真正存放数据
    public Node next;//指向下一个节点
    public Node pre;//指向前一个节点
    public Node(Object name){
        this.item=name;
    }
    public String toString(){
        return "Node name="+item;
    }
}

ArrayList和LinkedList比较

类型	底层结构	增删的效率	改查的效率
ArrayList	可变数组	较低，数组扩容	较高
LinkedList	双向链表	较高、通过链表追加	较低

如何选择ArrayList和LinkedList：
1. 如果我们改查的操作多，选择ArrayList
2. 如果我们增删的操作多，选择LinkedList
3. 一般来说，在程序中，80%-90%都是查询，因此大部分情况下回选择ArrayList
4. 在一个项目中，根据业务灵活选择，也可能这样，一个模板使用的是ArrayList，另外一个模块是LinkedList，也就是说，要根据业务来进行选择

Set接口

Set接口基本介绍
1. 无序(添加和取出的顺序不一致)，没有索引
2. 不允许重复元素，所以最多包含一个null
3. 常用的实现类：HashSet、TreeSet
4. 注：取出的顺序虽然不是添加的顺序，但是他是固定的
Set接口的常用方法

和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样

Set接口的遍历方式

同Collection的遍历方式一样，因为Set接口是Collection接口的子接口

可以使用迭代器
增强for
不能使用索引的方式来获取

HashSet

HashSet特点
1. HashSet实现了Set接口
2. HashSet实际上是HashMap
```
public HashSet(){
    map=new HashMap<>();
}
```
1. 可以存放null值，但是只能有一个null
2. HashSet不保证元素是有序的，取决于hash后，再确定索引的结果
3. 不能有重复元素/对象
HashSet底层机制说明
1. HashSet的底层是HashMap，HashMap底层是(数组+链表+红黑树)
2. 添加一个元素时，先得到hash值-会转成->索引值
3. 找到存储数据表table，看这个索引位置是否已经存放的有元素
4. 如果没有，直接加入
5. 如果有，调用equals比较，如果相同，就放弃添加，如果不相同，则添加到最后
  1. HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值是16*加载因子是0.75=12
  2. 如果table数组使用到了临界值12，就会扩容到16 * 2=32，新的临界值计算32 * 0.75=24,以此类推
  3. 在Java8，如果一条链表的元素个数到达TRRRIFY_THRESHOLD(默认是8)，，并且table的大小>=MIN_TREEIFY_CAPACITY(默认是64)，就会进行树化(红黑树)，否则仍然采用数组扩容机制

public class   HashMap {    public static void main(String[] args) {        //模拟一个HashSet的底层(HashMap的底层结构)        //1.创建一个数组，数组的类型是Node[]        //2.有些人直接把Node[]数组称为表        Node[] table = new Node[16];        //创建节点        Node zh = new Node("张三", null);        table[2]=zh;        Node li = new Node("李四", null);        zh.next=li;        Node wu = new Node("王五", null);        li.next=wu;        Node yi = new Node("甲乙", null);        table[3]=yi;        System.out.println("table="+table);    }}class Node{//节点，存储数据，开头指向下一个节点，从而形成链表    Object item;//存放数据    Node next;//指向下一个节点    public Node(Object item, Node next) {        this.item = item;        this.next = next;    }}

LinkedHashSet

LinkedHashSet说明
1. LinkedHashSet是HashSet的子类
2. LinkedHashSet底层是一个LinkedHashMap,底层维护了一个数组+双向链表
3. LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的
4. LinkedHashSet不允许添重复元素
LinkedHashSet底层机制说明
1. 在LinkedHashSet中维护了一个hash表和双向链表(LinkedHashSet有head和tail)
2. 每一个节点有pre和next属性，这样可以形成双向链表
3. 在添加一个元素时，先求hash值，再求索引，确定该元素在hashtable的位置，然后将添加的元素加入到双向链表(如果已经存在，不添加[原则和hashset一样])
```
tail.next=newElement//简单指定newElement.pre=tail    tail=newEelment;
```
1. 这样的话，我们遍历LinkedHashSet也能确保插入的顺序和遍历顺序一致
LinkedHashSet特点
1. LinkedHashSet加入顺序和取出元素/数据的顺序一致
2. LinkedHashSet底层维护的是一个LinkedHashMap(是HashMap的子类)
3. LinkedHashSet底层结构(数组table+双向链表)
4. 添加第一次时，直接将数组table扩容到16，存放的节点类型是LinkedHashMap$Entry
5. 数组是HashMap $N o d e [] 存放的元素 / 数据是 L i n k e d H a s h M a p$ Entry

TreeSet

TreeSet特点：
1. 当我们使用无参构造器，创建TreeSet时，是自然升序
2. 当希望添加元素按照字符串大小排序可以使用TreeSet提供的一个构造器，可以传入一个比较器(匿名内部类)并指定排序规则，也可以根据元素的长度进行排序

TreeSet treeSet = new TreeSet(new Comparator() {            @Override            public int compare(Object o1, Object o2) {                //按照String大小进行排序                //return ((String)o2).compareTo((String)o1);                //按照长度大小排序                return ((String)o1).length()-((String)o2).length();            }        });

Map接口

Map接口实现类的特点：[很实用]
注：这里是jdk8的Map接口特点
1. Map和Collection并列存在。用于保存具有映射关系的数据：Key-Value
2. Map中的key和value可以是任何数据类型的数据，会封装到HashMap$Node对象中
3. Map中的key不允许重复，原因和HashSet一样
4. Map中的value可以重复
5. Map的key可以为null，Value也可以为null，注意key为null，只能有一个，value为null可以多个
6. 常用String类作为Map的key
7. key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
8. Map存放数据的key-value，一对k-v是放在一个Node中的，又因为Node实现了Entry接口，有些书上也说一对k-v就是一个Entry
Map接口常用方法
1. put:添加
2. remove:根据键删除映射关系
3. get:根据键获取值
4. size:获取元素个数
5. isEmpty:判断个数是否为0
6. clear:清除
7. containsKeys:查找键是否存在

public static void main(String[] args) {        //创建HashMap对象        Map map = new HashMap();        // put:添加        map.put("斯卡蒂","辅助");        map.put("斯卡蒂","近卫");        map.put("浊心斯卡蒂","辅助");        map.put("凯尔希","医疗");        map.put("歌蕾蒂娅","特种");        System.out.println("map="+map);        //remove:根据键删除映射关系        map.remove("斯卡蒂");        System.out.println("map="+map);        //get:根据键获取值        Object val = map.get("凯尔希");        System.out.println(val);        //size:获取元素个数        System.out.println(map.size());        //isEmpty:判断个数是否为0        System.out.println(map.isEmpty());        //clear:清除        //map.clear();        //containsKeys:查找键是否存在        System.out.println(map.containsKey("浊心斯卡蒂"));    }

Map遍历

Map遍历方法
1. containsKey:查找键是否存在
2. KeySet:获取所有的键
3. entrySet:获取所有关系k-v
4. values:获取所有的值

public static void main(String[] args) {        //创建HashMap对象        Map map = new HashMap();        map.put("斯卡蒂","辅助");        map.put("斯卡蒂","近卫");        map.put("浊心斯卡蒂","辅助");        map.put("凯尔希","医疗");        map.put("歌蕾蒂娅","特种");       //第一组：先取出使用的key，通过key取出对应的Value        Set set = map.keySet();        //(1) 增强for        for (Object key : set) {            System.out.println(key+"-"+map.get(key));        }        //(2) 迭代器        Iterator iterator = set.iterator();        while (iterator.hasNext()) {            Object key = iterator.next();            System.out.println(key+"-"+map.get(key));        }        //第二种：把所有的Value取出        Collection values = map.values();        //这里可以使用所有的Collections使用的遍历方法        //(1) 增强for        for (Object value : values) {            System.out.println(value);        }        //(2) 迭代器        Iterator iterator1 = values.iterator();        while (iterator1.hasNext()) {            Object value = iterator1.next();            System.out.println(value);        }        //第三组：通过EntrySet来取k-v        Set entrySet = map.entrySet();//EntrySet<Map.Entry<k v>>        //(1) 增强for        for (Object entry : entrySet) {            //entry转成Map.Entry            Map.Entry m=(Map.Entry) entry;            System.out.println(m.getKey()+"-"+m.getValue());        }        //(2) 迭代器        Iterator iterator2 = entrySet.iterator();        while (iterator2.hasNext()) {            Object next = iterator2.next();            //System.out.println(next.getClass());//HashMap$Node-实现->Map.Entry(getKey,getValue)            //向下转型Map.Entry            Map.Entry m=(Map.Entry) next;            System.out.println(m.getKey()+"-"+m.getValue());        }    }

HashMap

HashMap小结
1. Map接口的常用实现类：HashMap、Hashtable和Properties
2. HashMap是Map接口使用频率最高的实现类
3. HashMap是以key-value对的方式来存储数据(HashMap$Node类型)
4. key不能重复，但是值对可以重复，允许使用null键和null值
5. 如果添加相同的key，则会覆盖原来的key-value，等同于修改(key不会替换，value会替换)
6. 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的(HashMap底层数组+链表+红黑树)
7. HashMap没有实现同步，因此是线程不安全的
HashMap底层机制
1. (k,v)是一个Node实现了Map.Entry<K,V>,查看HashMap的源码可以看到
2. jdk7.0的hashmap底层实现[数组+链表]，jdk8.0底层[数组+链表+红黑树]
HashMap扩容机制
1. HashMap底层维护了Node类型的数组table，默认为null
2. 当创建对象时，将加载因子(loadfactor)初始化为0.75
3. 当添加key-value时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key是否和准备加入的key相等，如果相等，则直接替换value；如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够；则需要扩容。
4. 第一次添加，则需要扩容table容量为16，临界值(threshold)为12
5. 以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍，即24，以此类推
6. 在Java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认是64)，就会进行树化(红黑树)

TreeMap

TreeMap底层
1. 构造器把传入的实现了Comparator接口的匿名内部类(对象)，传给TrreMap的comparator
2. 调用put方法，第一次添加把k-v封装到Entry，以后添加遍历所有的key，给当前key找到适当的位置
3. 如果遍历过程中，发现准备添加key和当前已有的key相等，就不添加

TreeMap treeMap = new TreeMap(new Comparator() {            @Override            public int compare(Object o1, Object o2) {                //按照String大小进行排序                //return ((String)o2).compareTo((String)o1);                //按照长度大小排序                return ((String)o1).length()-((String)o2).length();            }        });

Hashtable

Hashtable的基本介绍
1. 存放的元素是键值对：即k-v
2. Hashtable的键和值都不能为null
3. Hashtable使用方法基本上和HashMap一样
4. Hashtable是线程安全的，HashMap是线程不安全的
Hashtable的底层
1. 底层有数组 Hashtable$Entry[] 初始化大小为11
2. 临界值threshold 8=11*0.75
3. 扩容：按照自己的扩容机制来进行即可
4. 执行方法addEntry(hash,key value,index);添加k-v封装到Entry
5. 当if(count>=threshold)满足时，就进行扩容
6. 按照int newCapacity=(oldCapacity<<1)+1;的大小扩容

类型	版本	线程安全(同步)	效率	允许null键null值
HashMap	1.2	不安全	高	可以
Hashtable	1.0	安全	较低	不可以

Properties

Properties的基本介绍
1. Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据
2. 他的使用特点和Hashtable类似
3. Properties还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改
4. 说明：工作后xxx.properties文件通常作为配置文件

Collections工具类

Collections工具类介绍
1. Collections是一种操作Set，List和Map等集合的工具类
2. Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作
排序操作：(均为static方法)
1. reverse(List):反转List中元素的顺序
2. shuffle(List):对List集合元素进行随机排序
3. sort(List):根据元素的自然顺序对指定的List集合元素按升序排序
4. sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
5. swap(List,int,int) :将指定List集合中的i处元素和j处元素进行交换

public static void main(String[] args) {        ArrayList list = new ArrayList();        list.add("鸡翅");        list.add("42");        list.add("银灰");        list.add("小羊");//        1. reverse(List):反转List中元素的顺序        Collections.reverse(list);        System.out.println(list);//        2. shuffle(List):对List集合元素进行随机排序        Collections.shuffle(list);        System.out.println(list);//        3. sort(List):根据元素的自然顺序对指定的List集合元素按升序排序        Collections.sort(list);        System.out.println(list);//        4. sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序        Collections.sort(list, new Comparator() {            @Override            public int compare(Object o1, Object o2) {                return ((String)o1).length()-((String)o2).length();            }        });        System.out.println(list);//        5. swap(List,int,int) :将指定List集合中的i处元素和j处元素进行交换        Collections.swap(list,0,2);        System.out.println(list);    }

查找、替换
1. Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
2. Object max(Collection，Comparator):根据Comparator指定顺序，返回给定集合中的最大元素
3. Object min(Collection):根据元素的自然顺序，返回给定集合中的最小元素
4. Object min(Collection，Comparator):根据Comparator指定顺序，返回给定集合中的最小元素
5. int frequency(Collection,Object):返回指定集合中指定元素的出现次数
6. void copy(List dest,List src):将src中的内容复制到dest中
7. boolean replaceAll(List list,Object oldVal,Object new newVal):使用新值替换List对象的所有旧值

//        1. Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素        System.out.println("自然顺序最大元素："+Collections.max(list));//        2. Object max(Collection，Comparator):根据Comparator指定顺序，返回给定集合中的最大元素         Object maxObject=Collections.max(list, new Comparator() {            @Override            public int compare(Object o1, Object o2) {                return ((String)o1).length()-((String)o2).length();            }        });        System.out.println("长度最大的元素="+maxObject);//        3. Object min(Collection):根据元素的自然顺序，返回给定集合中的最小元素//        4. Object min(Collection，Comparator):根据Comparator指定顺序，返回给定集合中的最小元素        //参考上面两个即可//        5. int frequency(Collection,Object):返回指定集合中指定元素的出现次数        System.out.println("42出现的次数="+Collections.frequency(list,"42"));//        6. void copy(List dest,List src):将src中的内容复制到dest中        ArrayList dest = new ArrayList();        //为了完成一个完整拷贝，需要先给dest赋值，大小和list.size()一样        for (int i = 0; i < list.size(); i++) {            dest.add("");        }        //拷贝        Collections.copy(dest,list);        System.out.println(dest);//        7. boolean replaceAll(List list,Object oldVal,Object new newVal):使用新值替换List对象的所有旧值        Collections.replaceAll(list,"42","小火龙");        System.out.println(list);    }

总结

开发中如何选择集合实现类

在开发中，选择什么集合实现类，主要取决于业务特点，然后根据集合实现类特性进行选择，分析如下：
1. 先判断存储的类型(一组对象[单列]或者一组键值对[双列])
2. 一组对象：Collections
允许重复增删多改查多
List LinkedList[底层维护了一个双向链表] ArrayList[底层维护Object类型的可变数组]

不允许重复无序排序插入和取出顺序一致
Set HashSet[底层是HashMap，维护了一个哈希表，即(数组+链表+红黑树)] TreeSet LinkedHashSet，维护数组+双向链表
1. 一组键值对：Map
键无序键排序键插入和取出顺序一致读取文件
HashMap[底层是：哈希值jdk7：数组+链表，jdk8：数组+链表+红黑树] TreeMap LinkedHashMap Properties

允许重复	增删多	改查多
List	LinkedList[底层维护了一个双向链表]	ArrayList[底层维护Object类型的可变数组]

不允许重复	无序	排序	插入和取出顺序一致
Set	HashSet[底层是HashMap，维护了一个哈希表，即(数组+链表+红黑树)]	TreeSet	LinkedHashSet，维护数组+双向链表

键无序	键排序	键插入和取出顺序一致	读取文件
HashMap[底层是：哈希值jdk7：数组+链表，jdk8：数组+链表+红黑树]	TreeMap	LinkedHashMap	Properties

我走后的夜与昼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java集合

集合什么是集合概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。和数组的区别数组长度固定，集合长度不固定数组可以存储基本类型和引用类型，集合只能存储引用类型位置：java.utilCollection体系集合Java的集合类主要由Map接口和Collection接口派生而来Collection接口有两个常用的子接口，即List接口和Set接口通常说的Java三大类接口构成(Map接口、List接口和Set接口)List接口的特点：有序、有下标、元素可重
复制链接

扫一扫