Java集合--Collection、Map、List、Set、Iterator、Collections工具类

文章目录

  • 一、Java集合框架概述
  • 二、Collection接口方法
    • 2.1、Collection子接口一:List
      • 2.1.1、ArrayLIst的源码分析
      • 2.1.2、LinkedList的源码分析
      • 2.1.3、List接口中的常用方法
    • 2.2、Collection子接口二:Set
      • 2.2.1、Set接口的无序性
      • 2.2.2、添加元素的过程:以HashSet为例
      • 2.2.3、Set实现类之二:LinkedHashSet
      • 2.2.4、Set实现类之三:TreeSet
  • 三、Map接口
    • 3.1、HashMap
      • 3.1.1、HashMap的底层实现原理?
      • 3.1.2、LinkedHashMap
    • 3.2、TreeMap
    • 3.3、Hashtable
      • 3.3.1、Properties
    • 3.4、Map中的常用方法
  • 四、Iterator迭代器接口
    • 4.1、hasNext() 和 next()
    • 4.2、remove()
  • 五、Collections工具类
    • 5.1、Collections常用方法

一、Java集合框架概述

  1. 集合、数组都是对多个数据进行存储从左的结构,简称Java容器

说明:此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储(.txt, .jpg, .avi,数据库中)

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

  1. 一旦初始化以后,其长度就确定了。

  2. 数组一旦定义好,其元素的类型就确定了。我们也就只能操作指定类型的数据了。

    比如:String[] arr; int[] arr1; Object[] arr2;

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

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

二、Collection接口方法

单列数据(List、Set),定义了存取一组对象的方法的集合

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第1张图片
结论:
*Collection接口的实现类的对象中添加数据obj时,要求obj所在类要重写equals()

常用的15个方法:

//1.add(Object e):将元素 e 添加到集合 coll中
Collection coll = new ArrayList();
coll.add("AA");
coll.add(55);//自动装箱
coll.add(new Date());//添加对象
//2.size()://获取添加元素的个数
System.out.println(coll.size());
//3.addAll(Collection c):将c集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add("SS");
coll1.addAll(coll);
//4.clear():清空集合元素
System.out.println(coll1.isEmpty());
coll1.add(new String("Jerry"));
//5.contains(Object obj)//判断当前集合中是否包含obj,我们在判断时会调用obj对象所在类的equals()
boolean contains = coll1.contains("abc");
// 6.containsAll(Collection coll1)//判断形参coll1中的所有元素是否都在当前集合中
boolean b = coll1.containsAll(coll);
//7.remove(Object obj):从当前集合中移除obj元素
coll.remove("BB");
coll.remove("CC");
coll.remove(5);
//8.removeAll(Collection coll1):从当前集合中移除coll1中的所有元素
Collection coll = new ArrayList();
coll.add(123);
coll.add("AA");
coll.add(987);//自动装箱
coll.add("SS");
coll.add("CC");

Collection coll1 = Arrays.asList(123,456,987);
coll.removeAll(coll1);
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(false);
Collection coll1 = Arrays.asList(123,456,987);

//9.retainAll(Collection coll1):交集:获取当前集合和coll1集合的交集,并返回给当前集合
coll.retainAll(coll1);
System.out.println(coll);//[123, 456]
//10.equals(Object obj):要想返回true,需要当前集合和形参集合的元素都相同
Collection coll1 = new ArrayList();//List,顺序是有序的,顺序不同就是false
coll1.add(123);
coll1.add(456);
coll1.add(false);
boolean equals = coll.equals(coll1);
System.out.println(equals);//true
//11.hashCode():返回当前对象的哈希值
System.out.println(coll1.hashCode());
//12.集合-->数组toArray()
Object[] array = coll1.toArray();
for (int i=0;i<array.length;i++){
    System.out.println(array[i]);
}
//数组-->集合: 调用Arrays的静态方法asList()
List<String> list = Arrays.asList(new String[]{"AA","BB","CC"});
System.out.println(list);
List<Integer> list1 = Arrays.asList(new Integer[]{123, 456});
System.out.println(list1.size());//2

List list2 = Arrays.asList(new int[]{123, 456});
System.out.println(list2.size());//1
System.out.println(list2);//[[I@7dc36524],识别成一个元素
//13.返回iterator接口的实例,用于遍历集合元素。放在TteratorTest.java中测试

2.1、Collection子接口一:List

List:元素有序、可重复的集合。---->”动态数组“

经典面试题:ArrayList、LinkedList、Vector三者的异同?

同:实现了List接口,存储数据的特点相同:存储有序的、可重复的数据

异:

  • ArrayList作为List接口的主要实现类:线程不安全的,效率高;底层使用Object[] 存储
  • LinkedList:对于频发的插入、删除操作,使用此类的效率比ArrayList高;底层使用的双向链表存储
  • Vector作为List接口的古老实现类:线程安全的,效率低;底层使用Object[] 存储

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第2张图片

2.1.1、ArrayLIst的源码分析

2.1 jdk7情况下
ArrayList list = new ArrayList();//底层创建了长度是10的object[]数组eLementData
list.add(123); //eLementData[e] = 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初始化为{}.并没有创建长
list.add(123);//第一次调用add()时,底层才创建了长度1e的数组,并将数据123添加到eLemer
后续的添加和扩容操作与jdk 7无异。


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

2.1.2、LinkedList的源码分析

LinkedList list = new LinkedList();内部声明了Node类型的first和last属性,默认值为null
List.add(123);//将123封装到Node中,创建了Node对象。
// 其中,Node定义为:体现了LinkedList的双向链表的说法

2.1.3、List接口中的常用方法

List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引来
操作集合元素的方法。

总结:常用方法

增:add(Object obj)

删:remove(int index) / remove(Object obj)//一个按照索引删除;一个直接删除对象(元素)

改:set(int index, Object ele)

查:get(int index)

插:add(int index, Object ele)

长度:size()

遍历:① Iterator 迭代器方法;② 增强for循环;③ 普通的for循环

//迭代器方式循环
Iterator iterator = list.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next());
}

//增强for循环
for (Object obj:list){
    System.out.println(obj);
}

//普通for循环
for (int i=0;i<list.size();i++){
    System.out.println(list.get(i));
}
ArrayList list = new ArrayList();
list.add(123);
list.add(465);
list.add("AA");
list.add(new Date());
list.add("BB");
list.add("CC");

//1.void add(int index, Object ele):在index位置插入ele元素
    list.add(1,"BB");
    
//2.boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1,2,3);
list.addAll(list1);
System.out.println(list.size());

//3.Object get(int index):获取指定index位置的元素
Object o = list.get(0);//123
Object o1 = list.get(6);//2

//4.int indexOf(Object obj):返回obj在集合中首次出现的位置
int index = list.indexOf(465);//1

//5.int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
int lastIndexOf = list.lastIndexOf("AA");//2

//6.Object remove(int index):移除指定index位置的元素,并返回此元素
Object obj = list.remove(0);
System.out.println(obj);//123

//7.Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"XX");

//8.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
List subList = list.subList(1, 4);//左闭右开

2.2、Collection子接口二:Set

Set接口的概述

  • Set接口是Collection的子接口,set接口没有提供额外的方法
  • Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法
  • Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个 Set 集合中,则添加操作失败。

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

HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值

LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的

TreeSet:可以按照添加对象的指定属性。进行排序

Set接口:元素无序、不可重复的集合。---->高中将的”集合“

HashSet、LinkedHashSet(是HashSet的子类)、TreeSet

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第3张图片 Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第4张图片 Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第5张图片

2.2.1、Set接口的无序性

以HashSet为例说明:

  1. 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值。
  2. 不可重复性:保证添加的元素按照equals()判断时,不能返回true。即:相同的元素只能添加一个。

2.2.2、添加元素的过程:以HashSet为例

我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断数组此位置上是否已经有元素;
如果此位置上没有其他元素,则元素a添加成功。—>情况1
如果此位置上有其他元素(或以链表形式存在的多个元素),则比较元素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底层:数组+链表的结构。

2.2.3、Set实现类之二:LinkedHashSet

  1. LinkedHashSet 是 HashSet 的子类
  2. LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
  3. LinkedHashSet插入性能略低于 HashSet,但在迭代访问 Set 里的全部元素时有很好的性能。
  4. LinkedHashSet 不允许集合元素重复。
Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第6张图片

LinkedHashSet的使用

LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据前一个数据和后一个数据。

优点:对于频繁的遍历操作,LinkedHashSet效率高于Hashset

2.2.4、Set实现类之三:TreeSet

向TreeSet中添加的数据,要求是相同类的对象。

TreeSet 是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态。

TreeSet底层使用红黑树结构存储数据

TreeSet 两种排序方法:自然排序和定制排序。默认情况下,TreeSet 采用自然排序。

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第7张图片

三、Map接口

List :单列数据

Map:双列数据

List 和 Map都可以看作是 key-value的形式,只不过 List的key是 index,是索引,自动生成的,而Map的key可以是任意类型。

Map:双列数据,保存具有映射关系“key-value对”键值对的集合。---->高中函数:y=f(x)。x:key ; y:value

HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第8张图片

image.png

Map中的key value的图示:

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第9张图片

高频面试考点:

  1. HashMap的基层原理是什么?
  2. HashMap和Hashtable的异同?

补充:

HashMap的底层:

数组+链表 (jdk7及之前)

数组+链表+红黑树 (jdk8)

3.1、HashMap

作为Map的主要实现类;线程不安全的,效率高;可以存储null的key和value

3.1.1、HashMap的底层实现原理?

以jdk7 为例说明:

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第10张图片

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第11张图片

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第12张图片

3.1.2、LinkedHashMap

LinkedHashMap是HashMap的一个子类:保证在遍历map元素时,可以按照添加的顺序实现遍历。

原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。

对于频繁的遍历操作,此类执行效率高于HashMap。

3.2、TreeMap

保证按照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序。

底层使用红黑树。

Properties 类是 Hashtable 的子类,该对象用于处理属性文件

由于属性文件里的 key、value 都是字符串类型,所以 Properties 里的 key 和 value 都是字符串类型

存取数据时,建议使用setProperty(String key,String value)方法和 getProperty(String key)方法

3.3、Hashtable

作为古老的实现类,线程安全的,效率低;不能存储null的key和value

3.3.1、Properties

Properties是Hashtable的一个子类:常用来处理配置文件。key和vaLue都是String类型

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第13张图片

3.4、Map中的常用方法

总结:常用方法:
1.添加:put(Object key,Object value)
2.删除:remove(Object key)
3.修改:put(Object key,Object value)
4.查询:get(Object key)
5.长度:size()
6.遍历:keySet()	/ values()	/ entrySet()
 添加、删除、修改操作:
 Object put(Object key,Object value):将指定key-value添加到(或修改)当前map对象中
 void putAll(Map m):将m中的所有key-value对存放到当前map中
 Object remove(Object key):移除指定key的key-value对,并返回value
 void clear():清空当前map中的所有数据
 元素查询的操作:
 Object get(Object key):获取指定key对应的value
 boolean containsKey(Object key):是否包含指定的key
 boolean containsValue(Object value):是否包含指定的value
 int size():返回map中key-value对的个数
 boolean isEmpty():判断当前map是否为空
 boolean equals(Object obj):判断当前map和参数对象obj是否相等
 元视图操作的方法:
 Set keySet():返回所有key构成的Set集合
 Collection values():返回所有value构成的Collection集合
 Set entrySet():返回所有key-value对构成的Set集合

//遍历所有的key-value
//方式一:entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
    Object obj = iterator1.next();
    //entrySet集合中的元素都是entry
    Map.Entry entry = (Map.Entry) obj;//强转
    System.out.println(entry.getKey()+"--->"+ entry.getValue());
}
System.out.println("**********");

//方式二:自己根据已有的方法(keySet())自己拼凑
Set keySet = map.keySet();
Iterator iterator2 = keySet.iterator();
while (iterator2.hasNext()){
    Object key = iterator2.next();
    Object value = map.get(key);
    System.out.println(key+"===="+ value);
}

四、Iterator迭代器接口

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

重点掌握:

  1. 内部的方法:hasNext() 和 next()
  2. 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合 的第一个元素之前。
  3. 内部定义了remove(),可以在遍历的时候,删除集合中的元素。此方法不同于集合直接调用remove()

4.1、hasNext() 和 next()

public void test(){
        Collection coll = new ArrayList();
        coll.add("AA");
        coll.add(55);//自动装箱
        coll.add("SS");
        coll.add(new Date());
        Iterator iterator = coll.iterator();

        //方式一:
//        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
//            System.out.println(iterator.next());
//        }

        //方式三:推荐
        while (iterator.hasNext()){//使用hasNext(),查看下一个是否为空
            System.out.println(iterator.next());
        }
    }

迭代器的执行原理如下:

说明:

  • 调用hasNext()的时候指针没有下移,调next()的时候指针才下移。
  • iterator只是迭代的,用于遍历,不是容器,当前集合coll是一个容器
  • next():① 指针下移; ② 讲下移后的集合位置上的元素返回

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

Java集合--Collection、Map、List、Set、Iterator、Collections工具类_第14张图片

4.2、remove()

如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法, 再调用remove都会报IllegalStateException。

@Test
public void test3(){
    Collection coll = new ArrayList();
    coll.add("AA");
    coll.add(55);//自动装箱
    coll.add("SS");
    coll.add(new Date());

    //iterator.remove(): 删除集合中的"AA"
    Iterator iterator = coll.iterator();
    while (iterator.hasNext()){
        Object obj = iterator.next();
        if ("AA".equals(obj)){
            iterator.remove();
        }
    }

    Iterator iterator1 = coll.iterator();
    while (iterator1.hasNext()){
        System.out.println(iterator1.next());
    }
}

五、Collections工具类

作用:操作Collection和Map的工具类

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

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作, 还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

面试题:Collection 和 Collections 的区别?

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

5.1、Collections常用方法

排序操作:(均为static方法)

1.reverse(List):反转 List 中元素的顺序
2.shuffle(List):对 List 集合元素进行随机排序
3.sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
4.sort(ListComparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
5.swap(Listintint):将指定 list 集合中的 i 处元素和 j 处元素进行交换
查找、替换
1.Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
2.Object max(CollectionComparator):根据 Comparator 指定的顺序,返回
给定集合中的最大元素
3.Object min(Collection)
4.Object min(CollectionComparator)
5.int frequency(CollectionObject):返回指定集合中指定元素的出现次数
6.void copy(List dest,List src):将src中的内容复制到dest中
7.boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List 对象的所有旧值
//对6.void copy(List dest,List src),的详细使用说明
@Test
    public void test2() {
        List list = new ArrayList();
        list.add(123);
        list.add(33);
        list.add(45);
        list.add(-52);

//        List dest = new ArrayList();//错误的,会报异常
        List dest = Arrays.asList(new Object[list.size()]);//更健壮
        System.out.println(dest.size());
        System.out.println(dest);
        Collections.copy(dest, list);
        System.out.println(dest);
    }

说明:ArrayList和HashMap都是线程不安全的,如果程序要求线程安全,我们可以将ArrayList、HashMap转为线程安全的。

使用synchronizedList(List list) 和 synchronziedMap( Map map)

同步控制
Collections 类中提供了多个 synchronizedXxx() 方法,该方法可使将指定集
合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全
问题
    
    //返回的list1即为线程安全的list
    List list1 = Collections.synchronizedList(list);

你可能感兴趣的:(Java,java,list)