集合 复习

已于 2022-07-27 23:25:00 修改
阅读量160 收藏
点赞数
文章标签： java
于 2021-09-14 17:40:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZZR_ZZR_/article/details/120292711
版权

title: 集合复习
date: 2020/8/10

1.集合框架

|----Collection接口：单列集合，用来存储一个一个的对象

​ |----List接口：存储序的、可重复的数据。 -->“动态”数组

​ |----ArrayList、LinkedList、Vector

​ |----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”

​ |----HashSet、LinkedHashSet、TreeSet

|----Map接口：双列集合，用来存储一对（key-value）一对的数据 -->高中函数：y=f（x）

​ |—HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

注：不同的key可以对应同一个value

2. List

2.1 ArrayList

public class CollectionTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList<>();

        //add(Object e)：将元素e添加到结合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        coll.add(new person("zzr",20));

        //contains判断是否包含"AA",判断的是内容
        System.out.println(coll.contains("AA"));

        //addAll():将coll1集合中的元素添加到当前集合中
        Collection coll1 = new ArrayList<>();
        coll1.add(456);
        coll1.add("cc");
        coll.addAll(coll1);

        System.out.println(coll.size());
        System.out.println(coll);

        //isEmpty():判断结合是否为空
        System.out.println(coll1.isEmpty());

        //clear():清空集合元素
        coll.clear();
    }
}

2.2 Iterator迭代器（不是容器）

2.2.1 三种遍历方法

public class IteratorTest {
    @Test
    public void test1(){

        Collection coll = new ArrayList<>();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        coll.add(new person("zzr",20));
        coll.add(new String("Tom"));

        Iterator iterator = coll.iterator();

//        //方式一
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());


        System.out.println("-----------------------------");
//        //方式二
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }

        //方式三:hasNext如果集合李还有元素，则继续遍历
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

2.2.2 原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZrKA0tCh-1631612437005)(C:\Users\ZZR\AppData\Roaming\Typora\typora-user-images\image-20210902150455629.png)]

2.3 增强for循环遍历集合和数组

public class ForeachTest {
    @Test
    public void test(){

        Collection coll = new ArrayList<>();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        coll.add(new person("zzr",20));
        coll.add(new String("Tom"));


        //for(coll集合中元素的类型 局部变量（随便取名字） :  集合对象)
        //内部调用的是迭代器Iterator
        for(Object obj : coll){
            System.out.println(obj);
        }

        //遍历数组
        int[] arr = new int[]{1,2,3,4,5,6};
        for (int i: arr) {
            System.out.println(i);
        }
    }
}

2.4 List接口常用方法

ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] （数组）elementData存储

分析：对数组的删除，需要被删除元素后的所有元素前移，对数组的增加，需要被添加元素后的所有元素后移，效率低

LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储

分析：双向链表的删除和增加元素，只跟该元素的前后位置有关

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4TxptgNF-1631612437008)(C:\Users\ZZR\AppData\Roaming\Typora\typora-user-images\image-20210902153936047.png)]

Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

相同点：三个类都是实现了List接口，存储数据的特点相同：存储序的、可重复的数据

2.4.1 ArrayList的源码分析

2.1 jdk 7情况下

ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData

list.add(123);//elementData[0] = new Integer(123);

list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。

默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

2.2 jdk 8中ArrayList的变化

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
后续的添加和扩容操作与jdk 7 无异。

2.3 小结：

jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

当不涉及大量插入和删除时候，用ArrayList，不用维护指针，有下标，查找更简单

2.4.2 LinkedList的源码分析

LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null

list.add(123);//将123封装到Node中，创建了Node对象。
其中，Node定义为：体现了LinkedList的双向链表的说法
  
private static class Node<E> {
     E item;
     Node<E> next; 
     Node<E> prev;
```
 Node(Node<E> prev, E element, Node<E> next) {
 this.item = element;
 this.next = next;
 this.prev = prev;
 }
```
 }

2.4.3 Vector的源码分析：

jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。

2.5 List遍历及方法

增删改查、插入、遍历、长度

public class ListTest {
    @Test
    public void test(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new person("zzr",20));

        System.out.println(list);

        //1.void add(int index,Object ele):在index位置插入ele元素
        list.add(1,"BB");

        System.out.println(list);


        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list);

        //2.Object get(int index):获取指定index位置的元素
        System.out.println(list.get(2));

        //3.int indexof(Object obj):返回obj在集合中首次出现的位置,不存在则返回-1
        int index = list.indexOf(456);
        System.out.println(index);

        //4.Object remove(int index):移除指定index位置的元素，并返回此元素
        list.remove(1);
        //按照对象删除
        list.remove("AA");
        list.remove(new Integer(123));
        System.out.println(list);

        //5.Object set(int index,Object ele):设置指定index位置的元素为ele
        list.set(2,"张子然");
        System.out.println(list);

        //6.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
    }
}

3. set接口

|----Collection接口：单列集合，用来存储一个一个的对象

​ |----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”

​ |----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值

​ |----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历

​ 在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。对于频繁的遍历操作，LinkedHashSet效率高于HashSet.

​ |----TreeSet：可以照添加对象的指定属性，进行排序。（必须是相同类型）

3.1 元素添加的过程

例如：插入数据a：计算a所在类的哈希值->某种算法计算位置->若该位置上为空，则直接插入成功，若位置上已经有元素b（此时a和b的哈希值不一定一样）->比较a和b的哈希值->若a和b的哈希值不一样则通过链表的形式添加a，若哈希值一样，则调用equals方法，若返回TRUE，则添加失败，若返回false，则添加成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KIluPpCd-1631612437009)(C:\Users\ZZR\AppData\Roaming\Typora\typora-user-images\image-20210902191713923.png)]

元素添加过程：(以HashSet为例)

我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置，判断
数组此位置上是否已经元素：
如果此位置上没其他元素，则元素a添加成功。 —>情况1
如果此位置上其他元素b(或以链表形式存在的多个元素，则比较元素a与元素b的hash值：
如果hash值不相同，则元素a添加成功。—>情况2
如果hash值相同，进而需要调用元素a所在类的equals()方法：
equals()返回true,元素a添加失败
equals()返回false,则元素a添加成功。—>情况2

对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素(新的元素放到数组中)。
jdk 8 :原来的元素在数组中，指向元素a
总结：七上八下

HashSet底层：数组+链表的结构。（前提：jdk7)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rx7o8HLQ-1631612437010)(C:\Users\ZZR\AppData\Roaming\Typora\typora-user-images\image-20210902192534915.png)]

3.2 Treeset的排序

3.2.1 自然排序（对象User实现Comparable接口，重写compareTo方法）

3.2.2 定制排序（重写compare方法如果没写定制排序，则默认自然排序）

    @Test
    public void test2(){
        Comparator com = new Comparator() {
            //照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else{
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };
    
     TreeSet set = new TreeSet(com);
    set.add(new User("Tom",12));
    set.add(new User("Jerry",32));
    set.add(new User("Jim",2));
    set.add(new User("Mike",65));
    set.add(new User("Mary",33));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));
    
     Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

注：

TreeSet:
1.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
2.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().

4.0 Map接口

|----Map:双列数据，存储key-value对的数据 —类似于高中的函数：y = f(x)

​ |----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value

​ |----LinkedHashMap:保证在遍历map元素时，可以照添加的顺序实现遍历。

​ 原因：在原的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。

​ |----TreeMap:保证照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序底层使用红黑树

​ |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value

​ |----Properties:常用来处理配置文件。key和value都是String类型

  •  HashMap的底层：数组+链表  （jdk7及之前)

  •                数组+链表+红黑树 （jdk 8)

4.1 key-value的特点

key用set存储，无序，不可重复

value用collection存储，无序可重复

Entry=key+value，无序，不可重复，用set存储

Map中的key:无序的、不可重复的，使用Set存储所的key —> key所在的类要重写equals()和hashCode() （以HashMap为例)
Map中的value:无序的、可重复的，使用Collection存储所的value —>value所在的类要重写equals()
一个键值对：key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的，使用Set存储所的entry

4.2 HashMap

4.2.1 HashMap在jdk7中实现原理

HashMap map = new HashMap():

在实例化以后，底层创建了长度是16的一维数组Entry[] table。

…可能已经执行过多次put…

map.put(key1,value1):

首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。

如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1

如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：

如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2

如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：

如果equals()返回false:此时key1-value1添加成功。----情况3

如果equals()返回true:使用value1替换value2。

补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原的数据复制过来。

4.2.2 HashMap在jdk8中实现原理

HashMap在jdk8中相较于jdk7在底层实现方面的不同：

  1. new HashMap():底层没创建一个长度为16的数组
  2. jdk 8底层的数组是：Node[],而非Entry[]
  3. 首次调用put()方法时，底层创建长度为16的数组
  4. jdk7底层结构只：数组+链表。jdk8中底层结构：数组+链表+红黑树。
    4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
    4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

4.2.3 HashMap底层典型属性的属性的说明

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

4.3 LinkedHashMap的底层实现原理

LinkedHashMap底层使用的结构与HashMap相同，因为LinkedHashMap继承于HashMap.
区别就在于：LinkedHashMap内部提供了Entry，替换HashMap中的Node.

4.4 TreeMap的使用

向TreeMap中添加key-value，要求key必须是由同一个类创建的对象,因为要照key进行排序：自然排序 、定制排序.

4.5 Map的使用

增删改查长遍

@Test
public void test1(){
    Map map = new HashMap();

    //添加Object put(Object key,Object value):将指定key-value添加到（或修改）当前map对象中
    map.put("AA", 123);  //key一般是String，value一般是Integer
    //key一样，体现为修改
    map.put("AA", 130);
    map.put(123, "AA");
    System.out.println(map);

    Map map1 = new HashMap();
    map.put("CC", 123);
    map.put("DD", 123);
    //void putAll(Map m);将m中的所有key-value对存放到当前map中
    map.putAll(map1);
    System.out.println(map);

    //remove按key删除
    Object value = map.remove("CC");
    System.out.println(value);

    System.out.println(map);

    //clear清空
    map.clear();
    System.out.println(map);
}

@Test
public void test2(){
    Map map = new HashMap();
    map.put("AA", 123);
    map.put(45, 123);
    map.put("BB", 123);

    System.out.println(map);

    // Object get(Object key):获取指定key对应的value
    System.out.println(map.get(45));

    //containsKey(Object key):找key是否存在
    boolean bb = map.containsKey("BB");
    System.out.println(bb);

    //
    boolean b = map.containsValue(123);
    System.out.println(b);
}

@Test
public void test3(){
    Map map = new HashMap();
    map.put("AA", 123);
    map.put(45, 123);
    map.put("BB", 123);

    //遍历所有的key集：keySet()
    Set set = map.keySet();
    Iterator iterator = set.iterator();

    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }

    //遍历所有的value集：values()
    Collection values = map.values();

    for ( Object obj: values) {
        System.out.println(obj);
    }

    //遍历所有的key-value
    //entrySet():
    Set entrySet = map.entrySet();

    for (Object obj:entrySet
         ) {
        System.out.println(obj);
    }
}

5.Collections工具类

5.1.作用：

操作Collection和Map的工具类

5.2.常用方法：

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值

5.3 Collection 和 Collections的区别？

Collections 是一个操作 Set、List 和 Map 等集合的工具类

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，

还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
st，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值

5.3 Collection 和 Collections的区别？

Collections 是一个操作 Set、List 和 Map 等集合的工具类

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，

还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

ZZ?R
关注
Map集合
weixin_55830623的博客
06-22 304
​ HashMap 与 与 Hashtable 的区别 No. 区别点 HashMap Hashtable 1 推出时间 JDK1.2推出的新的操作类 JDK1.推出的旧的操作类 2 性能 异步处理，性能较高 同步处理，性能较低 3 null 允许设置为null 不能设置，否则将出现空指针异常 排序的子类：TreeMap 常用方法 V put(K key,V value)：向集合中增加内容 V get(Object key) ：根据 key 找到其对应的 value package lesson4_3
集合的学习
weixin_59347653的博客
08-06 724
学习笔记
Collection 中的简单命令
Bug_marker的博客
08-09 242
'当key是自定义的对象时，重写hashCode() 和 equals() 方法。：从Java 1.2开始，该类改进了List接口，与新的集合实现不同， Vector被同步。TreeSet：底层是二叉树，可以对 set 集合中的元素进行排序，元素有序、线程不同步。2、迭代的过程中不能使用集合本身的增删方法来操作集合。返回map集合中的所有value值，保存到Collection集合中。返回map集合中的所有key值，保存到Set集合中。返回Map集合中的键值对对象到Set集合中。'用于遍历Map集合操作。
Java中List常用API整理
想要上南大的同学的博客
12-03 3619
Java中List常用API整理 List接口是继承Collection接口，所以Collection集合中有的方法，List集合也继承过来。 1 collection的API介绍 1.1 boolean add(E e) 添加元素到Collection集合中。 1.2 boolean addAll(Collection<? extends E> c) 将指定c中的所有元素都添加到此Collection集合中。 1.3 void clear() 移除此collection集合中的所有元素
Collection集合容器基础讲解
听海的博客
03-19 1610
1.简介 Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。 2.图解 即：...
mybatis plus查询条件拼接
job_csdn的博客
02-20 3517
mybatisplus 的拼接条件in、eq 的基本使用
集合学习（二）
lyy07210的博客
03-01 369
LinkedList介绍 LinkedList使用示例： LinkedList<Integer> linkedList = new LinkedList<>(); linkedList.add(12); linkedList.add(23); linkedList.add(45); linkedList.add(23); linkedList.add(null); Iterator&lt
中职数学集合复习课PPT课件.pptx
10-07
中职数学集合复习课PPT课件 知识点一：集合的表示方法 集合可以用三种方法表示： 列举法：将集合的元素一一列举出来，写在大括号中。适用于有限集。 描述法：用确定条件表示某些对象是否属于这个集合。适用...
E04_集合复习.pdf
11-02
集合是Java编程中不可或缺的一部分，它们提供了存储和操作对象的有效方式。在Java中，单列集合的顶层接口是`Collection`，它包含了所有单个元素的集合，如`List`和`Set`。双列集合的顶层接口是`Map`，用于存储键值对...
数学集合复习课北师必修PPT学习教案.pptx
10-05
在这个北师大必修的数学集合复习课中，我们主要关注以下几个知识点： 1. **列举法表示集合**： 集合可以用列举法来表示，即将集合内的所有元素一一列出。例如，集合`{(2,4), (5,2), (8,0)}`表示一个由有序对组成的...
集合复习总结PPT课件.pptx
10-10
这篇文档实际上是一个集合理论的复习材料，主要涵盖了集合的一些基本概念和运算。下面是对这些知识点的详细解释： 1. **集合元素的特性**：集合中的元素具有三个特性，分别是确定性、无序性和互异性。确定性指的是...
高一集合复习.doc
11-13
这些题目覆盖了集合的基本性质、运算、不等式解集的表示以及集合与实际问题的结合，是高一数学复习的重要内容。通过解决这些问题，学生可以加深对集合理论的理解，提高逻辑推理和问题解决能力。
Mapped Statements collection already contains value for***
王树钰的博客
10-18 9169
mybatis使用过程中出现Mapped Statements collection already contains value for 最常规的原因： id 重复：同一个文件中有两个相同的id 但是： 有的时候id不重复也会出现上面的错误比较坑的一个问题，需要认真排查相关参数 1.parameterMap改成parameterType... 2. resultType参数有
java之collection总结
basycai的博客
07-06 6759
java.util。 线性表，链表，哈希表是常用的数据结构 Collection 主要方法: boolean add(Object o)添加对象到集合 boolean remove(Object o)删除指定的对象 int size()返回当前集合中元素的数量 boolean contains(Object o)查找集合中是否有指定的对象 boolean isEmpty()判断集合
Collection集合
热门推荐
不再想当菜鸟了
07-17 1万+
计算机领域的定义 Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 coll
海量数据存储之Key-Value存储简介
weixin_30851409的博客
04-04 1365
转自：http://forchenyun.iteye.com/blog/744935 Key-value存储简介 具备高可靠性及可扩 展性的海量数据存储对互联网公司来说是一个巨大的挑战，传统的数据库往往很难满足该需求，并且很多时候对于特定的系统绝大部分的检索都是基于主键的的查 询，在这种情况下使用关系型数据库将使得效率低下，并且扩展也将成为未来很大的难题。在这样的情况...
JavaSE集合练习题
天问的博客
04-18 1636
JavaSE集合练习题简答编程参考文献 简答 1.Collection 和 Collections的区别 解：Collection是集合类的上级接口，继承于他的接口主要有 Set 和 List Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作 2.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别 解：Set里的元素是不能重复的，用equals()方法判读两个Set是否相等 equals(
JavaSE集合练习
weixin_51985152的博客
03-15 967
集合练习实验要求实验过程 实验要求 1、集合Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？​ 2、ArrayList,LinkedList,Vector三者的相同点和不同点​ 3、List接口的常用方法有哪些​ 4、Set存储数据的特点是什么？有哪些实现类，简述各实现类的特点​ 5、如何去除list中重复的数据​ 6、创建一个List集合的对象，添加几个数字，反转对象中元素的顺序；根据元素的自然顺序排序​ 7、一组数列A[25,36,17,23,14] ,一组数列B[1
Java企业面试题3
最新发布
m0_74972727的博客
09-15 388
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Java集合与泛型复习：接口、异常与数据结构
本资源是一份关于集合复习的详细讲解，主要涵盖了Java集合框架中的关键知识点。首先，单列集合（如List）的顶层接口是`Collection`，而双列集合（如Map）的顶层接口则是`Map`。在编程中，通过`Collection<String> c ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值