Java api05（collection集合 list set queue 底层实现原理 数据结构二叉树）（文字配图）

最新推荐文章于 2022-07-08 17:40:33 发布
最新推荐文章于 2022-07-08 17:40:33 发布
阅读量160 收藏
点赞数 1
分类专栏： java笔记 文章标签： 数据结构 队列 链表 二叉树 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xujiaqiqiqi/article/details/117189880
版权

集合:
Collection(I) + Map(I)
Collection(I):
|- List(I) - 顺序结构
|- ArrayList© - 数组
|- LinkedList© - 链表
|- Vector© - 数组

|- Set(I) - 散列结构 -> Map(I)
|- SortedSet(I)
|- TreeSet©
|- hashSet©

|- Queue(I) - 队列
|- Dueque(I)
|-LinkedList©

List集合 - 顺序结构
1.List集合的特点
a.List集合是顺序结构,所以是有序列表,可以是用index
b.List集合允许有重复值
c.List集合允许有null值

2.特有方法(带有index)
add(int index, E element)
addAll(int index, Collection<? extends E> c)
set(int index, E element)
subList(int fromIndex, int toIndex)
remove(int index)
get(int index)

3.实现类
ArrayList©
底层实现:数组
底层数据结构:数组
特点:
优点: 查询速度很快(因为有连续的下标,可以根据下标进行查询)
缺点:
a.插入/删除很慢的
b.顺序结构需要连续的物理空间
导致空间的使用率非常低

package api05.Collection.list;

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

/*
    List集合
 */
public class ListDemo01 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("1");
        list.add("1");
        list.add("2");
        list.add("4");
        System.out.println(list);

        //subList
        //前包含后不包含
        List sub = list.subList(0, 2);
        System.out.println(sub);

        //sub新集合
        sub.add("张三");
        System.out.println(sub);

        //原集合有没有包含 张三
        //[1, 1, 张三, 2, 4]
        //原集合 和 子集合共用同一块内存空间
        System.out.println(list);
    }
}


package api05.Collection.list;

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

/*
    ArrayList和LinkedList的效率对比
 */
public class ListDemo02 {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList();
        LinkedList linked = new LinkedList<>();
        for (int i = 0; i < 5000000; i++) {
            arr.add("i" + i);
            linked.add("i"+i );
        }
        //查询 - ArrayList
       /* long time1 = System.currentTimeMillis();
        arr.get(0);
        long time2 = System.currentTimeMillis();
        linked.get(0);
        long time3 = System.currentTimeMillis();
        System.out.println("arr查询效率:" + (time2 - time1));
        System.out.println("linked查询效率:" + (time3 - time2));

        //从中间查
        long time4 = System.currentTimeMillis();
        arr.get(2500000);
        long time5 = System.currentTimeMillis();
        linked.get(2500000);
        long time6 = System.currentTimeMillis();
        System.out.println("arr查询效率:" + (time5 - time4));
        System.out.println("linked查询效率:" + (time6 - time5));

        //从尾部查询
        long time7 = System.currentTimeMillis();
        arr.get(4999999);
        long time8 = System.currentTimeMillis();
        linked.get(4999999);
        long time9 = System.currentTimeMillis();
        System.out.println("arr查询效率:" + (time8 - time7));
        System.out.println("linked查询效率:" + (time9 - time8));
        */

        //插入 - LinkedList快
        long time1 = System.currentTimeMillis();
        arr.add(0,"1");
        long time2 = System.currentTimeMillis();
        linked.add(0,"1");
        long time3 = System.currentTimeMillis();
        System.out.println("arr查询效率:" + (time2 - time1));
        System.out.println("linked查询效率:" + (time3 - time2));

        //从中间查
        long time4 = System.currentTimeMillis();
        arr.add(2500000,"1");
        long time5 = System.currentTimeMillis();
        linked.add(2500000,"1");
        long time6 = System.currentTimeMillis();
        System.out.println("arr查询效率:" + (time5 - time4));
        System.out.println("linked查询效率:" + (time6 - time5));

        //从尾部查询
        long time7 = System.currentTimeMillis();
        arr.add(4999990,"1");
        long time8 = System.currentTimeMillis();
        linked.add(4999990,"1");
        long time9 = System.currentTimeMillis();
        System.out.println("arr查询效率:" + (time8 - time7));
        System.out.println("linked查询效率:" + (time9 - time8));

    }
}

LinkedList©: 双向链表
1)底层实现:Node节点 -> date(数据) + next(下一个节点的引用)
底层数据结构: 链表
2)特点:
a.链表在内存中是固定顺序的,但是他的物理空间不连续
b.没有下标,只有头节点
c.所有的操作只能从头节点出发
d.头节点 head: 不存数据,只有next
4)优缺点:
优点: 插入/删除操作快
不需要连续的物理空间,所以空间使用率高
缺点: 查询速度,因为只能从头节点或尾节点开始查询

5)特有的方法:
	只要带有first/last
	addFirst(E e) 
	addLast(E e) 
	getFirst() 
	getLast() 
	removeFirst() 
	removeLast()

Vector©
底层实现:数组
和ArrayList一样
不一样的地方:
Vector加了锁(synchronized),线程安全,效率低

面试题:
ArrayList和LinkedList的区别
1.底层实现区别
2.优缺点的区别

对于插入/删除 单个操作而言 -> linkedList比较快
但是: 先查询,找到要插入/删除的位置的前一个节点
查询 + 插入(删除)
因为没有下标,所以查询非常慢

ArrayList和Vector的区别
1.线程安全分析
2.扩容容量
ArrayList扩容为原容量的1.5倍
Vector扩容为原容量的2倍

Queue(I) - 队列(线性结构)
1)特点:
a.先进先出
b.允许有重复值
2)常用方法:
offer() - 向队列尾部追加元素
peek() - 从队列头部获取元素,但是队列不变
poll() - 从队列头部获取元素,删除元素

3)子接口 - Dqueue(I) - 双端队列/栈
可以根据方法区分是双端队列还是栈
Dqueue中的栈实现:
push() - 压栈
pop() - 弹栈

package api05.Collection.queue;

import java.util.Deque;
import java.util.LinkedList;

/*
    LinkedList作为双端队列实现
    poll - 获取并删除数据

 */
public class LinkedDemo01 {
    public static void main(String[] args) {
        Deque linked = new LinkedList<>();
        //linked.add("张三");

        linked.offer("张三");
        linked.offer("张三");
        linked.offer("张三");
        //Fitst/last
        linked.offerLast("李四");
        linked.offerFirst("lucy");
        System.out.println(linked);


        //获取并删除
        Object poll = linked.poll();
        System.out.println(poll);
        System.out.println(linked);


    }
}


package api05.Collection.queue;

import java.util.Deque;
import java.util.LinkedList;

/*
    LinkedList作为栈实现
     push - 添加
     peek() - 获取但是不删除数据
     pop() - 获取并删除数据
 */
public class LinkedDemo02 {
    public static void main(String[] args) {
       Deque linked = new LinkedList<>();
       linked.push("张三");
        linked.push("李四");
        linked.push("王五");
        System.out.println(linked);

        //获取数据,但是不删除数据
        Object pop = linked.peek();
        System.out.println(pop);
        System.out.println(linked);


        //获取并删除数据 - 出栈(弹栈)
        /*Object pop = linked.pop();
        System.out.println(poll);
        System.out.println(linked);*/




    }
}

队列和栈的原理

Set集合 - 散列表 (没有顺序的集合,不是随机!!!)
1.Set特点
a.无序且唯一
b.使用equals判断元素是否重复
c.Set的物理空间是不连续的

2.实现类
HashSet©:
特点:
a.存储位置不是真正的随机位置,根据HashCode方法计算(决定)最终位置
b.使用equals()判断元素是否重复

存储过程:
  ①.调用自身的hashCode()计算存储位置
  ②.判断该位置上是否存在元素
  ③.如果该位置上存在元素
  	 则使用equals()判断是否相等
  	 如果相等则不存入
  	 如果不相等,则存放到链表末尾

HashSet的存储过程

package api05.Collection.set;

import java.util.HashSet;

public class HashSetDemo01 {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        User u1 = new User(18, "张三");
        User u2 = new User(19, "张三");
        set.add(u1);
        set.add(u2);

        u2.setAge(18);
        System.out.println(set);

        //通过HashSet中的构造方法 - 构建另一个集合
        HashSet newSet = new HashSet(set);
        System.out.println(newSet);
    }
}


package api05.Collection.set;

import java.util.HashSet;

public class HashSetDemo02 {
    public static void main(String[] args) {
        HashSet<User> set = new HashSet<>();
        User u1 = new User(18, "张三");
        User u2 = new User(19, "李四");
        User u3 = new User(18, "张三");
        User u4 = new User(19, "李四");
        set.add(u1);
        set.add(u2);
        set.add(u3);
        set.add(u4);
        System.out.println(set);

    }
}


package api05.Collection.set;

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo03 {
    public static void main(String[] args) {
        Set<User> set = new HashSet<User>();
        User u1 = new User(18,"张三");
        User u2 = new User(20,"李四");
        set.add(u1);
        set.add(u2);
        System.out.println(set);

        //修改了u2 的年龄
        u2.setAge(23);
        //删除u2的数据
        set.remove(u2);
        System.out.println(set);

        //将数据修改成原数据 - 用另一个集合进行构建

    }
}


package api05.Collection.set;

import java.util.HashSet;
import java.util.Set;

/*
    Set集合的特点
 */
public class SetDemo01 {
    public static void main(String[] args) {
        //hashSet
        //[how, are, hello, you]
        //物理空间没有顺序 - 无序
        Set set = new HashSet<>();
        set.add("hello");
        set.add("how");
        set.add("are");
        set.add("you");
        System.out.println(set);
        //[how, are, hello, you]
        //特点二: 唯一
        set.add("you");
        set.add("you");
        set.add("you");
        System.out.println(set);
    }
}


package api05.Collection.set;

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

/*
    Comparator自定义排序

        数组的排序方法:Arrays.sort() - 默认使用自然排序
        List:Collections.sort() - 默认使用自然排序
        Set: TreeSet() - 默认使用自然排序
        Map: TreeMap() - 默认使用自然排序

        自然排序: Comparable
            重写 compareTo() -> 比较 o 和 this
        自定义排序: Comparator
            重写 compare() -> o1 和 o2
                后 比 前 -> 倒序
                前 比 后 -> 正序
 */
public class SortedDemo05 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(12);
        list.add(8);
        list.add(55);
        //对List集合进行排序 [8, 12, 20, 55]
        //Collections.sort(list);//默认自然排序
        //自定义排序 Comparator
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                /*return o1 - o2;//正序*/
                return  o2 - o1;//倒序
            }
        });
        System.out.println(list);

//__________________________________
        //使用自定义排序对 TreeSet进行排序
        TreeSet<User> set = new TreeSet(new Comparator<User>() {
            @Override
            public int compare(User o1,  User o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        set.add(new User(18,"lucy"));
        set.add(new User(19,"tom"));
        set.add(new User(20,"tom"));
        System.out.println(set);

    }

}


package api05.Collection.set;

import java.util.TreeSet;

/*
    TreeSet - 排序
 */
public class TreeSetDemo01 {
    public static void main(String[] args) {
        //[4, 7, 8, 11]
        TreeSet<String> tree = new TreeSet();
        //A - 65 a - 97
        tree.add("a");
        tree.add("A");
        tree.add("b");
        tree.add("B");
        System.out.println(tree);

        //ClassCastException - 类型转换异常
        TreeSet<User> tree1 = new TreeSet<>();
        User u1 = new User(18, "lucy");
        User u2 = new User(19, "tom");
        tree1.add(u1);
        tree1.add(u2);
        System.out.println(tree1);
    }
}


package api05.Collection.set;

import java.util.Objects;
//实现Comparable接口 - 可排序
public class User /*implements Comparable<User>*/{
    int age;
    String name;

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public User() {
    }

    public int getAge() {
        return age;
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) return true;
        if (object == null || getClass() != object.getClass()) return false;
        User user = (User) object;
        return age == user.age &&
                Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }



    /* 如果 return 0 ->
        会认为存进来的所有数据都是一样的,不存入
       如果 o 比 this 大 -> 正数
       如果 o 比 this 小 -> 负数

        this.age - o.age -> 正序
        o.age - this.age -> 倒序
     */
   /* @Override
    public int compareTo(User o) {
        // o 和 this(user)
        *//*return this.age - o.age; 正序 *//*
         if(o.age != this.age){
             return o.age - this.age;
         }
        return o.name.compareTo(this.name);

    }*/

}

二叉树
特点:
a.不允许有重复值
b.永远都是(左在前,右在后)
c.左节点 < 父节点 < 右节点

遍历方式:
先序遍历 - 中左右
后序遍历 - 左右中
中序遍历 - 左中右
二叉树原理

TreeSet©
1)底层实现:二叉树
2)父接口 -> SortedSet(I)
3)特点:
a.用来排序,最常用的是中序遍历
4)TreeSet存储过程:
①.最开始的数据跟根节点比较 - compareTo进行比较
②.如果比根节点大,存储在右边
③.如果比根节点小,存储在左边
④.如果元素一样,则不存入

Comparable 自然排序 和 Comparator 自定义排序(指定比较器)

1)所有的自然排序,底层下都是实现了Comparable接口
2)自然排序 Comparable
重写了compareTo()
比较 obj 和 this 进行对比

数组: Arrays.sort()
List: Collections.sort()
Set: TreeSet()
Map: TreeMap()

3)比较器排序 Comparator
重写了compare()
比较 o1 和 o2

数组: Arrays.sort(new Comparator)
List: Collections.sort(new Comparator)
Set: TreeSet(new Comparator)
Map: TreeMap(new Comparator)

4)结论:
sort方法不指定比较器的时候,需要的元素必须是实现Comparable

sort方法指定比较器,元素不需要实现Comparable
caicaicai..
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA 数据结构之Queue处理实例代码
08-31
主要介绍了JAVA 数据结构之Queue处理实例代码的相关资料,需要的朋友可以参考下
java 集合(list-queue-set)学习
01-25
记录自己的java学习进度。
集合各实现类的底层实现原理
热门推荐
kris
02-16 5万+
ArrayList实现原理要点概括参考文献：http://zhangshixi.iteye.com/blog/674856l ArrayList是List接口的可变数组非同步实现，并允许包括null在内的所有元素。 底层使用数组实现 该集合是可变长度数组，数组扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量增长大约是其容量的1.5倍，这种操作的代价很高。 采用了Fail-Fast机制
Java集合Collection之实现原理解读(HashSet)
weixiaohuai的博客
10-04 411
一、简介 HashSet实现Set接口，底层是由哈希表实现(实际上是HashMap),Set里面的元素无序不重复，可以允许null值。对于熟悉HashMap底层实现的同学相信很容易理解HashSet底层实现原理。   二、实现原理 HashSet底层是通过HashMap实现的，通过HashMap来保存所有的元素，HashSet对数据的操作基本上都是调用HashMap的一些方法进行操作，所以...
Java集合Collection之实现原理解读(LinkedList)
weixiaohuai的博客
10-03 1320
一、简介 LinkedList与ArrayList一样都实现了List接口，不过LinkedList底层实现是双向链表，对于插入、修改、删除速度比较快，对于查询就比较慢，因为要循环遍历查找。本章将模仿LinkedList源码实现一个简单的自定义LinkedList，以帮助饿哦们理解LinkedList底层是怎么实现的。 二、实现原理 LinkedList底层是通过双向链表实现的，通过一系列的...
List、Set、Map底层原理详解（面试必背）
ydl1128的博客
07-08 2728
HashMap底层原理、List集合介绍、Set集合介绍
java集合底层实现
weixin_33794672的博客
02-22 244
Set和Map的关系 Set代表无序，不能重复的集合；Map代表Key-Value组成的集合，是一种关联数组。Map的Key要求是不能重复，没有顺序。把Map的所有Key组合起来就是Set。 Set<K> keySet(); HashMap和HashSet原理 HashMap底层是用数组链表存储的，元素是Entry。 向HashMap添加<Key,Value>时，...
数据结构和算法：用Java实现的抽象数据结构的集合
02-05
这是用Java实现的抽象数据结构和算法的集合。 该代码经过了很好的注释，可以轻松理解。 每个数据结构都经过良好测试。 您可以通过与我联系。 数据结构 ： 此仓库包含以下数据结构： 排序算法 图上的算法 图表示 ...
queue 1.zip_queue 数据结构 实现_rhythmlft
09-24
queue 数据结构 实现，仅供学习参考
Java超详细！Java实现数据结构PPT课件
最新发布
02-24
线性数据结构动态数组（ArrayList） 链表（LinkedList） 单向链表 双向链表 循环链表 静态链表 栈（Stack） 队列（Queue） 双端队列（Deque） 循环队列 哈希表（HashTable） 树形数据结构 二叉树（BinaryTree）、...
关于collection的底层实现博客
supli的博客
07-30 856
https://my.oschina.net/90888/blog/1624758 （以上）
集合底层实现原理
dragonyangl的博客
10-16 516
ArrayList  底层实现原理是数组。 因为数组是定长的，所以在最初的时候建立了一个初始化长度默认16的基础数组，加素因子默认是0.75。可存储长度为16*0.75=12。 当存储数据达到12的时候，数组会内部操作建一个更长的数组，将现在数组的数据拷入新的数组。 所以就完成了动态添加且不定长度的原因。 LinkedList 底层实现原理是链表 链表本身可以自动增长的，所以是利用链...
集合Collection底层
HD243608836的博客
03-26 1141
集合:1.ArrayList的实现原理: ArrayList实现List接口、底层使用数组保存所有元素,每次数组容量的增长大约是其原容量的1.5倍,数组进行扩容时，会将老数组中的元素重新拷贝一份到新的数组中,这种做法代价是很高的. Vector和ArrayList差不多,就是线程是安全的原文:http://www.cnblogs.com/batys/archive/2011/11/02/22335...
从底层设计分析List和Set区别
sinat_21924579的博客
06-23 695
List和Set区别最直观的List是有序可重复，Set无序不可重复； 但是3年以上工作更注重的是底层数据结构与算法。 List最常用的是ArrayList（可变长度的动态数组） ArrayList源码中指定transient （不能被序列化）修饰的Object[] ，就是个数组。 注意：正常使用中是可以序列化的，因为ArrayList重写了readObject、writeObject方法 （...
论set、map、list之间的区别和底层实现
z2014ypd的博客
03-04 768
ArrayList： 数组实现的底层架构，先进后出原则，有序存储，因为元素都有索引，队尾添加元素快，查询以及替换元素效率高，线程不安全。 LinkedList： 双向链表作为底层架构，先进先出原则，有序存储，因为是通过地址来定位到元素位置，增加元素和插入元素效率高，线程不安全。 vector： 类似于ArrayList，但线程安全，使用动态数组进行添加。 HashSet： 底层使用HashCode...
Python中关于list和set的搜索效率及底层原理浅析
Mr_LiShao的博客
09-05 1758
从上图可以看到，同样情况下，在set中查找大概60纳秒，在list中查找大概440微秒=440*1000纳秒=440000纳秒。所用时间大概是set的6000倍。 总结原因： list是顺序存储的，在查找的时候遍历整个数组，所以时间复杂度是O(n) set在底层是被设计成没有值的字典型，即只有key没有value。而字典dict类型在python中的实现是基于hash map哈希表的，有一个映射关系，所以在查找时候，通过哈希函数f(x)就能轻易地找到相应的值，所以时间复杂度是O(1)。在Pytho..
黑马程序员________Java集合List和Set的原理应用学习笔记
人不狠、站不稳
10-12 1238
------- android培训、java培训、期待与您交流！ ----------            集合是一种可以存储对象的容器，当然这个容器也是一个对象。和数组相比，集合的优势在于他的长度是可以变化，另外集合可以存储多个类型的对象，而数组的长度是固定的，只能存储一个类型的元素；但是集合不能存储基本数据类型，而数组却可以。         所有的集合类都是Collectio
从底层设计分析List和Set的区别
依剑行走天下的博客
03-12 574
1. List List是有序并且允许重复 ArrayList 可变长度的动态数组 （它其实就是一个Object[] 的数组） 可以使用readObjec() 和 writeObject() 去序列化 ArrayList 有三种构造方式 new 一个ArrayList的时候是不会去初始化数组的，当调用add操作的时候，才会去初始化数组，如果没有传初始化因子的时候，默认数组大小是10； ArrayList 扩容的操作 接着进行元素的拷贝 remove()方法 2. Set set不允许重复且无序
java中集合collection和map集合框架有什么用法，他们的底层原理是什么
04-19
Collection 的主要实现类包括 List、Set 和 Queue。 Map 接口表示的是一组键值对，其中键是唯一的，Value 是值。Map 中常用的操作包括增加、删除、查找等。HashMap 和 TreeMap 是 Java 中常用的 Map 实现类。 底层...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值