Java集合：Collection集合架构、加强for循环、迭代器、List、Set

最新推荐文章于 2023-03-20 22:20:00 发布

JustDo IT

最新推荐文章于 2023-03-20 22:20:00 发布

阅读量116

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/m0_63104578/article/details/125795796

版权

JavaSE 专栏收录该内容

40 篇文章 1 订阅

订阅专栏

package com.atguigu.java2;

import org.junit.Test;

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

/**
 * 一：集合框架的概述
 *
 * 1.集合、数组都是对多个数据进行储存操作的结构，简称Java容器。
 *      说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储。
 *
 * 2.1数组在存储多个数据方面的特点：
 *      >一旦初始化，其长度就确定了。
 *      >数组一旦定义好，其元素的类型也就确定了，我们就只能操作指定类型的数据了，
 *      比如：String[] char[] int[] Object[] arr2;
 *
 * 2.2数组在存储多个数据方面的缺点：
 *      >一旦初始化其长度就不可修改了
 *      >数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不方便，效率不高
 *      >获取数组中实际元素的个数的需求，数组没有现成的属性或者方法可用。
 *      >数组存储数据的特点：有序的、可重复。对于无序、不可重复的需求，不能满足。
 *
 *二：集合框架：
 *
 * |-----Collection接口：单列集合，用来存储一个一个的对象。
 *
 *        |-----list接口:存储有序、可重复数据   ---->“动态“数组
 *              |----ArrayList、LinkedList、Vector
 *
 *        |-----set接口：存储无序、不可重复数据  ----->高中讲的集合
 *              |----HashSet、LinkedHashSet、TreeSet
 *
 * |-----Map接口：双列集合，用来存储一对一对（key- value）的数据：--->函数：y=f(x)
 *              |----HashMap、LinkedHashMap、TreeMap、HashTable、Properties
 *
 * 三、Collection接口中的API:
 *
 *
 * @author
 * @create 2022-07-13 12:11
 */
public class CollectionTest {

    @Test
    public void test1(){

        Collection coll = new ArrayList();

        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());//4

        //addAll(Collection coll1):将coll1集合中的元素添加到coll集合中
        Collection coll1 = new ArrayList();
        coll1.add("dwd");
        coll1.add(666);
        coll1.add(444);

        coll.addAll(coll1);
        System.out.println(coll.size());//7
        System.out.println(coll.toString());

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

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


    }
}

package com.atguigu.java;

import org.junit.Test;

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

/**
 *Collection 接口中声明的方法的测试
 *
 * 向Collection接口中的实现类的对象中添加数据obj时，要求他的所在类要重写equals()方法。
 *
 * @author
 * @create 2022-07-13 18:53
 */
public class CollectionTest {
    @Test
    public void test1() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("rr");
        coll.add(new String("Tom"));
//        Person p = new Person("Jerry",78);
//        coll.add(p);
        coll.add(new Person("Jerry", 78));

        //1.contains(Object obj):判断当前集合是否包含obj
        //我们在判断时会调用obj对象所在类的equals()方法
        boolean contains = coll.contains(323);
        System.out.println(contains);

        System.out.println(coll.contains(new String("Tom")));
//        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry", 78)));

        //2.containsAll(Collection coll1):判断形参中的元素是否全在当前集合之中。
        Collection coll1 = Arrays.asList(323, "rr");
        System.out.println(coll.containsAll(coll1));
    }

    @Test
    public void test2() {

        //3.remove(Object obj):从当前集合删除obj元素
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("rr");
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 78));
        coll.add(false);

        coll.remove(123);
        System.out.println(coll);

        coll.remove(new Person("Jerry", 78));
        System.out.println(coll);

        //3.removeAll(Collection coll1):从当前集合删除coll1中所有元素
        Collection coll1 = Arrays.asList("rr", "Tom");
        coll.removeAll(coll1);
        System.out.println(coll);
    }

    @Test
    public void test3() {
        //5.retainAll(Collection coll1):交集，获取当前集合和参数集合的交集，并返回给当前集合。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("rr");
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 78));
        coll.add(false);

        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add("rr");

        coll.retainAll(coll1);
        System.out.println(coll);
    }

    @Test
    public void test4() {
        //6.equals(Object obj):要想返回true,需要当前集合和参数集合的数据一样(顺序也要一样)
        //因为list是有序的可重复的。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("rr");
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 78));
        coll.add(false);

        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add("rr");
        coll1.add(new String("Tom"));
        coll1.add(new Person("Jerry", 78));
        coll1.add(false);

        System.out.println(coll.equals(coll1));
    }

    @Test
    public void test5() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("rr");
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 78));
        coll.add(false);

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

        //8.集合---转换为--->数组 toArray()

        Object[] array = coll.toArray();
        for(int i = 0;i < array.length;i++){
            System.out.println(array[i]);
        }

        //拓展：数组--->集合？可以的:调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"aa","cc"});
        System.out.println(list.toString());

        List<int[]> arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1.size());//1

        List<Integer> arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2.size());

        //9.iterator():返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试。


    }
}

package com.atguigu.java;

import org.junit.Test;

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

/**
 * 集合元素的遍历操作，使用迭代器Iterator接口
 *
 * 1.内部的 hasNext() 和 next()方法
 * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
 * 默认游标都在集合的第一个元素之前。
 * 3.内部定义了remove()方法，可以在遍历的时候，删除集合中的元素，
 * 此方法不同于集合直接调用remove()
 *
 * @author
 * @create 2022-07-13 21:06
 */
public class IteratorTest {
    @Test
    public void test(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("rr");
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 78));
        coll.add(false);

        Iterator iterator = coll.iterator();
//        //方式一：只是来演示一下
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
        //报异常：NoSuchElementException
//        System.out.println(iterator.next());
        //方式二：不推荐
//        for (int i = 0;i < coll.size();i++){
//            System.out.println(iterator.next());
//        }
        //方式三：推荐!
        while(iterator.hasNext()){//判断是否还有下一个元素
            //①指针下移②将下移后集合位置的上的元素 返回。
            System.out.println(iterator.next());
        }
    }
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("rr");
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 78));
        coll.add(false);
//错误方式一：
//        Iterator iterator = coll.iterator();
//        while((iterator.next() != null)){
//            System.out.println(iterator.next());
//        }
//错误方式二：
//        while(coll.iterator().hasNext()){
//            System.out.println(coll.iterator().next());
//        }

    }

    //测试Iterator中的remove()方法

    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("rr");
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 78));
        coll.add(false);

        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());
        }
    }
}

package com.atguigu.java;

import org.junit.Test;

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

/**
 *1.List接口框架
 * |-----Collection接口：单列集合，用来存储一个一个的对象。
 *
 *    |-----list接口:存储有序、可重复数据   ---->“动态“数组
 *        |----ArrayList：作为List接口的主要实现类，是线程不安全的，效率高。底层使用Object[] elementDate储存；
 *        |----LinkedList：对于频繁的插入和删除操作使用此类效率比ArrayList效率高。底层是使用的双向链表储存；
 *        |----Vector：作为List接口的古老实现类：线程安全的。效率低。底层使用Object[] elementDate储存；
 *
 * 2.ArrayList源码分析：
 *
 * ArrayList的源码分析：jdk7和jdk8稍有不同
 *
 *   2.1jdk7情况下:
 *   ArrayList list = new ArrayList();底层创建了长度是10的Object[]数组:elementDate
 *   list[0] = 123;//elementData[0] = new Integer(123);
 *   ...
 *   list.add(11);如果此时的添加导致底层elementData数组的容量不够,就进行扩容。
 *   默认情况下，扩容为原来容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
 *   结论：建议在开发中建议使用带参数的构造器：ArrayList arrList = new ArrayList[20];
 *
 *   2.2jdk8情况下的变化:
 *
 *   ArrayList list = new ArrayList();//底层的elementData初始化为{}，意味着并没有创建长度为10的数组。
 *
 *   list.add();//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到里面的第一个位置，后续的添加、扩容操作就和jdk一样了。
 *
 *   2.3小结：jdk7 ArrayList的创建类似于单例模式的饿汉式
 *   jdk8 ArrayList的创建类似于单例模式的懒汉式，延迟了数组的创建，节约了内存空间。
 *
 *
 *  3.LinkedList源码分析：
 *
 *  linkedList list = new LinkedList();内部声明了Node()类型的first和last属性，默认值为null.
 *  list.add(123);//将123封装到Node中，创建了Node对象
 *
 *  其中，Node定义为:体现了LinkedList双向链表的说法。
 *  private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
        }
    }
 *
 *
 * 4.Vector的源码分析：jdk7jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组，
 * 在扩容方面，默认扩容为原来的数组长度的2倍。
 *
 *
 * 5.List接口中的常用方法：
 *
 *
 *
 *
 *
 *面试题：ArrayList、LinkedList、Vector三者之间的异同
 *同：三个类都实现了List接口，储存数据的特点相同：都是储存有序可重复的数据。
 * 不同：见上
 * @author 李长勇
 * @create 2022-07-14 12:55
 */
public class ListTest {

    /*
    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在集合中首次出现的位置
    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位置的子集合

    总结：常用方法
        增：add(Object obj)
        删：remove(Object obj) remove(int index)
        改：set(int index,Object obj)
        查：get(int index)
        插：add(int index,Object obj)
        长度：size()
        遍历：①iterator迭代器
              ②增强for循环
              ③普通循环
     */
    @Test
    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(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }

    }

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

        //int indexOf(Object obj):返回obj在集合中首次出现的位置;如果不存在返回-1
        int indexOf = list.indexOf(456);
        System.out.println(indexOf);

        //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置;如果不存在返回-1
        int lastIndexOf = list.lastIndexOf(456);
        System.out.println(lastIndexOf);

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        Object remove = list.remove(4);
        System.out.println(remove);
        System.out.println(list);

        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1, "CC");
        System.out.println(list);

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
        System.out.println(list);


    }

    @Test
    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);
        //void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);

        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list.size());//9

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


    }
}

package com.atguigu.java;

/**
 * @author 李长勇
 * @create 2022-07-13 19:00
 */
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) {
        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;
    }

//    @Override
//    public int hashCode() {
//        int result = name != null ? name.hashCode() : 0;
//        result = 31 * result + age;
//        return result;
//    }
}

package com.atguigu.java1;

import com.atguigu.java.Person;
import org.junit.Test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 *
 * 二：集合框架：
 *
 * |-----Collection接口：单列集合，用来存储一个一个的对象。
 *
 *     |-----set接口：存储 无序、不可重复数据  ----->高中讲的集合
 *
 *          |----HashSet:作为 Set 接口的主要实现类；线程不安全的；可以储存null值；
 *
 *              |----LinkedHashSet:作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。
 *
 *          |----TreeSet:可以按照添加对象的指定属性进行排序。
 * 1.Set接口中没有额外定义新的方法，使用的都是Collection接口中定义好的方法。
 *
 * 2.要求：向Set中添加的数据所在的类一定要重写两个方法，一个是equals()方法和hashCode()方法
 *   要求：重写的hashCode方法和equals方法尽可能的保持一致性：相等的对象必须具有相等的散列码。
 *   重写两个方法的技巧：对象中用作equals()方法比较的Field，都应该用来计算hashCode值
 *
 * @author
 * @create 2022-07-14 20:50
 */
public class SetTest {
    /*
    set接口：存储 无序、不可重复数据

    以HashSet为例说明。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值进行添加！
    1.无序性：不等于随机性。

    2.不可重复性：保证添加的元素按照equals()方法判断时不能返回true.即：相同元素只能添加一个。

    二、添加元素的过程：以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添加成功。--->情况2|

        对于添加成功的情况2和情况3而言:元素a与已经存在指定索引位置上数据以链表的方式存储。
        jdk 7 :元素a放到数组中，指向原来的元素。
        jdk 8 :原来的元素在数组中，指向元素a .
        总结:七上八下

     */
    @Test
    public void test(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        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());
        }
    }

    //LinkedHashSet的使用
    //LinkedHashSet作为HashSet的子类，在添加数据时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据。
    //优点：对于比较频繁的遍历操作，LinkedHashSet效率高于HashSet
    public void test1(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        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());
        }
    }
}

package com.atguigu.java1;

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * @author 李长勇
 * @create 2022-07-15 0:05
 */
public class TreeSetTest {
    /*
    1.向TreeSet中添加的数据，要求是相同类的对象。

    2.两种排序方式：自然排序（实现Comparable接口） 和 定制排序（Comparator）。

    3.自然排序中，比较两个对象是否相同的标准为：compareTo()方法返回 0 ，不再是equals方法。

    4.在定制排序中，较两个对象是否相同的标准为：compare()方法返回 0 ，不再是equals方法。

     */
    @Test
    public void test(){
        TreeSet set = new TreeSet();
//        set.add(123);
//        set.add(456);
//        //不能添加不同类的对象
//        set.add("AA");
//        set.add(new User("Tom",12));

        //举例一：
//        set.add(123);
//        set.add(-123);
//        set.add(1523);
//        set.add(1233);
//        set.add(123423);

        //举例二：
        set.add(new User("Tom",12));
        set.add(new User("Tm",1542));
        set.add(new User("To",15242));
        set.add(new User("Tomhg",12542));
        set.add(new User("Togm",162));
        set.add(new User("Togm",62));

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

    @Test
    public void test1(){

        //按照年龄从小到大排列：
        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("输入有误");
                }
            }
        };

        TreeSet set = new TreeSet(com);

        set.add(new User("Tom",12));
        set.add(new User("Tm",1542));
        set.add(new User("To",15242));
        set.add(new User("Tomhg",12542));
        set.add(new User("Togm",162));
        set.add(new User("Togm",62));

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


}

package com.atguigu.java1;

/**
 * @author 李长勇
 * @create 2022-07-14 21:17
 */
public class User implements Comparable {
    private String name;
    private int age;

    public User() {
    }

    public User(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 "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;

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

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

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

    }
}

package com.auguigu.exer;

import org.junit.Test;

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

/**
 * @author 李长勇
 * @create 2022-07-14 18:10
 */
public class ListExer {
    @Test
    public void testListRemove() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//[1,2]
    }
    private static void updateList(List list) {
//        list.remove(2);//按照索引删除的
        list.remove(new Integer(2));//删除的就是数据2了
    }
}