java中List的用法

合集下载

java list用法

java list用法

java list用法Java List用法List是Java中的一种重要的集合框架,它可以存储和操作一组有序的元素。

List集合实现了Collection接口,Collection接口是List、Set等集合接口的父接口,所以List也称为“有序集合”。

List通过索引来访问元素,并且支持重复的元素。

List集合的基本特点如下:1. List集合可以存储任何类型的对象,包括基本数据类型,而且可以存储重复的元素。

2. List集合的元素是有序的,按照添加的顺序排列。

3. List集合通过索引访问元素,索引从0开始,最大值为list.size()-1。

4. List集合可以在任意位置添加、删除、修改元素。

5. List集合不能保证线程安全,一般情况下,在多线程操作时需要加锁来保证线程安全。

6. List集合的遍历方式有for循环、foreach循环、Iterator迭代器等。

7. List集合提供了sort()和reverse()方法,可以对list集合进行排序和翻转。

8. List集合提供了sublist()方法,可以把list集合分割成多个子list集合。

9. List集合提供了removeIf()方法,可以根据条件删除元素。

10. List集合提供了indexOf()和lastIndexOf()方法,可以根据元素获取其在list集合中的索引。

11. List集合提供了replaceAll()方法,可以根据条件修改list集合中的元素。

12. List集合提供了contains()方法,可以判断list集合中是否包含指定的元素。

13. List集合提供了addAll()方法,可以把一个list集合的元素添加到另一个list集合中。

14. List集合提供了stream()方法,可以将list集合转换为流,然后进行处理。

15. List集合提供了equals()方法,可以比较两个list集合是否相等。

java中list的方法

java中list的方法

java中list的方法在 Java 中,`List` 是一个接口,它继承自 `Collection` 接口,代表着一种有序、可重复的集合。

`List` 接口有多种实现类,比较常用的包括 `ArrayList`、`LinkedList` 和 `Vector` 等。

以下是 `List` 接口提供的一些常用方法:1. 添加元素:- `boolean add(E element)`: 将指定元素添加到列表的末尾。

- `void add(int index, E element)`: 在指定位置插入指定元素。

2. 获取元素:- `E get(int index)`: 返回列表中指定位置的元素。

- `int indexOf(Object o)`: 返回指定元素在列表中首次出现的位置索引。

- `int lastIndexOf(Object o)`: 返回指定元素在列表中最后一次出现的位置索引。

3. 移除元素:- `E remove(int index)`: 移除列表中指定位置的元素。

- `boolean remove(Object o)`: 移除列表中首次出现的指定元素。

4. 判断元素是否存在:- `boolean contains(Object o)`: 判断列表中是否包含指定元素。

- `boolean isEmpty()`: 判断列表是否为空。

5. 列表大小和清空:- `int size()`: 返回列表的大小(元素个数)。

- `void clear()`: 清空列表中的所有元素。

6. 替换元素:- `E set(int index, E element)`: 将列表中指定位置的元素替换为指定元素。

7. 列表转换为数组:- `Object[] toArray()`: 将列表转换为对象数组。

- `<T> T[] toArray(T[] a)`: 将列表转换为指定类型的数组。

这些方法是 `List` 接口提供的常用方法。

list在java中的用法

list在java中的用法

list在java中的用法在Java中,List是一个接口,它代表着有序的集合。

它允许存储重复的元素,并且能够根据元素的索引来访问和操作集合中的元素。

常用的实现类有ArrayList和LinkedList。

以下是List在Java中的一些主要用法:1. 创建List对象:List<T> list = new ArrayList<T>(); // 创建一个ArrayList对象 List<T> list = new LinkedList<T>(); // 创建一个LinkedList对象2. 添加元素到List中:list.add(element); // 添加元素到末尾list.add(index, element); // 在指定位置插入元素3. 获取List中的元素:T element = list.get(index); // 获取指定位置的元素4. 更新List中的元素:list.set(index, element); // 更新指定位置的元素5. 删除List中的元素:list.remove(index); // 删除指定位置的元素list.remove(element); // 删除指定元素6. 判断List是否包含指定元素:boolean contains = list.contains(element);7. 获取List的大小:int size = list.size();8. 遍历List中的元素:for (T element : list) {// 处理每个元素}9. 将List转换为数组:T[] array = list.toArray(new T[list.size()]);10. 使用迭代器遍历List:Iterator<T> iterator = list.iterator();while (iterator.hasNext()) {T element = iterator.next();// 处理每个元素}这些是List在Java中的主要用法,通过它们可以方便地对集合中的元素进行增删改查操作。

java list foreach用法

java list foreach用法

java list foreach用法Java List类是Java集合框架中一个重要的接口,它实现了Java集合框架中的一个可变大小的动态数组,可以存储多个元素。

Java List类内置了一个foreach循环,可以用来遍历List中的所有元素。

foreach 循环是一种简化版的for循环,可以通过以下方式使用:javaList<String> list = new ArrayList<String>();list.add("Java");list.add("Python");list.add("C++");for(String language : list) {System.out.println(language);}上述代码中,我们首先定义一个List对象,并向其中添加一些元素。

然后,我们使用foreach循环遍历List中的所有元素,并将它们打印到控制台上。

需要注意的是,在使用foreach循环时,我们必须指定一个元素引用变量(例如上述代码中的“language”变量),这个变量会在循环的每一次迭代中引用List 中的一个元素。

另外,由于List是一个接口,我们通常需要使用它的实现类,例如ArrayList、LinkedList等。

以下是一个完整的示例:javaimport java.util.ArrayList;import java.util.List;public class Test {public static void main(String[] args) {List<String> list = new ArrayList<String>();list.add("Java");list.add("Python");list.add("C++");for(String language : list) {System.out.println(language);}}}。

java的list用法

java的list用法

java的list用法List是Java中非常重要的一种数据结构,它是一种有序的列表,拥有许多灵活的操作方法,可以按需要进行操作和排序,对于开发者来说是一个非常有用的工具。

本文将介绍Java中List的一些用法和最佳实践,希望能够帮助到各位读者。

1、List接口List是Java中表示有序集合的数据结构,它继承自java.util.Collection接口,是一种非常重要的容器,属于动态数组,List集合支持可变大小的集合,支持对元素的插入和删除,也提供了查询和遍历方法,可以高效的操作。

2、List的实现List是一种接口,而不是一种具体的数据结构,在Java的util 包下,有多种实现列表的类,其中最常用的是ArrayList和LinkedList,他们各有优缺点,需要在特定的场景下使用。

(1)ArrayListArrayList是基于数组的动态数组,在ArrayList中,可以快速地检索和访问特定的元素,但是在插入和删除元素时,需要移动大量的元素,此时就会比较耗时,所以ArrayList适用于以检索为主的场景。

(2)LinkedListLinkedList是基于链表的实现,他的每个元素都是由一个节点组成的,和ArrayList相比,LinkedList的插入和删除操作更快,但是检索元素的效率要低很多,所以LinkedList适用于以插入和删除为主的场景。

3、List的常见用法(1)添加元素List中有很多添加元素的方法,最常用的有add,addAll,set和addAll,它们具有不同的功能,有时也会在不同的场景下使用。

add方法是List中最常用的添加元素的方法,它可以将指定元素添加到List的末尾,如果List为空,添加的元素会变成第一个元素,返回布尔值。

addAll方法可以将另一个集合中的元素全部添加到List的末尾,当另一个集合为空时,不会添加任何元素,也不会发生异常,返回布尔值。

set方法可以将指定位置的元素替换为指定的元素,它可以用来更新List中的元素,返回替换的元素。

java中list的常用方法

java中list的常用方法

java中list的常用方法J a v a中的L i s t是一种常用的数据结构,用于存储和操作一系列的元素。

L i s t接口扩展了C o l l e c t i o n接口,并提供了许多常用的方法,方便我们对列表中的元素进行增删改查等操作。

本文将一步一步回答关于L i s t常用方法的问题。

第一步:创建一个L i s t对象要使用L i s t,首先需要创建一个L i s t对象。

J a v a提供了多个实现L i s t接口的类,包括A r r a y L i s t、L i n k e d L i s t和V e c t o r等。

我们可以根据实际需求选择合适的实现类来创建Li s t对象。

下面以Ar r a y L i s t为例来创建一个L i s t对象:j a v aL i s t<S t r i n g>l i s t=n e w A r r a y L i s t<>();在上面的代码中,我们通过使用A r r a y L i s t 类来创建一个L i s t对象,并使用泛型来指定列表中的元素类型为S t r i n g。

第二步:向Li s t中添加元素下一步是向Li s t中添加元素。

L i s t接口提供了多个用于添加元素的方法,常用的有ad d()和a d d A l l()方法。

a d d()方法用于向列表末尾添加一个元素,a d d A l l()方法用于向列表末尾添加多个元素。

例如:j a v al i s t.a d d("e l e m e n t1");l i s t.a d d("e l e m e n t2");L i s t<S t r i n g>a n o t h e r L i s t=n e wA r r a y L i s t<>();a n o t h e r L i s t.a d d("e l e m e n t3");a n o t h e r L i s t.a d d("e l e m e n t4");l i s t.a d d A l l(a n o t h e r L i s t);在上面的代码中,我们先使用a d d()方法向l i s t中添加了两个元素,然后使用a d d A l l()方法将a n o t h e r L i s t中的所有元素添加到l i s t中。

java list find用法

java list find用法

java list find用法在Java中,List是一种有序集合,可以存储多个元素。

List接口提供了find方法来查找指定元素的索引。

List的find方法可以通过以下方式使用:1.使用indexOf方法:`int index = list.indexOf(element);`该方法会返回指定元素在列表中第一次出现的索引。

如果指定元素不存在于列表中,则返回-1。

2.使用contains和indexOf方法的组合:```javaif (list.contains(element)) {int index = list.indexOf(element);//执行相关操作}```首先使用contains方法检查指定元素是否存在于列表中,然后使用indexOf方法获取其索引。

请注意,List的find方法是基于元素的相等性进行比较的。

如果列表中存在多个相同的元素,find方法只会返回第一个匹配的元素的索引。

除了find方法,List还提供了其他常用的方法来处理元素的查找,如lastIndexOf方法可以返回指定元素在列表中最后一次出现的索引。

此外,可能还需要注意的是List接口的实现类ArrayList和LinkedList,它们在元素查找方面的性能不同。

ArrayList通过索引直接获取元素,查找效率高;而LinkedList需要从头部开始遍历链表,查找效率相对较低。

因此,在进行频繁的查找操作时,ArrayList通常比LinkedList更合适。

在实际应用中,可以根据具体的需求选择合适的方法和数据结构来进行元素的查找操作。

java中List的用法和实例详解

java中List的用法和实例详解

java中List的用法和实例详解List的用法List包括List接口以及List接口的所有实现类。

因为List接口实现了Collection接口,所以List接口拥有Collection接口提供的所有常用方法,又因为List 是列表类型,所以List接口还提供了一些适合于自身的常用方法,如表1所示。

表1 List接口定义的常用方法及功能从表1可以看出,List接口提供的适合于自身的常用方法均与索引有关,这是因为List集合为列表类型,以线性方式存储对象,可以通过对象的索引操作对象。

List接口的常用实现类有ArrayList和LinkedList,在使用List集合时,通常情况下声明为List类型,实例化时根据实际情况的需要,实例化为ArrayList或LinkedList,例如:List<String> l = new ArrayList<String>();// 利用ArrayList类实例化List集合List<String> l2 = new LinkedList<String>();// 利用LinkedList类实例化List集合1.add(int index, Object obj)方法和set(int index, Object obj)方法的区别在使用List集合时需要注意区分add(int index, Object obj)方法和set(int index, Object obj)方法,前者是向指定索引位置添加对象,而后者是修改指定索引位置的对象,例如执行下面的代码:src\com\mwq\TestCollection.java关键代码:public static void main(String[] args) {String a = "A", b = "B", c = "C", d = "D", e = "E";List<String> list = new LinkedList<String>();list.add(a);list.add(e);list.add(d);list.set(1, b);// 将索引位置为1的对象e修改为对象blist.add(2, c);// 将对象c添加到索引位置为2的位置Iterator<String> it = list.iterator();while (it.hasNext()) {System.out.println(it.next());}}在控制台将输出如下信息:ABCD因为List集合可以通过索引位置访问对象,所以还可以通过for循环遍历List集合,例如遍历上面代码中的List集合的代码如下:src\com\mwq\TestCollection.java关键代码:for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));// 利用get(int index)方法获得指定索引位置的对象}src\com\mwq\TestCollection.java完整代码如下:package com.mwq;import java.util.ArrayList;import java.util.LinkedList;import java.util.Iterator;import java.util.List;public class TestCollection {public static void main(String[] args) {System.out.println("开始:");String a = "A", b = "B", c = "C", d = "D", e = "E";List<String> list = new LinkedList<String>();list.add(a);list.add(e);list.add(d);list.set(1, b);// 将索引位置为1的对象e修改为对象blist.add(2, c);// 将对象c添加到索引位置为2的位置Iterator<String> it = list.iterator();while (it.hasNext()) {System.out.println(it.next());}// for (int i = 0; i < list.size(); i++) {// System.out.println(list.get(i));// 利用get(int index)方法获得指定索引位置的对象// }System.out.println("结束!");}}2.indexOf(Object obj)方法和lastIndexOf(Object obj)方法的区别在使用List集合时需要注意区分indexOf(Object obj)方法和lastIndexOf(Object obj)方法,前者是获得指定对象的最小的索引位置,而后者是获得指定对象的最大的索引位置,前提条件是指定的对象在List集合中具有重复的对象,否则如果在List集合中有且仅有一个指定的对象,则通过这两个方法获得的索引位置是相同的,例如执行下面的代码:src\com\mwq\TestCollection.java关键代码:public static void main(String[] args) {String a = "A", b = "B", c = "C", d = "D", repeat = "Repeat";List<String> list = new ArrayList<String>();list.add(a); // 索引位置为 0list.add(repeat); // 索引位置为 1list.add(b); // 索引位置为 2list.add(c); // 索引位置为 4list.add(repeat); // 索引位置为 5list.add(d); // 索引位置为 6System.out.println(list.indexOf(repeat));System.out.println(stIndexOf(repeat));System.out.println(list.indexOf(b));System.out.println(stIndexOf(b));}src\com\mwq\TestCollection.java完整代码如下:package com.mwq;import java.util.ArrayList;import java.util.List;public class TestCollection {public static void main(String[] args) {System.out.println("开始:");String a = "A", b = "B", c = "C", d = "D", repeat = "Repeat";List<String> list = new ArrayList<String>();list.add(a); // 索引位置为 0list.add(repeat); // 索引位置为 1list.add(b); // 索引位置为 2list.add(repeat); // 索引位置为 3list.add(c); // 索引位置为 4list.add(repeat); // 索引位置为 5list.add(d); // 索引位置为 6System.out.println(list.indexOf(repeat));System.out.println(stIndexOf(repeat));System.out.println(list.indexOf(b));System.out.println(stIndexOf(b));System.out.println("结束!");}}在控制台将输出如下信息:15223.subList(int fromIndex, int toIndex)方法在使用subList(int fromIndex, int toIndex)方法截取现有List集合中的部分对象生成新的List集合时,需要注意的是,新生成的集合中包含起始索引位置代表的对象,但是不包含终止索引位置代表的对象,例如执行下面的代码:src\com\mwq\TestCollection.java关键代码:public static void main(String[] args) {String a = "A", b = "B", c = "C", d = "D", e = "E";List<String> list = new ArrayList<String>();list.add(b); // 索引位置为 1list.add(c); // 索引位置为 2list.add(d); // 索引位置为 3list.add(e); // 索引位置为 4list = list.subList(1, 3);// 利用从索引位置 1 到 3 的对象重新生成一个List集合for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}}src\com\mwq\TestCollection.java完整代码:package com.mwq;import java.util.ArrayList;import java.util.List;public class TestCollection {public static void main(String[] args) {System.out.println("开始:");String a = "A", b = "B", c = "C", d = "D", e = "E";List<String> list = new ArrayList<String>();list.add(a); // 索引位置为 0list.add(b); // 索引位置为 1list.add(c); // 索引位置为 2list.add(d); // 索引位置为 3list.add(e); // 索引位置为 4list = list.subList(1, 3);// 利用从索引位置 1 到 3 的对象重新生成一个List集合for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}System.out.println("结束!");}}在控制台将输出如下信息:BCList 应用1.数组列数据的添加与删除:List list = new LinkedList();list = new ArrayList();产生一个数组列对象并建立双向连表。

java list泛型的用法

java list泛型的用法

java list泛型的用法Java中的List是一个非常常用的集合类,它提供了存储和操作一组对象的机制。

为了使List能够存储不同类型的对象,Java引入了泛型。

泛型是一种在编译时提供类型安全的技术,它允许程序员编写可重用的代码,同时确保类型安全。

本文将介绍Java List泛型的用法。

一、定义泛型在Java中,List泛型允许我们为List指定一个或多个类型参数。

这些类型参数在编译时被确定,从而确保List只能存储指定类型的对象。

定义泛型的基本语法如下:```javaList<类型参数> list = new ArrayList<类型参数>();```例如,我们可以创建一个只能存储Integer对象的ArrayList,如下所示:```javaArrayList<Integer> intList = new ArrayList<Integer>();```二、使用泛型使用泛型时,我们可以为List指定任意类型的对象,例如String、Integer、Person等。

以下是一些常见的用法:1. 添加元素:使用add()方法向List中添加元素。

由于List是泛型类型,因此add()方法可以接受任意类型的参数。

例如:```javaList<Integer> intList = new ArrayList<Integer>();intList.add(1); // 添加整数元素intList.add("2"); // 添加字符串元素,编译时会报错```2. 遍历元素:使用for-each循环遍历List中的元素。

由于List是泛型类型,因此循环变量可以自动推断为List中存储的类型。

例如:```javaList<Integer> intList = new ArrayList<Integer>();int[] numbers = {1, 2, 3};for (Integer num : intList) {System.out.println(num); // 输出整数元素}```3. 访问元素:使用get()方法访问List中的元素。

Java中List集合的常用方法详解

Java中List集合的常用方法详解

Java中List集合的常⽤⽅法详解⽬录1、voidadd(intindex, Eelement)2、booleanaddAll(intindex, Collection<?extends E>c)3、E get(intindex)4、intindexOf(Objecto)5、ListIterator<E>listIterator()6、ListIterator<E>listIterator(intindex)7、E remove(intindex)8、E set(intindex, Eelement)9、List<E>subList(intfromIndex,inttoIndex)总结List接⼝是继承Collection接⼝,所以Collection集合中有的⽅法,List集合也继承过来。

这篇⽂章就不讲继承Collection接⼝的那些⽅法了1、void add(intindex, Eelement)在指定位置插⼊元素,后⾯的元素都往后移⼀个元素。

2、boolean addAll(intindex, Collection<? extends E>c)在指定的位置中插⼊c集合全部的元素,如果集合发⽣改变,则返回true,否则返回false。

意思就是当插⼊的集合c没有元素,那么就返回false,如果集合c有元素,插⼊成功,那么就返回true。

3、E get(intindex)返回list集合中指定索引位置的元素4、int indexOf(Objecto)返回list集合中第⼀次出现o对象的索引位置,如果list集合中没有o对象,那么就返回-15、ListIterator<E> listIterator()返回此列表元素的列表迭代器(按适当顺序)。

listIterator和iterator的区别是什么呢?下⾯这篇博客⽐较详细的分析,可以参考。

list集合的写法

list集合的写法

list集合的写法全文共四篇示例,供读者参考第一篇示例:List集合是Java中最常用的数据结构之一,它提供了一种方便存储和管理一组元素的方法。

在编程中,我们经常需要处理大量的数据,而List集合正是为此而设计的。

它可以动态添加、删除和修改元素,使我们能够更加灵活地操作数据。

List集合的写法非常简单,只需要使用如下的代码:List<类型> 变量名= new ArrayList<>();要创建一个存储整型数字的List集合,可以这样写:这行代码创建了一个ArrayList类型的List集合,用于存储整型数字。

我们还可以通过元素的索引来访问和修改List集合中的元素,例如:list.add(10); // 添加一个元素list.add(20);list.add(30);System.out.println(list.get(1)); // 输出第二个元素上面的代码将在控制台输出20,因为元素在List集合中是从0开始编号的。

List集合也提供了一些常用的操作方法,如添加、删除、查找等,让我们更加方便地对数据进行处理。

List集合还有一个重要的特性就是它可以存储不同类型的数据,只需要将泛型的类型参数设置为Object即可。

这样,我们可以在一个List集合中存储各种不同类型的数据,非常灵活。

除了ArrayList,Java中还提供了其他类型的List集合,如LinkedList、Vector等,它们各自有自己的特点和适用场景。

选择合适的List集合要根据具体的需求来决定。

第二篇示例:List是在Java中使用非常频繁的一种数据结构,它是一种有序的集合,可以存储重复的元素。

List的使用非常灵活,能够满足各种不同的需求。

本文将介绍List集合的基本概念、常见的写法以及一些常见的操作方法。

一、List集合的基本概念List是Java中的接口,它继承自Collection接口,因此List可以存储任意类型的对象。

Java中List排序的3种方法!

Java中List排序的3种方法!

Java中List排序的3种⽅法!在某些特殊的场景下,我们需要在 Java 程序中对 List 集合进⾏排序操作。

List 排序的常见⽅法有以下 3 种:使⽤ Comparable 进⾏排序;使⽤ Comparator 进⾏排序;如果是 JDK 8 以上的环境,也可以使⽤ Stream 流进⾏排序。

下⾯我们分别来看各种排序⽅法的具体实现。

新建实体类如下://以下 set/get/toString 使⽤的是 lombok 的注解@Getter@Setter@ToStringclass Person implements Comparable<Person> {private Integer age;private String name;public Person(Integer age, String name) {this.age = age; = name;}@Overridepublic int compareTo(Person p) {return p.getAge() - this.getAge();}}1.使⽤ Comparable 排序class TestDemo{public static void main(String[] args) {// 创建并初始化 ListList<Person> list = new ArrayList<Person>() {{add(new Person(30, "Jesse"));add(new Person(10, "luxi"));add(new Person(40, "Jack")); }};// 使⽤ Comparable ⾃定的规则进⾏排序 Collections.sort(list);// 打印 list 集合list.forEach(p -> {System.out.println(p);});}}2.使⽤ Comparator 排序/*** 新建 Person ⽐较器*/class PersonComparator implements Comparator<Person> {@Overridepublic int compare(Person p1, Person p2) {return p2.getAge() - p1.getAge();}}class TestDemo{public static void main(String[] args) {// 创建并初始化 ListList<Person> list = new ArrayList<Person>() {{add(new Person(30, "Jesse"));add(new Person(10, "luxi"));add(new Person(40, "Jack"));}}; //新建 Person ⽐较器 Collections.sort(list,new PersonComparator()); //或者// 使⽤匿名⽐较器排序Collections.sort(list, new Comparator<Person>() {@Overridepublic int compare(Person p1, Person p2) {return p2.getAge() - p1.getAge();}}); // 打印 list 集合list.forEach(p -> { System.out.println(p); });} } 3.使⽤ Stream 流排序class TestDemo{public static void main(String[] args) {// 创建并初始化 ListList<Person> list = new ArrayList<Person>() {{add(new Person(30, "Jesse"));add(new Person(10, "luxi"));add(new Person(40, "Jack"));add(new Person(null, "marry")); }};// 使⽤ Stream 排序,但是年龄中有个null,所以会报错list = list.stream().sorted(paring(Person::getAge).reversed()).collect(Collectors.toList());//java8排序(正确)// 按照[年龄]正序,但年龄中有⼀个 null 值list.stream().sorted(paring(Person::getAge,Comparator.nullsFirst(Integer::compareTo)).reversed()).collect(Collectors.toList());// 打印 list 集合list.forEach(p -> { System.out.println(p);});}}  总结:其中 reversed() 表⽰倒序的意思,如果不使⽤此⽅法则是正序。

javalist的用法详解

javalist的用法详解

javalist的用法详解java list的用法详解java中可变数组的原理就是不断的创建新的数组,将原数组加到新的数组中。

以下是店铺搜索整理的关于java list的用法详解,需要的朋友可以参考一下!想了解更多相关信息请持续关注我们店铺!|--List:元素是有序的(怎么存的就怎么取出来,顺序不会乱),元素可以重复(角标1上有个3,角标2上也可以有个3)因为该集合体系有索引,|-- ArrayList:底层的数据结构使用的是数组结构(数组长度是可变的百分之五十延长)(特点是查询很快,但增删较慢)线程不同步|-- LinkedList:底层的数据结构是链表结构(特点是查询较慢,增删较快)|-- Vector:底层是数组数据结构线程同步(数组长度是可变的百分之百延长)(无论查询还是增删都很慢,被ArrayList替代了)List:特有的方法,凡是可以操作角标的方法都是该体系特有的方法增代码如下:boolean add(int index, E element)boolean addAll(index,Collection)代码如下:public static void List_add(){ArrayList a1 = new ArrayList();a1.add("java");a1.add("php");//List集合中的元素可以重复a1.add(".net");System.out.println("原集合:"+a1);a1.add(1, "Flash");a1.add(0, "ps");System.out.println(a1);ArrayList a2 = new ArrayList();a2.add("javascript");a2.add("3dMax");a2.add("IBM");a1.addAll(0, a2);System.out.println(a1);}删除指定位置的元素代码如下:boolean remove(int index)代码如下:public static void List_remove(){ArrayList a1 = new ArrayList();a1.add("javascript");a1.add("php");a1.add("flash");System.out.println("原集合:"+a1);a1.remove(0);System.out.println(a1);}修改指定角标的元素 set(int index, E element) 返回的是修改的那个元素代码如下:public static void List_set() {ArrayList a1 = new ArrayList();a1.add("javascript");a1.add("php");a1.add(".net");System.out.println("原集合:"+a1);a1.set(1, "falsh");System.out.println(a1);}查代码如下:get(int index) 返回列表中指定位置的元素subList(int fromIndex, int toIndex) 返回列表中指定的fromIndex(包括)和 toIndex(不包括)之间的部分元素。

Java中初始化List集合的8种方式!

Java中初始化List集合的8种方式!

Java中初始化List集合的8种⽅式! List 是在开发中⽐较常⽤的集合,今天总结⼀下 Java 中初始化 List 的⼏种⽅式。

1、常规⽅式List<String> list = new ArrayList<>();list.add("1");list.add("2");list.add("3");System.out.println("getList1: " + list);输出getList1: [1, 2, 3]2、Arrays ⼯具类// ⽣成的list不可变List<String> list = Arrays.asList("1", "2", "3");System.out.println("getList2: " + list);// 如果要可变需要⽤ArrayList包装⼀下List<String> numbers = new ArrayList<>(Arrays.asList("1", "2", "3"));numbers.add("4");System.out.println("numbers: " + numbers);输出getList2: [1, 2, 3]numbers: [1, 2, 3, 4]3、Collections ⼯具类// ⽣成的list不可变List<String> list = Collections.nCopies(3, "1");System.out.println("getList3: " + list);// 如果要可变需要⽤ArrayList包装⼀下List<String> dogs = new ArrayList<>(Collections.nCopies(3, "dog"));dogs.add("dog");System.out.println("dogs: " + dogs);输出getList3: [1, 1, 1]dogs: [dog, dog, dog, dog]4、Lists ⼯具类List<String> list = Lists.newArrayList("1", "2", "3");System.out.println("getList4: " + list);输出getList4: [1, 2, 3]5、匿名内部类List<String> list = new ArrayList<String>() {{add("1");add("2");add("3");}};System.out.println("getList5: " + list);输出getList5: [1, 2, 3]6、ImmutableListList<String> list = ImmutableList.of("1", "2", "3");System.out.println("getList6: " + list);输出getList6: [1, 2, 3]7、Java8 StreamList<String> list = Stream.of("1", "2", "3").collect(Collectors.toList()); System.out.println("getList7: " + list);输出getList7: [1, 2, 3]8、Java9 List.ofList<String> list = List.of{"1", "2", "3"};System.out.println("getList8: " + list);输出getList8: [1, 2, 3]。

java查询list数量高级用法

java查询list数量高级用法

java查询list数量高级用法在Java中,可以使用`List`接口中的`size()`方法来查询一个`List`的元素数量。

该方法返回一个`int`类型的值,表示列表中元素的个数。

除了`size()`方法外,还可以使用其他方法来查询`List`数量的高级用法。

以下是一些例子:1.使用`stream()`方法和`count()`方法:```javaList<String> list = Arrays.asList("a", "b", "c");long count = list.stream().count();System.out.println("List中元素的个数:" + count);```2.使用`Iterator`迭代器:```javaList<String> list = Arrays.asList("a", "b", "c");int count = 0;Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {iterator.next();count++;}System.out.println("List中元素的个数:" + count);```3.使用Java 8中的Lambda表达式和Stream API:```javaList<String> list = Arrays.asList("a", "b", "c");long count = list.stream().filter(e ->e.startsWith("a")).count();System.out.println("以字母'a'开头的元素的个数:" + count);```拓展:以上展示的是一些常见的查询`List`数量的方法,还有很多其他的方式可以实现相同的功能。

JAVA8新特性之List的各种用法(最大、最小、平均值、分组、求和、遍历、过滤、排序)

JAVA8新特性之List的各种用法(最大、最小、平均值、分组、求和、遍历、过滤、排序)

JAVA8新特性之List的各种⽤法(最⼤、最⼩、平均值、分组、求和、遍历、过滤、排序)构建⼀个User实体类供演⽰public class Users {/*** ID*/private Long id;/*** ⽤户名*/private String name;/*** 年龄*/private int age;/*** ⼯号*/private String jobNumber;/*** 性别*/private String sex;/*** 注册时间*/private Date entryDate;/*** 成员组织*/private BigDecimal familyMemberQuantity;private Long userId;public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getJobNumber() {return jobNumber;}public void setJobNumber(String jobNumber) {this.jobNumber = jobNumber;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public Date getEntryDate() {return entryDate;}public void setEntryDate(Date entryDate) {this.entryDate = entryDate;}public BigDecimal getFamilyMemberQuantity() {return familyMemberQuantity;}public void setFamilyMemberQuantity(BigDecimal familyMemberQuantity) {this.familyMemberQuantity = familyMemberQuantity;}public Long getUserId() {return userId;}public void setUserId(Long userId) {erId = userId;}@Overridepublic String toString() {return "Users{" +"id=" + id +", name='" + name + '\'' +", age=" + age +", jobNumber='" + jobNumber + '\'' +", sex='" + sex + '\'' +", entryDate=" + DateFormatUtils.format(entryDate, "yyyy-MM-dd HH:mm:ss") +", familyMemberQuantity=" + familyMemberQuantity +'}';}}⼀、根据字段分组得到多个List集合构建⼀个产⽣Users的静态法/*** ⽣产虚拟⽤户** @return*/public static List<Users> produceUser() {List<Users> usersList = new ArrayList<>();for (int i = 1; i <= 10; i++) {Users users = new Users();users.setId(Long.valueOf(i));users.setName("kobe" + i);users.setAge(15 + new Random().nextInt(5));users.setJobNumber("jobNumber" + i);if (i % 2 == 0) {users.setSex("男");} else {users.setSex("⼥");}users.setEntryDate(new Date());users.setFamilyMemberQuantity(new BigDecimal(i));usersList.add(users);}return usersList;}利⽤Java8 特性,根据对象的某个属性进⾏分组@Testpublic void groupByGender() {List<Users> list = produceUser();// 根据性别进⾏分组Map<String, List<Users>> collect = list.stream().collect(Collectors.groupingBy(Users::getSex)); Set<Map.Entry<String, List<Users>>> entries = collect.entrySet();entries.forEach(item -> {// 性别男 / ⼥String gender = item.getKey();// 男集合 / ⼥集合List<Users> usersList = item.getValue();System.out.println(gender);usersList.forEach(user -> System.out.println(user));});}输出结果如下⼆、集合求和2.1 根据对象中的某个字段求和/*** 根据年龄字段求总和*/@Testpublic void getSumByStream() {List<Users> list = produceUser();int sum = list.stream().mapToInt(Users::getAge).sum();System.out.println("共计:" + list.size() + "个⽤户,所有年龄总和为:" + sum);// 求最⼤年龄Integer integer = list.stream().map(Users::getAge).max(Integer::compareTo).get();System.out.println(integer);// 得到最⼤年龄对象Users users = list.stream().max(paringInt(Users::getAge)).get();System.out.println(users);// 求平均年龄System.out.println(list.stream().mapToInt(Users::getAge).average().getAsDouble());// 求最⼤年龄System.out.println(list.stream().mapToInt(Users::getAge).max().getAsInt());}输出结果如下2.2 List<数值型> 求和/*** 根据List求和*/@Testpublic void getListSumByJava8() {List<Integer> listInt = new ArrayList();List<Double> listDoub = new ArrayList();for (int i = 0; i < 500; i++) {listInt.add(new Random().nextInt(1000));listDoub.add(new Random().nextDouble());}System.out.println("=======数值型Integer求和======");Integer integer = listInt.stream().reduce(Integer::sum).orElse(0);System.out.println(integer);System.out.println("=======数值型Double求和======");Double integer1 = listDoub.stream().reduce(Double::sum).orElse(0.00);System.out.println(integer1);// 取最⼤值System.out.println(listInt.stream().reduce(Integer::max).orElse(0));System.out.println(listInt.stream().mapToInt(Integer::valueOf).max().getAsInt());// 取最⼩值System.out.println(listInt.stream().reduce(Integer::min).orElse(0));// 取平均值System.out.println(listInt.stream().mapToInt(Integer::valueOf).average().getAsDouble());}输出结果如下三、遍历List集合/*** 遍历对象*/@Testpublic void traverseByJava8(){List<Users> list = produceUser();list.forEach(System.out::println);}输出结果如下四、过滤List集合/*** 过滤对象*/@Testpublic void filterByJava8() {List<Users> list = produceUser();System.out.println("原始数据为:");System.out.println("==============过滤后的数据为===============");list.forEach(System.out::println);//筛选出年龄⼤于3岁⼩于8岁的对象List<Users> collect = list.stream().filter(s -> s.getAge() > 13 && s.getAge() < 18).collect(Collectors.toList()); System.out.println("过滤结束后的数据为:");collect.forEach(System.out::println);}输出结果如下五、获取List中的最⼤最⼩值5.1 根据特定需求中的某个字段求最⼤最⼩/*** 求最⼤最⼩值,根据业务类型选择合适的类型值*/@Testpublic void maxOrMinByJava8() {List<Users> list = produceUser();//根据mapTO**得到最⼤最⼩ ---写法⼀double asDouble = list.stream().mapToDouble(Users::getAge).max().getAsDouble(); System.out.println("将最⼤值转换为Double类型进⾏展⽰,最⼤为:" + asDouble);double asDouble1 = list.stream().mapToDouble(Users::getAge).min().getAsDouble(); System.out.println("将最⼩值转换为Double类型进⾏展⽰,最⼩为:" + asDouble1);int asInt = list.stream().mapToInt(Users::getAge).max().getAsInt();System.out.println("将最⼤值转换为Int类型进⾏展⽰,最⼤为:" + asInt);//根据map得到最⼤最⼩ ---写法⼆(推荐)Integer integer = list.stream().map(Users::getAge).max(Integer::compareTo).get();System.out.println("将最⼤值转换为字段对应类型进⾏展⽰,最⼤为:" + integer);Integer integer1 = list.stream().map(Users::getAge).min(Integer::compareTo).get();System.out.println("将最⼩值转换为字段对应类型进⾏展⽰,最⼩为:" + integer1);}输出结果如下5.2 根据特定需求中的某个字段求平均值/*** 求最⼤最⼩值,根据业务类型选择合适的类型值*/@Testpublic void avgByJava8() {List<Users> list = produceUser();double avgAge = list.stream().mapToDouble(Users::getAge).average().getAsDouble(); System.out.println("平均年龄为:" + avgAge);}输出结果如下六、根据需求将List转为Map/*** List -> Map* 需要注意的是:* toMap 如果集合对象有重复的key,会报错Duplicate key ....* user1,user2的id都为1。

java中List对象的操作方法和List对象的遍历

java中List对象的操作方法和List对象的遍历

java中List对象的操作⽅法和List对象的遍历List对象的操作⽅法List<String> list = new ArrayList<String>();//增加list.add("苹果");list.add("橘⼦");list.add("⾹蕉");list.add("苹果");list.add(1, "榴莲"); //向指定位置增加元素list.clear(); //清空listlist.contains("苹果"); //判断list中是否包含某个元素list.get(2); //获取指定位置的元素int a = list.indexOf("⾹蕉"); //返回某元素在集合中第⼀次出现的位置,没有就返回-1int b = stIndexOf("⾹蕉"); //返回某元素在集合中最后次出现的位置,没有就返回-1System.out.println(a+"====="+b);list.isEmpty(); //是否为空Iterator iterator = list.iterator(); //获取Iterator 迭代对象while(iterator.hasNext()){System.out.println(iterator.next());}System.out.println("=================");Iterator it =list.listIterator(2); //从第⼏个元素开始迭代while(it.hasNext()){System.out.println(it.next());}list.remove(2);//删除list.remove("⾹蕉");list.set(1, "油桃");System.out.println(list);list.size();list.subList(1, 2);list.toString();String[] arr = list.toArray(new String[list.size()]);System.out.println(arr[0]);List对象的遍历List<String> list = new ArrayList<String>();list.add("qqq");list.add("eee");list.add("ccc");list.add("rrr");//for循环遍历for(int i=0;i<list.size();i++){System.out.println(list.get(i));}//增强for循环for(String st:list){System.out.println(st);}//Iterator迭代Iterator iterator = list.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}。

Java中Listfor循环的6种写法

Java中Listfor循环的6种写法

Java中Listfor循环的6种写法List<String> list = new ArrayList<String>();/*** ⽅法⼀:最普通的不加思考的写法* <p>* 优点:较常见,易于理解* <p>* 缺点:每次都要计算list.size()*/for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}/*** ⽅法⼆:数组长度提取出来* <p>* 优点:不必每次都计算* <p>* 缺点:1、m的作⽤域不够⼩,违反了最⼩作⽤域原则 2、不能在for循环中操作list的⼤⼩,⽐如除去或新加⼀个元素*/int m = list.size();for (int i = 0; i < m; i++) {System.out.println(list.get(i));}/*** ⽅法三:数组长度提取出来* <p>* 优点:1、不必每次都计算 2、所有变量的作⽤域都遵循了最⼩范围原则* <p>* 缺点:1、m的作⽤域不够⼩,违反了最⼩作⽤域原则 2、不能在for循环中操作list的⼤⼩,⽐如除去或新加⼀个元素*/for (int i = 0, n = list.size(); i < n; i++) {System.out.println(list.get(i));}/*** ⽅法四:采⽤倒序的写法* <p>* 优点:1、不必每次都计算 2、所有变量的作⽤域都遵循了最⼩范围原则* <p>* 缺点:1、结果的顺序会反 2、看起来不习惯,不易读懂* <p>* 适⽤场合:与显⽰结果顺序⽆关的地⽅:⽐如保存之前数据的校验*/for (int i = list.size() - 1; i >= 0; i--) {System.out.println(list.get(i));}/*** ⽅法五:Iterator遍历* <p>* 优点:简洁* <p>* 缺点:*/for (Iterator<String> it = list.iterator(); it.hasNext();) {System.out.println(it.next());}/*** ⽅法六:jdk1.5新写法* <p>* 优点:简洁结合泛型使⽤更简洁* <p>* 缺点:jdk1.4向下不兼容*/for (Object o : list) {System.out.println(o); }。

Java中的List——有序序列

Java中的List——有序序列

Java中的List——有序序列List 在 java 中是个有序序列:⼀、容量ArrayList 中有⼀个容量概念,表⽰基础数组的⼤⼩(⽆参时默认为 10)。

在需要的时候(⽐如 add操作)会⾃动增加其容量。

LinkedList 没有这个概念。

TreeMap 也有容量,默认是 16.⼆、改善的 search ⽅法LinkedList 与 ArrayList 都很低效O(N)。

⽐如 Collection 的 contain 和 remove ⽅法⽽⾔。

他们均花费线性时间。

下⾯对存、取、查找这三类情况进⾏⽐较:访问数组中第 n 个数据的时间花费是 O(1) (类似地 HashMap 中通过 key 访问 value,但其存取都是 O(1) ,因为其索引是⽆序的,⽽数组是有序的索引),但是要在数组中查找⼀个指定的数据则是 O(N) 。

当向数组中插⼊或者删除数据的时候,最好的情况是在数组的末尾进⾏操作,时间复杂度是 O(1) ,但是最坏情况是插⼊或者删除第⼀个数据,时间复杂度是 O(N) 。

在数组的任意位置插⼊或者删除数据的时候,后⾯的数据全部需要移动,移动的数据还是和数据个数有关所以总体的时间复杂度仍然是 O(N) 。

在链表中查找第 n 个数据以及查找指定的数据的时间复杂度是 O(N) ,但是链表插⼊和删除数据的时间复杂度是 O(1) ,因为只需要调整指针就可以。

堆栈实现了⼀种后进先出的语义 (LIFO) ,可以使⽤数组或者是链表来实现它。

队列实现了先⼊先出的语义 (FIFO) 。

队列也可以使⽤数组和链表来实现提⾼运⾏效率 O(logn),可以使⽤ Collections.binarySearch(List list),⼆分法进⾏查找,需要对原集合/数组进⾏排序(双枢纽快速排序 O(n log(n))。

注意:Collections.binarySearch 不⽀持 Set 集合,因为 HashSet/LinkedHashSet 使⽤的是哈希表,查询值(的位置/是否存在)只需要⽐较哈希值,时间效率是 O(1)。

java中list的用法

java中list的用法

java中list的用法
Java中的List是一个接口,它继承自Collection接口,用于存储一组元素。

List中的元素可以按照顺序访问和添加,允许重复元素,并且可以根据索引位置对元素进行访问和操作。

List常用的实现类有ArrayList和LinkedList,其中ArrayList 是基于数组实现的,对元素的访问和修改速度较快,但是插入和删除元素的效率较低;而LinkedList则是基于链表实现的,对元素的插入和删除速度较快,但是访问和修改元素的效率较低。

List常用的方法包括:
1. add(E e):向列表末尾添加元素e。

2. add(int index, E e):在指定索引位置插入元素e。

3. remove(int index):删除指定索引位置的元素。

4. get(int index):获取指定索引位置的元素。

5. set(int index, E e):替换指定索引位置的元素。

6. size():返回列表中元素的个数。

7. indexOf(Object o):返回元素在列表中第一次出现的索引位置。

8. clear():清空列表中的所有元素。

需要注意的是,对于使用Iterator迭代器遍历List时,不能在遍历过程中对List进行修改,否则会抛出ConcurrentModificationException异常。

- 1 -。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

java中List的用法和实例详解List的用法List包括List接口以及List接口的所有实现类。

因为List接口实现了Collection接口,所以List接口拥有Collection接口提供的所有常用方法,又因为List是列表类型,所以List接口还提供了一些适合于自身的常用方法,如表1所示。

表1 List接口定义的常用方法及功能从表1可以看出,List接口提供的适合于自身的常用方法均与索引有关,这是因为List集合为列表类型,以线性方式存储对象,可以通过对象的索引操作对象。

List接口的常用实现类有ArrayList和LinkedList,在使用List集合时,通常情况下声明为List类型,实例化时根据实际情况的需要,实例化为ArrayList或LinkedList,例如:List<String> l = new ArrayList<String>();// 利用ArrayList类实例化List集合List<String> l2 = new LinkedList<String>();// 利用LinkedList类实例化List集合1.add(int index, Object obj)方法和set(int index, Object obj)方法的区别在使用List集合时需要注意区分add(int index, Object obj)方法和set(int index, Object obj)方法,前者是向指定索引位置添加对象,而后者是修改指定索引位置的对象,例如执行下面的代码:src\com\mwq\TestCollection.java关键代码:public static void main(String[] args) {String a = "A", b = "B", c = "C", d = "D", e = "E";List<String> list = new LinkedList<String>();list.add(a);list.add(e);list.add(d);list.set(1, b);// 将索引位置为1的对象e修改为对象blist.add(2, c);// 将对象c添加到索引位置为2的位置Iterator<String> it = list.iterator();while (it.hasNext()) {System.out.println(it.next());}}在控制台将输出如下信息:ABCD因为List集合可以通过索引位置访问对象,所以还可以通过for循环遍历List集合,例如遍历上面代码中的List集合的代码如下:src\com\mwq\TestCollection.java关键代码:for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));// 利用get(int index)方法获得指定索引位置的对象}src\com\mwq\TestCollection.java完整代码如下:package com.mwq;import java.util.ArrayList;import java.util.LinkedList;import java.util.Iterator;import java.util.List;public class TestCollection {public static void main(String[] args) {System.out.println("开始:");String a = "A", b = "B", c = "C", d = "D", e = "E";List<String> list = new LinkedList<String>();list.add(a);list.add(e);list.add(d);list.set(1, b);// 将索引位置为1的对象e修改为对象blist.add(2, c);// 将对象c添加到索引位置为2的位置Iterator<String> it = list.iterator();while (it.hasNext()) {System.out.println(it.next());}// for (int i = 0; i < list.size(); i++) {// System.out.println(list.get(i));// 利用get(int index)方法获得指定索引位置的对象// }System.out.println("结束!");}}2.indexOf(Object obj)方法和lastIndexOf(Object obj)方法的区别在使用List集合时需要注意区分indexOf(Object obj)方法和lastIndexOf(Object obj)方法,前者是获得指定对象的最小的索引位置,而后者是获得指定对象的最大的索引位置,前提条件是指定的对象在List集合中具有重复的对象,否则如果在List集合中有且仅有一个指定的对象,则通过这两个方法获得的索引位置是相同的,例如执行下面的代码:src\com\mwq\TestCollection.java关键代码:public static void main(String[] args) {String a = "A", b = "B", c = "C", d = "D", repeat = "Repeat";List<String> list = new ArrayList<String>();list.add(a); // 索引位置为 0list.add(repeat); // 索引位置为 1list.add(b); // 索引位置为 2list.add(repeat); // 索引位置为 3list.add(c); // 索引位置为 4list.add(repeat); // 索引位置为 5list.add(d); // 索引位置为 6System.out.println(list.indexOf(repeat));System.out.println(stIndexOf(repeat));System.out.println(list.indexOf(b));System.out.println(stIndexOf(b));}src\com\mwq\TestCollection.java完整代码如下:package com.mwq;import java.util.ArrayList;import java.util.List;public class TestCollection {public static void main(String[] args) {System.out.println("开始:");String a = "A", b = "B", c = "C", d = "D", repeat = "Repeat";List<String> list = new ArrayList<String>();list.add(a); // 索引位置为 0list.add(repeat); // 索引位置为 1list.add(b); // 索引位置为 2list.add(repeat); // 索引位置为 3list.add(c); // 索引位置为 4list.add(repeat); // 索引位置为 5list.add(d); // 索引位置为 6System.out.println(list.indexOf(repeat));System.out.println(stIndexOf(repeat));System.out.println(list.indexOf(b));System.out.println(stIndexOf(b));System.out.println("结束!");}}在控制台将输出如下信息:15223.subList(int fromIndex, int toIndex)方法在使用subList(int fromIndex, int toIndex)方法截取现有List集合中的部分对象生成新的List集合时,需要注意的是,新生成的集合中包含起始索引位置代表的对象,但是不包含终止索引位置代表的对象,例如执行下面的代码:src\com\mwq\TestCollection.java关键代码:public static void main(String[] args) {String a = "A", b = "B", c = "C", d = "D", e = "E";List<String> list = new ArrayList<String>();list.add(a); // 索引位置为 0list.add(b); // 索引位置为 1list.add(c); // 索引位置为 2list.add(d); // 索引位置为 3list.add(e); // 索引位置为 4list = list.subList(1, 3);// 利用从索引位置 1 到 3 的对象重新生成一个List集合for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}}src\com\mwq\TestCollection.java完整代码:package com.mwq;import java.util.ArrayList;import java.util.List;public class TestCollection {public static void main(String[] args) {System.out.println("开始:");String a = "A", b = "B", c = "C", d = "D", e = "E";List<String> list = new ArrayList<String>();list.add(a); // 索引位置为 0list.add(b); // 索引位置为 1list.add(c); // 索引位置为 2list.add(d); // 索引位置为 3list.add(e); // 索引位置为 4list = list.subList(1, 3);// 利用从索引位置 1 到 3 的对象重新生成一个List集合for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}System.out.println("结束!");}}在控制台将输出如下信息:BC。

相关文档
最新文档