Collection集合学习

最新推荐文章于 2022-01-19 09:00:00 发布

qq_42573597

最新推荐文章于 2022-01-19 09:00:00 发布

阅读量230

点赞数 2

分类专栏：学习

本文链接：https://blog.csdn.net/qq_42573597/article/details/89061984

版权

学习专栏收录该内容

29 篇文章 0 订阅

订阅专栏

1.Collection集合

1.1集合体系结构

集合类的特点

提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

1.2Collection集合概述和基本使用

Collection集合概述

1、是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素

2、JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

Collection集合基本使用

package com.itfenghua01;

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

public class CollectionDemo {
    public static void main(String[] args) {
        Collection<String> cc = new ArrayList<String>();
        cc.add("12");
        cc.add("22");
        cc.add("33");
        Iterator<String> it = cc.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("----------");
        for (String ss:cc){
            System.out.println(ss);
        }
        System.out.println("==========");
        Collection<String> c =new ArrayList<String>();
        c.addAll(cc);
        for (String sss:c){
            System.out.println(sss);
        }
    }
}

1.3Collection集合的遍历

迭代器的介绍

迭代器，集合的专用遍历方式

Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到

迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

Collection集合的遍历

package com.itfenghua01;

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

public class CollectionDemo {
    public static void main(String[] args) {
        Collection<String> cc = new ArrayList<String>();
        cc.add("12");
        cc.add("22");
        cc.add("33");
        Iterator<String> it = cc.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("----------");
    }

2.List集合

2.1List集合概述和特点

List集合概述

   有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素

与Set集合不同，列表通常允许重复的元素

List集合特点

有索引

可以存储重复元素

元素存取有序

package com.itfenghua02;

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

    public Student() {
    }

    public Student(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;
    }
}
------------------------------------------
package com.itfenghua02;

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

public class ListDemo {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<Student>();
        Student s1 = new Student("上杉绘梨衣",21);
        Student s2 = new Student("刘亦菲",20);
        Student s3 = new Student("日向雏田",19);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        Iterator<Student> it = list.iterator();
        while (it.hasNext()){
            Student st = it.next();
            System.out.println(st.getName()+", "+st.getAge());
        }
        System.out.println("-----------");
        List<Student> list1 =new ArrayList<Student>();
        Student s4 = new Student("路明非",22);
        Student s5 = new Student("楚子航",21);
        Student s6 = new Student("漩涡鸣人",23);
        list.add(1,s4);

        //方法一
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).getName()+" ,"+list.get(i).getAge());

        }
        //方法二
        System.out.println("----------");
        for (Student s:list){
            System.out.println(s.getName()+"  "+s.getAge());
        }
        System.out.println("-----=----");
        ListIterator<Student> str = list.listIterator();
        while (str.hasNext()){
            Student ss = str.next();
            System.out.println(ss.getName()+"  "+ss.getAge());
        }

    }
}

2.2并发修改异常

出现的原因

迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException

解决的方案

用for循环遍历，然后用集合对象做对应的操作即可

2.3列表迭代器

ListIterator介绍

通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器

用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

package cn.itobject01;


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

public class ListIteratorDemo {
    public static void main(String[] args) {
        List<String> ll = new ArrayList<String >();
        ll.add("路明非");
        ll.add("楚子航");
        Iterator<String> it = ll.iterator();
 /*       while (it.hasNext()){
            //ConcurrentModificationException
            String s=it.next();
            if (s.equals("楚子航")){
                //iterator()中含没有add的方法，用集合的add方法没有并发异常修改
                list.add("上杉绘梨衣");
            }
        }*/
    /*    for (int i = 0; i < list.size(); i++) {
            if (list.equals("bb")){
            //ArrayList中的add 方法不会出现并发异常修改
                list.add("ff");
            }
        }*/
        ListIterator<String> lit = ll.listIterator();
        while (lit.hasNext()){
            String s=lit.next();
            if (s.equals("路明非")){
                lit.add("上杉绘梨衣");
                //使用listIterator迭代器添加元素不会出现并发修改异常
               // ll.add("上杉绘梨衣");
                //使用ArrayList集合添加元素会出现并发修改异常
                //ConcurrentModificationException
            }

        }
        System.out.println(ll);
        //[路明非, 上杉绘梨衣, 楚子航]

    }
}

2.4增强for循环

定义格式

for(元素数据类型变量名 : 数组/集合对象名) {
循环体;
}

3.数据结构

3.1数据结构之栈和队列

栈结构

先进后出
队列结构

先进先出

3.2数据结构之数组和链表

数组结构

查询快、增删慢
队列结构

查询慢、增删快

4.List集合的实现类

List集合子类的特点

ArrayList集合

底层是数组结构实现，查询快、增删慢
LinkedList集合

底层是链表结构实现，查询慢、增删快

package cn.itobject01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

public class ListDemo {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<String>();
        arr.add("路明非");
        arr.add("楚子航");
        arr.add("上杉绘梨衣");
        //遍历方式一
        for (String s:arr){
            System.out.println(s);
        }
        System.out.println("----------");
        //遍历方式二
        Iterator<String> st = arr.iterator();
        while (st.hasNext()){
            System.out.println(st.next());
        }
        System.out.println("----------");
        //方式三
        for (int i = 0; i < arr.size(); i++) {
            System.out.println(arr.get(i));
        }
        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("胡歌");
        linkedList.add("刘亦菲");
        linkedList.add("霍建华");
        System.out.println("------------");
        //方式一
        for (int j = 0; j <linkedList.size() ; j++) {
            System.out.println(linkedList.get(j));

        }
        System.out.println("------------");
        //方式二
        for (String ss:linkedList){
            System.out.println(ss);
        }
        System.out.println("------------");
        //方式三
        Iterator<String> ite = linkedList.iterator();
        while (ite.hasNext()){
            System.out.println(ite.next());
        }
    }
}