集合框架 Collection 接口的特点以及具体实现类ArrayList类 LinkedList类 Vector类

已于 2024-01-26 11:39:26 修改
阅读量429 收藏 7
点赞数 11
文章标签： java 算法 开发语言
于 2024-01-25 20:03:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68041576/article/details/135852234
版权

一、Collection 接口

1.单列集合

2.子接口

list 接口：

特点:有序、允许重复

具体实现类

ArrayList类
    数据结构：Object[ ] elementData
    扩容

  • 无参构造方法，数组的容量初始化为空
  • 添加第1个元素时，数组的容量扩容为10
  • 当容量不足时，数组的容量按照1.5倍扩容

    特点：适合遍历、查找
    常用方法

  • add( E e)：添加新元素至集合的指定位置
  • add(int index , E e)：添加新元素至集合的指定位置
  • addAll(Collection c)： 添加集合中所有的元素至当前集合
  • addAll(int index , Collection c)：添加另外一个集合中所有的元素至当前集合
  • get(int index)：获取元素（按照下标位置，获取元素）
  • remove(int index)：删除元素 按照下标进行删除）
  • remove(Object value)：删除元素 按照值进行删除）
  • indexOf(Object o)：查找元素
  • set (int index ,E element)：按照下标位置修改 

 LinkedList类
    数据结构：双向链表

  • 链表由若干个Node对象组成
  • 链表不扩容，每次添加元素时，都创建一个Node，并加入链表

    特点：适合插入、删除
    常用方法

  • add():获取链表的头元素
  • getLast()：获取链表的尾元素
  • remove()：删除元素
  • 1.根据下标，在链表中删除元素
  • 2.根据值,在链表中删除元素
  • removeFirst()：删除链表的头元素
  • removeLast()：删除链表的尾元素

Vector类
    数据结构：Object[] elementData
    特点：线程安全
    子类：Stack类
     特点：Stack是一个“栈”的实现类，具备Fist In Last Out 先进后出的特点。
     常用方法

  • push(E item)：添加新元素（向栈顶添加）
  •  E pop()：获取元素（从栈顶获取并删除）
  •  E peek()： 获取元素（从栈顶获取） 
package com.ztt.Demo01;

import java.util.ArrayList;

public class demo01 {
	public static void main(String[] args) {
		//数组:一组相同数据的数据容器，在内存中分配“连续空间”进行保存
		//问题1:容量
		//问题2:不擅长"插入"、"删除"等操作
		
		int[] array=new int[10];
		array[0]=1;
		
		//集合：通过某个集合类，创建该集合类的对象
		ArrayList list = new ArrayList();
		list.add(1);
	}
}
package com.ztt.Demo01;

import java.util.ArrayList;

public class demo02 {
	
	public static void main(String[] args) {
			//创建集合对象
			ArrayList<String> list = new ArrayList<String>();
			
			// 操作1: 添加新元素【add() addAll()方法】
			// add(E e)方法 : 添加新元素至集合的尾部
			list.add("小乔");
			list.add("曹操");
			list.add("刘备");
			list.add("后羿");
			System.out.println(list);
			
			// add(int index,E e)方法 : 添加新元素至集合的指定位置
			list.add(1, "李白");
			System.out.println(list);
			
			// addAll(Collection c) 方法
			// addAll(int index，Collection c) 方法
			// 添加另外一个集合中所有的元素至当前集合
			
			ArrayList<String> subList = new ArrayList<String>();
			subList.add("孙悟空");
			subList.add("猪八戒");
			subList.add("白骨精");
			
			// 将subList中的所有元素添加至list集合的尾部
			//list.addAll(subList);
			list.addAll(0, subList);
			System.out.println(list);
		}
	}

运行结果：

[小乔, 曹操, 刘备, 后羿]
[小乔, 李白, 曹操, 刘备, 后羿]
[孙悟空, 猪八戒, 白骨精, 小乔, 李白, 曹操, 刘备, 后羿]
package com.ztt.Demo01;

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

public class demo03 {

	public static void main(String[] args) {
		//创建临时的List集合
		List<String> girlList=Arrays.asList("张甜甜","袁艺鸣","任敏","韩乔菲","史碧蓉","张雅丽");
		
		//全部添加至ArrayList集合中
		ArrayList<String> list=new ArrayList<String>();
		list.addAll(girlList);
		
		System.out.println(list);
		
		//操作2：获取元素（按照下标位置，获取元素）
		//get(int index)
		String first=list.get(0);
		String last=list.get(list.size()-1);
		System.out.println("首元素："+first);
		System.out.println("尾元素："+last);
		
		//操作3：删除元素（按照下标或值，进行删除）
		//remove(int index)按照下标删除
		//remove(Object value)按照值删除
		System.out.println("删除前："+list);
		
		list.remove(1);//按照下标删除
		list.remove("任敏");//按照值删除
		
		System.out.println("删除后："+list);
		
		//操作4：查找元素
		//indexOf(Object o)
		int index1=list.indexOf("田恬");
		System.out.println("查找一个不存在的元素时："+index1);
		
		int index2=list.indexOf("张甜甜");
		System.out.println("查找一个已存在的元素时："+index2);
		
		//操作5：修改元素
		//set(int index,E element):按照下标位置修改
		System.out.println("修改前："+list);
		list.set(1, "艺鸣");
		System.out.println("修改后："+list);
		

	}

}

运行结果：

[张甜甜, 袁艺鸣, 任敏, 韩乔菲, 史碧蓉, 张雅丽]
首元素：张甜甜
尾元素：张雅丽
删除前：[张甜甜, 袁艺鸣, 任敏, 韩乔菲, 史碧蓉, 张雅丽]
删除后：[张甜甜, 韩乔菲, 史碧蓉, 张雅丽]
查找一个不存在的元素时：-1
查找一个已存在的元素时：0
修改前：[张甜甜, 韩乔菲, 史碧蓉, 张雅丽]
修改后：[张甜甜, 艺鸣, 史碧蓉, 张雅丽]

package com.ztt.Demo01;

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

public class demo04 {
	public static void main(String[] args) {
List<String> girlList=Arrays.asList("张甜甜","袁艺鸣","任敏","韩乔菲","史碧蓉","张雅丽");
		
		//全部添加至ArrayList集合中
		ArrayList<String> list=new ArrayList<String>();
		list.addAll(girlList);
		
		System.out.println(list);
		
		//清空
		//list.clear();
		
		//查看元素是否存在
		//boolean isContains = list.contains( "张甜甜");
		//System.out.println(isContains );
		
		//截取子集合
		//List<String> subs = list.subList(0,3);
		//System.out.println( subs ) ;
		
		//转换成数组
		Object[]array1 = list.toArray(); // object数组
		String[] array2=list.toArray(new String[list.size()]);
		
		System.out.println(Arrays.toString(array1));
		System.out.println(Arrays.toString(array2));
	}
}

运行结果：

[张甜甜, 袁艺鸣, 任敏, 韩乔菲, 史碧蓉, 张雅丽]
[张甜甜, 袁艺鸣, 任敏, 韩乔菲, 史碧蓉, 张雅丽]
[张甜甜, 袁艺鸣, 任敏, 韩乔菲, 史碧蓉, 张雅丽]
package com.ztt.Demo01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class demo05 {
	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();
		list.addAll(Arrays.asList("E","D","K","M","N","A"));
		
		//方式1：冒泡排序
		for(int i=0,n=list.size();i<n-1;i++) {
			for(int k=0;k<n-1-i;k++) {
				if(list.get(k).compareTo(list.get(k+1))>0) {
					String temp=list.get(k);
					list.set(k, list.get(k+1));
					list.set(k+1, temp);
				}
			}
		}
		System.out.println(list);
		
		//方式2：使用sort()方法
		list=new ArrayList<String>();
		list.addAll(Arrays.asList("E","D","K","M","N","A"));
		list.sort(new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				
				return o1.compareTo(o2);
			}
		});
		System.out.println(list);
	}
}

运行结果：

[A, D, E, K, M, N]
[A, D, E, K, M, N]
package com.ztt.Demo01;

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

public class demo06 {
	public static void main(String[] args) {
		//通过【无参构造方法】创建ArrayList集合
		//数组默认被初始化成一个空数组
		ArrayList<Integer> list1=new ArrayList<Integer>();
		list1.add(1587);//添加第1个元素时,将数组扩容为10
		list1.add(1852);//添加第2个元素
		list1.add(1555);//添加第..个元素
		list1.add(9527);//添加第10个元素
		
		//添加第11个元素时，容量不足，再次将数组扩容，按照原容量的1.5倍
		list1.add(1024);
		
		//通过【有参构造方法】创建ArrayList集合
		//根据预估数据元素的规模数量，初始化elementData数组
		//减少扩容的次数频率
		ArrayList<Integer> list2=new ArrayList<Integer>(200);
		//创建集合时，传入另外一个collection集合，并且按照该集合的元素进行初始化
		ArrayList<Integer> list3=new ArrayList<Integer>(Arrays.asList(1,2,3,4));
	}
}

package com.ztt.Demo01;

import java.util.LinkedList;

public class demo07 {
	public static void main(String[] args) {
		LinkedList<String> list=new LinkedList<String>();
		
		//添加新元素
		// add() /list.addLast() :将新元素添加至链表的尾部
		list.add("s1");
		list.add("s2");
		list.add("s3");
		list.add("s4");
		list.addLast("s5");
		System.out.println(list);
		
		//将新元素添加至链表的头部
		list.addFirst("sx");
		System.out.println(list);
		
		//获取元素
		//根据元素的下标位置,在链表中通过遍历，查找获取元素
		String item = list.get(1);
		System.out.println(item);
		
		//获取链表的头元素和尾元素
		String first = list.getFirst();
		String last = list.getLast();
		System.out.println(first);
		System.out.println(last);
		
		//删除元素
		list.remove(2); //根据下标，在链表中删除元素
		list.remove("s1"); //根据值,在链表中删除元素
		System.out.println(list);
		
		list.removeFirst(); //删除链表的头元素
		list.removeLast(); //删除链表的尾元素
		System.out.println(list);
	}
}

运行结果：

[sx, s1, s2, s3, s4, s5]
s1
sx
s5
[sx, s3, s4, s5]
[s3, s4]

package com.ztt.Demo01;

import java.util.Stack;

public class demo08 {
	public static void main(String[] args) {
		//创建“栈”
		Stack<String> stack=new Stack<String>();
		
		//添加新元素（向栈顶添加）
		stack.push("s1");
		stack.push("s2");
		stack.push("s3");
		stack.push("s4");
		stack.push("s5");
		stack.push("s6");
		
		System.out.println(stack);
		
		//获取元素（从栈顶获取并删除）
//		System.out.println(stack.pop());
//		System.out.println(stack.pop());
//		System.out.println(stack.pop());
//		System.out.println(stack);
		
		//获取元素（从栈顶获取）
//		System.out.println(stack.peek());
//		System.out.println(stack.peek());
//		System.out.println(stack.peek());
		
		//遍历栈
		while(!stack.isEmpty()) {
			System.out.println(stack.pop());
		}
		
	}
}

运行结果：

[s1, s2, s3, s4, s5, s6]
s6
s5
s4
s3
s2
s1
package com.ztt.Demo01;

import java.util.Stack;

public class demo09 {
	public static void main(String[] args) {
		String s="大漠孤烟直长河落日圆";
		//方式1：StringBuilder
		StringBuilder sb=new StringBuilder(s);
		sb.reverse();
		System.out.println(sb);
		
		//方式2：Stack栈
		Stack<Character> stack=new Stack<Character>();
		for(int i=0;i<s.length();i++) {
			char c=s.charAt(i);
			stack.push(c);
		}
		
		StringBuilder ret=new StringBuilder();
		while(!stack.isEmpty()) {
			ret.append(stack.pop());
		}
		System.out.println(ret);
	}
}

运行结果：

圆日落河长直烟孤漠大
圆日落河长直烟孤漠大

甜甜不甜-
关注
Collection接口实现类的addAll()/removeAll()方法出现java.lang.NullPointerException
qq_35673036的博客
09-26 1463
阿里巴巴Java开发手册提示：在使用Collection接口任何实现类的addAll()方法时，都要对输入的集合参数进行NPE判断。 package com.cn.demo; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class ListTest { public s...
Java40——java集合之Collection子接口：List接口、Set接口
youhaitao_do的博客
09-06 309
一、Collection子接口：List接口 1. 存储的数据特点：存储有序的、可重复的数据。 2. 常用方法：(记住)增：add(Object obj) 删：remove(int index) / remove(Object obj) 改：set(int index, Object ele) 查：get(int index) 插：add(int index, Object ele) 长度：size() 遍历：① Iterator迭代器方式 ② 增强for循环 ③ 普通的循环 3...
集合的三大接口
qq_52500761的博客
03-25 1363
（1）集合有两个父接口 Collection、Map（2）Collection有两个子接口 List、set（3）List有两个常见的实现类 ArrayList、LinkedList（4）Set有两个常见的实现类 HashSet、TreeSet（5）Map有两个常见的实现类 HashMap、HashTable。
集合框架-----list接口、set接口、Map接口
weixin_65978343的博客
01-30 1283
集合框架-------list接口(ArrayList、LinkedList、Vector)、set接口(HashSet、LinkedHashSet、TreeSet)、Map接口(HashMap、LinkedHashMap、TreeMap、HashTable)
Java开发手册（嵩山版）阅读笔记
chen_heng_Ali的博客
05-28 1164
Java开发手册（嵩山版）阅读笔记
Java中 List集合接口及其主要的实现类ArrayList，Vector，LinkedList的详解
路宇的博客
05-16 1707
一、ArrayList:作为list接口的主要实现类；线程不安全，效率高；底层使用Object[] elementData存储 二、list接口中的常用方法： @Test public void test1(){ ArrayList list=new ArrayList(); list.add(45); list.add("aa"); list.add("你好"); list.add("456"); S
JavaSE入门学习35：Java集合框架之List接口及其实现类ArrayList和LinkedList
life is wonderful
05-02 4338
一List接口概述        List接口是Collection接口的子接口，实现List接口的集合类中的元素是有顺序的，而且可以重复，被称为序列。        List集合中的元素都对应一个整数型的序列容器中的序号记载其在容器中的位置，可以根据序号存取容器中的元 素。List接口可以精确的控制每个元素的插入位置，或者删除某个位置元素。        Java所提供的List集合实现
关于List集合类ArrayList、LinkedList、Vector详解
扎哇太枣糕的笔记博客
06-02 1025
  各位小伙伴们大家好，欢迎来到这个小扎扎的《Java核心技术 卷Ⅰ》笔记专栏，在这个系列专栏中我将记录浅学这本书所得收获，鉴于 看到就是学到、学到就是赚到 精神，这波简直就是血赚
List实现类中的ArrayList、Vector、LinkedList
01-20
首先，List接口继承于Collection接口，其中的所有方法都被继承，而Collection是无序、无下标，元素不可重复的，List是有序，有下标，元素可以重复，所以，List就有一些自己独有的方法。和数组相比较更加灵活，方便。...
Java编程：深入理解List接口与实现类ArrayList、Vector、LinkedList
通过具体的代码示例，我们分析了List接口的实现类ArrayList、Vector和LinkedList，探讨了它们的特点和使用场景。" 在Java中，`Map`和`List`是两种重要的数据结构，它们都属于Java集合框架的一部分，用于存储和管理...
Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector
Colorful_X的博客
04-27 763
文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List特性：LinkedList的Queue特性总结Vector类继承关系类成员属性类构造器Vector的扩容机制增删
Java集合类详解：ArrayList, Vector与LinkedList的区别
本总结主要关注于Java中的List和Set接口以及它们的主要实现类，包括Vector、ArrayList和LinkedList，以及HashSet、LinkedHashSet和TreeSet。 1. **Collection接口**： - Collection是最基础的集合接口，它代表了一...
Java集合类详解：ArrayList, Vector, LinkedList比较
- Collection是所有集合类的根接口，它定义了集合的基本操作，如添加、删除、遍历元素等。 2. **List接口**： - List是Collection的子接口，它维护了元素的顺序，并允许重复元素。List接口的主要实现类包括： - ...
java集合类框架的基本接口有哪些
热门推荐
子衿_青青的博客
10-13 2万+
转自：牛客网 java集合类框架的基本接口有哪些？ 答：Collection：代表一组对象，每一个对象都是它的子元素 Set：不包括重复元素的Collection List：有顺序的Collection，并且可以包含重复元素 Map：可以把键（key）映射到值（value）的对象，键不能重复 下面是详细解释： 转自：牛客网 （一）总共有两大接口：Collecti
Java集合框架及基本接口
qq_36109477的博客
01-12 1919
Collection接口及迭代器 泛型方法的使用 集合基本接口和实现 List ArrayList LinkedList ListIterator接口和Iterable接口的区别 Set HashSet TreeSet Queue ArrayDeque和LinkedList PriorityQueue Map TreeMap HashTable和ConcurrentHashMap LinkedHashMap
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 435
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1285
项目功能：商品分类,商品信息,用户。
Hadoop生态圈框架部署（二）- 配置IP地址映射为主机名及免密登录
zcs2312852665的博客
10-29 1241
介绍在虚拟机hadoop1、hadoop2和hadoop3配置IP地址映射为主机名配置虚拟机hadoop1、hadoop2和hadoop3互相免密登录。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1056
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值