java集合-尚硅谷学习笔记

第十一章集合

Java集合框架概述

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

说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（txt.jpg...avi，数据库中）

2.1 数组在存储多个数据方面的特点：

一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
- 比如：String[] arr; int[] arr1; Object[] arr2;

2.2 数组在存储多个数据方面的缺点：

一旦初始化以后，其长度就不可修改。
- 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

集合框架

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

|----List接口：存储有序的，可重复的数据。-->“动态”数组
- |----ArrayList、LinkedList、Vector
|----Set接口：存储无序的、不可重复的数据-->高中讲的“集合”
- |----HashSet、LinkedHashSet、TreeSet

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

|----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

Collection接口方法

向Collection接口的实现类的对象中添加数据obj时，要求obj所在的类要重写equals()。

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());
    
    //size():获取添加的元素的个数
    System.out.println(coll.size());//4
    
    //addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
    Collection coll1 = new ArrayList();
    coll1.add(456);
    coll1.add("cc");
    coll.addAll(coll1);
    
    System.out.println(coll.size());//6
    System.out.println(coll);
    
    //clear();清空集合元素
    //与coll=null不同，没有空指针
    coll.clear();
    
    //isEmpty():判断当前集合是否为空
    System.out.println(coll.isEmpty());
  }
  @Test
  public void test2(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    Person p = new Person("Jerry",20);
    coll.add(p);
    //coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    
    //1.contains(Object obj):判断当前集合中是否包含obj
    //我们在判断时会调用obj对象所在类的equals()
    boolean contains = coll.contains(123);
    System.out.println(contains);//true
    System.out.println(coll.contains(new String("Tom")));//true，重写了equals
    //未重写equals()之前，调用object中的equals（比较地址值），分别返回true，false
    //重写了equals之后，只比较内容，都为true
    System.out.println(coll.contains(p));//true
    System.out.println(coll.contains(new Person("Jerry",20)));//false-->true
    
    //2.containsAll(Collection coll1):判断形参coll1中所有元素是否都存在于当前集合中
    Collection coll1 = Arrays.asList(123,456);
    System.out.println(coll.containsAll(coll1));//true
    Collection coll2 = Arrays.asList(123,4567);
    System.out.println(coll.containsAll(coll2));//false
  }
  @Test
  public void test3(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    //3.remove(Object obj):从当前集合中移除obj元素
    //remove执行也需要调用equals
    coll.remove(1234);
    System.out.println(coll);
    
    coll.remove(new Person("Jerry",20));
    System.out.println(coll);
    //4.removeAll(Collection coll1):差集：从当前集合中移除coll1中所有的元素
    Collection coll1 = Arrays.asList(123,456);
    coll.removeAll(coll1);
    System.out.println(coll);//[Tom,false]
  }
  @Test
  public void test4(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    //5.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
    
    //Collection coll1 = Arrays.asList(123,456,789);
    //coll.retainAll(coll1);
    //System.out.println(coll);//[123,456]
    
    //6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同
    Collection coll1 = new ArrayList();
    coll1.add(123);
    coll1.add(456);
    coll1.add(new Person("Jerry",20));
    coll1.add(new String("Tom"));
    coll1.add(false);
    
    System.out.println(coll.equals(coll1));//ArrayList有序，需顺序一致
    
    //7.hashCode():返回当前对象的哈希值
    System.out.println(coll.hashCode());
    
    //8.集合--->数组：toArray()
    Object[] arr = coll.toArray();
    for (int i=0;i<arr.length;i++){
      System.out.println(arr[i]);
    }
    
    //扩展：数组--->集合：调用Arrays类的静态方法asList()
    List list = Arrays.asList(new String[]{"AA","BB","CC"});
    System.out.println(list);//[AA,BB,CC]
    
    //把int数组看为一个对象，所以长度为1
    List arr1 = Arrays.asList(new int[]{123,456});
    System.out.println(arr1);//[[I@78e03bb5]
    System.out.println(arr1.size());//1
    //自动装箱
    List arr3 = Arrays.asList(123,456);
    System.out.println(arr3);//[123,456]
    System.out.println(arr3.size());//2
    
    List arr2 = Arrays.asList(new Integer[]{123,456});
    System.out.println(arr2);//[123,456]
    System.out.println(arr2.size());//2
  }
}
class Person{
  private String name;
  private int age;
  
  public Person(){
    
  }
  
  public Person(String name, int age){
    this.name = name;
    this.age = age;
  }
  
  @Override
  public boolean equals(Object 0){
    if(this == o) return true;
    if(o == null || getClass() != o.getClass()) return false;
    
    Person person = (Person)o;
    
    if(age != person.age) return false;
    return name != null?name.equals(person.anem):person.name == null;
  }
  
  @Override
  public String toString(){
    return "Person{}" +
      "name=" + name + '\'' +
      ",age=" + age +
      '}';
  }
}

Iterator迭代器接口

集合元素的遍历操作，使用迭代器Iterator接口

1.内部的方法：hasNex()和next()

2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

3.内部定义了remove()，可以在便利的时候，删除集合中的元素。此方法不同于集合直接调用remove()

public class IteratorTest{
  @Test
  public void test1(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    
    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());
    //报异常：NoSuchElementException
    //System.out.println(iterator.next());
    
    //方式二：不推荐
    for(int i=0;i<coll.size();i++){
      System.out.println(iterator.next());
    }
    
    //方式三：推荐
    //hasNext():判断是否还有下一个元素
    while(iterator.hasNext()){
      //next():①指针下移②将下移以后集合位置上的元素返回
      System.out.println(iterator.next());
    }
  }
  @Text
  public void test2(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    
    //错误方式一：
    Iterator iterator = coll.iterator();
    while(iterator.next() != null){//指针下移
      System.out.println(iterator.next());//指针下移，跳着输出，出现异常
    }
    //错误方式二：
    //集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
    while(coll.iterator().hasNext()){
      System.out.println(coll.iterator().next());//死循环123
    }
  }
  //测试Iterator中的remove()
  //如果还未调用next()或在上一次调用next方法之后已经调用了remove方法
  //再调用remove都会报IllegalStateException
  @Test
  public void test3(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    
    //删除集合中"Tom"
    Iterator iterator = coll.iterator();
    while(iterator.hasNext()){
      Object obj = iterator.next();
      if("Tom".equals(obj)){
        iterator.remove();
      }
    }
    iterator = coll.iterator;//需要重新调用iterator();
    
    while(iterator.hasNext()){
      System.out.println(iterator.next());
    }
  }
}

foreach遍历

public class ForTest{
  @Test
  public void test(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    
    //for(集合元素的类型 局部遍历：集合对象)
    //内部仍然调用了迭代器
    for(Object obj:coll){
      System.out.println(obj);
    }
  }
  @Test
  public void test2(){
    int[] arr = new int[]{1,2,3,4,5,6};
    //for(数组元素的类型 局部变量:数组对象)
    for(int i:arr){
      System.out.println(i);
    }
  }
  @Test
  public void test3(){
    String[] arr = new String[]{"MM","MM","MM"};
    //方式一：普通for赋值
    for(int i = 0; i<arr.length; i++){
      arr[i]="GG";
    }
    //直接改变数组的值
    for(int i = 0; i<arr.length; i++) {
      System.out.println(arr[i]);
    }
    //方式二：增加for循环
    for(String s:arr){
      s='gg';
    }
    //未改变数组的值，只是改变了形参s
    for(String s:arr){
      System.out.println(s);
    }
  }
  @Test
  public void test4(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(234);
    coll.add(456);
    coll.add(133);
    
    coll.forEach(System.out::println)
  }
}

Collection子接口一：List

List接口框架

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

|----List接口：存储有序的、可重复的数据。-->“动态”数组，替换原有的数组

ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储（主要是头部和中间插入）
Vector：作为List接口的古老实现类；现成安全的，效率低；底层使用Object[] elementData存储

ArrayList的源码分析：

2.1 jdk7清空下

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 jdk8中ArrayList的变化：

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}，并没有创建长度为10的数组

list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]

...

后续的添加和扩容操作与jdk7无异

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

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;
             }
         }

Vector的源码分析

jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组

在扩容方面，默认扩容为原来的数组长度的2倍

面试题：ArrayList、LinkedList、Vector三者的异同？

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

不同：见上

查找复杂度：ArrayList—o(1),LinkedList—o(n)
删除复杂度：ArrayList—o(n),LinkedList—o(1)

List接口中的常用方法

总结：常用方法

增：add(Object obj)

删：remove(int index) (与remove(Object obj)方法构成重载)/remove(Object obj)

改：set(int index, Object ele)

查：get(int index)

插：add(int index, Object ele)

长度：size()

遍历：①Iterator迭代器方式 ②增强for循环 ③普通的循环

面试题

@Test
public void testListRemove(){
  List list = new ArrayList();
  list.add(1);
  list.add(2);
  list.add(3);
  updateList(list);
  System.out.println(list);//[1,2]--->[1,3]
}
private static void updateList(List list){
  //list.remove(2);//调用remove(int index)
  list.remove(new Integer(2));//调用remove(Object obj)
}

Collection子接口一：Set

Set接口的框架

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

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

HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null
LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历（添加了两个引用，记录前后数据）。对于频繁的遍历操作，LinkedHashSet效率高于HashSet
TreeSet：可以按照添加对象的指定属性，进行排序

1.Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法

2.要求：向Set（主要指：HashSet、LinkedHashSet）中添加数据，其所在的类一定要重写hashCode()和equals()

要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码

重写两个方法的小技巧：对象中用作equals()方法比较的Field，都应该用来计算HashCode值

一、Set：存储无序的、不可重复的数据

以HashSet为例说明：

1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的

2.不可重复性：保证添加的元素按照equals()判断是，不能返回true，即：相同的元素只能添加一个

二、添加元素的过程：以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添加成功 -->情况3
对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式存储
- jdk7：元素a放到数组中，指向原来的元素
- jdk8：原来的元素在数组中，指向元素a

总结：七上八下

HashSet底层：数组+链表的结构

TreeSet

1.向TreeSet中添加的数据，要求是相同类的对象

2.两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）

3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()

4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals()

public class SetTest{
  @Test
  public void test1(){
    TreeSet set = new TressSet();
    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("Jack",33));
    set.add(new User("Jack",56));
    
    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
      System.out.println(iterator.next());
    }
  }
  @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());
    }
  }
}
class User implements Comparable{
  private String name;
  private int age;
  
  public User(){
    
  }
  
  public User(String name, int age){
    this.name = name;
    this.age = age;
  }
  
  public String getName(){
    return name;
  }
  
  public int getAge(){
    return age;
  }
  
  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    User user = (User) o;

    if (age != user.age) return false;
    return name != null ? name.equals(user.name) : user.name == null;
  }

  @Override
  public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + age;
    return result;
  }

  @Override
  public String toString() {
    return "User{" +
      "name='" + name + '\'' +
      ", age=" + age +
      '}';
  }
  
  //按照姓名从大到小排列，年龄从小到大排列
  @Override
  public int compareTo(Object o){
    if(o instanceof User){
      User u = (User)o;
      
      if(name.compareTo(u.name)==0){
        return Integer.compare(age,u.age);
      }else{return -name.compareTo(u.name);}
    }
    throw new RuntimeException("输入数据类型不匹配");
  }
}

面试题

public class TreesetExer{
  @Test
  public void test(){
    HashSet set = new HashSet();
    Person1 p1 = new Person1(1001,"AA");
    Person1 p2 = new Person1(1002,"BB");
    set.add(p1);
    set.add(p2);
    p1.name = "CC";//p1的哈希值改变
    set.remove(p1);//按照p1的新哈希值找位置删除(此时新位置值为空，CC是添加到AA的原哈希值位置，所以没有删除掉CC)
    System.out.println(set);////[Person1{id=1002, name='BB'}, Person1{id=1001, name='CC'}]
    set.add(new Person1(1001,"CC"));//按照新哈希值位置，进行添加，对比新旧哈希值不同，添加成功（新哈希值位置没有相同值）
    System.out.println(set);//[Person1{id=1002, name='BB'}, Person1{id=1001, name='CC'}, Person1{id=1001, name='CC'}]
    set.add(new Person1(1001,"AA"));//按照P1的旧哈希值位置，进行添加，对比新旧哈希值不同，添加成功（旧位置已经存放的CC，所以可以添加成）
    System.out.println(set);//[Person1{id=1002, name='BB'}, Person1{id=1001, name='CC'}, Person1{id=1001, name='CC'}, Person1{id=1001, name='AA'}]
  }
}

Map接口

一、Map的实现类的结构：

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

HashMap：作为Map的主要实现类；线程不安全的，效率高；存储null的keyhevalue
- LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历
  原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap
TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序。底层使用红黑树
Hashtable：作为古老的实现类；线程安全的，效率低；不能存储null的key和value
- Properties：常用来处理配置文件，key和value都是String类型

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

数组+链表+红黑树（jdk8）

面试题：

1.HashMap的底层实现原理？

2.HashMao和Hashtable的异同？

3.CurrentHashMap与Hashtable的异同？

二、Map结构的理解：

Map中的key：无序的、不可重复的，使用Set存储所有的key-->**key所在的类要重写equals()和hashCode()（以HashMap为例）

Map中的value：无序的、可重复的，使用Collection存储所有的value->value所在的类要重写equals()

一个键值对：key-value构成了一个Entry对象

Map中的entry：无序的、不可重复的，使用Set存储所有的entry

三、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：使用vlaue1替换value2
- 补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储

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

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

1.new HashMap()：底层没有创建一个长度为16的数组

2.jdk8底层的数组是：Node[]，而非Entry[]

3.首次调用put()方法时，底层创建长度为16的数组

4.jdk7底层结构只有：数组+链表。jdk8底层结构：数组+链表+红黑树

4.1形成链表时，七上八下（jdk7：新的元素指向旧的元素。jdk8：旧的元素指向新的元素）

4.2当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时索引位置上的数据改为使用红黑树存储

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

四、LinkedHashMap的底层实现原理（了解）

源码中：

static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;//能够记录添加的元素的先后顺序
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
hashset相当于hashmap中的key，value都未new objects

总结：常用方法

添加：put(Object key,Object value)

删除：remove(Object key)

修改：put(Object key,Object value)

查询：get(Object key)

长度：size()

遍历：keySet()/values()/entrySet()

public class MapTest{
  @Test
  public void test1(){
    Map map = new HashMap();
    //添加
    map.put("AA",123);
    map.put(45,123);
    map.put("BB",56);
    System.out.println(map);//{AA=123,BB=56,45=123}
    //修改
    map.put("AA",87);
    System.out.println(map);//{AA=87,BB=56,45=123}
    
    Map map1 = new HashMap();
    map1.put("CC",123);
    map1.put("DD",123);
    map.putAll(map1);
    System.out.println(map);
    
    //remove(Object key)
    Object value = map.remove("CC");
    System.out.println(value);//123
    System.out.println(map);
    
    //clear()
    map.clear();//与map = null操作不同
    System.out.println(map.size());//0
    System.out.println(map);//{}
  }
  @Test
  public void test2(){
    Map map = new HashMap();
    map.put("AA",123);
    map.put(45,123);
    map.put("BB",56);
    //Object get(Object key)
    System.out.println(map.get(45));
    //containsKey(Object key)
    System.out.println(map.containsKey("BB"));
    
    System.out.println(map.containsValue(123));
    
    map.clear();
    System.out.println(map.isEmpty());
  }
  @Test
  public void test3(){
    Map map = new HashMap();
    map.put("AA",123);
    map.put(45,1234);
    map.put("BB",56);
    //遍历所有的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 set = map.entrySet();
    Iterator iterator1 = set1.iterator();
    while(iterator1.hasNext()){
      //System.out.println(iterator1.next());
      //AA=123
      //BB=56
      //45=1234
      Object obj = iterator1.next();
      Map.Entry entry = (Map.Entry)obj;
      System.out.println(entry.getKey()+"----"+entry.getValue());
    }
    //方式二：
    Set set2 = map.keySet();
    Iterator iterator2 = set2.iterator();
    while(iterator2.hasNext()){
      Object key = iterator2.next();
      Object value = map.get(key);
      System.out.println(key+"==="+value);
    }
  }
}

Collections工具类

面试题：Collection 和 Collections的区别？

@Test
public void test2(){
  List list = new ArrayList();
  list.add(123);
  list.add(43);
  list.add(765);
  list.add(-97);
  list.add(0);
  //报异常：IndexOutOfBoundsException("Source does not fit in dest")
  //list的size大于dest的，异常
  //List dest = new ArrayList();
  //Collections.copy(dest,list);
  List dest = Arrays.asList(new Object[list.size()]);
  System.out.println(dest.size());
  Collections.copy(dest,list);
  System.out.println(dest);
  
  /*
  Collections类中提供了多个synchronizedXxx()方法，该方法可使将指定集合包装成线程同步的结合，从而可以解决多线程并发访问集合时的线程安全问题
  */
  //返回的list1即为线程安全的List
  List list1 = Collections.synchronizedList(list);
}

转载：https://blog.csdn.net/alyja/article/details/107425648

posted @ 2022-02-19 18:10 小曺阅读(94) 评论(0) 编辑收藏举报

刷新页面返回顶部

小曹

不忘初心，方得始终

java集合-尚硅谷学习笔记

公告