集合，迭代器

集合的体系

单列集合

  • 集合可以存储任意类型的数据对象，集合长度可变。

  • Collection是单例集合的根接口，List，Set是其子接口。

  • List的特点是元素有序，可重复，Set的特点是元素无序，不可重复。

Collection

Collection中的API

public static void demo() {
        Collection<String> collection = new ArrayList();
        collection.add("Demo"); //添加一个元素，类型为Object
        collection.addAll(null); //添加一个Collection集合
        
        collection.clear(); //清空集合
        collection.remove("Demo"); //删除集合中的某个元素
        collection.removeAll(null); //删除一个集合中的所有相同元素
        collection.retainAll(null);//保留交集元素，删除其他元素
        
        collection.isEmpty();//判断集合是不是为空
        collection.contains("Demo");//判断集合是否包含这个元素
        collection.containsAll(null);//判断集合中时候包含指定集合中的所有元素
        
        collection.iterator();//迭代器
        collection.size();//返回集合大小
}

List

List的特点是集合中的元素有序，可重复，可以通过索引来访问集合中的指定元素。

List的有序是指：元素的存入顺序和取出顺序一致，因为List集合中的元素是以线性的顺序存储的。

ArrayList

  • ArrayList底层维护了一个Object数组，使用无参的构造函数时默认Object数组容量是10，当长度不够用时自动增长0.5倍。

  • 由于底层实现使用的是数组方式，在增加或删除指定位置的元素时都会创建新的数组，效率低，不适合做大量的增删操作，但其是线性数据结构，可以通过索引来访问元素，查找效率高。

Vector
  • Vector底层也是维护了一个Object数组，实现与ArrayList一样，但它是线程安全的，安全的同时意味着效率低。
LinkedList
  • LinkedList内部维护的结构是一个双向循环链表，对于元素的操作，增删快，查找慢。
List提供的API
public static void demo() {
        ArrayList<String> list = new ArrayList<>();
        list.add(0,"Demo");//将元素插入指定索引处
        list.addAll(1,list);//将集合插入指定索引处

        list.get(0);//获取指定索引处的元素
        list.set(0,"Changed");//修改指定索引处元素数据
        list.remove(1);//删除指定索引出元素

        list.indexOf("Demo");//返回该元素在集合中的位置索引
        list.lastIndexOf("Demo");//返回该元素在集合中最后一次出现的位置索引

        //Linked
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.addFirst("First");
        linkedList.addLast("Last");

        linkedList.removeFirst();
        linkedList.removeLast();

        linkedList.getFirst();
        linkedList.getLast();
    }
Set

Set的特点是集合中的元素无序，不重复。
Set的无序是指：添加元素的顺序与取出元素的顺序不一致。

HashSet

  • 添加元素时，HashSet会先调用元素的hashCode()的方法获得元素的哈希值，然后通过元素的哈希值经过位移等运算，算出该元素在哈希表中的存储位置。

  • 如果算出的元素存储位置，目前没有任何元素存储，那么该元素可以直接存储到该位置。

  • 如果算出的元素存储位置，目前有元素存在，那么还会调用该元素的equals()方法与该位置的元素再比较一次，如果返回true，那么该元素与这个位置上的元素就视为重复元素不允许添加，否则允许添加。

注意细节

  • hashCode()每次都调用，equals()只在比较的时候调用一次。

  • hashCode()默认情况下是内存地址，String类重写了Object的hashCode()，如果两个字符串的内容一致，返回的hashCode码一定也一致。

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

    public static void test() {

        HashSet<User> hashSet = new HashSet<>();
        hashSet.add(new User(1, "Test1"));
        hashSet.add(new User(1, "Test2"));
        hashSet.add(new User(1, "Test3"));

        System.out.println(hashSet);

    }
}

class User {
    int id;
    String name;

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

    @Override
    public String toString() {
        return id + ":" + name;
    }

    @Override
    public int hashCode() {
        return this.id;
    }

    @Override
    public boolean equals(Object obj) {
        User user = (User) obj;
        return this.id == user.id;
    }
}
TreeSet

内部采用平衡二叉树来存储元素，二叉树结构可以保证TreeSet集合中没有重复的元素，并且可以对其内元素进行排序。

TreeSet注意事项

  • 添加元素的时候，如果元素本身具备了自然顺序的特性，那么就按照元素自然顺序的特性进行存储。

  • 如果不具备自然顺序的特性，那么该元素所属的类必须要实现Comparable接口，把元素比较规则定义在compareTo()方法。

class Test<T> implements Comparable<T> {

    @Override
    public int compareTo(T o) {

        // 返回负整数，零或正整数，根据此对象是小于，等于还是大于指定对象
        return 0;
    }
}

  • 在比较元素的时候，如果compareTo()返回为0，就被视为重复元素，不允许添加。

  • 添加元素时，如果元素本身不具备自然顺序的特性，而元素所属的类也没有实现Comparable接口，必须要在TreeSet的时候传入一个比较器。

class Test<T> implements Comparator<T> {

    @Override
    public int compare(T o1, T o2) {
        return 0;
    }
}
  • 往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，而元素所属的类已经实现了Comparable接口，在创建TreeSet对象的时候也传入了比较器，那么是以比较器的比较规则优先使用，推荐使用比较器Comparator。

Map集合

 public static void demo() {
        Map<String, String> map = new HashMap<>();
        for (int i = 1; i <= 3; i++)
            map.put("Key" + i, "Value" + i);

        map.get("Key1"); //获取数据
        map.containsKey("Key1"); //是否包含这个Key
        map.containsValue("Value1"); //是否包含这个Value

        for (Map.Entry<String, String> item : map.entrySet()) {
            System.out.println(item.getKey() + ":" + item.getValue());
        }
    }

Collections集合工具类

    public static void main(String[] args) throws Exception {

        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Test1");
        linkedList.add("Test3");
        linkedList.add("Test2");
        linkedList.add("Test4");

        //升序排列
        Collections.sort(linkedList);
        //倒序排序
        Collections.reverse(linkedList);
        //随机排序
        Collections.shuffle(linkedList);
        //折半查找
        Collections.binarySearch(linkedList, "Test1");

        //复制集合
        //      Collections.copy(dest, src);

        System.out.println(linkedList);
    }
迭代器

迭代器的作用就是抓取集合的元素。

Iterator

  • hasNext() 是否有下一个元素可遍历，如果有元素可以遍历返回true否则返回false。

  • next() 获取当前指针指向的元素并返回当前的元素，然后指针向下移动一个单位。

  • add() 方法会跳过指针，不会出现死循环，remove() 移除迭代器返回的最后一个元素。

  • 在迭代器迭代元素的过程中，不允许使用集合对象来改变集合中的元素个数，如果需要添加或删除只能使用迭代器提供的方法，使用for循环来修改不会有这些问题。

    public static <T> void test(ArrayList<T> list) {

        Iterator<T> iterator = list.iterator();
        
        while (iterator.hasNext()) {
            
//          iterator.remove();
            
            System.out.println(iterator.next());
        }
    }
ListIterator

ListIterator为Iterator的子类

public static <T> void test(ArrayList<T> list) {

        ListIterator<T> listIterator = list.listIterator(list.size());

        // hasPrevious 是否有上一个元素
        while (listIterator.hasPrevious()) {

            // add() 把当前元素插入当前指针指向的位置上
            // listIterator.add();

            // 替换迭代器最后一次返回的元素
            // listIterator.set();

            // previous先将指针上移，再取出元素
            System.err.println(listIterator.previous());

        }
    }
增强for循环

简化迭代器的书写格式（增强for循环的底层还是使用迭代器实现的)。

//格式
for(目标变量类型 变量名:遍历的集合/数组){

}
增强for注意事项

  • 底层的实现依旧是迭代器，所以使用增强for循环的过程中，不准使用集合对象对集合的元素个数进行修改。

  • 使用迭代器遍历集合元素时，可以删除集合元素，而增强for循环遍历集合元素时，不能使用迭代器remove()删除元素。

//自定一个类使用增强for循环
class MyList implements Iterable<String>{
    
    Object[] arr = new Object[10];
    
    int index = 0 ; //当前的指针
    
    public void add(Object o){
        arr[index++] = o;  // 1
    }
    
    public int size(){
        return index;
    }

    @Override
    public Iterator<String> iterator() {
        
        
        return new Iterator<String>() {

            int cursor  = 0;

            @Override
            public boolean hasNext() {
                return cursor<index;
            }

            @Override
            public String next() {
                return (String) arr[cursor++];
            }

            @Override
            public void remove() {
                
            }
        };
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • java中的集合
    Collection ├List │├LinkedList │├ArrayList │└Vector │└Stac...
    AndyZX阅读 893评论 0赞 1
  • java集合容器
    3.3 集合 一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另...
    闫子扬阅读 752评论 0赞 1
  • 集合总论
    Collection接口 Collection接口是所有集合的祖先类。他有两个构造方法，一个无参构造，一个是带Co...
    夜幕繁华阅读 613评论 0赞 0
  • Java基础——集合类 左Collection，右Map。
    集合类简介 为什么出现集合类？面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就要对对象进...
    阿敏其人阅读 1,442评论 0赞 7
  • JAVA集合类——难得的总结
    以下资料是在学习中总结出来的，希望对你有所帮助。如果需要请转载，谢谢。 1. StringBuffer 线程安全，...
    尚学先生阅读 736评论 0赞 1