Java集合-List

棉花糖老丫

于 2024-04-15 23:44:37 发布

阅读量921

点赞数 28

分类专栏： Java基础文章标签： java list 开发语言数据结构

本文链接：https://blog.csdn.net/qq_35701567/article/details/137798924

版权

Java基础专栏收录该内容

31 篇文章 0 订阅

订阅专栏

1、List

---| Iterable 接口

Iterator iterator()

----| Collection 接口

------| List 接口元素可以重复，允许在指定位置插入元素，并通过索

引来访问元素

1.1 List集合特有方法

1：增加

void add(int index, E element) 指定位置添加元素

boolean addAll(int index, Collection c) 指定位置添加集合

2：删除

E remove(int index) 删除指定位置元素

3：修改

E set(int index, E element) 返回的是需要替换的集合中的元素

4：查找：

E get(int index) 注意： IndexOutOfBoundsException

int indexOf(Object o) // 找不到返回-1

lastIndexOf(Object o)

5：求子集合

List<E> subList(int fromIndex, int toIndex) // 不包含toIndex

1.1.1 增加

public static void main(String[] args) {

List list = new ArrayList();

// 增加：add() 将指定对象存储到容器中

list.add("计算机网络");

list.add("现代操作系统");

list.add("java编程思想");

list.add("java核心技术");

list.add("java语言程序设计");

System.out.println(list);

// add,在0角标位置添加一本书

list.add(0, "舒克和贝塔");

System.out.println(list);

// 在list2集合的1角标位置添加list集合元素

List list2 = new ArrayList();

list2.add("史记");

list2.add("资治通鉴");

list2.add("全球通史");

boolean addAll = list2.addAll(1, list);

System.out.println(addAll); //true System.out.println(list2);

}

1.1.2 删除

public static void main(String[] args) {

List list = new ArrayList();

// 增加：add() 将指定对象存储到容器中

list.add("计算机网络");

list.add("现代操作系统");

list.add("java编程思想");

list.add("java核心技术");

list.add("java语言程序设计");

System.out.println(list);

// 删除0角标元素

Object remove = list.remove(0);

System.out.println(remove);

}

1.1.3 修改

public static void main(String[] args) {

List list = new ArrayList();

// 增加：add() 将指定对象存储到容器中

list.add("计算机网络");

list.add("现代操作系统");

list.add("java编程思想");

list.add("java核心技术");

list.add("java语言程序设计");

System.out.println(list);

// 修改2角标位置的书，返回的原来2角标位置的书

Object set = list.set(2, "边城");

System.out.println(set); //java编程思想

System.out.println(list);

}

1.1.4 查找

public static void main(String[] args) {

List list = new ArrayList();

// 增加：add() 将指定对象存储到容器中

list.add("计算机网络");

list.add("现代操作系统");

list.add("java编程思想");

list.add("java核心技术");

list.add("java语言程序设计");

list.add("java编程思想");

System.out.println(list);

// 查找： E get(int index) 注意角标越界

Object set = list.get(list.size() - 1);

System.out.println(set); // java语言程序设计

System.out.println(list);

// list.get(list.size()); //IndexOutOfBoundsException

// indexOf(Object o) 返回第一次出现的指定元素的角标

int indexOf = list.indexOf("java编程思想");

System.out.println(indexOf); // 2

// 没有找到，返回-1

int indexOf2 = list.indexOf("三国志");

System.out.println(indexOf2); // -1

// lastIndexOf 返回最后出现的指定元素的角标

int lastIndexOf = list.lastIndexOf("java编程思想");

System.out.println(lastIndexOf); // 5

}

1.2 ArrayList

--| Iterable

----| Collection

------| List

---------| ArrayList 底层采用数组实现，默认10。每次增长

60%,（(oldCapacity * 3)/2 + 1）查询快，增删慢。

---------| LinkedList

ArrayList:实现原理：

数组实现, 查找快, 增删慢

数组为什么是查询快?因为数组的内存空间地址是连续的.

ArrayList底层维护了一个Object[] 用于存储对象，默认数组的长度是10。可以通过 new ArrayList(20)显式的指定用于存储对象的数组的长度。

当默认的或者指定的容量不够存储对象的时候，容量自动增长为原来的容量的1.5倍。

由于ArrayList是数组实现, 在增和删的时候会牵扯到数组增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快

可以考虑,假设向数组的0角标未知添加元素,那么原来的角标位置的元素需要整体往后移,并且数组可能还要增容,一旦增容,就需要要将老数组的内容拷贝到新数组中.所以数组的增删的效率是很低的.

练习：去除ArrayList集合中重复元素

1：存入字符串元素

2：存入自定义对象元素（如Perosn对象）

原理：

循环遍历该集合，每取出一个放置在新的集合中，放置之前先判断新的集合是否以包含了新的元素。

思路:

存入人的对象.

1先定义person 类

2将该类的实例存入集合

3 将对象元素进行操作. 注意:自定义对象要进行复写toString 和 equals 方法.

为什么? 因为object 是person 的父类,object 中的toString 返回的是哈希值,object 类中equals

方法比较的是对象的地址值.

思路

1存入字符串对象

2存入自定义对象如person

2创建容器,用于存储非重复元素

3对原容器进行遍历,在遍历过程中进行判断遍历到的元素是否在容器中存在.(contains)

4如果存在,就不存入,否则存入.

5 返回新容器

public class Demo6 {

public static void main(String[] args) {

ArrayList arr = new ArrayList();

Person p1 = new Person("jack", 20);

Person p2 = new Person("rose", 18);

Person p3 = new Person("rose", 18);

arr.add(p1);

arr.add(p2);

arr.add(p3);

System.out.println(arr);

ArrayList arr2 = new ArrayList();

for (int i = 0; i < arr.size(); i++) {

Object obj = arr.get(i);

Person p = (Person) obj;

if (!(arr2.contains(p))) {

arr2.add(p);

}

System.out.println(arr2);

}

class Person {

private String name;

private int age;

public Person() {

}

public Person(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public int hashCode() {

return this.name.hashCode() + age * 37;

}

@Override

public boolean equals(Object obj) {

if (!(obj instanceof Person)) {

return false;

}

Person p = (Person) obj;

return this.name.equals(p.name) && this.age == p.age;

}

@Override

public String toString() {

return "Person@name:" + this.name + " age:" + this.age;

}

在实际的开发中ArrayList是使用频率最高的一个集合。

1.3 LinkedList

--| Iterable

----| Collection

------| List

---------| ArrayList 底层采用数组实现，默认10。每次增长

60%,（(oldCapacity * 3)/2 + 1）查询快，增删慢。

---------| LinkedList 底层采用链表实现，增删快，查询慢。

LinkedList:链表实现, 增删快, 查找慢

由于LinkedList:在内存中的地址不连续,需要让上一个元素记住下一个元素.所以每个元素中保存的有下一个元素的位置.虽然也有角标,但是查找的时候,需要从头往下找,显然是没有数组查找快的.但是,链表在插入新元素的时候,只需要让前一个元素记住新元素,让新元素记住下一个元素就可以了.所以插入很快.

由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高。

但查询时需要一个一个的遍历, 所以效率较低。

特有方法

1：方法介绍

addFirst(E e)

addLast(E e)

getFirst()

getLast()

removeFirst()

removeLast()

如果集合中没有元素，获取或者删除元

素抛：NoSuchElementException

2：数据结构

1：栈（1.6）

先进后出

push()

pop()

2：队列（双端队列1.5）

先进先出

offer()

poll()

3：返回逆序的迭代器对象

descendingIterator() 返回逆序的迭代器对象

基本方法

import java.util.Iterator;

import java.util.LinkedList;

public class Demo3 {

public static void main(String[] args) {

LinkedList list = new LinkedList();

list.add("西游记");

list.add("三国演义");

list.add("石头记");

list.add("水浒传");

list.add("全球通史");

list.addFirst("史记");

list.addLast("呐喊");

// list.addFirst(null);

// list.addLast(null);

System.out.println(list);

// 获取指定位置处的元素。

String str = (String) list.get(0);

// 返回此列表的第一个元素。

String str2 = (String) list.getFirst();

System.out.println(str.equals(str2));

// 获取指定位置处的元素。

String str3 = (String) list.get(list.size() - 1);

// 返回此列表的最后一个元素。

String str4 = (String) list.getLast();

System.out.println(str3.equals(str4));

// 获取但不移除此列表的头（第一个元素）。

Object element = list.element();

System.out.println(element);

int size = list.size();

System.out.println(size);

}

迭代

mport java.util.Iterator;

import java.util.LinkedList;

public class Demo3 {

public static void main(String[] args) {

LinkedList list = new LinkedList();

list.add("西游记");

list.add("三国演义");

list.add("石头记");

list.add("水浒传");

list.add("全球通史");

Iterator it = list.iterator();

while (it.hasNext()) {

String next = (String) it.next();

System.out.println(next);

}

逆序迭代

import java.util.Iterator;

import java.util.LinkedList;

public class Demo6 {

public static void main(String[] args) {

LinkedList list = new LinkedList();

list.add("aa");

list.add("bb");

list.add("cc");

Iterator dit = list.descendingIterator();

while (dit.hasNext()) {

System.out.println(dit.next());

}

注意：可以使用该集合去模拟出队列(先进先出) 或者堆栈(后进先出) 数据结构。

堆栈(后进先出)

//堆栈(后进先出) 数据结构

public class Demo3 {

public static void main(String[] args) {

LinkedList list = new LinkedList();

// 压栈，先进后出

list.push("西游记");

list.push("三国演义");

list.push("石头记");

list.push("水浒传");

System.out.println(list);

// 弹栈

String str1 = (String) list.pop();

System.out.println(str1);

String str2 = (String) list.pop();

System.out.println(str2);

String str3 = (String) list.pop();

System.out.println(str3);

String str4 = (String) list.pop();

System.out.println(str4);

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

System.out.println(list); //[]

}

队列，先进先出

import java.util.LinkedList;

public class Demo3 {

public static void main(String[] args) {

LinkedList list = new LinkedList();

// 队列，先进先出

list.offer("西游记");

list.offer("三国演义");

list.offer("石头记");

list.offer("水浒传");

System.out.println(list);

// 出队列

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

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

System.out.println(list.peek()); // 获取队列的头元素，但是不删除

System.out.println(list.peekFirst()); // 获取队列的头元素，但是不删除

System.out.println(list.peekLast()); // 获取队列的最后一个元素但是不删除

}

ArrayList 和 LinkedList的存储查找的优缺点：

1、ArrayList 是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。

2、LinkedList 是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快

问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。

1.4 Vector

Vector: 描述的是一个线程安全的ArrayList。

ArrayList：单线程效率高

Vector ：多线程安全的，所以效率低

特有的方法：

void addElement(E obj) 在集合末尾添加元素

E elementAt( int index) 返回指定角标的元素

Enumeration elements() 返回集合中的所有元素，封装到Enumeration对象中

Enumeration 接口：

boolean hasMoreElements()

测试此枚举是否包含更多的元素。

E nextElement()

如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

public static void main(String[] args)

{

Vector v = new Vector();

v.addElement("aaa");

v.addElement("bbb");

v.addElement("ccc");

System.out.println( v );

System.out.println( v.elementAt(2) ); // ccc

// 遍历Vector遍历

Enumeration ens = v.elements();

while ( ens.hasMoreElements() )

{

System.out.println( ens.nextElement() );

}

棉花糖老丫

关注

28
点赞
踩
15

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java集合-List

1、ArrayList 是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。2、LinkedList 是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。
复制链接

扫一扫