天天看点
返回

集合

什么是集合

由若干元素构成的集合

学生构成了一个班级 若干个班级构成了年级

父母亲人构成了家庭 等等

数组和集合的区别

  1. 数组

     长度初始化后不可改变

  2. 数组

     只能按索引顺序存取
  3. 集合大小可以

    任意改变
  4. 保证无重复元素的集合
  5. ...

Collection(除了Map之外的集合的老祖宗 是一个接口 在java.util包中)

java.util

 包中提供了以下三种类型的集合

  1. List

     集合 一种有序列表的集合

  2. Set

     集合 一种保证没有重复元素的集合

  3. Map

     集合 一种通过键值（key-value）查找的映射表集合

List示例 

package com.collection;


import org.junit.Test;

import java.util.*;

public class Demo01 {
    public static void main(String[] args) {
        List list1 = new ArrayList<>();

        // 集合是否为空
        System.out.println(list1.isEmpty());

        // 添加集合元素
        list1.add("wwbao");
        list1.add("yyll");
        list1.add(20);
        list1.add(false);
        list1.add(new Person("yyll", 22));
        list1.add(new String("1314"));

        System.out.println("==============size==========");
        int size = list1.size();
        System.out.println("==>Get size:" + size);

        System.out.println("============contains============");
        // contains 当前集合是否包含某个对象
        System.out.println(list1.contains(20));  // true

        /*
         * 当对比自定义类时 实际上contains 比较的是对象的equals方法
         * 如果没有重写equals方法 则调用的是Object类的equals方法
         * equals方法比较的是 值！！！
         * */
        System.out.println(list1.contains(new Person("yyll", 22))); // true
        System.out.println(list1.contains(new String("1314"))); // true
        System.out.println("============contailsAll==========");

        List list = Arrays.asList("wwbao", "yyll");
        // 判断list中所有元素是否存在于coll中
        System.out.println(list1.containsAll(list));

        System.out.println("=============遍历===========");
        Iterator it = list.iterator();
        // hasNext判断是否有下一个元素 有返回true 没有返回false
        while (it.hasNext()) {
            // next方法获取元素
            Object result = it.next();
            System.out.println("==>Get result:" + result);
        }

        System.out.println("=============indexOf===========");
        /*
         * 列表中指定元素的第一次出现的索引
         *
         * 列表不包含元素，则返回-1
         * */
        int index = list1.indexOf(111);
        System.out.println("返回indexOf的位置是:" + index);

        System.out.println("=============remove===========");
        System.out.println("删除前的list:" + list1);
        Object remove = list1.remove(3);
        System.out.println(remove);
        System.out.println("删除后的list:" + list1);

        System.out.println("=============toArray() ===========");
        Object[] arrays = list1.toArray();
        System.out.println(Arrays.toString(arrays));
    }
}

Person

 
package com.collection;

public class Person {
    private String name;
    private int age;

    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;

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

输出
集合

集合交集

 
@Test
    /**
     * 集合交集
     */
    public void test1() {
        Collection coll = new ArrayList();
        coll.add("wwbao");
        coll.add("yyll");
        coll.add(20);
        coll.add(false);
        coll.add(new String("1314"));

        Collection coll1 = new ArrayList();
        coll1.add("wwbao");
        coll1.add("yyll");
        coll1.add(20);
        coll1.add(false);
        coll1.add(new String("1314"));

//        coll.retainAll(coll1);
//        System.out.println(coll);
        /*
        * equals
        * 如果结果为true
        * 当前集合和形参必须数据完全一模一样
        * ArrayList是一个有序集合!!!!!!!!!
        * 顺序如果错了 数据相同 equals 判断也是false
        * */
        System.out.println(coll.equals(coll1));
    }

输出
集合

集合差集

 
@Test
    /**
     * 集合差集
     */
    public void test() {
        Collection coll = new ArrayList();
        coll.add("wwbao");
        coll.add("yyll");
        coll.add(20);
        coll.add(false);
        coll.add(new String("1314"));

        Collection coll1 = Arrays.asList(false, 20);
        coll.removeAll(coll1);
        System.out.println(coll);
    }

输出
集合

集合 数组互转

 
@Test
    /**
     * 集合转成数组
     * 数组到集合
     */
    public void test2() {
        Collection coll = new ArrayList();
        coll.add("wwbao");
        coll.add("yyll");
        coll.add(20);
        coll.add(false);
        coll.add(new String("1314"));
        Object[] arrays = coll.toArray();
        System.out.println("集合到数组：" + Arrays.toString(arrays));

        List list = Arrays.asList("wwbao", "yyll", 20);
        System.out.println("数组到集合：" + list);

        List list1 = Arrays.asList(new int[]{123, 456});
        System.out.println("new int:" + list1);
        System.out.println("new int size:" + list1.size());
        /*
         * new int:[[I@4ee285c6]
         * new int size:1
         *
         * int类型数组中有两个元素 但是转成集合后
         * size 为 1
         * */

        List list2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println("new Integer:" + list2);
        System.out.println("new Integer size:" + list2.size());
        /*
        * new Integer:[123, 456]
        * new Integer size:2
        * */
        
        
        /*
        * 以后使用Arrays.asList方法 
        * 如果使用基本类型为入参 则asList方法会将当成一个对象
        * 不会得到预期的结果
        * 要么使用基本类型对应的包装类
        * 要么直接赋值  Arrays.asList(123,456) ...
        * */
    }

输出
集合

迭代器

 
@Test
    public void test1() {
        Collection coll = new ArrayList();
        coll.add("wwbao");
        coll.add("yyll");
        coll.add(20);
        coll.add(false);
        coll.add(new String("1314"));

        Iterator it = coll.iterator();

        while (it.hasNext()) {
            // it.remove(); // java.lang.IllegalStateException
            Object value = it.next();
            if (value.equals(20)) {
                it.remove();
            }
            // it.remove(); // java.lang.IllegalStateException
        }
        System.out.println(coll);
        /*
        * 输出结果
        * [wwbao, yyll, false, 1314]
        * 1.在next方法没有调用之前 不能调用remove方法 否则
        * 报异常 java.lang.IllegalStateException
        *
        * 2.在next方法调用之后 只能调用一次remove方法
        * 还是会报异常 java.lang.IllegalStateException
        * */
    }

小结

  1. 集合类定义在

    java.util

     包中 有List Map Set三种集合类 使用

    Iterator

     进行遍历

  2. Arrays.asList

     不要用基本类型传参

  3. contains

     方法实际使用的是对象的equals方法
  4. 如果List集合中包含了

    自定义

     类 则该类必须重写equals方法 以保证数据的一致性

即使再小的帆也能远航

上一篇: List接口常用实现类对比
下一篇: Android View各种尺寸位置相关的方法探究