java list可以储存多少 java list最多能存多少条数据

Day16

集合

集合和数组的对比

• 数组的长度是不可变的，集合的长度是可变的。
• 数组可以存基本数据类型和引用数据类型。集合只能存引用数据类型，若要存基本数据类型，需要存对应的包装类。

集合类体系结构

Collection集合概述和使用

概述

• 是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
• JDK不提供接口的任何直接实现，它提供更具体的子接口实现

创建Collection集合的对象

• 多态的方式
• 具体的实现类ArrayList

Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行删除
void clear()	清空集合
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

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

public class CollectionTest {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        //添加元素
        collection.add("1a2b");
        collection.add("3c4d");
        collection.add("5e6");
        collection.add("7g8");
        System.out.println(collection);

        //移除指定元素
        boolean result1 = collection.remove("1a2b");
        boolean result2 = collection.remove("bbbb");
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(collection);

        //根据条件进行删除
        collection.removeIf(
                (String s)->{
                    return s.length()==3;
                }
        );
        System.out.println(collection);

        //判断集合中是否存在指定的元素
        boolean result3 = collection.contains("a");
        boolean result4 = collection.contains("3c4d");
        System.out.println(result3);
        System.out.println(result4);

        //集合长度
        int size = collection.size();
        System.out.println(size);

        //判断集合是否为空
        boolean result5 = collection.isEmpty();
        System.out.println(result5);
        //清空集合
        collection.clear();
        System.out.println(collection);
        //判断集合是否为空
        boolean result6 = collection.isEmpty();
        System.out.println(result6);
    }
}

运行结果：

Collection集合的遍历

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

• Iterator iterator()：返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引。

Iterator中的常用方法

• boolean hasNext()：判断当前位置是否有元素可以被取出
• E next()：获取当前位置的元素，将迭代器对象移向下一个索引位置

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

public class CollectionTest2 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        //获得迭代器对象
        //迭代器对象一旦被创建出来，默认指向集合的0索引处
        Iterator<String> it = list.iterator();
        //利用迭代器里的方法进行遍历
        //当前位置是否有元素可以被取出
        //System.out.println(it.hasNext());
        //取出当前位置的元素，迭代器往后移动一个位置的元素
        //System.out.println(it.next());

        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

迭代器中删除的方法

创建一个集合，有元素a b b c d e，使用循环遍历这个集合，判断当前获取到的元素是否为b，如果是就删除；

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

public class CollectionTest3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println(list);
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if("b".equals(s)){
                it.remove();
            }
        }
        System.out.println(list);
    }
}

运行结果:

增强for循环

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

• 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
• 实现Iterable接口的类才可以使用迭代器和增强for

增强for格式

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

import java.util.ArrayList;

public class CollectionTest4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");

        //数据类型一定是集合或者数组中元素的类型
        //str仅仅是一个变量名而已，在循环的过程中，依次表示集合或者数组中的每一个元素
        //list就是要遍历的集合或数组
        for(String str : list){
            System.out.println(str);
        }
    }
}

三中循环的使用场景

• 如果需要操作索引，使用普通for循环
• 如果在遍历的过程中需要删除元素，请使用迭代器
• 如果仅仅想遍历，那么使用增强for

案例：Collection集合存储学生对象并遍历

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

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

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

测试类

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

public class StudentTest {
    public static void main(String[] args) {
        ArrayList<Student> list = new  ArrayList<>();

        Student s1 = new Student("明明",19);
        Student s2 = new Student("亮亮",21);
        Student s3 = new Student("晶晶",22);
        Student s4 = new Student("姗姗",20);

        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        //迭代器的方式进行遍历
        Iterator<Student> it = list.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("------------------");
        for(Student student : list){
            System.out.println(student);
        }
    }
}

运行结果：

List集合概述和特点

概述

• 有序集合，这里的有序指的是存取顺序
• 用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
• 与set集合不同，列表通常允许重复的元素

List集合特点

• 有序：存储和取出的元素顺序一致
• 有索引：可以通过索引操作元素
• 可重复：存储的元素可以重复

import java.util.*;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("----------");
        for(String str : list){
            System.out.println(str);
        }
    }
}

List集合特有方法

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

import java.util.*;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        list.add(0,"qqq");
        System.out.println(list); //[qqq, aaa, bbb, ccc]

        //list集合中有两个删除方法
        //一个是，删除指定的元素，返回值表示当前元素是否删除成功
        //另一个是，删除指定所以的元素，返回值表示实际删除的元素
        String s1 = list.remove(0);
        System.out.println(s1); //qqq
        System.out.println(list); //[aaa, bbb, ccc]

        String s2 = list.set(0, "qqq");
        System.out.println(s2); //aaa
        System.out.println(list); //[qqq, bbb, ccc]

        String s3 = list.get(0);
        System.out.println(s3); //qqq
    }
}

数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率；

常见数据结构——栈

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

常见数据结构——队列

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

常见数据结构——数组

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

常见数据结构——链表

链表是一种查询慢，增删快的模型(对比数组)；

List集合常用实现类

• ArrayList：底层数据结构是数组，查询快，增删慢；
• LinkedList：底层数据结构是链表，查询慢，增删块；

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

public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList<String> list =new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-------------");
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-------------");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

运行结果：

LinkedList集合的特有功能

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

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList<String> list =new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        list.addFirst("qqq");
        System.out.println(list); //[qqq, aaa, bbb, ccc]

        list.addLast("qqq");
        System.out.println(list); //[qqq, aaa, bbb, ccc, qqq]

        String first = list.getFirst();
        String last = list.getLast();
        System.out.println(first); //qqq
        System.out.println(last); //qqq

        String s1 = list.removeFirst();
        String s2 = list.removeLast();
        System.out.println(s1); //qqq
        System.out.println(s2); //qqq
        System.out.println(list); //[aaa, bbb, ccc]
    }
}

练习1

请定义一个Collection类型的集合，存储以下字符串：“JavaEE企业级开发指南”，”Oracle高级编程”，”MySQL从入门到精通”，”Java架构师之路”；

请编程实现以下功能：
使用迭代器遍历所有元素，并打印
使用迭代器遍历所有元素，筛选书名小于11个字符的，并打印；
使用迭代器遍历所有元素，筛选书名中包含“Java”的，并打印
如果书名中包含“Oracle”，则删掉此书。删掉后，遍历集合，打印所有书名。
(注意：以上每个功能都单独写个方法，在main方法中逐个调用测试即可)

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

public class Lian1 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("JavaEE企业级开发指南");
        list.add("Oracle高级编程");
        list.add("MySQL从入门到精通");
        list.add("Java架构师之路");
        m1(list);
        System.out.println("书名小于11个字符的书>>>");
        m2(list);
        System.out.println("书名中包含“Java”的书>>>");
        m3(list);
        System.out.println("删掉Oracle后>>>");
        m4(list);
    }
    public static void m1(Collection<String> list){
        //使用迭代器遍历所有元素，并打印
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
    public static void m2(Collection<String> list){
        //使用迭代器遍历所有元素，筛选书名小于11个字符的，并打印；
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if(s.length()<11){
                System.out.println(s);
            }
        }
    }
    public static void m3(Collection<String> list){
        //使用迭代器遍历所有元素，筛选书名中包含“Java”的，并打印
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if (s.contains("Java")){
                System.out.println(s);
            }
        }
    }
    public static void m4(Collection<String> list){
        //如果书名中包含“Oracle”，则删掉此书。删掉后，遍历集合，打印所有书名
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if (s.contains("Oracle")){
                it.remove();
            }
        }
        for (String s : list) {
            System.out.println(s);
        }
    }
}

运行结果：

练习2

请定义一个Collection类型的集合，存储以下分数信息：86.5,39.5,76.6,58.5,88.8,99.9,59.9；

请编程实现以下功能：
使用增强for遍历所有元素，并打印
使用增强for遍历所有元素，打印不及格的分数；
使用增强for遍历所有元素，计算不及格的分数的数量，和平均分，并打印计算结果。
使用增强for遍历所有元素，求出最高分，并打印；

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

public class Lian2 {
    public static void main(String[] args) {
        Collection<Double> list = new ArrayList<>();
        list.add(86.5);
        list.add(39.5);
        list.add(76.6);
        list.add(58.5);
        list.add(88.8);
        list.add(99.9);
        list.add(59.9);
        //使用增强for遍历所有元素，并打印
        for (Double aDouble : list) {
            System.out.print(aDouble+" ");
        }
        //使用增强for遍历所有元素，打印不及格的分数；
        System.out.println("\r\n不及格的分数：");
        for (Double aDouble : list) {
            if(aDouble<60){
                System.out.print(aDouble+" ");
            }
        }
        //使用增强for遍历所有元素，计算不及格的分数的数量，和平均分，并打印计算结果
        int i = 0;
        int sum = 0;
        for (Double aDouble : list) {
            if(aDouble<60){
                i++;
            }
            sum += aDouble;
        }
        System.out.println("\r\n不及格的分数有"+i+"个；");
        System.out.println("平均分为："+sum/list.size());
    }
}

运行结果：

练习3

请定义方法找出集合中所有姓张的人并且年龄大于18岁的并全部返回,然后在main方法中输出返回的人;集合原始数据有: 张三,22 李四,26 张启山,38 吴邪,19 张启灵,103 张无忌,17 赵敏,16 ；集合中的人需要以对象的形式存在,人只要有姓名和年龄两个成员变量即可;

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

public class Lian3 {
    public static void main(String[] args) {
        //创建对象并初始化
        Person p1 = new Person("张三",22);
        Person p2 = new Person("李四",26);
        Person p3 = new Person("张启山",38);
        Person p4 = new Person("吴邪",19);
        Person p5 = new Person("张启灵",103);
        Person p6 = new Person("张无忌",17);
        Person p7 = new Person("赵敏",16);
        //创建一个集合
        ArrayList<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        list.add(p6);
        list.add(p7);
        ArrayList<Person> list1 = query(list);
        System.out.println(list1);
    }

    public static ArrayList<Person> query(ArrayList<Person> list){
        Iterator<Person> it = list.iterator();
        ArrayList<Person> list1 = new ArrayList<>();
        while (it.hasNext()){
            Person p = it.next();
            if(p.getName().startsWith("张") && p.getAge()>18){
                list1.add(p);
            }
        }
        return list1;
    }
}

运行结果：