Java集合（1）——基础介绍（1）——集合框架、Collection接口、Iterator接口、泛型

最新推荐文章于 2021-09-05 16:14:26 发布
最新推荐文章于 2021-09-05 16:14:26 发布
阅读量260 收藏
点赞数
分类专栏： # Java容器及源码剖析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34805255/article/details/90256702
版权

目录

1.集合的概述

2.集合框架图

3.Collection接口

（1）常用方法

（2）方法使用演示

4.Iterator接口

5.增强for循环

6.泛型

（1）什么是泛型

（2）创建集合对象时使用和不使用泛型的对比

（3）泛型的定义和使用

1）泛型类的定义和使用

2）含有泛型的方法定义和使用

3）泛型接口的定义与使用

（4）泛型通配符的使用

1）通配符基本使用

2）通配符高级使用----受限泛型

1.集合的概述

集合、数组都是对多个数据进行存储操作的结构，简称Java容器

  • 说明：此时的存储，指的是内存层面的存储，不涉及到持久化的存储

集合和数组既然都是容器，它们有啥区别呢？

  • 数组的长度是固定的。集合的长度是可变的。
  • 数组中存储的是同一类型的元素，可以存储基本数据类型值，也可以存储对象
int []arr = new int[10];

Student []arr = new Student[10];
  • 集合只能存储对象，而且对象的类型可以不一致，而对于基本类型可以使用它的包装类存储。在开发中一般当对象多的时候，使用集合进行存储。
ArrayList<Student>

//对于基本类型，可以使用它的包装类来存储
ArrayList<Integer>
  • 数组中提供的方法非常有限，对于添加、删除、插入数据、获取数组中实际元素的个数的需求等都没有现成的属性和方法可用
  • 数组中存储数据的特点是：有序（按照索引有顺序的存放），可重复（元素可以相同），对于无序、不可重复的需求，不能满足

集合应用的简单场景举例：

2.集合框架图

说明：下图来源于http://www.cnblogs.com/xiaoxi/p/6089984.html

所有集合类都位于java.util包下，集合按照其存储结构可以分为两大类，分别是

  • 单列集合java.util.Collection
  • 双列集合java.util.Map

3.Collection接口

Collection是所有单列集合的父接口，Collection接口有两个主要的子接口List和Set，注意Map不是Collection的子接口

（1）常用方法

public boolean add(E e)： 把给定的对象添加到当前集合中。

public void clear() :清空集合中所有的元素。

public boolean remove(E e): 把给定的对象在当前集合中删除。

public boolean contains(E e): 判断当前集合中是否包含给定的对象。

public boolean isEmpty(): 判断当前集合是否为空。

public int size(): 返回集合中元素的个数。

public Object[] toArray(): 把集合中的元素，存储到数组中。

public Iterator<E> iterator():返回在此 collection 的元素上进行迭代的迭代器。（在后文中演示）

（2）方法使用演示

package Collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo1 {
    public static void main(String[] args) {
        //创建集合对象，可以使用多态
        Collection<String> coll =new ArrayList<>();
        System.out.println(coll); //重写了toString方法

        //1.演示add
        System.out.println("-----------1.演示add---------");
        boolean b1=coll.add("张三");
        System.out.println(b1);

        coll.add("李四");
        coll.add("王五");
        System.out.println(coll);

        //2.演示remove
        System.out.println("-----------2.演示remove---------");
        boolean b2=coll.remove("王五");
        System.out.println(b2);

        boolean b3=coll.remove("李五");
        System.out.println(b3);

        //3.演示contains
        System.out.println("-----------3.演示contains---------");
        boolean b4=coll.contains("赵四");
        System.out.println(b4);

        //4.演示isEmpty
        System.out.println("-----------4.演示isEmpty---------");
        boolean b5=coll.isEmpty();
        System.out.println(b4);

        //5.演示size
        System.out.println("-----------5.演示size---------");
        int size=coll.size();
        System.out.println("size:"+size);

        //6.演示toArray
        System.out.println("-----------6.演示toArray---------");
        Object[] arr=coll.toArray();
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }

        //7.演示clear
        coll.clear();
        System.out.println(coll);
        System.out.println(coll.isEmpty());
        
    }
}

4.Iterator接口

集合有很多种，每种集合的存储方式不同，取出元素的方式不一样，于是就出现了迭代器，迭代器是一种通用的取出集合中元素的方式

注意，在Java中迭代器是仅仅是Collection集合元素的通用获取方式，不能用于Map，因为Collection实现了Iterable接口，而Iterable就是定义的就是返回迭代器的方法

      

在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

注意：Iterator是一个接口，我们无法直接使用，需要使用Iterator实现类对象，我们可以使用Collection的iterator返回一个迭代器的实现类对象

Iterator接口的常用方法如下：

public E next():返回迭代的下一个元素。

public boolean hasNext():如果仍有元素可以迭代，则返回 true。

迭代器的使用演示：

package Collection;

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

/**
 * java.util.Iterator接口
 */
public class IteratorDemo1 {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        coll.add("Jack");
        coll.add("Mark");
        coll.add("LiLy");
        coll.add("Lucy");

        //1.使用Collection的方法iterator()来获取迭代器的实现类对象，使用Iterator接口接收（多态），并且迭代器是有泛型的，
        //迭代器的泛型跟着集合的泛型走
        Iterator<String> iter= coll.iterator();
        //2.使用Iterator接口中的方法hasNext()判断有没有下一个元素
        while(iter.hasNext())
        {
            //3.使用Iterator接口中的方法next()取出集合中的下一个元素
            String e=iter.next();
            //注意next函数每被调用一次都会让迭代器的指针向后迭代1,所以不要在循环中多次使用next函数
            //当后面要多次使用下一个元素的值时，应该先用一个局部变量保存next()的返回值，
            // 再操作局部变量，而不是在使用时每次调用next函数
           System.out.println(e);
        }
        
        /*
        //for循环的使用方式
        for(Iterator iter=coll.iterator();iter.hasNext();)
        {
            String s=iter.next();
            System.out.println(s);
        }
         */
        
    }
}

迭代器的原理剖析：

注意：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发java.util.NoSuchElementException没有集合元素的错误。

5.增强for循环

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

 for(元素的数据类型 变量 : Collection集合or数组)
{ 
    //写操作代码 
}

可以看到只要实现了Iterable对象，就可以使用增强for循环遍历，

从前文中可以看到Collection实现了Iterable，所以所有的单列集合即Collection以及其实现类对象就可以使用增强for循环遍历

总结：增强for循环只能用来遍历数组和单列集合

遍历数组示例：

...... 

        int[] arr={1,2,3,4,5};
        for(int i:arr)
        {
            System.out.println(i);
        }
......

遍历集合示例：

......      
     Collection<String> coll=new ArrayList<>();
        coll.add("Jack");
        coll.add("Mark");
        coll.add("LiLy");
        coll.add("Lucy");

        for(String s:coll)
        {
            System.out.println(s);
        }
......

6.泛型

（1）什么是泛型

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型

泛型是将数据类型参数化，可以看成是一个形参变量，在给它传参的时候只能传递数据类型 

注意：泛型只能是引用类型，不能是基础类型

示例：

如下，ArrayList在定义的时候不知道集合中都会存储什么类型的数据，所以类型使用泛型

//E：未知的数据类型
public class ArrayList<E>
{
    public boolean add(E e){}
    public E get(int index){}  
}

创建集合对象的时候，就会确定泛型的数据类型

（2）创建集合对象时使用和不使用泛型的对比

创建时不使用泛型：

  • 好处:
  •             集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
  • 弊端:
  •             不安全,会引发异常
package Generic;

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

public class GenericDemo1 {
    public static void main(String[] args) {
        show01();
    }

    /*
        创建集合对象,不使用泛型
        好处:
            集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
        弊端:
            不安全,会引发异常
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        //使用迭代器遍历list集合
        //获取迭代器
        Iterator it = list.iterator();
        //使用迭代器中的方法hasNext和next遍历集合
        while(it.hasNext()){
            //取出元素也是Object类型
            Object obj = it.next();
            System.out.println(obj);

            //想要使用String类特有的方法,length获取字符串的长度;不能使用  多态 Object obj = "abc";
            //需要向下转型
            //会抛出ClassCastException类型转换异常,不能把Integer类型转换为String类型
            String s = (String)obj;
            System.out.println(s.length());
        }
    }
}

创建时使用泛型：

  • 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
  • 避免了类型强转的麻烦。
package Generic;

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

public class GenericDemo1 {
    public static void main(String[] args) {
        show01();
    }

    /*
        创建集合对象,使用泛型
        好处:
            1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型
            2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)
         弊端:
            泛型是什么类型,只能存储什么类型的数据
     */
    private static void show01() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        //list.add(1);//add(java.lang.String)in ArrayList cannot be applied to (int)

        //使用迭代器遍历list集合
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s+"->"+s.length());
        }
    }
}

注意：泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。

（3）泛型的定义和使用

1）泛型类的定义和使用

定义格式：

修饰符 class 类名<代表泛型的变量> { }

示例：

package Generic;

public class GenericDemo2 {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass gc = new GenericClass();
        gc.setName("只能是字符串");
        Object obj = gc.getName();

        //创建GenericClass对象,泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);

        Integer name = gc2.getName();
        System.out.println(name);

        //创建GenericClass对象,泛型使用String类型
        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("小明");
        String name1 = gc3.getName();
        System.out.println(name1);
    }
}


class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

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

2）含有泛型的方法定义和使用

定义格式：

 修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
            方法体;
        }

示例：

package Generic;

/*
    测试含有泛型的方法
 */
public class GenericDemo3 {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();

        /*
            调用含有泛型的方法method01
            传递什么类型,泛型就是什么类型
         */
        gm.method01(10);
        gm.method01("abc");
        gm.method01(8.8);
        gm.method01(true);

        gm.method02("静态方法,不建议创建对象使用");

        //静态方法,通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);
    }
}


/*
    定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间

    格式:
        修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
            方法体;
        }

    含有泛型的方法,在调用方法的时候确定泛型的数据类型
    传递什么类型的参数,泛型就是什么类型
 */
class GenericMethod {
    //定义一个含有泛型的方法
    public <M> void method01(M m){
        System.out.println(m);
    }

    //定义一个含有泛型的静态方法
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

3）泛型接口的定义与使用

示例：

定义一个含有泛型的接口

package Generic;

/*
    定义含有泛型的接口
 */
public interface GenericInterface<E> {
    public abstract void method(E e);
}

实现方式1：

package Generic;

/*
    含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
    public interface Iterator<E> {
        E next();
    }
    Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认就是String
    public final class Scanner implements Iterator<String>{
        public String next() {}
    }
 */
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

实现方式2：

package Generic;

/*
    含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
    就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
    public interface List<E>{
        boolean add(E e);
        E get(int index);
    }
    public class ArrayList<E> implements List<E>{
        public boolean add(E e) {}
        public E get(int index) {}
    }
 */
public class GenericInterfaceImpl2<E> implements GenericInterface<E> {
    @Override
    public void method(E e) {
        System.out.println(e);
    }
}

测试类：

package Generic;

/**
 * 测试含有泛型的接口
 */

public class GenericDemo4 {
    public static void main(String[] args) {

        GenericInterfaceImpl1 geninter1=new GenericInterfaceImpl1();
        geninter1.method("字符串");

        GenericInterfaceImpl2<Integer> geninter2=new GenericInterfaceImpl2<>();
        geninter2.method(100);

        GenericInterfaceImpl2<Double> geninter3=new GenericInterfaceImpl2<>();
        geninter3.method(12.1);

    }
}

（4）泛型通配符的使用

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

1）通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

示例：

package Generic;

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

/*
    泛型的通配符:
        ?:代表任意的数据类型
    使用方式:
        不能创建对象使用
        只能作为方法的参数使用
 */
public class GenericDemo5 {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("b");

        printArray(list01);
        printArray(list02);

        //定义泛型的时候不能使用泛型通配符
        //ArrayList<?> list03 = new ArrayList<?>();
    }

    /*
        定义一个方法,能遍历所有类型的ArrayList集合
        这时候我们不知道ArrayList集合使用什么数据类型,可以泛型的通配符?来接收数据类型
        注意:
            泛型没有继承概念的，Collection list = new ArrayList();这种是错误的。
     */
    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历集合
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            //it.next()方法,取出的元素是Object,可以接收任意的数据类型
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

2）通配符高级使用----受限泛型

上述在使用泛型时传递给泛型的数据类型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中使用泛型时可以指定一个泛型的上限和下限。

泛型的上限：

  • 格式： 类型名称 <? extends 类 > 对象名称
  • 意义： 只能接收该类型及其子类

泛型的下限：

  • 格式： 类型名称 <? super 类 > 对象名称
  • 意义： 只能接收该类型及其父类型

示例：

package Generic;

import java.util.ArrayList;
import java.util.Collection;

public class GenericDemo6 {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();

        getElement1(list1);
        //getElement1(list2);//报错
        getElement1(list3);
        //getElement1(list4);//报错

        //getElement2(list1);//报错
        //getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);

        /*
            类与类之间的继承关系
            Integer extends Number extends Object
            String extends Object
         */

    }
    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}
}

 

喵的波波鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java之集合的顶层父接口： Collection，list子接口：Arraylist、Linkedlist、Vector的使用
yalu_123456的博客
05-20 1453
对象数组的概述和使用 案例： 需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。 学生：Student 成员变量：name,age 构造方法：无参,带参 成员方法：getXxx()/setXxx() 存储学生的数组?自己想想应该是什么样子的? public class Student { private String name; priva...
JAVA集合框架
06-01
1. **集合框架接口**： - `Collection`是最基础的集合接口，它定义了一个对象集合，可以包含任何类型的对象。`Collection`接口提供了添加、删除和遍历元素的方法。`Collection`接口还有两个重要的子接口——`Set`和...
java单值集合的父接口,JAVA类集框架主要接口
weixin_27573409的博客
03-15 260
13.1.2 类集框架主要接口在整个Java类集中最常使用的类集接口是：Collection、List、Set、Map、Iterator、ListIterator、Enumeration、SortedSet、SortedMap、Queue、Map.Entry，这些接口的具体特点如表13-1所示。表13-1 类集框架接口的具体特点序 号接 口描 述1Collection是存放一...
java中集合的接口和类
crazy_yyyyy的专栏
05-15 1469
最近在一篇博客中看到的关于JAVA集合类的总结，从中把结论摘取出来了，跟大家分享一下： 1、List接口 List 关心的是索引，与其他集合相比，List特有的就是和索引相关的一些方法：get(int index) 、 add(int index,Object o) 、 indexOf(Object o) 。 ArrayList 可以将它理解成一个可增长的数组，它提供快速迭代和快速随机访
java中常用集合类，接口
Wild
09-03 1024
为什么要使用集合类    当你事先不知道要存放数据的个数，或者你需要一种比数组下标存取机制更灵活的方法时，你就需要用到集合类。    理解集合类    集合类存放于java.util包中。    集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference）。    集合类型主要有3种：set（集）、list（列表）和
java集合框架
lllwwyy的博客
09-05 95
常用的集合类 Map接口和Collection接口是所有集合框架的父接口 Collection接口是List Queue Set的父接口 Map接口的实现类主要包括HashMap、TreeMap、HashTable、ConcurrentHashMap等 Set接口的实现有HashSet、TreeSet、LinkedHashSet等 List接口的实现类有ArrayList、LinkedList、Vector等 集合框架的底层数据结构 List接口（有序重复 索引访问）按照 添加顺排列 ArrayL
Java 实例 - 集合长度源代码-详细教程.zip
最新发布
08-09
1. **集合接口**：Java集合框架主要包括两种基本接口——`List`和`Set`。`List`接口存储有序的元素，允许重复；`Set`接口存储不重复的元素。此外，还有`Queue`、`Deque`等其他接口。 2. **实现类**：Java提供了多种...
java技巧java中可以用来循环遍历任何一个集合的通用方法
03-31
集合框架是Java中非常基础且重要的组成部分之一，它提供了存储和管理对象的强大工具。在实际开发中，我们常常需要遍历集合中的每一个元素来进行数据处理或逻辑运算。因此，掌握一种高效且灵活的遍历方式显得尤为重要...
2JAVA编程高级-集合类.pdf
07-29
`Collection`接口是Java集合框架的核心接口之一，它是所有集合类的根接口。该接口定义了一组对象的通用操作，并且是`Set`和`List`接口的父接口。 **Collection接口的主要特点**： - 可以存放不同类型的数据。 - 子...
JAVA_Collection框架
11-08
1. **接口层次**：在 Java Collection 框架中，主要有两大顶级接口——`Collection` 和 `Map`。 - `Collection` 接口主要处理单个对象的集合，而 `Map` 接口则用于处理键值对的形式。 - `Collection` 接口有两个子...
java集合相关类与接口
jessieca的专栏
11-16 868
   Collection├List│├LinkedList│├ArrayList│└Vector│　└Stack└SetCollection接口　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供
mysql创建集合collection,Java——Collection集合、迭代器、泛型
weixin_33628926的博客
03-23 264
集合——集合就是java提供的一种容器，可以用来存储多个数据。集合和数组的区别数组的长度是固定的。集合的长度是可变的。数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。接口继承关系与实现集合类存放于 Java.util 包中，主要有 3 种：set(集)、list(列表包含 Queue)和 map(映射...
Java集合父类接口的中常用方法
Less的博客
06-01 357
Collection接口中常用方法： 1). public boolean add(E e) ： 把给定的对象添加到当前集合中 。 2). public void clear() :清空集合中所有的元素。 3). public boolean remove(E e) : 把给定的对象在当前集合中删除。如果有多个重复元素，只删除第一个。 底层是基于：对象的equals()方法先进行比较查询，查到后再删除。 4). public boolean contains(Object obj) : 判断当前集合中
Java之集合框架 常用接口的继承、实现关系图
笑笑是一个码农
03-18 1856
Collection接口：Map&lt;k,v&gt;接口：
集合类的接口和类层级结构图及示例程序
young4u
12-04 2520
1. Collection和Collections     首先，我们要清楚”Collection“和”Collections“是两个不同的概念。你可以从下面的层次结构图中看出，”Collection“是Collection层次结构中的根级接口，而”Collections“只是提供一些静态方法的类，这些方法是用于操作一些Collection类型的数据的。 2. Collection的类
11、集合类
雪龙的学习历程
01-23 460
------- android培训、java培训、期待与您交流！ ---------- 为什么出现集合类？  面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。 数组和集合类同是容器，有何不同？     数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。     数组中可以存储基本数据类型，集合
java 的接口到底起什么作用
罗罗的专栏
01-04 1647
我想，可能不止我一个人有这个疑问，所以，把它贴出来。 　　下面是madai和clkrst给我的回答。 　　在此谢谢两位。 　　我的问题是： 　　java 的接口到底起什么作用？  　　1、从书中看到的是java程序的接口中只定义了常量及空方法，空的方法有什么用呢？还要在类中写方法体，那还要接口干什么？ 　　2、一个程序中写了2个接口，并在同一个类中写
类和接口
it_lele的博客
09-14 194
public class Employee extends Person {//继承父类的子类 private String company;//定义的属性 private String specialTechnical; private String position;  public Employee(String myCompany,//返回值 函数名 String mySpecia
Java常见集合接口的比较与区别
bangboom666的博客
07-11 820
1.ArrayList VS HashSetArrayList: 有顺序HashSet: 无顺序List中的数据可以重复Set中的数据不能够重复重复判断标准是:首先看hashcode是否相同如果hashcode不同，则认为是不同数据如果hashcode相同，再比较equals，如果equals相同，则是相同数据，否则是不同数据2.ArrayList VS LinkedListArrayList 插...
Java集合框架与泛型基础教程
在Java中，集合框架的核心接口包括Collection、Map以及Iterator。 Collection接口是所有单值容器的基础，它定义了基本的操作如添加、删除元素，检查元素存在性，以及获取元素数量等。此外，Collection接口还引入了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值