集合

1-Collection接口

2021-07-09 478 1

简介 Java集合中的重要结构,Collection中的重要方法。

1. 集合概述

面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储。使用Array存储对象方面具有一些弊端,而Java 集合就像一种容器,可以动态地把多个对象的引用放入容器中。

数组在内存存储方面的特点:

数组初始化以后,长度就确定了。

数组声明的类型,就决定了进行元素初始化时的类型

数组在存储数据方面的弊端:

数组初始化以后,长度就不可变了,不便于扩展

数组中提供的属性和方法少,不便于进行添加、删除、插入等操作, 且效率不高。同时无法直接获取存储元素的个数

数组存储的数据是有序的(顺序存储的)、可以重复的。存储数据的类型单一

Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。

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

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

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

     > 一旦初始化以后,其长度是确定的。

     > 数组一旦定义好,其元素的类型也是确定的,只能操作指定类型的数据,比如:String[] arr;int[] arr1;Object[] arr2;

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

     > 一旦初始化以后,其长度就不可修改

     > 数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。

     > 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用

     > 数组存储数据的特点:顺序存储的、可重复。对于无序存储、不可重复的需求,不能满足,而如果使用容器中的Map可解决。

Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组,并提供了丰富的方法用于操作容器中的数据。

2. 集合中的重要结构

二、集合框架

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

         |----List接口:存储有序的、可重复的数据,动态数组,可动态扩容

             |----ArrayListLinkedListVector

         |----Set接口:存储无序的、不可重复的数据,类比于高中学的集合”(有限性、确定性、互异性、无序性)

             |----HashSetLinkedHashSetTreeSet

     |----Map接口:双列集合,用来存储一对(key - value)一对的数据,类比高中学习的函数:y = f(x)

             |----HashMapLinkedHashMapTreeMapHashtableProperties


3. Collection接口方法的使用

3.1 add() 、 size() 、 addAll()、  clear()、 isEmpty() 方法的使用

  1. @Test

  2. public void testColl(){

  3.     Collection coll = new ArrayList();

  4.     // boolean add(E e);

  5.     coll.add(123);

  6.     coll.add('a');

  7.     coll.add("ylaihui");

  8.     // size() 返回元素的个数

  9.     System.out.println(coll.size()); // 3

  10.     Collection coll2 = new ArrayList();

  11.     coll2.add(new java.lang.String("ylaihui"));

  12.     coll2.add(new java.lang.StringBuffer("ylaihui"));

  13.     //addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中

  14.     coll.addAll(coll2);

  15.     System.out.println(coll.size());  // 5

  16.     // 调用 ArrayList的 toString方法 [123, a, ylaihui, ylaihui, ylaihui]

  17.     System.out.println(coll);

  18.     // 判断集合是否为空 (集合中是否有元素) return size() == 0

  19.     Collection coll3 = new ArrayList();

  20.     System.out.println(coll3.isEmpty());  // true

  21.     System.out.println(coll.isEmpty());   // false

  22.     // 清空集合元素

  23.     coll.clear();

  24.     System.out.println(coll.isEmpty());  // true

  25. }


代码输出:

3

5

[123, a, ylaihui, ylaihui, ylaihui]

true

false

true


3.2 contains()、 containsAll()、 remove()、removeAll()方法的使用

order类

  1. class Order {

  2.     private int id;

  3.     private double price;

  4.     public Order() {

  5.     }

  6.     public Order(int id, double price) {

  7.         this.id = id;

  8.         this.price = price;

  9.     }

  10.     @Override

  11.     public boolean equals(Object o) {

  12.         if (this == o) return true;

  13.         if (o == null || getClass() != o.getClass()) return false;

  14.         Order order = (Order) o;

  15.         return id == order.id &&

  16.                 Double.compare(order.price, price) == 0;

  17.     }

  18.     @Override

  19.     public String toString() {

  20.         return "Order{" +

  21.                 "id=" + id +

  22.                 ", price=" + price +

  23.                 '}';

  24.     }

  25. }


  1. @Test

  2. public void testMethod() {

  3.     Collection objects = new ArrayList();

  4.     objects.add(123);

  5.     objects.add(false);

  6.     objects.add(new String("ylaihui"));

  7.     // contains(Object obj):判断当前集合中是否包含obj

  8.     // 会调用obj对象所在类的equals(),并非比较的对象的地址,而是比较的对象的内容

  9.     System.out.println(objects.contains(123));  // 自动装箱 true

  10.     System.out.println(objects.contains("ylaihui")); // true

  11.     System.out.println(objects.contains(new String("ylaihui")));  // true

  12.     Order order = new Order(111100.00);

  13.     objects.add(order);

  14.     // 不管有没有重写equals,结果都为true,因为是同一个对象 调用== 或 equals都是true

  15.     System.out.println(objects.contains(order));  // true

  16.     // true, 如果Order类没有重写equals方法,结果为 false

  17.     System.out.println(objects.contains(new Order(111100.00))); // true

  18.     Collection coll1 = Arrays.asList(123false);

  19.     // 判断 objects 集合中是否包含集合 coll1, 子集的关系

  20.     System.out.println(objects.containsAll(coll1)); // true

  21.     // remove(Object obj):从当前集合中移除obj元素。

  22.     objects.remove(new Order(111100.00));

  23.     System.out.println(objects);  // [123, false, ylaihui]

  24.     //removeAll():移除两个部分的交集(coll2和objects的交集被移除)

  25.     Collection coll2 = Arrays.asList(123false1111);

  26.     objects.removeAll(coll2);

  27.     System.out.println(objects);  // [ylaihui]

  28. }


3.3 retainAll() 方法的使用

  1. @Test

  2. public void test3() {

  3.     Collection coll = new ArrayList();

  4.     coll.add(123);

  5.     coll.add(456);

  6.     coll.add(new Order(1111100.00));

  7.     coll.add(new String("ylaihui"));

  8.     coll.add(false);

  9.     //retainAll(Collection coll1):交集:获取当前集合和coll1集合的交集,并返回给当前集合

  10.     Collection coll1 = Arrays.asList(123456789);

  11.     coll.retainAll(coll1);

  12.     System.out.println(coll);  // [123, 456]

  13. }

3.4 equals() 方法的使用

  1. @Test

  2. public void test4() {

  3.     Collection coll = new ArrayList();

  4.     coll.add(123);

  5.     coll.add(456);

  6.     coll.add(new Order(1111100.00));

  7.     coll.add(new String("ylaihui"));

  8.     coll.add(false);

  9.     Collection coll2 = new ArrayList();

  10.     coll2.add(123);

  11.     coll2.add(456);

  12.     coll2.add(new Order(1111100.00));

  13.     coll2.add(new String("ylaihui"));

  14.     coll2.add(false);

  15.     //equals(Object obj):要想返回true,需要当前集合和形参集合的元素都相同。

  16.     System.out.println(coll.equals(coll2));  // true

  17. }


3.5 toArray()、hashCode()、 Arrays.asList()

  1. @Test

  2. public void test5() {

  3.     Collection coll = new ArrayList();

  4.     coll.add(123);

  5.     coll.add(456);

  6.     coll.add(new Order(1111100.00));

  7.     coll.add(new String("ylaihui"));

  8.     coll.add(false);

  9.     //hashCode():返回当前对象的哈希值

  10.     System.out.println(coll.hashCode());

  11.     //集合 -> 数组:toArray()

  12.     Object[] objects = coll.toArray();

  13.     for (int i = 0; i < objects.length; i++) {

  14.         System.out.println(objects[i]);

  15.     }

  16.     //数组 -> 集合:调用Arrays类的静态方法asList(),基本数据类型的数组无法转换为多元素的集合

  17.     Collection coll2 = Arrays.asList(objects);

  18.     System.out.println(coll2);  // [[123, 456, Order{id=1111, price=100.0}, ylaihui, false]]

  19.     System.out.println("coll2.size() = " + coll2.size());  // 5

  20.     Collection coll3 = Arrays.asList(new String[]{"y""lai""hui"});

  21.     System.out.println(coll3);  // [y, lai, hui]

  22.     System.out.println(coll3.size()); // 3

  23.     Collection coll4 = Arrays.asList(new int[]{123});

  24.     System.out.println(coll4);  // [[I@22927a81]

  25.     System.out.println(coll4.size()); // 1

  26.     Collection coll5 = Arrays.asList(new Integer[]{123});

  27.     System.out.println(coll5);  // [1, 2, 3]

  28.     System.out.println(coll5.size()); // 3

  29. }



3.6 iterator() 方法的使用

 Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。

GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。 迭代器模式,就是为容器而生。 类似于“公交车上的售票员”、“火车上的乘务员”、 “空姐” 。

 Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了

Iterator接口的对象。

 Iterator 仅用于遍历集合, Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。

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

在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用,且

下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。

  1. @Test

  2. public void testIterator(){

  3.     Collection coll = new ArrayList();

  4.     coll.add(123);

  5.     coll.add(234);

  6.     coll.add("ylaihui");

  7.     Iterator iterator = coll.iterator();

  8.     while(iterator.hasNext()){

  9.         System.out.println(iterator.next());

  10.     }

  11.     // 迭代器遍历结束后,需要重新初始化 否则报异常 NoSuchElementException

  12.     // 可以这样实现,但是不推荐这么使用

  13.     iterator = coll.iterator();

  14.     for (int i = 0; i < coll.size(); i++) {

  15.         System.out.println(iterator.next());

  16.     }

  17. }


3.7 iterator() 方法的原理

调用 next() 时指针下移

每次调用 Iterator() 方法都会返回一个  Iterator 对象

System.out.println(iterator.getClass());   对于ArrayList集合的迭代器, 是其内部类的类型, class java.util.ArrayList$Itr,该内部类实现了 Iterator接口

upfile





4. 迭代器的remove()方法

如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法,

再调用remove都会报IllegalStateException。

  1. public class IteratorRemove {

  2.     @Test

  3.     public void testremove(){

  4.         Collection coll = new ArrayList();

  5.         coll.add(111);

  6.         coll.add(222);

  7.         coll.add("ylaihui");

  8.         Iterator it = coll.iterator();

  9.         while(it.hasNext()){

  10.             Object next = it.next();

  11.             if(next.equals(111)){

  12.                 it.remove();

  13.             }

  14.         }

  15.         it = coll.iterator();

  16.         while (it.hasNext())

  17.             System.out.println(it.next());

  18.     }

  19. }

代码运行结果

222

ylaihui

5. foreatch 增强for循环

jdk 5.0 新增了foreach循环,用于遍历集合、数组

for(集合元素的类型 局部变量 : 集合对象)

内部仍然调用了迭代器。

  1. //ForeatchTest.java

  2. package com.ylaihui.collectionitf;

  3. import org.junit.Test;

  4. import java.util.ArrayList;

  5. import java.util.Collection;

  6. public class ForeatchTest {

  7.     @Test

  8.     public void testremove() {

  9.         Collection coll = new ArrayList();

  10.         coll.add(111);

  11.         coll.add(222);

  12.         coll.add("ylaihui");

  13.         for(Object obj : coll){

  14.             System.out.println(obj);

  15.         }

  16.     }

  17.     @Test

  18.     public void testArray(){

  19.         int[] ints = {12345};

  20.         for(int i : ints){

  21.             System.out.println(i);

  22.         }

  23.     }

  24. }


点赞 1

文章评论

欢迎您:

纸上得来终觉浅,绝知此事要躬行!

112 文章 36783 浏览 3 评论

联系我

  •   QQ:    361352119
  •  Email:  lisimmy@sina.com
  • 微信: