Java数组、集合是什么，怎么用，有什么区别，项目中实战用来干什么，stream流怎么操作数据达到想要的结果

雪见冰

已于 2022-12-08 18:20:21 修改

阅读量98

点赞数

分类专栏： java 文章标签： java 数据结构链表

于 2022-11-11 18:19:41 首次发布

本文链接：https://blog.csdn.net/TheFoolman/article/details/127808308

版权

java 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

数组

用来存储一批同种类型数据的容器

静态初始化数组

定义数组时直接给数组进行赋值

格式

// 完整格式
数据类型[]  数组名 = new 数据类型[]{元素1，元素2 ，元素3… };
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] ages = new int[]{12, 24, 36}

// 简化格式
数据类型[] 数组名 = { 元素1，元素2 ，元素3，… };
int[] ages = {12, 24, 36};

基本原理

数组变量名中存储的是数组在内存中的地址，数组为引用类型

因为为引用类型，所以要查看具体内容需要通过索引位置进行访问

数组名称[索引]

数组最大长度可以表示为数组名称.length

在内存中索引从0开始，所以数组最大索引可以表示为

数组名称.length - 1

数组的几个注意事项

“数据类型[] 数组名”也可以写成 “数据类型数组名[] ”。
什么类型的数组存放什么类型的数据否则报错
数组一旦定义出来，程序执行的过程中，长度、类型就固定了。

动态初始化数据

定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据。

格式

数据类型[]  数组名 = new 数据类型[长度];
int[] arr = new int[3];

// 后赋值
arr[0] = 10;
System.out.println(arr[0]); // 10

两种初始化的使用场景总结、注意事项说明

动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。
两种格式的写法是独立的，不可以混用。

动态初始化数组后元素的默认值

byte、short、int 、char、long类型数组元素的默认值都是0
float、double类型数组元素的默认值都是0.0
boolean类型数组元素的默认值是false、String类型数组元素的默认值是null

集合

Collection单列
每个元素（数据）只包含一个值

Collection 集合体系

在这里插入图片描述

Map双列
每个元素包含两个值（键值对）。

ArrayList

集合是与数组类似，也是一种容器，用于装数据的。

特点

集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。
集合非常适合做元素个数不确定，且要进行增删操作的业务场景。
集合还提供了许多丰富、好用的功能，而数组的功能很单一。

ArrayList 集合常用API

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

import java.util.ArrayList;

/**
    目标：掌握ArrayList集合的常用API
 */
public class ArrayListDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Java");
        list.add("MySQL");
        list.add("MyBatis");
        list.add("HTML");

        // 1、public E get(int index)：获取某个索引位置处的元素值
        String e = list.get(3);
        System.out.println(e);

        // 2、public int size()：获取集合的大小（元素个数）
        System.out.println(list.size());

        // 3、完成集合的遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 4、public E remove(int index)：删除某个索引位置处的元素值,并返回被删除的元素值
        System.out.println(list); // [Java, Java, MySQL, MyBatis, HTML]
        String e2 = list.remove(2);
        System.out.println(e2);
        System.out.println(list);

        // 5、public boolean remove(Object o):直接删除元素值，删除成功返回true，删除失败返回false
        System.out.println(list.remove("MyBatis"));
        System.out.println(list);

        ArrayList<String> list1 = new ArrayList<>();
        list1.add("Java");
        list1.add("王宝强");
        list1.add("Java");
        list1.add("MySQL");
        System.out.println(list1);
        // 只会删除第一次出现的这个元素值，后面的不删除
        System.out.println(list1.remove("Java"));
        System.out.println(list1);
        
        // 6、public E set(int index,E element)：修改某个索引位置处的元素值。
        String e3 = list1.set(0 , "贾乃亮");
        System.out.println(e3);
        System.out.println(list1);
    }
}

Collection

两大常用集合体系
List系列集合：添加的元素是有序、可重复、有索引。
Set系列集合：添加的元素是无序、不重复、无索引。
集合支持泛型，集合和泛型只支持引用数据类型，不支持基本数据类型。

Collection常用API

Collection是单列集合的祖宗接口，它的功能是全部单列集合都能继承使用的。

方法名称	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有的元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(Object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数
public Object[] toArray()	把集合中的元素，存储到数组中

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

/**
    目标：Collection集合的常用API.
    Collection是集合的祖宗类，它的功能是全部集合都可以继承使用的，所以要学习它。
    Collection API如下:
         - public boolean add(E e)：  把给定的对象添加到当前集合中 。
         - public void clear() :清空集合中所有的元素。
         - public boolean remove(E e): 把给定的对象在当前集合中删除。
         - public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
         - public boolean isEmpty(): 判断当前集合是否为空。
         - public int size(): 返回集合中元素的个数。
         - public Object[] toArray(): 把集合中的元素，存储到数组中。
    小结：
        记住以上API。
 */
public class CollectionDemo {
    public static void main(String[] args) {
        // HashSet:添加的元素是无序，不重复，无索引。
        Collection<String> c = new ArrayList<>();
        // 1.添加元素, 添加成功返回true。
        c.add("Java");
        c.add("HTML");
        System.out.println(c.add("HTML"));
        c.add("MySQL");
        c.add("Java");
        System.out.println(c.add("黑马"));
        System.out.println(c); // [Java, HTML, HTML, MySQL, Java, 黑马]

        // 2.清空集合的元素。
        // c.clear();
        // System.out.println(c);

        // 3.判断集合是否为空 是空返回true,反之。
        // System.out.println(c.isEmpty());

        // 4.获取集合的大小。
        System.out.println(c.size());

        // 5.判断集合中是否包含某个元素。
        System.out.println(c.contains("Java"));  // true
        System.out.println(c.contains("java")); // false
        System.out.println(c.contains("黑马")); // true

        // 6.删除某个元素:如果有多个重复元素默认删除前面的第一个！
        System.out.println(c.remove("java")); // false
        System.out.println(c);
        System.out.println(c.remove("Java")); // true
        System.out.println(c);

        // 7.把集合转换成数组  [HTML, HTML, MySQL, Java, 黑马]
        Object[] arrs = c.toArray();
        System.out.println("数组：" + Arrays.toString(arrs));

        System.out.println("----------------------拓展----------------------");
        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("赵敏");
        c2.add("殷素素");
        // addAll把c2集合的元素全部倒入到c1中去。
        c1.addAll(c2);
        System.out.println(c1);
        System.out.println(c2);
    }
}

遍历

一、Iterator迭代器方式

迭代器在Java中的代表是Iterator，迭代器是集合的专用的遍历方式。

Iterator中的常用方法

方法名称	说明
boolean hasNext()	询问当前位置是否有元素存在，存在返回true ,不存在返回false
E next()	获取当前位置的元素，并同时将迭代器对象移向下一个位置，注意防止取出越界。

/**
a.迭代器遍历集合。
        -- 方法：
             public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的
             boolean hasNext():判断是否有下一个元素，有返回true ,反之。
             E next():获取下一个元素值！
        --流程：
            1.先获取当前集合的迭代器
                Iterator<String> it = lists.iterator();
            2.定义一个while循环，问一次取一次。
              通过it.hasNext()询问是否有下一个元素，有就通过
              it.next()取出下一个元素。
              */
Iterator iterator = list.iterator();
while(iterator.hasNext()){
        System.out.println(iterator.next());
 }
//---------------------------------------------------------------
ArrayList<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("素素");
        lists.add("灭绝");
        System.out.println(lists);
        // [赵敏, 小昭, 素素, 灭绝]
        //   it

        // 1、得到当前集合的迭代器对象。
        Iterator<String> it = lists.iterator();
//        String ele = it.next();
//        System.out.println(ele);
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
        // System.out.println(it.next()); // NoSuchElementException 出现无此元素异常的错误

        // 2、定义while循环
        while (it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
        }
        System.out.println("-----------------------------");

二、增强for循环

/**
b.foreach(增强for循环)遍历集合。
         foreach是一种遍历形式，可以遍历集合或者数组。
         foreach遍历集合实际上是迭代器遍历集合的简化写法。
         foreach遍历的关键是记住格式：
            for(被遍历集合或者数组中元素的类型 变量名称 : 被遍历集合或者数组){
            }
 */
 for(Object obj : list){
      System.out.println(obj);
 }
//--------------------------------------------------------------
Collection<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("殷素素");
        lists.add("周芷若");
        System.out.println(lists);
        // [赵敏, 小昭, 殷素素, 周芷若]
        //  ele

        for (String ele : lists) {
            System.out.println(ele);
        }

        System.out.println("------------------");
        double[] scores = {100, 99.5 , 59.5};
        for (double score : scores) {
            System.out.println(score);
//            if(score == 59.5){
//                score = 100.0; // 修改无意义，不会影响数组的元素值。
//            }
        }
        System.out.println(Arrays.toString(scores));

三、Lambda表达式

Collection结合Lambda遍历的API

方法名称	说明
default void forEach(Consumer<? super T> action):	结合lambda遍历集合

/**
     目标：Collection集合的遍历方式。
     什么是遍历? 为什么开发中要遍历？
     遍历就是一个一个的把容器中的元素访问一遍。
     开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。
     Collection集合的遍历方式是全部集合都可以直接使用的
     c.JDK 1.8开始之后的新技术Lambda表达式。
 */
public class Test {
    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("殷素素");
        lists.add("周芷若");
        System.out.println(lists);
        // [赵敏, 小昭, 殷素素, 周芷若]
        //  s
        lists.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

//        lists.forEach(s -> {
//                System.out.println(s);
//        });

        // lists.forEach(s ->  System.out.println(s) );

        lists.forEach(System.out::println );
    }
}

List

List系列集合特点

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

List集合特有方法

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

/**
Collection集合体系的特点:
         Set系列集合： 添加的元素，是无序，不重复，无索引的。
             -- HashSet：添加的元素，是无序，不重复，无索引的。
             -- LinkedHashSet：添加的元素，是有序，不重复，无索引的。
         List系列集合：添加的元素，是有序，可重复，有索引的。
             -- LinkedList： 添加的元素，是有序，可重复，有索引的。
             -- ArrayList： 添加的元素，是有序，可重复，有索引的。
             -- Vector 是线程安全的，速度慢，工作中很少使用。
         1、List集合继承了Collection集合的全部功能，"同时因为List系列集合有索引"，
         2、因为List集合多了索引，所以多了很多按照索引操作元素的功能:
         3、ArrayList实现类集合底层基于数组存储数据的，查询快，增删慢！
             - public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
             - public E get(int index):返回集合中指定位置的元素。
             - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
             - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回更新前的元素值。
      小结：
            ArrayList集合的底层是基于数组存储数据。查询快，增删慢！（相对的）
 */
public class ListDemo01 {
    public static void main(String[] args) {
        // 1.创建一个ArrayList集合对象：
        // List:有序，可重复，有索引的。
        ArrayList<String> list = new ArrayList<>(); // 一行经典代码！
        list.add("Java");
        list.add("Java");
        list.add("HTML");
        list.add("HTML");
        list.add("MySQL");
        list.add("MySQL");

        // 2.在某个索引位置插入元素。
        list.add(2, "黑马");
        System.out.println(list);

        // 3.根据索引删除元素,返回被删除元素
        System.out.println(list.remove(1));
        System.out.println(list);

        // 4.根据索引获取元素:public E get(int index):返回集合中指定位置的元素。
        System.out.println(list.get(1));

        // 5.修改索引位置处的元素: public E set(int index, E element)
        System.out.println(list.set(1, "传智教育"));
        System.out.println(list);
    }
}

ArrayList集合底层原理

ArrayList底层是基于数组实现的：根据索引定位元素快，增删需要做元素的移位操作。
第一次创建集合并添加第一个元素的时候，在底层创建一个默认长度为10的数组。

前面有具体API介绍

LinkedList

底层数据结构是双链表，查询慢，首尾操作的速度是极快的，所以多了很多首尾操作的特有API。

方法名称	说明
public void addFirst(E e)	将指定元素插入此列表的开头
public void addLast(E e)	将指定元素添加到此列表的结尾
public E getFirst()	返回此列表的第一个元素
public E getLast()	返回此列表的最后一个元素
public E removeFirst()	移除并返回此列表的第一个元素
public E removeLast()	移除并返回此列表的最后一个元素
public E pop()	从此列表所表示的堆栈处弹出一个元素
public void push(E e)	将元素推入此列表所表示的堆栈

/**
LinkedList也是List的实现类：底层是基于双链表的，增删比较快，查询慢！！
     LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的
     所以LinkedList除了拥有List集合的全部功能还多了很多操作首尾元素的特殊功能：
         - public void addFirst(E e):将指定元素插入此列表的开头。
         - public void addLast(E e):将指定元素添加到此列表的结尾。
         - public E getFirst():返回此列表的第一个元素。
         - public E getLast():返回此列表的最后一个元素。
         - public E removeFirst():移除并返回此列表的第一个元素。
         - public E removeLast():移除并返回此列表的最后一个元素。
         - public E pop():从此列表所表示的堆栈处弹出一个元素。
         - public void push(E e):将元素推入此列表所表示的堆栈。

    小结：
         LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的。
         所以提供了很多操作首尾元素的特殊API可的实以做栈和队列现。

         如果查询多而增删少用ArrayList集合。(用的最多的)
         如果查询少而增删首尾较多用LinkedList集合。
 */
public class ListDemo03 {
    public static void main(String[] args) {
        // LinkedList可以完成队列结构，和栈结构 （双链表）
        // 1、做一个队列：
        LinkedList<String> queue = new LinkedList<>();
        // 入队
        queue.addLast("1号");
        queue.addLast("2号");
        queue.addLast("3号");
        System.out.println(queue);
        // 出队
        // System.out.println(queue.getFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);

        // 2、做一个栈
        LinkedList<String> stack = new LinkedList<>();
        // 入栈 压栈 (push)
        stack.push("第1颗子弹");
        stack.push("第2颗子弹");
        stack.push("第3颗子弹");
        stack.push("第4颗子弹");
        System.out.println(stack);

        // 出栈  弹栈 pop
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack);

    }
}

集合的并发修改异常问题

哪些遍历存在问题

迭代器遍历集合且直接用集合删除元素的时候可能出现。
增强for循环遍历集合且直接用集合删除元素的时候可能出现。

哪些遍历且删除元素不存在问题

迭代器遍历集合但是用迭代器自己的删除方法操作可以解决。
使用for循环遍历并删除元素不会存在这个问题。

/**
    目标：研究集合遍历并删除元素可能出现的：并发修改异常问题。
 */
public class Test {
    public static void main(String[] args) {
        // 1、准备数据
        ArrayList<String> list = new ArrayList<>();
        list.add("芜湖");
        list.add("Java");
        list.add("Java");
        list.add("司马");
        list.add("司马");
        list.add("大司马");
        System.out.println(list);
        //        it

        // 需求：删除全部的Java信息。
        // a、迭代器遍历删除
        Iterator<String> it = list.iterator();
//        while (it.hasNext()){
//            String ele = it.next();
//            if("Java".equals(ele)){
//                // 删除Java
//                // list.remove(ele); // 集合删除会出毛病
//                it.remove(); // 删除迭代器所在位置的元素值（没毛病）
//            }
//        }
//        System.out.println(list);

        // b、foreach遍历删除 (会出现问题，这种无法解决的，foreach不能边遍历边删除，会出bug)
//        for (String s : list) {
//            if("Java".equals(s)){
//                list.remove(s);
//            }
//        }

        // c、lambda表达式(会出现问题，这种无法解决的，Lambda遍历不能边遍历边删除，会出bug)
//        list.forEach(s -> {
//            if("Java".equals(s)){
//                list.remove(s);
//            }
//        });

        // d、for循环(边遍历边删除集合没毛病，但是必须从后面开始遍历删除才不会出现漏掉应该删除的元素)
        for (int i = list.size() - 1; i >= 0 ; i--) {
            String ele = list.get(i);
            if("Java".equals(ele)){
                list.remove(ele);
            }
        }
        System.out.println(list);
    }
}