精华内容
下载资源
问答
  • List集合List接口Collection接口是集合框架的最顶层接口,描述的是集合框架中最共性的操作;在它下面有很多子接口和实现类,其中有两个子接口非常重要,是我们学习的重点,他们分别是List接口和Set接口,我们先来看...

    List集合

    List接口

    Collection接口是集合框架的最顶层接口,描述的是集合框架中最共性的操作;在它下面有很多子接口和实现类,其中有两个子接口非常重要,是我们学习的重点,他们分别是List接口和Set接口,我们先来看List接口;

    341281d18860a798d9016c50f5737fae.png

    List接口介绍

    85d332cfcd07512d243171560779c4c5.png

    总结:

    1. List集合都有下标;这个下标也是从0开始,和数组的下标一样;我们可以通过下标精确地操作某一个元素;
    2. List集合是有序的,迭代集合的顺序和添加元素的顺序一致;
    3. List集合允许保存重复的元素

    List的特有方法

    List接口是Collection接口的子接口,所以拥有Collection接口中规定的所有方法;

    要单独定义一个接口来继承父接口,目的是对父接口的扩展;

    List集合中保存的元素都具有顺序,List接口扩展的方法,主要是就是针对元素的位置设计的;

    这些特有的方法主要可以分为以下几类:

    添加方法

    1、向指定位置插入一个元素

    5993f4544ee40e4d1529ff1b7f839f46.png
    1. 向指定位置插入多个元素

    e6c518f7d1f17c529dfb1cc6a834630a.png

    65c1a17fb8831d63d03c73cefa731d93.png

    删除方法

    1、删除指定位置的一个元素

    f9d30f16c5f396deaddc45a749122087.png

    d3a81c3fd7fd3f9166e406379337d5ef.png

    修改方法

    1. 替换指定位置的元素

    20ac97551954de5739b03151b2b4b83f.png

    47256d81f837fe589c17d3f5db4fb629.png

    获取方法

    1、获取指定位置的一个元素

    3b0e863bfd06bebefd51f81970d34f26.png

    c06b41737a247a27783ef9ea5b757103.png

    2、获取指定区间的多个元素

    7c6d580f38382b582618261d8cbac589.png

    8364f439360be745584c93036a379ed3.png
    1. 获取指定元素在集合中第一次出现的位置

    08ead4974ab5c7ea3cf156a256eab551.png
    1. 获取指定元素在集合中最后一次出现的位置

    cd85fd4633d0b8dd2ad2dd1cb9c7d7df.png
    7c61ba333ae8b5224050b31d5e6d6ea1.png
    https://www.zhihu.com/video/1068288920290263040

    List的特有迭代器

    为了遍历集合中的元素,Collection提供了一个迭代器Iterator;

    List集合继承了Collection接口,所以也可以使用迭代器进行迭代;

    但是Iterator使用时,光标只能从前往后移动,而且在迭代期间,不能修改集合中的元素;

    而在list集合中的数据都具有索引,为了使用方便,对Iterator接口进行了扩展,得到一个新的列表迭代器接口,叫做ListIterator:

    65e513f1848097b98d99aa01253cafe3.png

    d842b2ba49ae5cb4b3b813af7b99ab65.png

    957b48cb6176aabd4ddc202faedf3393.png

    迭代器的使用演示:

    aeb9b4effd06941cf16976b2735de8d0.png

    319e1064ca3774b33adfaa2ec3641e36.png

    d0df28f87e6a1c61697fa79bba118ce6.png

    88b92aa45192ad394e42a67d08986788.png

    通过索引遍历List集合

    因为List集合中保存的数据都有索引,所以List集合的遍历可以使用普通for循环,通过索引获取元素;

    047151db4d03c5d073fd50f1d69fec80.png

    注意:因为迭代器对象是具体的集合类创建的,所以具体的迭代器对象知道这个具体的集合类底层如何保存数据,如何遍历效率最高;所以开发中推荐使用迭代器迭代;

    (如果使用的是ArrayList集合,直接使用for循环遍历效率就很高;)

    a3c5f3afd263c8c37e1951cce254c43b.png
    https://www.zhihu.com/video/1068289160418217984

    List接口常用实现类介绍

    list接口介绍完了,我们来说一说它的实现类;它的实现类也比较多,这里我们只介绍其中三个主要的实现类:

    ArrayList;LinledList;Vector

    ArrayList介绍

    662c2a40adaa7189eb2c07028ca79bd2.png
    1. List 接口的大小可变数组的实现:说明,这个集合底层使用一个可变的数组(默认创建一个数组,随着数据的添加,原来数组容量不够,就会创建一个新的更大的数组来替换原来的数组)来保存数据;

    练习:自己实现一个类,里面使用可变数组保存数据;提供添加数据的方法(add),和一个获取数据容量(size);初始数组大小为5;

    2、ArrayList集合可以保存null元素;

    3、ArrayList是线程不安全的;

    57c1c065cd259ae317ab08c0ceb0c9a8.png
    展开全文
  • 如何创建不可变的集合?示例代码如下List不可变集合public class MyVariableParameter { public static void main(String[] args) { List<String> list = List.of("a", "b", "c", "d"); ...

    什么是不可变的集合?

    就是长度与内容都不能变化的集合。

    如何创建不可变的集合?

    8c13bbe7cd735a93439e6581d79e78c8.png

    示例代码如下

    List不可变集合

    public class MyVariableParameter {
        public static void main(String[] args) {
            List<String> list = List.of("a", "b", "c", "d");
            System.out.println(list);
            //list.add("Q");//不能添加
    //        list.remove("a");//不能删除
    //        list.set(0,"A");//不能修改
    //        System.out.println(list);
            //传统的添加方式
            /*ArrayList<String> list2 = new ArrayList<>();
            list.add("aaa");
            list.add("aaa");
            list.add("aaa");
            list.add("aaa");*/
    
            //集合的批量添加
            //首先是通过调用List.of方法来创建个不合变的集合,of方法的形参就是一个可变参数
            //再创建一个ArrayList集合,并把这个不可变的集合中所有的数据都添加到ArrayList中
            ArrayList<String> list3 = new ArrayList<>(List.of("a","b","c","d"));
            System.out.println(list3);
        }
    }

    Set不可变集合

    public class MyVariableParameter {
        public static void main(String[] args) {
            //传递的参数中,不能重复,所以该代码中,必须去掉一个"a"
            Set<String> set = Set.of("a", "b", "c", "d","a");
            System.out.println(set);
        }
    }

    Map不可变集合1

    public class MyVariableParameter {
            public static void main(String[] args) {
            Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
            System.out.println(map);
        }
    }

    Map不可变集合2

    public class MyVariableParameter {
            public static void main(String[] args) {
                Map<String, String> map = Map.ofEntries(
                        Map.entry("zhangsan", "江苏"),
                        Map.entry("lisi", "北京")
                );
                System.out.println(map);
            }
    }

    总结:

    ee366da05d2a39d2b9bbcfd96823c680.png
    展开全文
  • List 是一个有序、可重复的集合集合中每个元素都有其对应的顺序索引。List 集合允许使用重复元素,可以通过索引来访问指定位置的集合元素。List 集合默认按元素的添加顺序设置元素的索引,第一个添加到 List 集合...

    List 是一个有序、可重复的集合,集合中每个元素都有其对应的顺序索引。List 集合允许使用重复元素,可以通过索引来访问指定位置的集合元素。List 集合默认按元素的添加顺序设置元素的索引,第一个添加到 List 集合中的元素的索引为 0,第二个为 1,依此类推。
    List 实现了 Collection 接口,它主要有两个常用的实现类:ArrayList 类和 LinkedList 类。

    ArrayList 类

    ArrayList 类实现了可变数组的大小,存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式,对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合,允许对集合中的元素进行快速的随机访问,不过,向 ArrayList 中插入与删除元素的速度相对较慢。
    ArrayList 类的常用构造方法有如下两种重载形式:

    • ArrayList():构造一个初始容量为 10 的空列表。

    • ArrayList(Collection<?extends E>c):构造一个包含指定 Collection 元素的列表,这些元素是按照该 Collection 的迭代器返回它们的顺序排列的。

    ArrayList 类除了包含 Collection 接口中的所有方法之外,还包括 List 接口中提供的如表 1 所示的方法。

    表 1 ArrayList类的常用方法
    方法名称说明
    E get(int index)获取此集合中指定索引位置的元素,E 为集合中元素的数据类型
    int index(Object o)返回此集合中第一次出现指定元素的索引,如果此集合不包含该元
    素,则返回 -1
    int lastIndexOf(Object o)返回此集合中最后一次出现指定元素的索引,如果此集合不包含该
    元素,则返回 -1
    E set(int index, Eelement)将此集合中指定索引位置的元素修改为 element 参数指定的对象。
    此方法返回此集合中指定索引位置的原元素
    List subList(int fromlndex, int tolndex)返回一个新的集合,新集合中包含 fromlndex 和 tolndex 索引之间
    的所有元素。包含 fromlndex 处的元素,不包含 tolndex 索引处的
    元素

    注意:当调用 List 的 set(int index, Object element) 方法来改变 List 集合指定索引处的元素时,指定的索引必须是 List 集合的有效索引。例如集合长度为 4,就不能指定替换索引为 4 处的元素,也就是说这个方法不会改变 List 集合的长度。

    例 1

    使用 ArrayList 类向集合中添加三个商品信息,包括商品编号、名称和价格,然后遍历集合输出这些商品信息。
    1)创建一个商品类 Product,在该类中定义 3 个属性和 toString() 方法,分别实现 setter/getter 方法。代码的实现如下:

    public class Product {    // 商品类    private int id; // 商品编号    private String name; // 名称    private float price; // 价格    public Product(int id, String name, float price) {        this.name = name;        this.id = id;        this.price = price;    }    // 这里是上面3个属性的setter/getter方法,这里省略    public String toString() {        return "商品编号:" + id + ",名称:" + name + ",价格:" + price;    }}

    2)创建一个测试类,调用 Product 类的构造函数实例化三个对象,并将 Product 对象保存至 ArrayList 集合中。最后遍历该集合,输出商品信息。测试类的代码实现如下:

    public class Test {    public static void main(String[] args) {        Product pd1 = new Product(4, "木糖醇", 10);        Product pd2 = new Product(5, "洗发水", 12);        Product pd3 = new Product(3, "热水壶", 49);        List list = new ArrayList(); // 创建集合        list.add(pd1);        list.add(pd2);        list.add(pd3);        System.out.println("*************** 商品信息 ***************");        for (int i = 0; i < list.size(); i++) {            // 循环遍历集合,输出集合元素            Product product = (Product) list.get(i);            System.out.println(product);        }    }}

    该示例中的 ArrayList 集合中存放的是自定义类 Product 的对象,这与存储的 String 类的对象是相同的。与 Set 不同的是,List 集合中存在 get() 方法,该方法可以通过索引来获取所对应的值,获取的值为 Object 类,因此需要将该值转换为 Product 类,从而获取商品信息。


    该程序的运行结果如下所示。

    *************** 商品信息 ***************
    商品编号:4,名称:木糖醇,价格:10.0
    商品编号:5,名称:洗发水,价格:12.0
    商品编号:3,名称:热水壶,价格:49.0

    例 2

    在使用 List 集合时需要注意区分 indexOf() 方法和 lastIndexOf() 方法。前者是获得指定对象的最小索引位置,而后者是获得指定对象的最大索引位置。前提条件是指定的对象在 List 集合中有重复的对象,否则这两个方法获取的索引值相同。
    下面的案例代码演示了 indexOf() 方法和 lastIndexOf() 方法的区别。

    public static void main(String[] args) {    List list = new ArrayList();    list.add("One");    list.add("|");    list.add("Two");    list.add("|");    list.add("Three");    list.add("|");    list.add("Four");    System.out.println("list 集合中的元素数量:" + list.size());    System.out.println("list 集合中的元素如下:");    Iterator it = list.iterator();    while (it.hasNext()) {        System.out.print(it.next() + "、");    }    System.out.println("\n在 list 集合中'丨'第一次出现的位置是:" + list.indexOf("|"));    System.out.println("在 list 集合中'丨'最后一次出现的位置是:" + list.lastIndexOf("|"));}

    上述代码创建一个 List 集合 list,然后添加了 7 个元素,由于索引从 0 开始,所以最后一个元素的索引为 6。输出结果如下:

    list 集合中的元素数量:7
    list 集合中的元素如下:
    One、|、Two、|、Three、|、Four、
    在 list 集合中'|'第一次出现的位置是:1
    在 list 集合中'|'最后一次出现的位置是:5

    例 3

    使用 subList() 方法截取 List 集合中部分元素时要注意,新的集合中包含起始索引位置的元素,但是不包含结束索引位置的元素。例如,subList(1,4) 方法实际截取的是索引 1 到索引 3 的元素,并组成新的 List 集合。
    下面的案例代码演示了 subList() 方法的具体用法。

    public static void main(String[] args) {    List list = new ArrayList();    list.add("One");    list.add("Two");    list.add("Three");    list.add("Four");    list.add("Five");    list.add("Six");    list.add("Seven");    System.out.println("list 集合中的元素数量:" + list.size());    System.out.println("list 集合中的元素如下:");    Iterator it = list.iterator();    while (it.hasNext()) {        System.out.print(it.next() + "、");    }    List sublist = new ArrayList();    sublist = list.subList(2, 5); // 从list集合中截取索引2~5的元素,保存到sublist集合中    System.out.println("\nsublist 集合中元素数量:" + sublist.size());    System.out.println("sublist 集合中的元素如下:");    it = sublist.iterator();    while (it.hasNext()) {        System.out.print(it.next() + "、");    }}

    输出结果如下:

    list 集合中的元素数量:7
    list 集合中的元素如下:
    One、Two、Three、Four、Five、Six、Seven、
    sublist 集合中元素数量:3
    sublist 集合中的元素如下:
    Three、Four、Five、

    LinkedList类

    LinkedList 类采用链表结构保存对象,这种结构的优点是便于向集合中插入或者删除元素。需要频繁向集合中插入和删除元素时,使用 LinkedList 类比 ArrayList 类效果高,但是 LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特定索引位置的元素。
    LinkedList 类除了包含 Collection 接口和 List 接口中的所有方法之外,还特别提供了表 2 所示的方法。

    表 2 LinkList类中的方法
    方法名称说明
    void addFirst(E e)将指定元素添加到此集合的开头
    void addLast(E e)将指定元素添加到此集合的末尾
    E getFirst()返回此集合的第一个元素
    E getLast()返回此集合的最后一个元素
    E removeFirst()删除此集合中的第一个元素
    E removeLast()删除此集合中的最后一个元素

    例 4

    在仓库管理系统中要记录入库的商品名称,并且需要输出第一个录入的商品名称和最后—个商品名称。下面使用 LinkedList 集合来完成这些功能,实现代码如下:

    public class Test {    public static void main(String[] args) {        LinkedList products = new LinkedList(); // 创建集合对象        String p1 = new String("六角螺母");        String p2 = new String("10A 电缆线");        String p3 = new String("5M 卷尺");        String p4 = new String("4CM 原木方板");        products.add(p1); // 将 p1 对象添加到 LinkedList 集合中        products.add(p2); // 将 p2 对象添加到 LinkedList 集合中        products.add(p3); // 将 p3 对象添加到 LinkedList 集合中        products.add(p4); // 将 p4 对象添加到 LinkedList 集合中        String p5 = new String("标准文件夹小柜");        products.addLast(p5); // 向集合的末尾添加p5对象        System.out.print("*************** 商品信息 ***************");        System.out.println("\n目前商品有:");        for (int i = 0; i < products.size(); i++) {            System.out.print(products.get(i) + "\t");        }        System.out.println("\n第一个商品的名称为:" + products.getFirst());        System.out.println("最后一个商品的名称为:" + products.getLast());        products.removeLast(); // 删除最后一个元素        System.out.println("删除最后的元素,目前商品有:");        for (int i = 0; i < products.size(); i++) {            System.out.print(products.get(i) + "\t");        }    }}

    如上述代码,首先创建了 5 个 String 对象,分别为 p1、p2、p3、p4 和 p5。同时将 p1、 p2、p3 和 p4 对象使用 add() 方法添加到 LinkedList 集合中,使用 addLast() 方法将 p5 对象添加到 LinkedList 集合中。分别调用 LinkedList 类中的 getFirst() 方法和 getLast() 方法获取第一个和最后一个商品名称。最后使用 removeLast() 方法将最后一个商品信息删除,并将剩余商品信息打印出来。


    LinkedList 中的 是 
    Java 中的泛型,用于指定集合中元素的数据类型,例如这里指定元素类型为 String,则该集合中不能添加非 String 类型的元素。
    运行程序,执行结果如下:

    *************** 商品信息 ***************
    目前商品有:
    六角螺母 10A 电缆线 5M 卷尺 4CM 原木方板 标准文件夹小柜
    第一个商品的名称为:六角螺母
    最后一个商品的名称为:标准文件夹小柜
    删除最后的元素,目前商品有:
    六角螺母 10A 电缆线 5M 卷尺 4CM 原木方板

    ArrayList 类和 LinkedList 类的区别

    ArrayList 与 LinkedList 都是 List 接口的实现类,因此都实现了 List 的所有未实现的方法,只是实现的方式有所不同。
    ArrayList 是基于动态数组
    数据结构的实现,访问元素速度优于 LinkedList。LinkedList 是基于链表数据结构的实现,占用的内存空间比较大,但在批量插入或删除数据时优于 ArrayList。
    对于快速访问对象的需求,使用 ArrayList 实现执行效率上会比较好。需要频繁向集合中插入和删除元素时,使用 LinkedList 类比 ArrayList 类效果高。
    不同的结构对应于不同的算法,有的考虑节省占用空间,有的考虑提高运行效率,对于程序员而言,它们就像是“熊掌”和“鱼肉”,不可兼得。高运行速度往往是以牺牲空间为代价的,而节省占用空间往往是以牺牲运行速度为代价的。

    75d894f5812d0349e7aa8170e705fdcf.png

    展开全文
  • Java 9 对此进行了简化,程序直接调用 Set、List、Map 的 of() 方法即可创建包含 N 个元素的不可变集合,这样一行代码就可创建包含 N 个元素的集合。不可变意味着程序不能向集合中添加元素,也不能从集合中删除...

    Java 9 版本以前,假如要创建一个包含 6 个元素的 Set 集合,程序需要先创建 Set 集合,然后调用 6 次 add() 方法向 Set 集合中添加元素。Java 9 对此进行了简化,程序直接调用 Set、List、Map 的 of() 方法即可创建包含 N 个元素的不可变集合,这样一行代码就可创建包含 N 个元素的集合。不可变意味着程序不能向集合中添加元素,也不能从集合中删除元素。如下程序示范了如何创建不可变集合。

    public class Java9Collection {    public static void main(String[] args) {        // 创建包含4个元素的Set集合        Set set = Set.of("Java", "Kotlin", "Go", "Swift");        System.out.println(set);        // 不可变集合,下面代码导致运行时错误        // set.add("Ruby");        // 创建包含4个元素的List集合        List list = List.of(34, -25, 67, 231);        System.out.println(list);        // 不可变集合,下面代码导致运行时错误        // list.remove(1);        // 创建包含3个key-value对的Map集合        Map map = Map.of("语文", 89, "数学", 82, "英语", 92);        System.out.println(map);        // 不可变集合,下面代码导致运行时错误        // map.remove("语文");        // 使用Map.entry()方法显式构建key-value对        Map map2 = Map.ofEntries(Map.entry("语文", 89), Map.entry("数学", 82), Map.entry("英语", 92));        System.out.println(map2);    }}

    上面第 4、9、14 和 19 行代码示范了如何使用集合元素创建不可变集合,其中 Set、List 比较简单,程序只要为它们的 of() 方法传入 N 个集合元素即可创建 Set、List 集合。

    从上面代码可以看出,创建不可变的 Map 集合有两个方法。使用 of() 方法时只要依次传入多个 key-value 对即可;还可使用 ofEntries() 方法,该方法可接受多个 Entry 对象,因此程序显式使用 Map.entry() 方法来创建 Map.Entry 对象。

    1740fff5439f86c90c76fe6f1e021356.png

    展开全文
  • 由于集合的无序性因而集合不支持索引的方式访问元素,同时由于集合元素的唯一性从而集合中不存在相同的元素.# 创建集合 a = {} # 创建集合 b = set() # 通过字面值初始化 c = {1, 3, 5, 1, 3, 5, 1, 3, 5} # ...
  • ArrayList和Linkedlist的练习练习一:package list; import java.util.ArrayList; import java.util.Iterator; public class Demo1_ArrayList { ... * 需求:ArrayList去除集合中字符... * 思路:创建集合方式 ...
  • // List快速创建并添加元素的方法 List<String> arrayList = new ArrayList<>(); // 1.第一种方法使用Collections集合工具类,直接向已知集合中添加元素,返回booleean值,true添加成功false添加失败 ...
  • 程序中某段案例代码如下:Map> tMap = new HashMap>...程序运行抛出异常:java.lang.UnsupportedOperationException错误原因:为了快速创建List而使用了Arrays.asList方法,但此方法返回的Arra...
  • 上传的资料都是非常经典的,这也是我学习过程中的心得,希望大家能给我指点,也希望大家多上传资料共同学习。千万不要传空文件夹。。。
  • 程序中某段案例代码如下: ...String, List<CronTrigger>> tMap = new HashMap<String, List<CronTrigger>>(); tMap.put(name, Arrays.asList(new CronTrigger[] { tri...
  • 前台组装参数 //取easyUi多选行数据 var row = $('#tbl_finReceipt').datagrid('... var formParam = new FormData($("#frm_finReceipt_usageList")[0]); //创建数组 var param = new Array(); //装载数...
  • title: Java创建List、Map等集合对象的同时进行赋值操作date: 2019-11-28 23:25:47tags: JavaSEcategories: JavaSE问题简介在Java当中,若希望...String strs = {"a", "b", "c"}但是,如果我们创建List集合,或者Map...
  • List 集合

    2017-05-26 00:13:00
    1.创建list集合对象 List list=new ArrayList();2.添加元素 list.add("宋江");list.add("奥特曼");list.add("葫芦娃");list.add("宋江");// 不排重复元素System.out.println(list);3.根据索引值获取下标,从0开始...
  • 展开全部首先直接回答你的问题:运行期,遇到B元素会报错。即类型转换错误。泛型62616964757a686964616fe58685e5aeb931333365643661的出现就是为了预防这类错误。因为默认你存的object对象,可以强制类型转换,但在...
  • List集合创建及方法

    2020-04-12 10:25:06
    1.创建List List <String> <链表名>=newArrayList<>(); List <String> <链表名>=new LinkedList<>(); import java.util.ArrayList; import java.util.LinkedList; import ...
  • String strs = {"a", "b", "c"}但是,如果我们创建List集合,或者Map集合时,也想快速地为它赋初始值,应当如何做呢?解决方式方式1:调用函数请看如下代码:ArrayList list = new ArrayList<>(Arrays.as...
  • 带值的集合的创建 String[] a = {"1","2","3","4"}; boolean q = ArrayUtils.contains(a, "1"); System.out.println(q); ... //优雅的创建一个带值的list集合 List<String> str...
  • 通常创建list集合的时候,使用多态的方式创建 List list=new ArrayList<>(); list中特有的方法有 添加add(int index,E element)* 移除remove(int index) 换取set(int index,E element) 获取指定位置的元素get...
  • 其中包含 一级一级的往下寻找数据 Json.get()方法 获取JsonNode 然后创建 list集合格式的JavaType 并且将List集合中的数据格式确定 。
  • 1.List 创建数据: List 一次性创建300条数据,耗时基本为0毫秒,一次性创建5000条数据耗时2-5毫秒; 2.List添加数据: 在5000条数据上,再添加5000条数据,耗时为 3-7毫秒 总结:所以不用担心List创建数据过于...
  • (2)创建List集合对象 (3)创建学上对象 (4)把学生添加到集合 (5)遍历集合(迭代器方式、for循环方式) 完整代码: package com.xuexi; import java.util.ArrayList; import java.util.Iterator; import ...
  • 创建list集合对象3.获取指定下标对应的元素4.获取(List集合)迭代器5.元素取代(add)和添加(set)6.移出指定下标和指定集合5.set集合1.导包2.案例分析 1. 集合的由来 容器(数组和StringBuffer),数组的
  • List 集合的使用

    2018-04-16 09:43:31
    根据小栗子理解 list 集合的使用:  List&... // 创建list集合  list.add("A"); // 往 list 集合中添加 5 条数据  list.add("B");  list.add("C");  list.add...
  • Java中List集合

    2019-05-22 20:35:42
    基本用法 public class Demo { ... //创建List集合对象 List<String> list = new ArrayList<String>();//(多态) //add添加到集合的尾部 list.add("张三");//0 list.add(...
  • List集合(列表)

    2020-11-17 20:53:01
    List集合也称列表 List整体规则是存储的元素有序且可以重复;...创建List集合 List list1 = new ArrayList(); 添加 add() 添加元素 add(int index,object obj) 给参数角标位置插入参数元素。 addAll(int
  • 1.创建List集合 val l1 = List("a","b","c") 2.打印下标集合数据 println(l1(0)) 3.循环集合数据 for (a <- l1){ println(a) } 4.Nil方式创建集合 //Nil:空 val l2 = "a" :: ("b" :: Nil) //论方便的话 ...
  • List集合

    2019-03-03 19:41:24
    list集合特点 有序(存储和取出的元素一致),可重复的。 list集合的构造方法 1.List() : 创建新的滚动列表。 2.List(int rows) : 创建一个用指定可视行数初始化的新滚动列表。 3.List(int rows, boolean ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,273
精华内容 3,309
关键字:

创建list集合