Java面试题-集合

title: Java面试题—集合
categories:

  • 面试题
    tags:
  • Java
  • 后端开发
    date: 2023-02-27 19:26:00

集合
categories:

  • 面试题
    tags:
  • Java
  • 后端开发
    date: 2023-02-27 19:26:00

集合
categories:

  • 面试题
    tags:
  • Java
  • 后端开发
    date: 2023-02-27 19:26:00

集合
categories:

  • 面试题
    tags: [‘Java’,‘后端开发’]
    date: 2023-02-27 19:26:00

集合概述

Java集合,也是容器,构成于两个接口:Collection和Map接口.用于存放键值对。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4GoPShNQ-1680940906631)(/666.github.io/pic/1.png)]

说说List,Set,Queue,Map四种集合的区别。

  • List比较适合存储有序的、可以重复的元素
  • Set常用于存储无序的、不可重复的元素
  • Queue按照特定的排队规则来确定先后顺序,存储的元素是有序的且可以重复
  • Map查询比较快,其中key无序且不重复,value无序但可重复,一个键key对应一个value值

跟着视频复习一遍吧

韩顺平视频地址(https://www.bilibili.com/video/BV1YA411T76k/?spm_id_from=333.337.search-card.all.click&vd_source=7c6c7bb18c7ca81e3c9e3e6722861c9d)

主要的两大类,需要背
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0ofFemIK-1680940906632)(/666.github.io/pic/47.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9PlAnWeH-1680940906633)(/666.github.io/pic/48.png)]

List接口的三种实现方法

LinkedList,ArrayList,Vector。

List的三种输出方式

package com.jun.List_;

import java.util.ArrayList;
import java.util.Iterator;

/*
 * @Author: jun
 * @Date:2023/4/4 16:37
 * @概述:
 */
public class ListFor {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        for (int i = 0; i < 12; i++) {
            list.add("jun"+i);
        }
        System.out.println(list);

        //三种遍历方式
        //1.迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println("迭代器输出:"+next);
        }
        
        //2.增强for
        for (Object j :
                list) {
            System.out.println("增强for输出:"+j);
        }

        //3.常规for输出
        for (int i = 0; i < list.size(); i++) {
            System.out.println("常规for输出:"+list.get(i));
        }
    }
}

ArrayList是线程不安全的,因为没有添加 synchronized互斥锁,线程之前会同时进行操作,会导致脏读,幻读,错读。

所以在多线程情况下就不要使用ArrayList了。

ArrayList底层结构和源码分析

1) ArrayList中维护了一个Object类型的数组elementData.

2) 当创建ArrayList对象时,如果使用的是无参构造器(即没有指明大小),则初始化elementData容量为0,第一次添加,则扩容elementData为10,如果需要再次扩容elementData就为1.5倍。

3) 如果使用的指定大小的构造器,初始的大小elementData容量为指定大小,如果需要再次扩容,则直接扩容elementData为1.5倍。

Vector底层结构和源码分析

还是List接口的实现子类。

1) 底层也是一个对象数组。

2) 是线程同步的,即线程安全。Vector类的操作方法有synchronized
3) 在开发的过程中,需要考虑到线程同步安全问题时,可以考虑使用Vector。

LinkedList底层结构和源码分析

1) LinkedList底层实现了双向链表和双端队列特点
2) 可以添加任意元素(元素可以重复),包括null
3) 线程不安全,没有实现同步。

😂

双向链表

package com.jun.List_;

/*
 * @Author: jun
 * @Date:2023/4/7 19:12
 * @概述:
 */
public class LinkedList01_ {
    public static void main(String[] args) {
        //模拟一个简单的双向链表
        node jack = new node("jack");
        node tom = new node("tom");
        node jun = new node("jun");

        //连接三个节点,形成双向链表
        //jack -> tom -> jun
        jack.next = tom;
        tom.next = jun;
        //jun -> tom -> jack
        jun.pre = tom;
        tom.pre = jack;

        node first = jack; //让first引用指向jack,就是双向链表的头结点
        node last = jun;    //让last引用指向jun.就是双向链表的尾结点

        System.out.println("从头到尾遍历");
        while (true) {
            if (first == null) {
                break;
            }
            //输出first信息
            System.out.println(first);
            first = first.next;
        }

        System.out.println("从尾到头遍历");
        //演示,从尾到头遍历
        while (true) {
            if (last == null) {
                break;
            }
            //输出first信息
            System.out.println(last);
            last = last.pre;
        }

    }


}

//定义一个node,表示一个双向连表的节点
class node{
    public Object item; //真正存放数据
    public node next; //指向下一个结点
    public node pre;    //

    public node(Object name){
        this.item = name;
    }

    @Override
    public String toString() {
        return "node name" + item;
    }
}

ArrayList和LinkedList比较

ArrayList和LinkedList的比较:

ArrayList是可变数组,增删的效率比较低,数组可以扩容,改查的效率也比较高

LinkedList 是双向链表,通过链表追加,改查的效率比较低。

Set接口

主要的两个子实现类:HashSet和TreeSet

1)接口无序:添加和取出的顺序不一致,没有索引
2)不允许重复元素,最多包含一个null
3)JDK API中Set接口的实现类有AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet

package com.jun.Set;

import java.util.HashSet;

/*
 * @Author: jun
 * @Date:2023/4/7 20:05
 * @概述:
 */
public class SetMethod {
    public static void main(String[] args) {
        //1. 以Set接口的实现类HashSet 为例
        //2. set接口的实现类对象,不能存放重复的元素
        //3. 无序,即添加的顺序与取出的数据不一致
        //4. 注意:取出的顺序是始终一致的,不会每次都不一样
        HashSet set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("jun");
        set.add("jack");
        set.add(null);
        set.add(null);
        System.out.println(set);
    }
}

遍历方式

//方式1:迭代器
        Iterator iterator = 					set.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }


        //方式2:增强for
        for (Object o :
                set) {
            System.out.println(o);
        }
        

HashSet

1) 实现了Set接口
2) 实际上是HashMap
3) 可以存放null值,但是只有一个null
4) 不保证有序,即,不保证存放元素的顺序和取出的顺序一致。
5) 不重复的元素。

Map

package com.jun.map_;

import java.util.HashMap;
import java.util.Map;

/*
 * @Author: jun
 * @Date:2023/4/8 10:13
 * @概述:
 */
public class Map_ {
    public static void main(String[] args) {
        //1.Map用于保存具有映射关系的数据Key-Value
        //2.Map与Collection并列存在,用于保存具有映射关系的数据:Key-Value(双列元素)
        //3.Map中的Key和Value可以是任何引用类型的数据,会封装到HashMap&Node对象中
        //4.一般情况下以String类作为Map的Key
        //5.key和value之间存在单向一对一的关系,即通过指定的key可以找到对应的value
        Map map = new HashMap();
        map.put("no1","jun");
        map.put("no2","lili");
        map.put("no1","zhang");//当有相同的k,就等价于替换
        map.put("no3","lili");//value可以重复
        map.put(null,null);//map中的key可以为null,value也可以为null
        //两者的细微不同是,key只能一个为null,而value可以有多个null

        map.put(new Object(),"人人");
        System.out.println(map);

    }
}

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

选择什么集合实现类,主要取决于业务操作特点:
1) 先判断存储的类型(一组对象[单列]或者一组键值对[双列])
2) 一组对象:collection接口

允许重复:list

增删多:LinkedList(底层维护了一个双向链表)

不允许重复:Set

无序:HashSet
排序:TreeSet

3) 一组键值对:Map
键无序:HashMap(哈希表,jdk7:数组+链表,jdk8:数组+链表+红黑树)
键排序:TreeMap

键插入和取出一致:LinkedHashMap
读取文件:properties

Collections工具类

package com.jun.collection_;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
 * @Author: jun
 * @Date:2023/4/8 15:24
 * @概述:
 */
@SuppressWarnings({"all"})
public class Collections_tool {
    public static void main(String[] args) {
        //创建ArrayList集合,用于测试
        List list = new ArrayList();
        list.add("jun01");
        list.add("jun02");
        list.add("jun03");
        list.add("jun04");

        //reverse(List):反转List中元素的顺序
        Collections.reverse(list);
        System.out.println(list);//result:[jun04, jun03, jun02, jun01]

        //shuffle(List):对List集合元素进行随机排序
        Collections.shuffle(list);
        System.out.println(list);//[jun02, jun03, jun01, jun04]

        //sort(List):根据元素的自然顺序对指定List集合元素按升序排序
        Collections.sort(list);
        System.out.println(list);//[jun01, jun02, jun03, jun04]

        //swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换
        Collections.swap(list,0,1);
        System.out.println(list);//[jun02, jun01, jun03, jun04]

        //Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
        System.out.println(Collections.max(list));

        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);
    }
}

脑瓜子痛
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yQko03fx-1680940906633)(/666.github.io/pic/f4aa9cd4d88b8eda7d695ba4f1c6cbb0_1.jpg)]

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇

)">
下一篇>>