java-集合框架

认识集合

• 集合是一种容器，用来装数据的，类似于数组，但集合的大小可变，开发中也非常常用。

集合体系结构

Conllection 单列集合

• Conllection代表单列集合，每一个元素只包含一个值。

Map 双列集合

• Map代表双列集合，每个元素包含两个值（键值对）。

Conllection集合特点

• List系列元素：添加的元素是有序，可重复，有索引。

  • ArrayList，LinekdList：有序，可重复，有索引。

• Set系列集合：添加的元素是无序，不重复，无索引。

  • HashSet：无序，不重复，无索引。

  • LinekdHashSet：有序，不重复，无索引。

  • TreeSet：按照大小默认升序排序，不重复，无索引。

package YMP.Study.Class.collection;
​
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
​
public class CollectionDemo01 {
    public static void main(String[] args) {
        //目标：搞清楚Collection集合的整体特点
        //1.List家族的集合：有序，可重复，有索引。
        ArrayList<String> list=new ArrayList<>();
        list.add("Java");
        list.add("Java");
        list.add("C");
        list.add("C++");
        System.out.println(list);
​
        String rs=list.get(0);
        System.out.println(rs);
​
        //2.Set家族的集合：无序，不可重复，无索引。
        Set<String> set=new HashSet<>();
        set.add("Java");
        set.add("Java");
        set.add("C");
        set.add("C++");
        set.add("鸿蒙");
        System.out.println(set);
​
​
​
​
    }
}
​

小结

Collection集合

常用功能

• Collection是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的。

package YMP.Study.Class.collection;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class CollectionDemo02 {
    public static void main(String[] args) {
        //目标：搞清楚Collection提供的通用功能。
        Collection<String > list=new ArrayList<>();
​
        //添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");
        System.out.println(list);
​
​
        //获取集合的元素个数
        System.out.println(list.size());
​
        //删除集合元素
        list.remove("李四");
        System.out.println(list);
​
        //判断集合是否为空
        System.out.println(list.isEmpty());
        
​
        //判断集合中是否存在某个数据
        System.out.println(list.contains("张三"));
        
        
        //把集合转换为数组
        Object[] arr=list.toArray();
        System.out.println(arr);
        
        String [] arr2=list.toArray(String[]::new);
        System.out.println(arr2);
​
        //清空集合
        list.clear();
        System.out.println(list);
​
    }
}
​

List集合

list集合特点：

有序，可重复，有索引

ArrayList：有序，可重复，有索引

LinkedList:有序，可重复，有索引

底层实现不同！适合场景不同。

• List集合因为支持索引，所以多了很多与索引相关的方法，当然，Collection的功能List也继承了。

package YMP.Study.Class.List;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
public class listDemo01 {
    public static void main(String[] args) {
        //目标：掌握List系列集合独有的功能
        List<String > names=new ArrayList<>();
​
​
        //添加数据
        names.add("张三");
        names.add("李四");
        names.add("王五");
        names.add("赵六");
        System.out.println(names);
​
        //给第三个位置插入一个数据，熊小涛
        names.add(2,"熊小涛");
​
        System.out.println(names);
​
​
        //删除李四
        names.remove(1);
        System.out.println(names);
​
        //把王五修改为金毛
        names.set(2,"金毛");
        System.out.println(names);
​
        //获取张三
        System.out.println(names.get(0));
​
​
        //1.for循环
        for (int i=0;i<names.size();i++){
            System.out.println(names.get(i));
        }
​
        //2.迭代器
        Iterator<String > it=names.iterator();
        while (it.hasNext()){
            String name=it.next();
            System.out.println(name);
        }
​
        //3.增强for
        for (String name:names){
            System.out.println(name);
        }
    }
}
​

ArrayList和LinkedList的区别

• ArrayList底层是基于数组存储数据的。

• LinkedList底层是基于链表存储数据的。

数组的特点：

• 查询速度快（是根据索引查询数据快）：查询数据通过地址值和索引定位，查询任意数据包耗时相同。

• 增删数据效率低：可能需要把后面很多的数据进行前移。

链表的特点：

• 链表中的数据是一个一个独立的结点组成的，结点在内存中是不连续的，每个结点包含数据值和下一个结点的地址。

• 链表的特点1：查询慢，无论查询哪个数据都要从头开始找。

• 链表的特点2：链表增删相对快。

LinkedList是基于双链表实现的。

• 特点：对首尾元素进行增删改查的速度是极快的。

LinkedList新增了：很多首尾操作的特有方法

在Java中，LinkedList 类是 List 接口的一个实现，它除了提供了基本的列表操作外，还针对首尾元素的操作进行了优化，提供了更高效的方法。下面我将通过示例代码展示如何使用 LinkedList 进行首尾元素的操作。

添加元素到首尾

1. 向链表末尾添加元素：可以使用 add(E element) 方法，这是 List 接口提供的，但在 LinkedList 中特别高效，因为它只需要改变尾节点的引用。

2. 向链表开头添加元素：可以使用 addFirst(E element) 方法，这是 LinkedList 类特有的方法，它在列表的开头插入指定的元素。

import java.util.LinkedList;
​
public class LinkedListDemo {
    public static void main(String[] args) {
        // 创建一个 LinkedList
        LinkedList<String> linkedList = new LinkedList<>();
​
        // 向链表末尾添加元素
        linkedList.add("End Element");
        System.out.println("After adding at end: " + linkedList);
​
        // 向链表开头添加元素
        linkedList.addFirst("First Element");
        System.out.println("After adding at start: " + linkedList);
    }
}

删除首尾元素

1. 删除并返回链表的第一个元素：可以使用 removeFirst() 方法，如果链表为空，则会抛出 NoSuchElementException 异常。

2. 删除并返回链表的最后一个元素：可以使用 removeLast() 方法，同样，如果链表为空，也会抛出异常。

// 继续上面的代码示例
public static void main(String[] args) {
    // ... 上面的代码 ...
​
    // 删除并返回第一个元素
    String firstElement = linkedList.removeFirst();
    System.out.println("Removed first element: " + firstElement);
    System.out.println("After removing first: " + linkedList);
​
    // 删除并返回最后一个元素
    String lastElement = linkedList.removeLast();
    System.out.println("Removed last element: " + lastElement);
    System.out.println("After removing last: " + linkedList);
}

这些方法使得在需要频繁进行首尾元素操作的场景下，LinkedList 相较于其他 List 实现（如 ArrayList）具有更高的效率。

LinkedList可以用来设计栈

package YMP.Study.Class.List;
​
import java.util.LinkedList;
​
public class listDemo02 {
    public static void main(String[] args) {
        //目标：用LinkedList做一个对象
        LinkedList<String> queue=new LinkedList<>();
​
        //入队
        queue.addLast("赵敏");
        queue.addLast("西门吹雪");
        queue.addLast("菠萝吹雪");
        queue.addLast("橙留香");
        System.out.println(queue);
​
​
        //出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
​
​
        System.out.println("--------------------------");
​
​
        //做一个栈
        LinkedList<String> stack=new LinkedList<>();
​
        //压栈
        stack.push("第一颗子弹");
        stack.push("第二颗子弹");
        stack.push("第三颗子弹");
        stack.push("第四颗子弹");
        System.out.println(stack);
​
        //出栈
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack);
​
    }
}
​