Java集合之List

最新推荐文章于 2020-05-12 13:15:22 发布
最新推荐文章于 2020-05-12 13:15:22 发布
阅读量141 收藏
点赞数
文章标签： java 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Scar_shy/article/details/103795131
版权

java集合

  1. java集合就好比一个容器，可以用于存放数量不等的多个对象，可以保存具有映射关系地的关联数组，还可以保存多个对象的引用。
    2）java集合分为三种体系：List、Set、Map
    List: 存放的数据是有序的，可重复的
    Set:存放的数据是无序，不可重复的
    Map:存放的数据是具有映射关系的集合（键—值）
    3）集合框架图（Collection 接口是 List、Set 和 Queue 接口的父接口）
    此图片非原创
    在这里插入图片描述
    4）实现各个接口的集合
    1，List接口：ArrayList、LinkedList、Vector、Stack实现了List接口。
    ArrayList:内部通过数组实现，可以对元素进行快速的查找访问，但是由于数组大小有限当长度不够时需要扩容，就需要将数据复制到新的数组，而且进行添加或删除操作时，都需要对数组中的元素进行移动，代价太高，所以AyyayList适用于对数据进行查找、遍历的操作，不适用于插入和删除。
下面是自己使用数组实现的ArrayList：

在这里插入图片描述

package pm;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public class MyArryList<T> {
    private int count=0;     //数组元素个数
    private Object[] os;     //数组
    private int DEFAULT=5;   //默认数组长度

    public MyArryList() {
       os=new Object[DEFAULT];
    }
    //添加元素
    public boolean add(T t){
        Object[] newOs;    //用于存放添加后的元素
        if((count+1)>os.length){  //判断数组长度是否够用---->不够--->扩容
            int oldSize=os.length;
            int newSize=os.length+(oldSize>>1);
          // int newSize=os.length+2;
            newOs=new Object[newSize];
            //向新数组拷贝元素
            System.arraycopy(os,0,newOs,0,oldSize);
            //加入新添的元素
            newOs[count]=t;
            //覆盖原来的数组
            os=newOs;
        }else{    //数组够用，不用扩容
           os[count]=t;
        }
        count++;
        return true;
    }
    //显示集合元素
    public void show(){
       for(int i=0;i<os.length;i++){
           System.out.println((T)os[i]);
       }
    }
    //添加元素--按索引添加到相应的位置(索引值，元素值)
    public boolean add(int index,T t){
        Object[] newOs;    //用于存放添加后的元素
        if((count+1)>os.length){  //判断数组长度是否够用---->不够--->扩容
            int oldSize=os.length;
            //int newSize=os.length+(oldSize>>1);  //容量变大为原来的1.5倍
            int newSize=os.length+2;//容量加2
            newOs=new Object[newSize];
        }else{    //数组够用，不用扩容
           newOs=new Object[os.length];
        }
        //向新数组拷贝元素
        System.arraycopy(os,0,newOs,0,index);
        System.arraycopy(os,index,newOs,index+1,count-index);
        //加入新添的元素
        newOs[index]=t;
        //覆盖原来的数组
        os=newOs;
        count++;
        return true;
    }
    //删除指定索引的元素
    public boolean delete(int index){
        Object[] newOs;    //用于存放删除后的元素
        int oldSize=os.length;
        int newSize=os.length-1;
        newOs=new Object[newSize];
        if(index>0){
            System.arraycopy(os,0,newOs,0,index);
            System.arraycopy(os,index+1,newOs,index,count-index);
            os=newOs;
        }else if(index==0){
            System.arraycopy(os,index+1,newOs,0,os.length-1);
            os=newOs;
        }else{
            System.out.println("索引错误");
        }
            count--;
            return true;
    }
    //删除最后一个元素开始的自定义长度
    public boolean del_size(int index){
        Object[] newOs;    //用于存放删除后的元素
        int oldSize=os.length;
        int newSize=os.length-index;  //修改删除后的容量
        newOs=new Object[newSize];
        System.arraycopy(os,0,newOs,0,count-index);
        os=newOs;
        count=count-index;
        return true;
    }
    //获取list 里索引的对应元素
    public T get(int index){
        return (T)os[index];
    }
}

2，LinkedList:是使用双向链表结构存储数据的，适用于动态的插入和删除，而不适用与随机访问，遍历的速度也偏慢。可以用作堆栈，队列，和双向队列来使用。

单链表的实现

在这里插入图片描述

package am;

import javax.jws.WebParam;

public class MyLinkList <T>{
    //链表长度
    private int size;
    //链表头节点
    private Node head;
    //尾节点
    private Node tail;
    public class Node{
        private T data;
        private Node next;
        public Node(T data,Node node){
            this.data=data;
            next=node;
        }
        public Node(){}

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }
    public MyLinkList(){
        head=null;
        tail=null;
    }
    public MyLinkList(T ele){
        head=new Node(ele,null);
        tail=head;
        size++;
    }
    //返回链表长度
    public int length(){
        return size;
    }
    //在指定位置插入数据
    public  void insert(int index,T ele){
        //如果链表为空--->插入节点
        if(size==0) add(ele);
        //不为空--->在指定位置插入节点
        else{
            Node current=head;
            for(int i=0;i<size;i++){
                if(i==index-1 && index-1>=0){
                    Node node=new Node(ele,current.next);
                    current.next=node;
                }
                else if(index==0){
                    Node newNode=new Node(ele,head);
                }
                else{
                    current=current.next;
                }
        }

    }
        size++;
    }
    //删除指定位置数据
    public void delete(int index){
        if(size==-1) System.out.println("链表为空，不可删除了.");
        else if(size==0 && index==size){
            head=head.next;
            size--;
        }
        else{
            Node current=head;
            for(int i = 0; i < size && current != null; i++, current = current.next){
                if(i==index-1){
                    current.next=current.next.next;
                    size--;
                }
            }
        }
    }
    //显示链表
    public void show(){
        Node current = new Node();
        current=this.head;
        for (int i = 0; i < size && current != null; i++, current = current.next) {
            System.out.println(current.data);
        }
    }
    //在链表尾部添加节点
    public void add(T ele){
        if(head==null){
            head=new Node(ele,null);
            tail=head;
        }else{
            Node newNode=new Node(ele,null);
            tail.next=newNode;
            tail=newNode;
        }
        size++;
    }
    //得到相应索引的节点
    public Node get(int index){
        if(index<0 || index >size-1) System.out.println("输入索引出错！");
        else{
            Node current=head;
            for(int i=0;i<size && current!=null;i++,current=current.next){
                if(i==index) return current;
            }
        }
        return null;
    }
}
栈
package homework;

import java.util.Arrays;

public class MyStack<T> {
    private Object[] os;
    private int DEFAULT_SIZE = 5;
    private int count = 0;

    public MyStack() {
        this.os = new Object[DEFAULT_SIZE];
    }

    public void push(T t) {
        if (count + 1 > DEFAULT_SIZE) {
            os = Arrays.copyOf(os, os.length * 2);
        }
        os[count] = t;
        count++;
    }

    public T pop() {
        if (count == 0) {
            System.out.println("栈为空");
            return null;
        }
        T t1 = (T) os[count - 1];
        os[count - 1] = null;
        count--;
        return t1;
    }

    public void empty(){
        if(count==0){
            System.out.println("栈为空");
        }else
            System.out.println("栈不为空");
    }

    public T peek(){
        if(count==0){
            System.out.println("栈为空");
        }
        T t1=(T)os[count-1];
        return t1;
    }

    public T search(){
        if(count==0){
            System.out.println("栈为空");
        }
        T t1=(T)os[1];
        return t1;
    }

    public void show(){
        for (int i=0;i<count;i++){
            System.out.print(os[i]+" ");
        }
        System.out.println(" ");
    }
}
双向链表
package homework;

public class MyDoubleLinkList<T> {
    private int size;
    private Node head;
    private Node tail;

    public class Node{
        private T data;
        private Node pre;
        private Node next;
        public Node(T data,Node node1,Node node2) {
            this.data = data;
            pre=node1;
            next=node2;
        }
        public Node() {
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public Node getPre() {
            return pre;
        }

        public void setPre(Node pre) {
            this.pre = pre;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }
    public  MyDoubleLinkList(){
        head=null;
        tail=null;
    }
    public MyDoubleLinkList(T ele){
       head=new Node(ele,null,null);
       tail=head;
       size++;
    }//返回链表长度
    public int size(){
        return size;
    }
    public T getData(int i) {
        T t= get(i).data;
        return t;
    }
    //在链表末尾加入数据
    public void add(T ele){
        if(head==null){
            head=new Node(ele,null,null);
            tail=head;
        }else{
          Node node=new Node(ele,tail,null);
          tail.next=node;
          tail=node;
        }
        size++;
    }
    //判断链表是否为空
    public boolean isEmpty(){
        if(size==0) return true;
        return false;
    }
    //获取相应索引的元素
    public Node get(int index) {
        if (index < 0 || index > size - 1) {
            System.out.println("索引异常！");
        } else {
            Node current = new Node();
            current = head;
            for (int i = 0; i < size && current != null; i++, current = current.next) {
                if (index == i)
                    return  current;
            }
        }
        return null;
    }
    //删除末尾元素
    public void delete(){
        if(size==0){
            System.out.println("不可删除，链表为空！");
        }else if(size>0){
            tail.pre=tail;
            tail=null;
        }
        else{
            System.out.println("索引出错！");
        }
        size--;
    }
    //删除相应位置的元素
    public void deleteN(int index){
        if(index==0){
            head=head.next;
        }else if(index>0){
            get(index).pre.next=get(index).next;
            get(index).next.pre=get(index).pre;
        }
        else{
            System.out.println("索引出错！");
        }
        size--;
    }
    //在相应索引处添加元素
    public void insert(int index,T ele){
        if(index==0){
            Node node=new Node(ele,null,head);
            head.pre=node;
            head=node;
        }else if(index>0){
            Node node=new Node(ele,null,null);
            get(index).pre.next=node;
            node.pre=get(index).pre;
            node.next= get(index);
            get(index).pre=node;
        }
        else{
            System.out.println("索引出错！");
        }
        size++;
    }
    //显示集合
    public void show(){
        Node current=new Node();
        current=head;
        for(int i=0;i<size && current!=null;i++,current=current.next){
            System.out.println(current.data);
        }
    }
}

3、Vector集合：底层数据结构是使用数组实现的，操作和ArrayList一致，查询快，增删慢，内部线程安全，但是效率低。
4、ArrayList与LinkedList的区别
ArrayList是基于动态数组的数据结构，LinkedList是基于链表的数据结构
对于随机访问，遍历来说，ArrayList优于LinkedList,因为LinkedList需要不断通过获得当前节点得到下一节点，有点移动指针的感觉。
对于增删操作，LinkedList优于ArrayList，因为LinkedList直接可以删除当前节点或在一处插入节点，只需要修改节点的下一节点的指向就行，而ArrayList则需要对数组中的数据进行复制，或还需修改数组长度，比较浪费时间。
5）Itrator接口:用于遍历集合中的元素----->迭代器
里面的方法有：hasNext()、next()、remove()

进击的菜鸟 (..•˘_˘•..)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java集合
06-13
Java的集合类是一种特别有用的工具类，它可以用于存储数量不等的多个对象，并可以实现常用数据结构，如栈，队列等，除此之外，Java集合还可用于保存具有映射关系的关联数组。 Java的集合大致上可分为：Set,List和Map三种体系，其中Set代表无序，不可重复的集合；List代表有序，重复的集合，而Map则代表具有映射关系的集合。Queue体系集合，代表一种队列集合实现。 Java集合就像是一个容器，我们可以把多个对象（实际上是对象的引用，习惯上叫对象，）保存到集合容器中。在JDK1.5以前Java集合会丢失容器中所有对象的数据类型，把所有对象都当初object对象来处理，JDK1.5以后增加了泛型，Java集合可以记住容器中对象的数据类型。从而可以编写出更简洁，健壮的代码。
java集合 collection-list-LinkedList详解
08-31
在Java集合框架中，`List`接口是`Collection`接口的一个子接口，它代表了有序的元素列表，其中元素可以重复，并且可以通过索引来访问。`LinkedList`类是实现`List`接口的一个具体类，它提供了链表结构的数据存储方式...
JAVA 集合
weixin_43164759的博客
12-08 92
JAVA 集合 Java 集合主要包括两种类型的容器：集合（Collection）、映射（Map）。 Collection 接口又有 3 种子类型：List、Set 和 Queue。 1 List List 是有序的 Collection。有三个实现类：ArrayList、Vector 和LinkedList。 1.1 ArrayList 排列有序，可重复 底层使用数组 查询快，增删慢 线程...
JAVA集合
weixin_37784899的博客
05-12 185
JAVA集合集合Map接口Stack类Queue接口 集合 JAVA在内存中进行存储的时候主要有两个方式，数组Array和集合Collection、Map。 |–Collection接口：单列集合，用来存储一个一个的对象 |-----list接口：存储有序的，可重复的数据 -------->“动态”数组 |----------ArrayList、LinkedList、Vector |-----set接口：存储无序的，不可重复的数据 |----------HashSet、LinkedHashSet、
Java中对List集合的常用操作详解
09-02
在Java编程中，List集合是Java集合框架的重要组成部分，它是一种有序的集合，可以存储重复的元素。本文将深入解析Java中对List集合的常用操作，帮助开发者更好地理解和使用List接口。 1. **添加、获取和删除元素** ...
Java-Java集合体系-List-Set
最新发布
07-12
理解并熟练运用Java集合体系中的List、Set、Map接口及其实现类，对于日常开发和面试来说至关重要，因为它们是许多Java框架和库的基础。在实际项目中，根据需求选择合适的集合类型可以提高代码的效率和可维护性。在...
浅析Java集合及LIst接口
08-26
"Java集合及List接口详解" Java集合是Java语言中的一种数据结构，用于存储和操作数据。Java集合可以分为两大类：Collection和Map。Collection接口是所有集合的父接口，它提供了基本的集合操作，如add、remove、...
javalist.zip_list集合 java
09-23
描述中提到“java中集合list的应用非常重要”，这确实不假，因为List在处理有序数据时具有广泛的应用场景。 List接口位于java.util包下，它继承自Collection接口。Java提供了多种List的实现类，如ArrayList、...
java 集合
01-30
集合 java基础 核心技术
java 集合
04-07
NULL 博文链接：https://wuzq1223.iteye.com/blog/1564290
集合(JAVA)
有点想法的专栏
04-21 248
文章目录1.集合1.1 继承关系图1.2 介绍1.3 iterator2.List(有序、可重复)2.1 ArrayList2.1 LinkedList3.Set(无序,唯一)3.1 HashSet 1.集合 java集合体系可分为Collection与Map两种体系 java集合超详解 Java集合中List,Set以及Map等集合体系详解(史上最全) 1.1 继承关系图 1.2 介绍 Col...
Java 集合
草帽的博客
06-08 183
Java 集合
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值