Java学习12-集合-1

1.Java集合框架概述

Java 集合可分为 Collection 和 Map 两种体系

Collection 接口：单列数据，定义了存取一组对象的方法的集合
- List：：元素有序、可重复的集合
- Set：：元素无序、不可重复的集合
Map 接口：双列数据，保存具有映射关系“key-value对”的集合

1.1集合与数组存储数据概述：

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

1.2数组存储的特点

一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了，就只能操作指定类型的数据了。

1.3数组存储的弊端

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

1.4集合存储的优点

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

2.Collection接口方法

在这里插入图片描述

Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。
JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)实现。
在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理；从 JDK 5.0 增加了泛型以后，Java 集合可以记住容器中对象的数据类型。

在这里插入图片描述

【例】
contains()和containsAll()

 /**
     * 测试contains()和containsAll()
     */
    public void test1() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        Person p = new Person("Jack", 20);
        coll.add(p);
        coll.add(new Person("Jerry", 20));

        //1. contains(Object obj)：判断当前集合中是否包含obj，调用obj所在类的equals()方法
        //向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()方法
        System.out.println(coll.contains(123));//true
        System.out.println(coll.contains(new String("Tom")));//true, String中的equals()方法是重写过的
        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry", 20)));//false， Person对象中的equals()没有重写，所以调用的是Object中的equals()方法，“==”
        //重写equals()方法后，快捷键alt+insert，结果将变为true


        System.out.println("------------------------------------");

        //2.containsAll(Collection coll):判断新年更惨coll1中的所有元素是否都存在于集合中
//        Collection coll1=new ArrayList();
//        coll1.add(123);
//        coll1.add(456);
        //简化写法：
        Collection coll1 = Arrays.asList(123, 456);
        System.out.println(coll.containsAll(coll1));//true

        Collection coll2 = Arrays.asList(123456);
        System.out.println(coll.containsAll(coll2));//false
    }

remove()和removeAll()

/**
     * 测试remove()和removeAll()
     */
    public void test2() {

        //3. remove(Object obj):从当前集合中移除obj元素
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        Person p = new Person("Jack", 20);
        coll.add(p);
        coll.add(new Person("Jerry", 20));

        coll.remove(123);
        System.out.println(coll);//[456, Tom, false, Person{name='Jack', age=20}, Person{name='Jerry', age=20}]

        coll.remove(4567);
        System.out.println(coll);//[456, Tom, false, Person{name='Jack', age=20}, Person{name='Jerry', age=20}]

        coll.remove(new Person("Jerry", 20));
        System.out.println(coll);//[456, Tom, false, Person{name='Jack', age=20}, Person{name='Jerry', age=20}]
        //此处不能移除的原因：没有重写Person类的equals()方法。
        // 向Collection接口的实现类的对象中移除数据obj时，要求obj所在类要重写equals()方法


        //4.removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素
        Collection coll1 = Arrays.asList(123, 456);
        coll.removeAll(coll1);
        System.out.println(coll);//[Tom, false, Person{name='Jack', age=20}, Person{name='Jerry', age=20}]

    }

returnAll()


    /**
     * 测试returnAll()
     */
    public void test3() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        Person p = new Person("Jack", 20);
        coll.add(p);
        coll.add(new Person("Jerry", 20));

        //5. retainAll(Collection coll1):交集，获取当前集合和coll1集合的交集，并返回给当前集合
        Collection coll1 = Arrays.asList(123, 456, 789);
        coll.retainAll(coll1);
        System.out.println(coll);//[123, 456]

    }

equals()

  /**
     * 测试equals()
     */
    public void test4() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.add(false);

        //6. equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同（重写实现类的equals()方法）
        System.out.println(coll.equals(coll1));//true


    }

hashCode()

 /**
     * 测试hashCode()
     */
    public void test5() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

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

toArray() 和 Arrays.asList()

 /**
     * 测试toArray() 和 Arrays.asList()
     */
    public void test6() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);


        //8. toArray()：集合->数组
        Object[] arr = coll.toArray();
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);//123
                                       //456
                                       //Tom
                                       //false


        }

        System.out.println("-----------------------");

        //9. 扩展：Arrays.asList():数组->集合
        List<String> list=Arrays.asList(new String[]{"AA","BB","CC"});
        System.out.println(list);//[AA, BB, CC]
    }

3.Iterator迭代器接口

3.1 next() 和 hasNext()

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

/**
 * 集合元素的遍历操作：使用迭代器Iterator
 */
public class IteratorTest {

    public void teat1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        Person p = new Person("Jack", 20);
        coll.add(p);
        coll.add(new Person("Jerry", 20));

        Iterator iterator=coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//[AA, BB, CC]
        }
    }

    public static void main(String[] args) {
        IteratorTest it=new IteratorTest();
        it.teat1();
    }
}

3.2 remove()

public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        Person p = new Person("Jack", 20);
        coll.add(p);
        coll.add(new Person("Jerry", 20));

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

        }
        //遍历集合
        //上一个迭代器的指针已经到头了，所以要再新建一个迭代器
        Iterator iterator1 = coll.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }

    }

【注意】

Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。

4.增强for循环：

增强for循环可以用来遍历集合或者数组

for(集合中元素的类型局部遍历：集合对象)
for(数组中元素的类型局部遍历：数组对象)

【例1】用增强for循环遍历集合

import java.util.ArrayList;
import java.util.Collection;

/**
 * 增强for循环
 */

public class ForTest {

    public void test1() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        Person p = new Person("Jack", 20);
        coll.add(p);
        coll.add(new Person("Jerry", 20));

        //for(集合中元素的类型  局部遍历：集合对象)
        //for(数组中元素的类型  局部遍历：数组对象)
        for (Object obj : coll) {
            System.out.println(obj);
        }
    }

    public static void main(String[] args) {
        ForTest ft = new ForTest();
        ft.test1();

    }
}

【例2】用增强for循环遍历数组

 public void test2() {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
 		////for(数组中元素的类型  局部遍历：数组对象)
        for (int i:arr) {
            System.out.println(i);
        }
    }

在这里插入图片描述

5.Collection子接口一：List

5.1 List接口概述

List集合类中 元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
List接口的实现类常用的有：ArrayList、LinkedList和Vector。

ArrayList、LinkedList、Vector三者的异同：

同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
不同：
- ArrayList：List接口的主要实现类，线程不安全，效率高；底层使用Object[]存储
- LinkedList：对于频繁的插入、删除操作的效率高；底层使用双向链表存储
- Vector：List接口的古老的实现类，线程安全，效率低；底层使用Object[]存储

5.2 List接口方法

5.3 List 实现类之一：ArrayList

ArrayList 是 List 接口的典型实现类、主要实现类
ArrayList是对象引用的一个”变长”数组
JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组
Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 实例，也不是eVector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合

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

void add(int index, Object ele): 在index 位置插入ele 元素
boolean addAll(int index, Collection eles): 从index 位置开始将eles中的所有元素添加进来
Object get(int index): 获取指定index 位置的元素
int indexOf(Object obj): 返回obj 在集合中首次出现的位置，若找不到obj元素，则返回-1
int lastIndexOf(Object obj): 返回obj 在当前集合中末次出现的位置
Object remove(int index): 移除指定index 位置的元素，并返回此元素
Object set(int index, Object ele): 设置指定index 位置的元素为ele
-List subList(int fromIndex, int toIndex): 返回从fromIndex 到toIndex位置的子集合

【例】

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListTest {

    public static void main(String[] args) {
        ListTest listTest = new ListTest();
        listTest.test1();

    }

    public void test1() {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom", 12));
        list.add(456);

        System.out.println(list);//[123, 456, AA, Person{name='Tom', age=12}, 456]

        //1. void(int index, Object ele)：在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456]

        //2. boolean addAll(int index, Collection eles): 从index 位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456, 1, 2, 3]

        list.add(list1);
        System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456, 1, 2, 3, [1, 2, 3]]
                //注意list.addAll(list1); 和 list.add(list1);的区别

        //3.  Object get(int index): 获取指定index 位置的元素
        System.out.println(list.get(0));//123

        //4. int indexOf(Object obj): 返回obj 在集合中首次出现的位置,若找不到obj元素，则返回-1
        System.out.println(list.indexOf("BB"));//1

        //5.  int lastIndexOf(Object obj): 返回obj 在当前集合中末次出现的位置
        System.out.println(list.lastIndexOf(456));//5

        //6.  Object remove(int index): 移除指定index 位置的元素，并返回此元素
        System.out.println(list.remove(3));//AA
        System.out.println(list);//[123, BB, 456, Person{name='Tom', age=12}, 456, 1, 2, 3, [1, 2, 3]]

        //7.Object remove(Object obj)
        list.remove(list1);
        System.out.println(list);//[123, BB, 456, Person{name='Tom', age=12}, 456, 1, 2, 3]
                //如果ArrayList内装的是Integer对象，则 .remove(8)是删掉下标为8的元素
               //remove(Integer.valueOf(8)) 是删掉8这个元素

        //8.Object set(int index, Object ele): 设置指定index 位置的元素为ele
        list.set(0,"CC");
        System.out.println(list);//[CC, BB, 456, Person{name='Tom', age=12}, 456, 1, 2, 3]

        //9.List subList(int fromIndex, int toIndex): 返回从fromIndex 到toIndex位置的子集合
        System.out.println(list.subList(0, 2));//[CC, BB]

    }
}

总结：ArrayList常用方法;

增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：1. Iterator迭代器方式 2. 增强for循环 3. 普通的循环

【例】遍历ArrayList方法总结

 /**
     * ArrayList的遍历
     */
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");

        //方式一：Iterator方式
        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));
        }

    }

5.4 List 实现类之二：LinkedList

对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高

新增方法：

void addFirst(Object obj)
void addLast(Object obj)
Object getFirst()
Object getLast()
Object removeFirst()
Object removeLast()

5.5 List 实现类之三：Vector

Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
在各种list中，最好把ArrayList作为首选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。

新增方法：

void addElement(Object obj)
void insertElementAt(Object obj,int index)
void setElementAt(Object obj,int index)
void removeElement(Object obj)
void removeAllElements()

6.Collection子接口二：Set

6.1 Set接口概述

Set接口是Collection的子接口，set接口没有提供额外的方法
Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。
Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法
对于存放在Set容器中的对象，对应的类一定要重写equals() 和hashCode(Objectobj) 方法（自动生成即可），以实现对象相等规则。

HsahSet：作为Set接口的主要实现类；线程不安全；可以存储null值
LinkedHashSet：HashSet的子类；遍历其内部顺序时，可以按照添加的顺序遍历
TreeSet：可以按照添加对象的指定属性，进行排序

6.2 Set 实现类之一：HashSet

HashSet概述：

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
HashSet 具有以下特点：
- 元素是无序的，无序不等于随机。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
- 元素是不可重复的，保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个
- HashSet 不是线程安全的
- 集合元素可以是 null
HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
对于存放在Set容器中的对象，对应的类一定要重写equals() 和hashCode(Objectobj) 方法（自动生成即可），以实现对象相等规则。

HashSet添加元素过程：

向HashSet中添加元素a，首先调用元素a所在类的hashCode方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组在此位置上是否已经有元素：

如果此位置上没有其他元素，则元素a添加成功-----------------------------------------> 情况1
如果此位置上有其它元素b（或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
- 如果hash值不同，则元素a添加成功-------------------------------------------------->情况2
- 如果hash值相同，进而需要调用元素a所在类的equals()方法：
  - equals()返回true，元素a添加失败
  - equals()返回false，元素a添加成功---------------------------------------------->情况3

对于添加成功的情况2 和情况3 而言，元素a与已经存在指定索引位置上的数据以链表方式存储：
jdk7：元素a放到数组中，指向原来的数组
jdk8：原来的元素放在数组中，指向元素a

 public void test1(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));

        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//AA
                                                // CC
                                                //129
                                                // 456
                                                //123
                                                //User{name='Tom', age=12}

        }

    }

6.3 Set 实现类之二：LinkedHashSet

LinkedHashSet概述：

LinkedHashSet 是 HashSet 的子类
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
LinkedHashSet 不允许集合元素重复。

public void test1(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//456
                                                // 123
                                                //AA
                                                // CC
                                                //User{name='Tom', age=12}
                                                //129

        }

    }

6.4 Set 实现类之三：TreeSet（了解）

TreeSet概述：

向TreeSet中添加的数据，要求时像同类的对象
TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。
自然排序中，比较两个对象是否相同的标准为：compareTo()，相同返回0，不同返回1，不再是使用equals()
定制排序中，比较两个对象是否相同的标准为：conpare()，返回0相同，不同返回1，不再使用equals()
TreeSet底层使用红黑树结构存储数据

【例】

User类

import java.util.Objects;

public class User implements Comparable {
    private String name;
    private int age;

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

    public User() {
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

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

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

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

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

    //按照姓名从小到大排列，年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if (o instanceof User) {
            User user = (User) o;
//            return this.name.compareTo(user.name);
            int compare = this.name.compareTo(user.name);
            if (compare != 0) {
                return compare;
            } else {
                return Integer.compare(this.age, user.age);
            }
        } else {
            throw new RuntimeException("输入的类型不匹配");
        }
    }

    //按照姓名从大到小排列，年龄从小到大排列
  /*  @Override
    public int compareTo(Object o) {
        if (o instanceof User) {
            User user = (User) o;
//            return -this.name.compareTo(user.name);
            int compare = -this.name.compareTo(user.name);
            if (compare != 0) {
                return compare;
            } else {
                return Integer.compare(this.age, user.age);
            }
        } else {
            throw new RuntimeException("输入的类型不匹配");
        }
    }*/

}

测试TreeSet()

import java.util.*;

/**
 * Set存储
 * 1. 无序性，无序性不等于随机性
 * 2. 不可重复
 */

public class SetTest {

    public static void main(String[] args) {
        SetTest setTest = new SetTest();
        //setTest.test2();
        setTest.test3();


    }

    /**
     * 自然排序
     */
    public void test1() {
        Set set = new TreeSet();
        //TreeSet只能添加像同类型的对象
        set.add(456);
        set.add(123);
        set.add(129);

        outPut(set);
        //123
        //129
        //456

    }

    /**
     * 自然排序（重写了User类的compareTo()方法）
     */
    public void test2() {
        Set set = new TreeSet();
        //TreeSet只能添加像同类型的对象
        set.add(new User("Tom", 12));
        set.add(new User("Jerry", 18));
        set.add(new User("Jack", 38));
        set.add(new User("Mike", 27));
        set.add(new User("Mike", 29));

        outPut(set);
//        User{name='Jack', age=38}
//        User{name='Jerry', age=18}
//        User{name='Mike', age=27}
//        User{name='Mike', age=29}
//        User{name='Tom', age=12}
    }

    /**
     * 定制排序
     */
    public void test3() {
        Comparator com = new Comparator() {
            // 照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User) {
                    User u1 = (User) o1;
                    User u2 = (User) o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else {
                    throw new RuntimeException("输入的类型不匹配");
                }
            }
        };

        Set set = new TreeSet(com);

        //TreeSet只能添加像同类型的对象
        set.add(new User("Tom", 12));
        set.add(new User("Jerry", 18));
        set.add(new User("Jack", 38));
        set.add(new User("Mike", 27));
        set.add(new User("Mike", 29));

        outPut(set);
//        User{name='Tom', age=12}
//        User{name='Jerry', age=18}
//        User{name='Mike', age=27}
//        User{name='Mike', age=29}
//        User{name='Jack', age=38}


    }

    /**
     * 迭代器
     *
     * @param set
     */
    public static void outPut(Set set) {
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }


}