集合（2） – neet`s Blog

Vector

Vector特点：

底层数据结构是数组，内存连续
查询速度快
增删速度慢
线程安全的集合
默认初始容量为10
默认扩容是翻倍，如果指定了容量增量，那么扩容 = 已有容量 + 指定增量

已经被ArrayList取代

Iterator迭代器

Java迭代器Iterator是Java集合框架中的一种机制，用于遍历集合（例如列表，集合和映射等）的接口
Collection中的Iterator的方法是从Iterable接口中继承的
Collection接口是Iterable接口的子接口，因此所有的集合都可以使用迭代器
实现这个接口的类产生的对象可以被增强for循环遍历，增强for循环本质上就是再进行迭代遍历

List接口的sort方法

public static void main(String[] args) {
    List
<Person> list = new ArrayList<>();
    list.add(new Person("张三丰", 100));
    list.add(new Person("张翠山", 60));
    list.add(new Person("张无忌", 99));
    list.add(new Person("谢逊", 80));
    list.add(new Person("周颠", 30));

    //方法一 
    list.sort(new Comparator
<Person>() {
        @Override
        public int compare(Person o1, Person o2) {
            return o1.getSore() - o2.getScore();
        }
    });

    //lambda表达式
    list.sort(((o1, o2) -> o1.getScore() - o2.getScore()));
    list.forEach(System.out::println);

}

private static void demo() {
    List
<String> list = new ArrayList<>();
    list.add("abc");
    list.add("rtyt");
    list.add("ghjng");
    list.add("ki");
    list.add("ert");
    list.add("vcbvc");
    list.add("qrty");
// 按照字符串的首字符进行排序
// 匿名内部类
    list.sort(new Comparator
<String>() {
        // 返回值如果是负值，那么参数o1排在o2前面
// 返回值如果是正值，那么参数o1排在o2后面
        @Override
        public int compare(String o1, String o2) {
            return o1.charAt(0) - o2.charAt(0);
        }
    });
    System.out.println(list);
}

Stack实现类

Stack实现类是Vector的子类，栈结构，后进先出(Last In First Out)

入栈：从栈顶到栈底
出栈：从栈底到栈顶

public static void main(String[] args) {
    Stack
<String> stack = new Stack&lt;&gt;();
    // 压栈
    stack.add(&quot;杨过&quot;);
    stack.add(&quot;小龙女&quot;);
    stack.add(&quot;雕兄&quot;);
    stack.add(&quot;周伯通&quot;);
    System.out.println(stack);
    // 先进后出
    // 弹栈
//        String pop = stack.pop();
//        System.out.println(pop);
    // 查看栈顶元素
    String peek = stack.peek();
    System.out.println(peek);
    // 入栈
    stack.push(&quot;欧阳锋&quot;);
    // 判断是否为空
    System.out.println(stack.empty());
    // 从栈顶向栈底搜索,从1开始
    int index = stack.search(&quot;小龙女&quot;);
    System.out.println(index);
    System.out.println(stack);
}

实现Stack

package cn.javasm.demo;

import java.util.Arrays;
import java.util.EmptyStackException;
import java.util.Objects;

public class StackDemo{

    // 栈底层存放的数据类型是数组
    private String[] data = new String[10];

    // 栈的实际大小
    private int size;

    /**
     * 判断是否为空
     */
    public boolean empty(){
        return size == 0;
    }

    /**
     * 返回栈顶元素
     */
    public String peek(){
        if (size == 0) throw new EmptyStackException();
        return data[size - 1];
    }

    /**
     * 返回和删除栈顶元素
     */
    public String pop(){
        // 获取栈顶元素
        String peek = peek();
        size--;
        return peek;
    }

    /**
     * 压栈
     */
    public void push(String str){
        if (size &gt;= data.length){
            data = Arrays.copyOf(data,data.length * 2);
        }
        data[size++] = str;
    }

    /**
     * 从栈顶向栈底搜索元素,从1开始
     */
    public int search(String str){

        // 方式一
//        for (int i = size - 1,j = 1; i &gt;=0; i--,j++){
//            // 判断字符串是否相同
//            if (Objects.equals(data[i],str)){
//                return j;
//            }
//        }
        // 方式二
        for (int i = size - 1;i &gt;= 0; i--){
            if (Objects.equals(data[i],str)){
                return size - i;
            }
        }

        return -1;
    }

}

}

Set接口

Set接口不包含重复的元素

HashSet类

HashSet的底层存储结构是HashMap,HashMap底层是数组+链表+红黑树的结构
HashSet不允许重复的元素，元素的位置可能发生改变，是无序的，线程不安全

![image-20241021153352182](https://www.neet0316.com/wp-content/uploads/2025/12/image-20241021153352182.png

LinkedHashSet

有序的集合
底层数据结构是哈希表和双向链表
线程不安全的集合，运行速度快

import java.util.ArrayList;
import java.util.LinkedHashSet;

public static void main(String[] args) {
    Set
<String> set = new LinkedHashSet<>();
    set.add("小陈");
    set.add("小王");
    set.add("超人");
    set.add("稻草人");
    set.add("谜语人");
    set.add("稻草人");
    System.out.println(set);
}

TreeSet

实例代码：

定义Person类

package cn.javasm.demo;

/**
 * @author gfs
 * @version 0.1
 * @className Person
 * @descriptioin:
 * @date 2024/10/21 11:38
 * @since jdk11
 */
public class Person implements Comparable
<Person> {
    // 返回值如果是正值，当前对象放在传入对象的后面
    // 返回值如果是负值，当前对象放在传入对象的前面
    @Override
    public int compareTo(Person o) {
        return this.score - o.score;
    }

    private String name;

    private int score;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public Person(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

}

package cn.javasm.demo;

import java.util.TreeSet;

/**
 * @author gfs
 * @version 0.1
 * @className TestDemo7
 * @descriptioin:
 * @date 2024/10/21 16:07
 * @since jdk11
 */
public class TestDemo7 {
    public static void main(String[] args) {
        // 可以排序的集合  不能重复  有序
        // 放入TreeSet中的对象的类，需要实现Comparable
        TreeSet
<Person> treeSet = new TreeSet<>();
        treeSet.add(new Person("狗杂种", 10000));
        treeSet.add(new Person("乔峰", 100));
        treeSet.add(new Person("天山童姥", 99));
        treeSet.add(new Person("虚竹", 98));
        treeSet.add(new Person("段誉", 101));
        System.out.println(treeSet);
    }

    private static void demo() {
        TreeSet
<String> set = new TreeSet<>();
        set.add("e");
        set.add("d");
        set.add("a");
        set.add("c");
        set.add("f");
        System.out.println(set);
    }
}

Vector

Iterator迭代器

List接口的sort方法

Stack实现类

实现Stack

Set接口

HashSet类

LinkedHashSet

TreeSet

发送评论 编辑评论

发送评论编辑评论