Java学习笔记——集合I

最新推荐文章于 2024-01-11 17:43:02 发布
最新推荐文章于 2024-01-11 17:43:02 发布
阅读量1.2k 收藏
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beecorn/article/details/109567084
版权

Java中的集合学习笔记I

集合概述

集合分类

Java集合可以分为Collection 与 Map两个分支。Collection 存储着单列数据、Map存储着双列数据——键值（Key、Value）对的集合。其中Collection下又分为两个主要的类别。List接口（有序、可重复）、Set接口（无序不可重复）

集合整体框架

在这里插入图片描述

Iterable接口

Interface Iterable<T(迭代器返回的元素的类型)>

Iterable接口（迭代器）是一种设计模式。实现了此接口的对象可以遍历并选择序列中的对象。Collection接口与Map接口均继承了Iterable接口。实现此接口可以允许一个对象使用“for—each”循环。

for-each循环使用方法

public class CollectionNote {
    public static void main(String[] args) {
        //使用foreach循环遍历数组中的元素
        int[] ints = {1, 2, 3, 4};
        for (int i:ints) {
            System.out.print(i + "\t");
        }
    }
}

使用迭代器对象遍历集合

public class CollectionNote {
    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<Integer>();
        for (int i = 0; i < 5; i++) {
            arr.add((int)(Math.random() * 5));
        }
        //获取一个序列的迭代器对象
        Iterator<Integer> iter = arr.iterator();
        //对序列进行遍历
        while (iter.hasNext()){
            System.out.println(iter.next());
        }

    }
}

Collection接口

Collection是集合框架结构中的根接口之一。JDK之中不提供此接口的任何直接实现，而是提供了更具体的更具体的子接口的实现。这里对学习过程中最经常遇到的两个接口——List、Set整理记录。

List接口

List集合类中的元素，有序且可重复。集合中的每个元素都有其对应的顺序索引。其常见的实现类有ArrayList、LinkedList和Vector（与ArrayList类似，但线程安全）

List接口常用方法

​ *void add(int index, E element);

​ *boolean addAll(int index, Collection<? extends E> c);

​ *get(int index);

​ *remove(int index);

​ *set(int index, E element);

ArrayList

ArrayList是List接口中的主要实现类（可以把它理解为一个变长的数组）

ArrayList底层实现

ArrayList 创建初始化一个大小为0的数组，添加第一个元素是开始扩容（首次扩容容量大小为10），每次以当前数组大小1.5倍进行扩容

源码分析：成员变量与构造器

//属性
//默认初始容量
private static final int DEFAULT_CAPACITY = 10;
//空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空数组（无参构造器时调用）
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//实际存储元素的数组
transient Object[] elementData; 
//数组大小
private int size;

//构造方法
//无参构造方法 —— 生成一个空的数组
 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
//传入一个整数（初始化参数大小的数组）
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
//传入一个集合
public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

API方法

//获取集合大小
public int size() {
    return size;
}


//添加一个元素
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 需要确保当前数组未满
        elementData[size++] = e;
        return true;
    }
//添加元素到指定位置
 public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
//内部方法，确定当前数组是否未满
private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity); //如果数组已满——扩容
    }
//数组的扩容
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);  //新的数组容量扩容为原来的1.5倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
    //将原来的数组拷贝到新的数组中
        elementData = Arrays.copyOf(elementData, newCapacity);
    }


//获取指定索引上的元素
 public E get(int index) {
            rangeCheck(index);
            checkForComodification();
            return ArrayList.this.elementData(offset + index);
        }


//删除一个元素 （本质上也需要
）
public E remove(int index) {
            rangeCheck(index); //确保数组没有越界
            checkForComodification();
            E result = parent.remove(parentOffset + index);
            this.modCount = parent.modCount;
            this.size--;
            return result;
        }
CRUD时间复杂度：

​ 直接添加元素至列表的末尾：O（1）

​ 添加到指定位置（插入）O（n）

​ 获取指定索引元素 O（1）

​ 删除指定索引的元素 O（n）

LinkedList

双向链表 ，List接口的主要实现类之一，也是Deque的主要实现类。

特有相关API方法

​ 栈相关：void push（E e）将一个元素压入栈

​ E peek（） 查看栈顶元素

​ E pop（） 弹出栈顶元素

​ 双端队列相关：

​ boolean offer（E e） 向列表的尾部添加元素

​ boolean offerFirst（E e）在列表的头部插入指定元素

​ boolean offerLast （E e）在列表的尾部添加元素

​ E peek（） 检索列表的头部元素

​ E peekFirst（） 检索列表的头部元素

​ E peekLast（） 检索列表的尾部元素

​ E poll（）检索并删除列表头部元素

​ E pollFirst（） 检索并删除列表头部元素

​ E pollLast（） 检索并删除列表尾部元素

LinkedList底层实现

（1）内部类——Node（节点）

private static class Node<E> {
    E item;   //节点的值（元素本身）
    LinkedList.Node<E> next;  //指向下一个节点的指针
    LinkedList.Node<E> prev;  //指向前一个节点的指针

    Node(LinkedList.Node<E> prev, E element, LinkedList.Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

（2）成员变量 构造器

transient int size; // 维护链表的长度（元素的个数）
transient LinkedList.Node<E> first;  //头节点
transient LinkedList.Node<E> last;	//尾节点
public LinkedList() {  	//空参构造器
        this.size = 0;
    }

（3）部分API方法

//添加元素
public boolean add(E e) {
    this.linkLast(e);   //调用非公有方法linkLast
    return true;
}

void linkLast(E e) {
        LinkedList.Node<E> l = this.last; 
        LinkedList.Node<E> newNode = new LinkedList.Node(l, e, (LinkedList.Node)null);
        this.last = newNode;  //将链表的尾节点指向新添加的节点
        if (l == null) {
            this.first = newNode;   //如果链表为空，此节点亦为头节点
        } else {
            l.next = newNode;   //否则，将原尾节点的next指针指向当前节点
        }

        ++this.size;    //更新链表长度
        ++this.modCount;
    }

//删除元素
public boolean remove(Object o) {
        LinkedList.Node x;  //临时初始化一个指针
        if (o == null) {
            for(x = this.first; x != null; x = x.next) {
                if (x.item == null) {
                    this.unlink(x);
                    return true;
                }
            }
        } else {
            for(x = this.first; x != null; x = x.next) {  //从链表头开始遍历
                if (o.equals(x.item)) {		//找到指定节点
                    this.unlink(x);		//调用非公有方法 unlike
                    return true;	//删除成功返回true
                }
            }
        }

        return false;	//删除失败，返回false
    }

E unlink(LinkedList.Node<E> x) {  //非公有方法unlike
        E element = x.item;		//去除待返回的元素
        LinkedList.Node<E> next = x.next;	//两个临时指针
        LinkedList.Node<E> prev = x.prev;
        if (prev == null) {
            this.first = next;
        } else {
            prev.next = next;		//重置前一个节点的next指针
            x.prev = null;		//置空prev指针
        }

        if (next == null) {
            this.last = prev;
        } else {
            next.prev = prev;  //重置后一个节点的prev指针
            x.next = null;	//置空next指针
        }

        x.item = null;
        --this.size;	//更新链表长度
        ++this.modCount;
        return element;
    }

//查询方法

public E get(int index) {
        this.checkElementIndex(index);  //检查索引是否合法
        return this.node(index).item;	//调用非公有方法node（int index)
    }

 LinkedList.Node<E> node(int index) {   //非公有方法node（int index)
        LinkedList.Node x;
        int i;
        if (index < this.size >> 1) {  //如果索引小于长度的一半，从头开始找目标元素
            x = this.first;

            for(i = 0; i < index; ++i) {
                x = x.next;
            }

            return x;
        } else { 		///否则，从尾部开始向前寻找目标元素
            x = this.last;

            for(i = this.size - 1; i > index; --i) {
                x = x.prev;
            }

            return x;
        }
    }

//插入元素
public void add(int index, E element) {
        this.checkPositionIndex(index);  //判断索引是否合法
        if (index == this.size) {
            this.linkLast(element);		//插入到队尾
        } else {
            this.linkBefore(element, this.node(index));  //调用非公有方法linkBefore  node
        }

    }

void linkBefore(E e, LinkedList.Node<E> succ) {  //非公有方法linkBefore  （传入插入元素，与插入位置后一个节点）
        LinkedList.Node<E> pred = succ.prev;	//找到插入位置前一个节点
        LinkedList.Node<E> newNode = new LinkedList.Node(pred, e, succ);  //创建存储当前元素的节点
        succ.prev = newNode;  //重置后一个节点的prev指针
        if (pred == null) {
            this.first = newNode;  //特殊情况（插入在头节点处）
        } else {
            pred.next = newNode;  //重置前一个节点next指针
        }

        ++this.size;  //更新数组大小
        ++this.modCount;
    }
CRUD时间复杂度

​ 直接添加元素至列表的末尾：O（1）

​ 添加到指定位置（插入）O（n） 实际上也需要便遍历寻找待插入的位置。但插入本身这个操作的时间复杂度为O（1）

​ 获取指定索引元素 O（n）

beecorn
关注
专栏目录
Iterable、Collection和List
weixin_44252126的博客
03-10 530
一、介绍 Iterable、Collection和List都是Java里的接口 Iterable 接口是 Java 集合框架的顶级接口，实现此接口使集合对象可以通过迭代器遍历自身元素 Collection:public interface Collection<E>extends Iterable<E>{} Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作：添加、删除、清空、遍历(读取)、是否为空、获取大小、是否保护某元素等等 List：继承自
JAVA学习笔记——集合
weixin_43410001的博客
04-24 548
目录Java 集合框架接口、实现分离Collection 接口迭代器集合框架中的接口泛型实用方法具体的集合链表散列集树集 Java 集合框架 接口、实现分离 Java 集合框架与现代的数据结构类库的常见情况一样，类库也将接口 (interface) 与实现 (implementation) 分离。每一个实现都可以通过一个实现了该接口的类表示。在程序运行过程中，我们并不知道如何实现接口才能使程序达到最高的效率，因此将接口与实现分离，能够更有效地编写程序。 另外，利用这种方式，可以轻松地使用另外一种不同的实现。
集合I
wangzhiyong1990的专栏
06-14 634
  基本类型包装类： (1)因为基本数据类型不能做更多的操作。为了对它进行更方便的操作，Java就针对每种基本类型提供了对应的包装类。   (2)基本类型和对应的包装类： byte---- Byte short ---- Short int ------ Integer long----- Long float ----- Float double ----- Double ...
java入门---集合操作实例之集合长度
luyaran的博客
05-31 1421
    以下实例演示了如何使用 Collections 类 的collection.add() 来添加数据并使用 collection.size()来计算集合的长度：import java.util.*; public class Main {   public static void main(String [] args) {         System.out.println( "集合实例...
数据结构--Iterable、Collection、List 的常见方法签名以及含义
5:00A.M的博客
03-27 1269
【数据结构】Iterable、Collection、List 的常见方法签名以及含义
[JAVA数据结构] 认识 Iterable、Collection、List 的常见方法签名以及含义
最新发布
weixin_55250388的博客
01-11 1390
Iterable接口是Java中的一个接口，它是集合框架中的根接口之一。Iterable接口表示实现了迭代功能，即可以通过迭代器遍历其中元素的类。它定义了一个抽象方法iterator()，该方法返回一个实现了Iterator接口的迭代器对象，通过这个迭代器对象可以依次访问集合中的元素。总的来说，Iterable接口为集合类提供了统一的遍历方式，使得集合类可以通过for-each循环来遍历其中的元素，提供了更加便利和统一的遍历方式。
Java学习笔记——集合框架（HashMap）
Rokieee的博客
03-04 333
Java学习笔记——集合框架（HashMap） Map Map是一种不同与数组或者链表的一种数据结构，它是按照k-v键值对的形式来存储数据，并且它是独立于Collection的。 在平常的使用过程中，主要用到了以下三个Map的子类： HashMap：利用哈希表的形式来存放k-v键值对，在java1.7版本中利用数据-链表地数据结构进行存储，但在1.8之后利用数组-链表-红黑树地数据结构进行存储。...
廖雪峰java教程学习笔记——集合
zhang35的博客
05-30 617
定义 Java的java.util包主要提供了三种类型的集合：List、Set、Map Java集合的设计特点： 接口和实现类相分离，例如有序表的接口是List，具体的实现类有ArrayList、LinkedList等 支持泛型 访问集合总是通过迭代器 避免使用历史遗留类和接口 有一小部分集合类是遗留类，不应该继续使用： Hashtable：一种线程安全的Map实现； Vector：一种线程安全的List实现； Stack：基于Vector实现的LIFO的栈。 还有一小部分接口是遗留接口，也不应该继
Java学习笔记——良葛格
06-12
"Java学习笔记——良葛格"是一份专为初学者设计的教程资料，由良葛格精心编写，旨在帮助读者掌握JDK5.0版本的Java基础知识。JDK（Java Development Kit）是Java开发的核心工具集，包含了编译器、调试器和运行环境等...
Java学习笔记——集合之Iterable接口
Lutra的博客
08-07 3270
Iterable&lt;T&gt;接口 附上Java api在线文档地址   在jdk1.8以前的版本只有一个Iterable&lt;T&gt;方法，Java1.8接口加入了新特性，打破了Java以前对接口的定义 Iterable&lt;T&gt; 返回一个iterator&lt;T&gt;迭代器，对集合里的元素进行迭代。例： public class Test { public s...
【JavaSE】Iterable,collection以及List的常见方法签名以及含义
孙宇航的博客
06-02 383
图片: 三者的关系如图： 由图可得出 Iterable，Collection，List都是接口。文章目录Iterable是一个具有迭代功能的 泛型 接口，可以通过通过for-each循环，从从Iterable获取Iterator或者通过Iterable的for each（）方法 通过for-each循环迭代 Collection Collection继承于Iterable的泛型接口，用来实现集合的接口。 Collection的方法：List是一个接口，接口不能进行实例化，只能引用实现其接口具体的类
Iterable、Collection、List 的常见方法签名以及含义
wrywry0813的博客
01-23 456
文章目录前言一、Iterable二、Collection常见方法三、List 前言 Iterable、Collection、List 都是接口 一、Iterable Iterable是一个泛型接口 。 T是被迭代元素的类型 public interface Iterable<T> { Iterator<T> iterator(); //抽象类中的抽象方法 default void forEach(Consumer<? super T> action)
【Java】Iterable、Collection、List 的常见方法签名以及含义
m0_63036262的博客
04-05 761
1.首先谈谈什么是方法签名？ 在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就可以定义方法名相同的方法呢？ 方法签名即：经过编译器修改过之后方法最终的名字。具体方法：方法全路径名+参数列表+返回值类型，构成方法完整的名字。 2.Iterable 常见方法：Iterator<T> iterator() 返回 T类型的元素的迭代器。 Iterable是一种设计模式，开发人员无需了解序列的...
将Iterable转换为Collection的简便方法
asdfgh0077的博客
05-21 772
In my application I use 3rd party library (Spring Data for MongoDB to be exact). 在我的应用程序中，我使用第三方库（确
浅谈Java中Collection、Iterable、List、ArrayList间的关系
热门推荐
Judy_c的博客
10-13 1万+
Java是一个高级语言，它提供了很多现成的数据结构，给我们的编程带来了极大的遍历。这都是由Java编程的高手给出的，学习这里面的实现方式无论是对于我们使用这些工具还是对于掌握Java的编程之道都是很有帮助的。本文主要讲述Java中的表的实现方式。         首先来介绍Collection接口：Collection位于Java的java.util包中。顾名思义，Collection就是用来实
Java中关于Iterable、Collection、List 的简介
m0_63501066的博客
07-09 491
Java中关于Iterable、Collection、List 的简介
java 集合解析（一）collection和Iterable
小小巴的博客
09-28 1914
java 集合解析（一）collection和Iterable先上一张从网上找的图，将集合也是概括的挺详细的 从图里可以看出collection是java中的一个顶层接口，list，queue和set继承了collection接口。 既然要说的是collection，我们打开源码collection看一下。public interface Collection<E> extends Iterab
Collection容器家族(Iterable接口、Collection接口、List接口、Set接口)
IdealSpring的博客
08-17 1363
一、什么是接口？          接口中定义的是该继承体系中的扩展功能。 举个例子：(猫狗案例)         狗一般就是看门，猫一般就是作为宠物了。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中...
java 上传文件_JAVA学习笔记——fileUpload文件上传
05-17
文件上传是Web开发中常见的功能之一，Java中也提供了多种方式来实现文件上传。其中，一种常用的方式是通过Apache的commons-fileupload组件来实现文件上传。 以下是实现文件上传的步骤： 1.在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.3</version> </dependency> ``` 2.在前端页面中添加文件上传表单： ```html <form method="post" enctype="multipart/form-data" action="upload"> <input type="file" name="file"> <input type="submit" value="Upload"> </form> ``` 3.在后台Java代码中处理上传文件： ```java // 创建一个DiskFileItemFactory对象，用于解析上传的文件 DiskFileItemFactory factory = new DiskFileItemFactory(); // 设置缓冲区大小，如果上传的文件大于缓冲区大小，则先将文件保存到临时文件中，再进行处理 factory.setSizeThreshold(1024 * 1024); // 创建一个ServletFileUpload对象，用于解析上传的文件 ServletFileUpload upload = new ServletFileUpload(factory); // 设置上传文件的大小限制，这里设置为10MB upload.setFileSizeMax(10 * 1024 * 1024); // 解析上传的文件，得到一个FileItem的List集合 List<FileItem> items = upload.parseRequest(request); // 遍历FileItem的List集合，处理上传的文件 for (FileItem item : items) { // 判断当前FileItem是否为上传的文件 if (!item.isFormField()) { // 获取上传文件的文件名 String fileName = item.getName(); // 创建一个File对象，用于保存上传的文件 File file = new File("D:/uploads/" + fileName); // 将上传的文件保存到指定的目录中 item.write(file); } } ``` 以上代码中，首先创建了一个DiskFileItemFactory对象，用于解析上传的文件。然后设置了缓冲区大小和上传文件的大小限制。接着创建一个ServletFileUpload对象，用于解析上传的文件。最后遍历FileItem的List集合，判断当前FileItem是否为上传的文件，如果是，则获取文件名，创建一个File对象，将上传的文件保存到指定的目录中。 4.文件上传完成后，可以给用户一个提示信息，例如： ```java response.getWriter().write("File uploaded successfully!"); ``` 以上就是使用Apache的commons-fileupload组件实现文件上传的步骤。需要注意的是，文件上传可能会带来安全隐患，因此在处理上传的文件时，需要进行严格的校验和过滤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值