Java常用集合基础（二）

最新推荐文章于 2024-09-21 10:38:43 发布

街角棒棒糖

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量158

点赞数

分类专栏：集合文章标签： java

本文链接：https://blog.csdn.net/dongtianyu_/article/details/107881769

版权

集合专栏收录该内容

6 篇文章 0 订阅

订阅专栏

List

1.概述

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

List集合特点

有序：存储和取出的元素顺序一致
可重复：存储的元素可以重复

package com.dong.list;

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

public class ListDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("hello");
        //输出集合对象
        System.out.println(list);
        //遍历集合对象(迭代器)
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
        String  s= it.next();
            System.out.println(s);
        }

    }
}

2.List集合特有方法

方法名	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

package com.dong.list;

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

public class ListDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("hello");
        //在指定位置插入元素
        list.add(1, "javaee");
        //删除元素
        list.remove(1);
        //修改元素
        list.set(1,"java");
        //获取集合指定位置元素
        list.get(1);
        //输出集合对象
        System.out.println(list);
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }


    }
}

3.遍历集合

需求。
创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
思路:
1:定义学生类
2:创建List集合对象
3:创建学生对象
4:把学生添加到集合
5:遍历集合(迭代器方式，for循环方式)

package com.dong.list;

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

public class ListDemo02 {
    public static void main(String[] args) {
        //创建List集合
        List<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student st1 = new Student("张三", 20);
        Student st2 = new Student("李四", 22);
        Student st3 = new Student("王五", 23);
        //把学生添加到集合
        list.add(st1);
        list.add(st2);
        list.add(st3);
        //调用集合的迭代器遍历集合
        Iterator<Student> it=list.iterator();
        while(it.hasNext()){
           Student s=it.next();
            System.out.println("姓名："+s.getName()+" 年龄："+s.getAge());
        }
        System.out.println("---------------");
        //用for循环方式
        for (int i = 0; i < list.size(); i++) {
            Student s=list.get(i);
            System.out.println("姓名："+s.getName()+" 年龄："+s.getAge());
        }

    }
}

4.并发修改异常

package com.dong.list;

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

/*需求:
       我有一个集合: list<string> list = new Arraylist<string>();
       里面有三个元素，list. add(. "hello");list. add( "world");list. add("java");
      遍历集合，得到每一个元素，看有没有"world"这个元素，如果有，我就添加一个"javaee“元素，请写代码实现
*/
//ConcurrentModificationException:当不允许这样修改时，可以通过检测到对象的并发修改的方法抛出此异常
public class ListDemo03 {
    public static void main(String[] args) {
        //创建集合对象
        List<String > list=new ArrayList<String >();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //遍历集合，得到每一个元素，看有没有world 这个元素，如果有，就添加一个javaee元素
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String s=iterator.next();
            //迭代器进行遍历集合时会对实际修改集合的次数与预期修改次数进行判断，是否相同
            //实际修改次数增加，预期没有增加就会出现并发修改异常
            if(s.equals("hello")){
                list.add("javaee");
            }
        }
        //采用for循环来解决
        for (int i=0;i<list.size();i++){
            String s=list.get(i);
            if (s.equals("world")){
                list.add("javaee");
            }
        }
            
       //输出结果
        System.out.println(list);
    }

}

5.ListIterator

ListIterator:列表迭代器

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

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

Listlterator中的常用方法

E next(): 返回迭代中的下一个元素
boolean hasNext():如果迭代具有更多元素，则返回true
E previou():返回列表中的上一个元素
boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
void add(Ee): 将指定的元素插入列表

package com.dong.list;

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

public class ListDemo04 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //通过lsit集合的listIterator()方法得到
        ListIterator<String> lit= list.listIterator();
        while(lit.hasNext()){
            String s=lit.next();
            System.out.println(s);
        }
        System.out.println("--------------------");
        while(lit.hasPrevious()){
            String s=lit.previous();
            System.out.println(s);
        }
        //add方法
        ListIterator<String> lis = list.listIterator();
        while(lit.hasNext()){
            String s=lit.next();
            if(s.equals("world")){
               lit.add("javaee");
            }
        }
        System.out.println(list);
    }
}

增强for循环

增强for：简化数组Collection集合的遍历

实现Iterable接口的类允许其对象称为增强型for语句的目标
它是JDK5之后出现的，其内部原理是一个Iterator迭代器

增强for的格式

格式:
for(元素数据类型变量名:数组或者Collection集合){
//在此处使用变量即可，该变量就是元素
}

package com.dong.list;

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

public class ListDemo05 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
      for (String s:list){
          System.out.println(s);
      }
    }
}

6.案例

List集合存储学生对象用三种方式遍历

需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路:
①定义学生类
②创建List集合对象
③创建学生对象
④把学生添加到集合
⑤遍历集合.
迭代器:集合特有的遍历方式
普通for:带有索引的遍历方式
增强for:最方便的遍历方式

package com.dong.list;

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

public class ListDemo06 {
    public static void main(String[] args) {
        //创建集合对象
        List<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student stu1 = new Student("张三", 20);
        Student stu2 = new Student("李四", 21);
        Student stu3 = new Student("王五", 22);
        //将学生信息放入集合
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        //迭代器
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName()+""+s.getAge());
        }
        System.out.println("---------------");
        //普通for循环
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName()+""+s.getAge());
        }
        System.out.println("---------------");
        //增强for循环
        for (Student s :
                list) {
            System.out.println(s.getName()+""+s.getAge());

        }
    }
}

7.数据结构

7.1栈

数据进入栈模型的过程称为：压/进栈

数据离开栈模型的过程称为：弹/出栈

栈是一种数据先进后出的模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8hR63a3N-1596875299049)(E:\记事本\JavaWeb\java.assets\image-20200802144102545.png)]

7.2队列

数据从后端进入队列模型的过程称为:入队列
数据从前端离开队列模型的过程称为:出队列

队列是一种先进先出的模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sRuTL7MZ-1596875299053)(E:\记事本\JavaWeb\java.assets\image-20200802144351579.png)]

7.3数组

查询数据通过索引定位，查询任意数据耗时相同，查询效率高
删除数据时，要将原始数据删除，同时后面每个数据前移,删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

数组是一种查询快，增删慢的模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-645HK1mN-1596875299055)(E:\记事本\JavaWeb\java.assets\image-20200802144804194.png)]

7.4链表

链表是一种增删快的模型(对比数组)

链表是一种查询慢的模型(对比数组)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n6vwdovm-1596875299059)(E:\记事本\JavaWeb\java.assets\image-20200802145059761.png)]

8.list集合子类特点

List集合常用子类: ArrayList, LinkedList

ArrayLlist:底层数据结构是数组,查询快，增删慢
LinkedList:底层数据结构是链表，查询慢，增删快

ArrayList

概念

ArrayList:
●可调整大小的数组实现
●:是一种特殊的数据类型,泛型。

怎么用呢?
在出现E的地方我们使用引用数据类型替换即可
举例: ArrayList ,ArrayList

ArrayList构造方法和添加方法

package com.dong.arraylist;

import java.util.ArrayList;

/*
   Arraylist构造方法:
       public Arraylist ().创建一个空的集合对象
   Arraylist添加方法。I
       public boolean add(E e): 将指定的元素追加到此集合的末尾
       public void add(int index,E element):在此集合中的指定位置插入指定的元素
*/
public class ArrayListDemo01 {

    public static void main(String[] args) {
        //创建一个空白集合对象
        ArrayList<String> array = new ArrayList<>();
        //将指定的元素追加到此集合的末尾
        array.add("hello");
        array.add("world");
        array.add("java");
        //在此集合中的指定位置插入指定的元素
        array.add(1,"he");
        //array.add(5,he);  IndexOutOfBoundsException集合索引下标越界
        //输出集合
        System.out.println("array:" + array);
    }
}

array:[hello, he, world, java]

ArrayList集合常用方法

说明	方法名
public boolean remove(Objecto)	删除指定的元素，返回删除是否成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size0	返回集合中的元素的个数

package com.dong.arraylist;
import java.util.ArrayList;
/*
Arraylist常用方法。
public boolean remove(object_ o): 删除指定的元素，返回删除是否成功
public E remove(int index); 删除指定索引处的元素，返回被删除的元素
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
public E get(int index): 返回指定索引处的元素
public int size(): 返回集合中的元素的个数
*/
public class ArrayListDemo02 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> array =new ArrayList<String>();
        //添加元素
        array.add("hello");
        array.add("world");
        array.add("java");
        //public boolean remove(object_ o):删除指定的元素，返回删除是否成功
        System.out.println(array.remove("hello"));//true
        System.out.println(array.remove("javaee"));//false
        //public E remove(int index): 删除指定索引处的元素，返回被删除的元素
        System.out.println(array.remove(1));//被修改元素：world
        System.out.println(array.remove(6));//集合索引下标越界异常
        // public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
        System.out.println(array.set(1,"javaee"));//被修改元素：world
        System.out.println(array.set(3,"javaee"));//集合索引下标越界异常
        //public E get(int index): 返回指定索引处的元素
        System.out.println(array.get(3));//集合索引下标越界异常
        //public int size(): 返回集合中的元素的个数
        System.out.println(array.size());
        //输出集合
        System.out.println(array);
    }
}

存储字符串并遍历

需求:创建一个存储字符串的集合,存储3个字符串元素，使用程序实现在控制台遍历该集合
思路:
①创建集合对象
②往集合中添加字符串对象
③遍历集合,首先要能够获取到集合中的每一个元素，这个通过getint index)方法实现
④遍历集合，其次要能够获取到集合的长度,这个通过size0方法实现
⑤遍历集合的通用格式

for(int i=0; i<集合对象size0;i++){
集合对象.get()就是指定索引处的元素
}

案例

案例一

存储学生对象并遍历

需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路:
①定义学生类.
②创建集合对象
③创建学生对象
④添加学生对象到集合中
⑤遍历集合,采用通用遍历格式实现

package com.dong.arraylist;

import java.util.ArrayList;

public class ArrayListDemo04 {
    public static void main(String[] args) {
   //创建集合对象
        ArrayList<Student> array=new ArrayList<>();

        //创建学生对象
        Student  st1=new Student("张三",20);
        Student  st2=new Student("李四",30);
        Student  st3=new Student("王五",40);

        //添加学生对象到集合中
        array.add(st1);
        array.add(st2);
        array.add(st3);
        //遍历集合，输出学生信息
        for (int i = 0; i < array.size(); i++) {
            Student student= array.get(i);
            System.out.println(student.getName()+" "+student.getAge()+"岁");
        }


    }

}

案例二

需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合。
学生的姓名和年龄来自于键盘录入

思路:
①定义学生类，为了键盘录入数据方便,把学生类中的成员变量都定义为String类型
②创建集合对象
③键盘录入学生对象所需要的数据
④创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
⑤往集合中添加学生对象
⑥遍历集合,采用通用遍历格式实现

package com.dong.arraylist;

import java.util.ArrayList;
import java.util.Scanner;
import java.util.SortedMap;

public class ArrayListDemo05 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> arrayList = new ArrayList<>();
        addStudent(arrayList);
        addStudent(arrayList);
        addStudent(arrayList);
        for (int i=0;i<arrayList.size();i++) {
            Student s = arrayList.get(i);
            System.out.println("学生姓名:"+s.getName() +" 学生年龄:"+ s.getAge1());
        }
    }
public  static void addStudent(ArrayList<Student> arrayList){
    Scanner scanner=new Scanner(System.in);
    System.out.println("请输入学生姓名：");
    String name=scanner.nextLine();
    System.out.println("请输入学生年龄：");
    String age=scanner.nextLine();

    //创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
    Student s=new Student();
    s.setName(name);
    s.setAge1(age);
    //往集合中添加学生对象
    arrayList.add(s);
}


}

LinkedList

概念

LinkedList:

双链表实现了List和Deque接口。实现所有可选列表操作，并允许所有元素（包括null ）。

所有的操作都能像双向列表一样预期。索引到列表中的操作将从开始或结束遍历列表，以更接近指定的索引为准。

集合特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst( )	返回此列表中的第一个元素
public E getLast( )	返回此列表中的最后一个元素
public E removeFirst( )	从此列表中删除井返回第一个元素
public E removeLast( )	从此列表中删除并返回最后一个元素

package com.dong.list;

import java.util.LinkedList;

public class LinkedListDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList<String> lks = new LinkedList<>();
        lks.add("hello");
        lks.add("world");
        lks.add("java");
        //添加元素
        lks.addFirst("javaee");
        lks.addLast("javase");
        //获取第一个/最后一个元素
        System.out.println(lks.getFirst());
        System.out.println(lks.getLast());
        //删除第一个/最后一个元素
        System.out.println(lks.removeFirst());
        System.out.println(lks.removeLast());
        //输出集合
        System.out.println(lks);


    }
}