List接口Collection集合(一)

List接口和Set接口单例集合

1.单例集合：将数据一个一个的进行存储。

在这里插入图片描述
.2双例集合：基于 Key 与 Value 的结构

2.集合中一些常用的方法
在这里插入图片描述

1.List接口

在这里插入图片描述

List 接口特点

**有序:**有序(元素存入集合的顺序和取出的顺序一致)。List 中每个元素都有索引标记。
可以根据元素的索引标记（在 List 中的位置）访问元素，从而精确控制这些元素。
**可重复:**List 允许加入重复的元素。更确切地讲，List 通常允许满足 e1.equals(e2) 的
元素重复加入容器。

List 的常用方法

在这里插入图片描述

1.1 ArrayList容器类

List<String> list = new ArrayList<>(); //定义方法

1.1.1添加元素和获取元素

list.add(Object) // 有顺序的添加元素 有返回值true|false   执行后list的内容会发生改变
list.get(i) 	 // 获取元素 返回索引i对应的元素  		   执行后list的内容不会发生改变

测试代码

import java.util.ArrayList;
import java.util.List;
// list.add()添加元素 有返回值true|false  list.get(i) 获取元素
public class AppTest{
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        // list.add() 有顺序的添加元素 有返回值
        boolean flag = list.add("jordan");
        list.add("kobe");
        list.add("james");
        System.out.println(flag);

        // list.get(i) 获取元素， 得到对应索引i的元素
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

运行结果：
在这里插入图片描述

1.1.2删除元素

方法1:根据索引位置i删除元素返回值为删除的元素执行后list的内容会发生改变

list.remove(i) //根据索引位置i删除元素 返回值为删除的元素 执行后list的内容会发生改变

测试代码

import java.util.ArrayList;
import java.util.List;
// list.remove(i) 根据索引位置删除元素
public class AppTest{
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // list.add() 有顺序的添加元素 有返回值true|false
        list.add("jordan");
        list.add("kobe");
        list.add("james");
        System.out.println(list.toString()); // 利用list.toString()打印列表

        // list.remove(i) //根据索引位置删除元素 返回值为被删除的元素
        String value = list.remove(1);
        System.out.println(value);
        System.out.println(list.toString()); // 利用list.toString()打印列表

    }
}

运行结果
在这里插入图片描述
方法2:

list.remove(Object)// 删除指定列表元素 返回值为true|false 执行后list的内容会发生改变

import java.util.ArrayList;
import java.util.List;
// list.remove() 删除指定列表元素
public class List02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // list.add() 有顺序的添加元素 有返回值true|false
        list.add("jordan");
        list.add("kobe");
        list.add("james");
        System.out.println(list.toString()); // 利用list.toString()打印列表

        // list.remove(Object) 删除指定列表元素 有返回值true|false
        boolean flag3 = list.remove("jordan");
        System.out.println(flag3);
        System.out.println(list.toString()); // 利用list.toString()打印列表

    }
}

运行结果:
在这里插入图片描述

1.1.3替换元素

list.set(i, Object) // i是索引，返回值值为被替换掉的元素 执行后list的内容会发生改变

测试代码

// list.set(i, Object)替换元素
public class List03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // list.add() 有顺序的添加元素 有返回值
        list.add("jordan");
        list.add("kobe");
        list.add("james");

        System.out.println(list.toString()); // 利用list.toString()打印列表
        String val = list.set(0, "curry"); // list.set()替换元素 返回值值为被替换掉的元素jordan
        System.out.println(val);

        System.out.println(list.toString()); // 利用list.toString()打印列表
    }
}

运行结果:
在这里插入图片描述

1.1.4清空列表

list.clear(); //判断列表是否为空 list.isEmpty()  返回true|false  执行后list的内容不会发生改变

测试代码

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

public class List04 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("jordan");
        list.add("kobe");
        list.add("james");

        System.out.println(list.toString());

        list.clear();  //清空list列表

        System.out.println(list.size());

        boolean flag = list.isEmpty(); // 判断列表是否为空 返回true|false
        System.out.println(flag);
    }
}

运行结果:
在这里插入图片描述

1.1.5判断容器中是否包含指定元素返回true|false

list.contains(Object)  # 判断容器中是否包含指定元素  返回true|false 执行后list的内容不会发生改变

//list.contains() // 判断容器中是否包含指定元素  返回true|false 执行后list的内容不会发生改变
public class List06 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("jordan");
        list.add("kobe");
        list.add("james");
        list.add("jordan");

        System.out.println(list.toString());

        boolean flag1 = list.contains("jordan");
        System.out.println(flag1);
        boolean flag2 = list.contains("dwade");
        System.out.println(flag2);

    }
}

运行结果:
在这里插入图片描述

1.1.6查找元素出现的位置

 list.indexOf(Object) //查找元素第一次出现的位置 返回值是一个索引 执行后list的内容不会发生改变
 list.lastIndexOf(Object) //查找元素最后一次出现的位置  返回值是一个索引 执行后list的内容不会发生改变

测试代码

//查找元素的位置
public class List07 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("jordan");
        list.add("kobe");
        list.add("james");
        list.add("jordan");

        System.out.println(list.toString());

        int index = list.indexOf("jordan"); //第一次出现的位置
        System.out.println(index);

        int lastIndex = list.lastIndexOf("jordan"); // 最后一次出现的位置
        System.out.println(lastIndex);
    }
}

运行结果
在这里插入图片描述

1.2Vector容器实现类

List<String> v = new Vector<>();  //定义方法  其他的方法和ArrayList方法类似

测试代码:

import java.util.List;
import java.util.Vector;

public class Vector01 {
    public static void main(String[] args) {
        //实例化 Vector
        List<String> v = new Vector<>();
        v.add("a");
        v.add("b");
        v.add("a");
        //方式1 遍历
        for(int i=0;i<v.size();i++){
            System.out.println(v.get(i));
        }
        System.out.println("----------------------");
        //方式2 遍历
        for(String str:v){
            System.out.println(str);
        }
        System.out.println("----------------------");
        //方式3 遍历
        System.out.println(v.toString());
    }
}

运行结果:
在这里插入图片描述

1.3Stack 容器(栈)

Stack 栈容器，是 Vector 的一个子类，它实现了一个标准的后进先出(LIFO：Last In Frist Out)
的栈。

1.3.1Stack的定义以及常用方法:

Stack<String> stack = new Stack<>(); // 定义栈
stack.push("a"); //元素a入栈
String p1 = stack.pop(); //出栈
stack.empty(); //判断栈容器是否为空
stack.peek();  //查看栈顶元素
stack.search("c"); //返回元素c在栈容器中的位置

测试代码

import java.util.Stack;

public class Stack01 {
    public static void main(String[] args) {
        //实例化栈容器
        Stack<String> stack = new Stack<>();
        //将元素添加到栈容器中
        stack.push("a");
        stack.push("b");
        stack.push("c");
        //判断栈容器是否为空
        System.out.println(stack.empty());
        //查看栈顶元素
        System.out.println(stack.peek());
        //返回元素在栈容器中的位置
        System.out.println(stack.search("c"));
        //获取栈容器中的元素
        String p1 = stack.pop();
        System.out.println(p1);
        String p2 = stack.pop();
        System.out.println(p2);
        String p3 = stack.pop();
        System.out.println(p3);
    }
}

运行结果:
在这里插入图片描述

1.3.2stack使用案例: 利用站判断符号的对称性，测试算术表达式括号是否正确

import java.util.Stack;
//匹配符号的对称性
public class Stack02 {
    public static void main(String[] args) {
        String str="...{.....[....(....)...]....}..(....)..[...].(.)."; // 等待测试的算术表达式
        //实例化 Stack
        Stack<String> stack = new Stack<>();
        //假设修正法
        boolean flag = true;//假设是匹配的
        //拆分字符串获取字符
        for(int i=0;i<str.length();i++){
            char c = str.charAt(i);
            if(c == '{'){
                stack.push("}");
            }
            if(c == '['){
                stack.push("]");
            }
            if(c == '('){
                stack.push(")");
            }
            //判断符号是否匹配
            if(c == '}' || c == ']' || c == ')'){
                if(stack.empty()){
                    //修正处理
                    flag = false;
                    break;
                }
                String x = stack.pop();
                if(x.charAt(0) != c){ // 因为x是String类型而c是字符类型所以要进行转化
                    //修正处理
                    flag = false;
                    break;
                }
            }
        }
        if(!stack.empty()){
        //修正处理
            flag = false;
        }
        System.out.println(flag);
    }
}

运行结果
在这里插入图片描述

1.4LinkedList 容器类

1.4.1 公共方法使用(List中的方法)

LinkedList 实现了 List 接口，所以 LinkedList 是具备 List 的存储特征的(有序，元素有重复)。

List<String> list = new LinkedList<>(); // 定义

测试代码

import java.util.LinkedList;
import java.util.List;

public class LinkedListTest {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        //添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("a");
        //获取元素
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("-------------------");
        for(String str :list){
            System.out.println(str);
        }
    }
}

运行结果
在这里插入图片描述

1.4.2 非公共方法使用

在这里插入图片描述

测试代码:

import java.util.LinkedList;

public class LinkedList02 {
    public static void main(String[] args) {
        System.out.println("-------LinkedList-------------");
        LinkedList<String> linkedList1 = new LinkedList<>();
        linkedList1.addFirst("a"); // 头插入
        linkedList1.addFirst("b");
        linkedList1.addFirst("c");
        for (String str:linkedList1){
            System.out.println(str);
        }
        System.out.println("----------------------");
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.addLast("a"); // 尾插入
        linkedList.addLast("b");
        linkedList.addLast("c");
        for (String str:linkedList){
            System.out.println(str);
        }
        System.out.println("---------------------------");
        System.out.println(linkedList.getFirst()); //得到头节点
        System.out.println(linkedList.getLast()); //得到尾节点
        System.out.println("-----------------------");
        linkedList.removeFirst(); //  出链表 移除头节点
        linkedList.removeLast(); //  出链表 移除尾节点
        for (String str:linkedList){
            System.out.println(str);
        }
        System.out.println("-----------------------");
        linkedList.addLast("c");
        linkedList.pop(); //linkedList.removeFirst(); 出链表 移除头节点
        for (String str:linkedList){
            System.out.println(str);
        }
        System.out.println("-------------------");
        linkedList.push("h"); // linkedList1.addFirst("h"); 插入头节点
        for (String str:linkedList){
            System.out.println(str);
        }
        System.out.println(linkedList.isEmpty());
    }
}

运行结果
在这里插入图片描述

1.5将单例集合转换成数组

Object[] arr = list.toArray(); list.toArray() //方式1  返回值为Object数组， list本身不会改变
String[] arr2 = list.toArray(new String[list.size()]); // 方式2 转化为指定的String泛型数组 list本身不会改变

测试代码

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

//将单例集合转换成数组
public class List08 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("jordan");
        list.add("kobe");
        list.add("james");

        System.out.println(list.toString());

        Object[] arr = list.toArray();
        for(int i=0;i<arr.length;i++){
            String str = (String)arr[i];  // 进行强制类型转化
            System.out.print(str+ "\t");
        }
        System.out.println();
        //可以将单例集合转换为指定类型数组。
        //但是。类型需要参考泛型中的类型。
        String[] arr2 = list.toArray(new String[list.size()]); // 转化为指定的String数组
        for(int i=0;i<arr2.length;i++){
            System.out.print(arr2[i]+ "\t");
        }
    }
}

运行结果
在这里插入图片描述

1.6容器的并集操作

a.addAll(b); //将集合b添加到a中  返回值为true|false 执行完之后a会发生改变， b不会

测试代码:

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

//容器的并集操作 a.addAll(b), 将b添加到a中
public class List09 {
    public static void main(String[] args) {
        List<String> a = new ArrayList<>();
        a.add("a");
        a.add("b");
        a.add("c");
        System.out.println(a.toString());

        List<String> b = new ArrayList<>();
        b.add("b");
        b.add("c");
        b.add("d");
        System.out.println(b.toString());

        //a 并 b
        boolean flag6 = a.addAll(b); //将b添加到a中
        System.out.println(flag6);
        System.out.println(a.toString());
    }
}

运行结果
在这里插入图片描述

1.7容器的交集操作

a1.retainAll(b1) // 容器的交集操作 返回值为true|false a1会改变 b1不会

测试代码

//容器的交集操作
public class List10 {
    public static void main(String[] args) {
        List<String> a1 = new ArrayList<>();
        a1.add("a");
        a1.add("b");
        a1.add("c");
        System.out.println(a1.toString());
        List<String> b1 = new ArrayList<>();
        b1.add("b");
        b1.add("c");
        b1.add("d");
        System.out.println(b1.toString());

        // a1会改变
        boolean flag2 = a1.retainAll(b1);// 容器的交集操作 返回值为true|false
        System.out.println(flag2);
        System.out.println(a1);
    }
}

运行结果
在这里插入图片描述

1.8容器的差集操作

a2.removeAll(b2); // 返回值为true|false 执行之后a2会发生改变 b2不会发生改变

测试代码

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

public class List11 {
    public static void main(String[] args) {
        List<String> a2 = new ArrayList<>();
        a2.add("a");
        a2.add("b");
        a2.add("c");
        System.out.println(a2.toString());
        List<String> b2 = new ArrayList<>();
        b2.add("b");
        b2.add("c");
        b2.add("d");
        System.out.println(b2.toString());

        boolean flag = a2.removeAll(b2); // 在集合a2去除b2中含有的元素
        System.out.println(flag);
        System.out.println(a2.toString());
    }
}

运行结果
在这里插入图片描述

集合详细笔记：https://pan.baidu.com/s/1hSg1HY1AjOLFCi3gY-go0Q

提取码：2022

原文链接：https://blog.csdn.net/qq_45056135/article/details/124102006

List接口和Set接口单例集合

1.List接口

List 接口特点

List 的常用方法

1.1 ArrayList容器类

1.1.1添加元素和获取元素

1.1.2删除元素

1.1.3替换元素

1.1.4清空列表

1.1.5判断容器中是否包含指定元素 返回true|false

1.1.6查找元素出现的位置

1.2Vector容器实现类

1.3Stack 容器(栈)

1.3.1Stack的定义以及常用方法:

1.3.2stack使用案例: 利用站判断符号的对称性， 测试算术表达式括号是否正确

1.4LinkedList 容器类

1.4.1 公共方法使用(List中的方法)

1.4.2 非公共方法使用

1.5将单例集合转换成数组

1.6容器的并集操作

1.7容器的交集操作

1.8容器的差集操作

集合详细笔记：https://pan.baidu.com/s/1hSg1HY1AjOLFCi3gY-go0Q

1.1.5判断容器中是否包含指定元素返回true|false

1.3.2stack使用案例: 利用站判断符号的对称性，测试算术表达式括号是否正确