java集合框架描述

集合框架

集合和数组一样都是对多个数据进行存储操作的结构，可看作一种容器

这里的存储主要指内存层面的存储，不是持久化层面的存储，如txt文本，数据库文件，图片.jpg等

为什么用集合

数组在存储多个数据时，有这样的特点：数组一旦初始化好，其长度就确定了；一旦定义好，其元素类型也就确定，只能存储指定类型的数据，String[] arr1, int[] arr2; Object[] arr3。

所以其缺点有：

数组初始化好后，长度不能修改；

其涉及到的元素操作方法有限，添加，删除，插入等有不便，效率低；

数组存储数据的特点：有序，存第一个后存第二个，依次，不能有空位；还可存储重复的数据，对于无序，不可重复的需求无法达到

概述

集合可分为两种，Collection和Map，都是接口

Collection, 单个数据，没提供直接的实现类

Collection子接口：

• List 存储的元素有序，可重复
• Set 存储的元素无序，不可重复

Map 映射，存储具有映射关系的“key-value对”，直接提供了具体的实现类

import java.util.Objects;

public class Person {

    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("person...equals");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class CollectionTest {


    @Test
    public void test1(){

        Collection coll = new ArrayList();

        //add(Object e)
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(true);


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

        //addAll(Collection c);
        Collection coll2 = new ArrayList();
        coll2.add(789);
        coll.addAll(coll2);

        System.out.println(coll.size());
        System.out.println(coll);  //[AA, BB, 123, true, 789]

        //isEmpty()判断当前集合是否为空
        System.out.println(coll.isEmpty());  //false

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

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


    @Test
    public void test2(){
        Collection coll = new ArrayList();

        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(true);

        coll.add(new Person("LiHua", 18));  1-1
        /*Person person = new Person("LiHua", 20);
        coll.add(person);
        System.out.println(coll.contains(person));  //true
*/

        //contains(Object o)  集合中是否包含o元素
        System.out.println(coll.contains(123));
        System.out.println(coll.contains(new String("Tom")));   //true,比较的是内容,equals方法String类重写过
        //System.out.println(coll.contains(new Person("LiHua",18)));  //false
        //在Perons类没重写equals方法时，实际上用的是Object类里的equalsf方法，就是==，返回值就是false;那么重写类里的equals方法,返回值为true
        System.out.println(coll.contains(new Person("LiHua",18))); 1-2

             //containsAll(Collection coll)  //判断形参coll集合中的元素是否都存在于当前元素中
        Collection list = Arrays.asList(123, true);  //该方法返回值为List类型值
        System.out.println(coll.containsAll(list));  //true

    }
}

执行结果是：

true
true
person...equals
person...equals
person...equals
person...equals
person...equals
true

实际是拿着1-2语句中创建的person对象作为equals方法的调用者，调用equals方法，参数为每个add的数值，每添加一个，都会执行一次equals方法。

 @Test
    public void test3(){
        Collection coll = new ArrayList();

        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(true);

        coll.add(new Person("LiHua", 18));

        //remove(Object o)
        System.out.println(coll.remove(123));

        System.out.println(coll);

        coll.remove(new Person("LiHua", 18));
        System.out.println(coll);


        //removeAll(Collection c)
        Collection collection = Arrays.asList(456,true);
        System.out.println(collection);
        coll.removeAll(collection);
        System.out.println(coll);
    }

执行结果是：

true
[456, Tom, true, Person{name='LiHua', age=18}]
person...equals
person...equals
person...equals
person...equals
[456, Tom, true]
[456, true]
[Tom]

 @Test
    public void test4(){
        Collection coll = new ArrayList();

        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(true);

        coll.add(new Person("LiHua", 18));


        Collection list = Arrays.asList(123,456);
        coll.retainAll(list);  //求交集
        System.out.println(coll);

        //equals(Object o)
        System.out.println(coll.equals(list));

执行结果：

person...equals
person...equals
[123, 456]
true

Collection接口继承了java.lang.Iterable接口，该接口中有一个iterator()方法，也就是说所有实现了Collection类型的集合都可以调用iterator()方法，返回一个实现了Iterator接口的对象，得到的是一个全新的迭代器对象。

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

内部方法有：

boolean hasNext() 判断是否有下个元素，有的话，返回true

E next() 指针下移；将下移以后集合位置上的元素返回，默认指针首先在第一个元素之前

void remove() 遍历时可删除集合中的元素

@Test
    public void test(){
        Collection coll = new ArrayList();

        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(true);

        coll.add(new Person("LiHua", 18));

        Iterator iterator = coll.iterator();

        for(int i = 0; i < coll.size(); i++){
            System.out.println(iterator.next());
        }

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

增强for循环

格式：

for(集合或数组元素类型 局部变量名 ： 集合或数组对象){

}

实则内部调用的还是迭代器，集合内自动取第一个元素赋给局部变量，输出，接着取第二个元素。即修改局部变量，不会改变数组或集合元素值