java集合01-集合框架，方法，迭代器

集合

集合框架的概述

java集合就像是一个容器，可以动态的把多个对象的引用放入容器中

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

---

1 集合、数组都是对多个数据进行存储操作的结构，简称jiava容器。说明：此时的存储，主要是指内存层面的存储，不涉及到持久化的存储（.txt .jpg .avi 数据库）

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

- 一旦初始化以后，长度确定，不可变

- 数组一旦定义好，其元素的类型也就确定了。比如String[] arr; int[] arr 1; Object[] arr2 只能操作指定类型的数据

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

- 一旦初始化后，其长度不可修改

- 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不方便

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

- 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

---

集合的使用场景

android客户端：向服务器端传送请求。将json对象或json数组转换为java对象或Java对象构成的list

服务器端：接受请求，并且访问数据库

数据库：将请求的数据以接口/对象的形式返回到服务器端。

服务器端：将java对象或java对象构成的list转换为json对象或json数组，返回到客户端

单列集合框架结构

java集合可分为collection和map两种体系

• collection接口：单列数据，定义了存取一组对象的方法和集合，用来存储一个一个的对象
  • list：元素有序，可重复的集合 “动态数组”
    • ArrayList, LinkedList, Vector
  • set：元素有序，不可重复的集合
    • HashSet, LinkedHashSet, TreeSet
• map接口：双列集合，用于存储一对一对的数据，保存具有映射关系“key-value”的集合
  • HashMap, LinkedHashMap, TreeMap, HashTable, Properties

---

collection 接口中的方法

向collection接口的实现类对象中添加obj时，要求obj所在类重写equals方法

package com.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;

// methods of collection
public class Demo00 {
    public static void main(String[] args) {
        Collection coll = new ArrayList();

        // 1. add(Object e)：将元素e添加到集合coll中
        coll.add("aa");
        coll.add("asd");
        coll.add("a123");
        coll.add("563");
        coll.add(new Date());
        System.out.println(coll); // [aa, asd, a123, 563, Fri May 29 20:19:59 PDT 2020]


        // 2. size()：获取添加的元素的个数
        System.out.println(coll.size()); // 5

        // 3. addAll(Collection coll1)：将coll1集合的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add("3245");
        coll1.add("3afad");
        coll.addAll(coll1);

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

        // 4. clear()：清空集合元素
        coll1.clear();

        // 5. isEmpty()：判断当前集合是否为空 -- size is 0?
        System.out.println(coll.isEmpty()); // false
        System.out.println(coll1.isEmpty()); // true

        // 6. contains(Object obj): 判断当前集合中是否包含 obj
        // 在判断时会调用obj对象所在类的equals()
        boolean contains = coll.contains(123);
        System.out.println(contains); // false
        System.out.println(coll.contains(new String("tom"))); // false

        // 7. containsAll(Collection coll1) 判断形参coll1中的所有元素是否都存在于当前集合中
        System.out.println(coll.containsAll(coll1));
    }
}

package com.collection;

import com.zepei.oop.demo.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

// methods of colleciton
public class Demo01 {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("jerry",20));
        coll.add(new String("tom"));
        coll.add(false);
        System.out.println(coll);

        // 8. remove(Object obj)
        coll.remove(123); // 调用了equals方法
        coll.remove(new Person("jerry",20)); // bug
        System.out.println(coll);

        // 9. removeAll(Collection coll1) 从当前集合中移除coll1中的所有元素
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll);

        // 10. retainAll(Collection coll1) 取coll和coll1的交集，将结果给coll
        coll.retainAll(coll1);
        System.out.println(coll);

        // 11. equals(Object obj): 顺序不一样，则也为false
        // 要想返回true，需要当前集合和形参集合的元素都相同
        // 顺序是否有决定性作用取决于 collection的类型
        // arraylist的顺序是一定的，因此顺序不一样，也为false
        System.out.println(coll.equals(coll1)); // false

        // 12. hashCode()：返回当前对象的哈希值
        System.out.println(coll.hashCode()); // 1

        // 13. 集合 转换为 数组：toArray()
        Object[] arr = coll.toArray();
        for(int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        // 14. 数组 转换为 集合：调用Arrays类的静态方法aslist()
        List<String> list = Arrays.asList(new String[]{"aa","bb","cc"});
        System.out.println(list);
        List<int[]> arr1 = Arrays.asList(new int[]{123, 563});
        List arr2 = Arrays.asList(324,521);
        System.out.println(arr1); // [[I@610455d6] 认为数组整体是一个元素
        System.out.println(arr2); // [324, 521]

        // iterator(): 返回iterator接口的实例，用于遍历集合元素
        
    }
}

iterator迭代器接口

用于遍历collection集合中的元素

package com.collection;

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

// 集合元素的遍历操作，使用iterator接口
// 内部的方法： hasNext()和next()

public class Demo02{

    public static void main(String[] args) {
        test();
    }

    public static void test(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("tom");
        coll.add("jerry");
        coll.add(false);

        Iterator iterator = coll.iterator();
        // way 1
        System.out.println(iterator.next()); // 123
        // way 2: not refer
        for(int i = 0;i < coll.size();i++){
            System.out.println(iterator.next());
        }
        // way 3 : refer
        // hasnext()判断是否还有下一个元素
        while(iterator.hasNext()){
            // next()：1 指针下移 2 将下移以后集合位置上的元素返回
            System.out.println(iterator.next());
        }
      
        // 错误方式一
        Iterator iterator = coll.iterator();
        while(iterator.next()!=null){
            System.out.println(iterator.next());
        }
        // 跳着输出  .NoSuchElementException

        // 错误方式二
        // 每次都会返回一个新的迭代器对象，指针的开头
        // 死循环 输出123
        while(coll.iterator().hasNext()){
            System.out.println(coll.iterator().next());
        }
      
        // 测试迭代器中的remove（）
        // 内部定义了remove（），可以在遍历的时候，删除集合中的元素
        // 此方法不同于集合直接调用remove（）
        Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            if("tom".equals(obj)){
                iterator.remove();
            }
        }
    }
}

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