List接口Collection集合(一)

已于 2022-04-15 15:11:47 修改
阅读量1.3k 收藏
点赞数
分类专栏： javaee 文章标签： java
于 2022-04-12 13:37:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45056135/article/details/124102006
版权

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

CodeWang_NC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合03：Collection子接口一：List接口
小贺想改变
10-13 643
对集合中的Collection子接口一：List接口，进行了详细阐述
Java学习路线（13）——Collection集合类：List集合与Set集合
Zain_horse的博客
05-27 1186
Collection集合类：List集合与Set集合
List<T>和ObservableCollection<T>的相互转化
热门推荐
JoelJay的专栏
08-10 2万+
在WPF ， silverlight ，WP7中经常会用到List和ObservableCollection。这里简单讲一下他们之间的相互转换。 1.List的简单介绍： 　List代表的是强类型的Ojbect集合，可以通过索引访问并且提供了查找、
List/Collection转换
murenyangdaren的博客
05-16 4028
Set occ = new HashSet<>(); List<> list = new ArrayList(occ); 与常用的List list = new ArrayList<>(); 不太一样，为两种构造方法； 也可以写List list = new ArrayList(occ); 或者List list = new ArrayList(occ);
java的list转化成collection
最新发布
weixin_42515631的博客
07-14 208
Java的List转换成Collection 在Java中，List 是一种有序集合，而 Collection 是一种接口，它是所有集合框架的根接口。因此，将List 转换为 Collection 是一种常见的需求。在本文中，我们将介绍如何实现这一过程，并提供相应的代码示例。 List和Collection的概念 在Jav...
List集合进阶之Collection集合
weixin_45432729的博客
01-24 1087
Collection集合快速入门
List、Set、数组之间的转换 数组转Collection
woshizoe的专栏
05-23 5063
http://www.360doc.com/content/08/0419/11/21290_1200000.shtml
Collection集合接口之 List接口
高度不够看到的都是问题，格局太小纠结的都是鸡毛蒜皮。
04-20 166
List接口介绍 1） List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。 2）List集合的元素的存储顺序和取出顺序一致。 3) List接口的实现类常用的有：ArrayList（主要实现类）、LinkedList和Vector。 4) List不但继承了Collection接口中的全部方法(上一篇博客已经介绍过Conllection接口)，还增加了一些根据元素位置索...
集合-Java Collection接口和list接口
雪落无痕的博客
06-15 910
ArrayList 和linkedlist
java集合 collection-list-LinkedList详解
08-31
在Java集合框架中，`List`接口是`Collection`接口的一个子接口，它代表了有序的元素列表，其中元素可以重复，并且可以通过索引来访问。`LinkedList`类是实现`List`接口的一个具体类，它提供了链表结构的数据存储方式...
浅析Java集合及LIst接口
08-26
List接口是Collection接口的子接口，它提供了有序的、可重复的集合操作。List集合中的每个元素都有对应的顺序索引，可以通过索引来访问指定位置的元素。List接口的实现类有ArrayList和LinkedList等。 ArrayList是...
Java集合教程之Collection实例详解
08-27
Collection是一个包含多个元素的对象，在Java中有两个顶层接口Collection和Map用于定义和规范集合的相关操作。在这篇文章中，我们主要讨论Collection部分。 Collection表示一组对象，这些对象可以是有序也可以是...
Java----List接口(Collection的子接口)
今天会营业的博客
11-07 633
java.util.List接口。另外，List集合还有一个特点就是。继承自Collection接口。的一个重要分支，习惯性地会将。，所有的元素是以一种。
Java List作为Collection集合的子接口
weixin_63215361的博客
05-15 405
【代码】Java List作为Collection集合的子接口。
Java开发技巧 数组，list，set之间的转换 Map转Collection
weixin_44131922的博客
07-22 2268
数组转list使用JDK自带Arrays.asList但这样的转换出来的只能时引用类型的数组，基本数据类型的数组不可以，同时转换出来的对象不能执行增删操作；使用JDK的Collections或者ApacheJakartaCommonsCollections使用时导入如下。此时还不能直接使用，可以调用Collection的toArray方法转为Object数组。通过使用Map的values()方法，这样获取的是map中所有的value。...
List、Set、数组之间的转换
宁静的森林(liuyeb)
02-04 677
★ 数组转Collection 使用Apache Jakarta Commons Collections： import org.apach
数组与集合的相互转换
weixin_48100716的博客
08-08 833
添加元素相当于要对数组扩容,数组是定长的不可以真实的扩容,因此会抛出不支持该操作的异常.删除也是一样的。如果我们需要增删元素，可另行创建一个集合同时包含该集合元素即可。Collection提供了一个方法:toArray,可以将当前集合转换为一个数组。数组的工具类java.util.Arrays提供了一个静态方法：asList。改集合相当于改数组，但是这个集合不能增删。该方法可以将一个数组转换为一个List集合。相当于先new再addAll。建立数组并转换成集合。...
java list iterable_java - 将Iterable转换为Collection的简便方法
weixin_34072003的博客
02-15 985
java - 将Iterable转换为Collection的简便方法在我的应用程序中，我使用第三方库(确切地说是MongoDB的Spring Data)。此库的方法返回foreach，而我的其余代码需要Collection。有什么实用方法可以让我快速将一个转换为另一个吗？ 我想避免在我的代码中为这么简单的事情创建一堆foreach循环。Ula Krukar asked 2019-01-30T04...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值