精华内容
下载资源
问答
  • ArrayListJava集合框架中一个经典的实现类。他比起常用的数组而言,明显的优点在于,可以随意的添加和删除元素而不需考虑数组的大小。下面跟着小编一起来看下吧
  • javaArrayList的概念和用法

    千次阅读 2021-02-12 11:10:37
    简介Java.util.ArrayList类是一个动态数组类型,可以随时从链表中添加或删除一个元素。ArrayList实现了List接口并且可以动态改变大小的。当我们不知道数据元素的个数时,就可使用ArrayList;如果知道数据元素个数,...

    一.简介

    Java.util.ArrayList类是一个动态数组类型,可以随时从链表中添加或删除一个元素。ArrayList实现了List接口并且可以动态改变大小的。当我们不知道数据元素的个数时,就可使用ArrayList;如果知道数据元素个数,就可以直接用数组。

    二.实现

    List lists = new ArrayList();(其中的String可以改为integer,double等类型)

    注:ArrayList对象只能存放对象,不能存放基础数据类型的数据。

    三.构造函数

    ArrayList中定义了三种构造方法

    1.ArrayList()----------------构造了空的链表。

    2.ArrayList(Collection extends E> c)------构造了一个包含指定元素集合的链表,字符E是一个标记,用来表示集合中元素的类型。

    3.ArrayList(int initialCapacity)---------构造了一个大小确定但内容为空的链表。initialCapacity参数表示初始容量大小。

    四.常用的一些方法

    1.添加元素

    (1)在List尾部添加元素

    void add(E element);

    (2)在指定位置添加元素

    void add(int index, E element);

    (3)插入其他集合全部的元素

    Boolean ArrayList(int index, Collection extends E> c);

    2.删除元素

    (1)删除所有元素

    void clear();

    (2)删除指定元素

    E remove(int index);

    (3)删除从某一个位置

    展开全文
  • Java 数组ArrayList语法

    千次阅读 2021-02-12 11:10:37
    导入import java.util.ArrayList;2.定义数组listArrayList list = new ArrayList(); 不能是基本类型,必须是类3.获取集合大小size()4.存入数据add(Object object);从下标0开始加入add(int idx,Object object);将...

    记录一下数组ArrayList的常用语法

    1.导入

    import java.util.ArrayList;

    2.定义数组list

    ArrayList list = new ArrayList();  不能是基本类型,必须是类

    3.获取集合大小

    size()

    4.存入数据

    add(Object object);从下标0开始加入

    add(int idx,Object object);将object插入索引为idx的位置,idx<=list.size();

    加入的东西是对象,一个对象在堆中各自有一片内存,在访问的时候利用栈中的地址指向堆,从堆中获取数值,通过改变一个对象的值再次用add加入数组,是将同一个对象加入两次,至于使用的时候,获取的数值是最后对象的数值。→

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    packagemy_acm;importjava.util.ArrayList;public classMyTest6 {public static voidmain(String []args) {

    ArrayList list1 = new ArrayList();

    Point p=newPoint();

    p.id=10086;

    p.age=25;

    list1.add(p);

    p.id=10088;

    p.age=33;

    list1.add(p);for(int i=0;i

    System.out.println("i="+i+" id="+list1.get(i).id+" age="+list1.get(i).age);

    }

    }classPoint{intid;intage;

    }/**i=0 id=10088 age=33

    i=1 id=10088 age=33*/

    View Code

    5.删除

    remove(int idx);删除索引为idx的元素,返回该元素,可以用变量去接收,也可不接收

    6.清空

    clear(); 清空数组

    7.替换

    set(int idx,Object object); 把object元素和原本索引为idx的元素替换

    8.获取指定位置元素

    Object get(int idx);

    9.判空

    bool isEmpty(); 一般不用,size()可以用于判空

    10.判断是否有某元素

    bool contains(Object object); 基本不用,可以通过查找元素的索引来解决

    11.查找元素的索引

    int indexOf(Object object); 如果元素存在,则返回索引,否则返回-1,通过是不是-1判断元素在不在数组里

    12..对数组list排序

    导入Collections类;

    import java.util.Collections;

    (1)默认自然排序,从小到大

    Collections.sort(list); //不可以new出Collections的对象,直接用

    (2)自定义排序

    导入Comparator类;

    import java.util.Comparator;

    创建对象的时候需要实现抽象方法compare(),实现自定义排序

    importjava.util.ArrayList;importjava.util.Collections;import java.util.Comparator;//自定义排序用的

    public classMyTest4 {public static voidmain(String [] args) {

    ArrayList list1 = new ArrayList();

    Comparator comparator = new Comparator() {public intcompare(Point p1, Point p2) {if(p1.id

    return -1;else

    return 1;

    }

    };

    Point p1= newPoint();

    p1.id=11;p1.age=21;

    list1.add(p1);

    Point p2= newPoint();

    p2.id=9;p2.age=44;

    list1.add(p2);

    Point p3= newPoint();

    p3.id=2;p3.age=68;

    list1.add(p3);/**修改变量的值在加到数组里是不可行的,(

    p3.id=14;p3.age=23;

    list1.add(p3);*/

    for(int i=0;i

    System.out.println("i="+i+" id="+list1.get(i).id+" age="+list1.get(i).age);

    }

    Collections.sort(list1,comparator);

    System.out.println("按id排序后");for(int i=0;i

    Point x= newPoint();

    x=list1.get(i);

    System.out.println("i="+i+" id="+x.id+" age="+x.age );

    }

    }

    }classPoint{intid;intage;

    }

    输出结果:

    i=0 id=11 age=21

    i=1 id=9 age=44

    i=2 id=2 age=68

    按id排序后

    i=0 id=2 age=68

    i=1 id=9 age=44

    i=2 id=11 age=21

    ArrayList原理

    1.数据结构

    ArrayList底层是数组,都说它是动态数组,所谓的动态就是不够的时候扩容,扩容是新开一个原来数组长度1.5倍数组,再把原来的值复制过去,用Arrays.copyOf()方法,速度比常规写的遍历快很多。可以存null值。

    2.添加操作add()

    先判断这个数组是否为空,

    如果空就新开一个数组,默认容量为10;然后赋值改大小。

    如果不为空,判断当前容量是否满足size+1,如果不满足就动态增长为1.5倍,然后赋值改大小。

    3.删除remove()

    删除指定位置元素E remove(int index):检查index合法性,获取指定位置的对象,计算后面需要往前移动位数,然后再调用移动元素的方法System.arraycopy()。(如果是普通人写就是遍历,调用这些方法会更快,具体源码就没继续深入下去看了),原来位置对象赋null让GC去回收,返回删除的对象。

    删除第一个指定内容的元素boolean remove(Object object):查找,再移位。找得到元素就返回真,找不到返回假。

    4.清空clear()

    将所有元素赋值null,让GC回收

    5.其他的方法例如插入set()等大多类似,原理很简单的,应该是调用很多底层的方法编写,提高效率。

    简单小结

    可以存null

    查询很快,本质是数组,直接通过下标定位获取,就算是查找指定元素遍历也远比删改移动数据快

    删除、插入操作比较慢,需要移动很多数据才能达到效果

    线程不安全,例如多个线程增删改查元素时,还没执行完就被其他线程抢了,最简单的例子就是查询很快,但是删除很慢,删除还没移动完数据 查询就查好返回了,想要让ArrayList实现同步,可以用Collections.synchronizedList(List list)函数包装后返回一个线程安全的ArrayList集合。

    List list=Collections.synchronizedList(new ArrayList<>());

    或者使用并发包(java.util.concurrent)的CopyOnWriteArrayList集合容器,CopyOnWrite是写入时复制,主要针对add()方法,添加元素时会

    顺便提一下Vector类,这是一个jdk1.2版本的古老的类,底层实现也是数组,和ArrayList差不多,最大区别就是Vector是线程安全的,很多方法加了synchronized修饰,还有一个区别是扩容是原来的2倍。因为已经有其他实现ArrayList同步的方法了,所以这个Vector很少人用了。

    展开全文
  • /* 一、定义 ArrayList集合的使用 是引用数据类型 实用的步骤: 1.导入包 java.util包中 2.创建引用类型的变量 数据类型&lt;集合储存的数据类型&gt; 变量名 = new 数据类系&lt;集合储存的数据类型&...

    /*

        一、定义

    ArrayList集合的使用
    是引用数据类型
    实用的步骤:
    1.导入包 java.util包中
    2.创建引用类型的变量
    数据类型<集合储存的数据类型> 变量名 = new 数据类系<集合储存的数据类型>();
    集合储存的数据类型:要将数据存储到集合的容器中(因为数组和集合都是容器),
    所以在创建集合引用变量的时候,必须要指定好储存的类型是什么

    ArrayList<String> array = new ArrayList<String>();

    3.变量名.方法名

    注意:集和储存的数据,8个基本类型对应8个引用类型
    储存引用类型,不储存基本类型


    */
    import java.util.ArrayList;
    public class ArrayListDemo{
    public static void main(String[] args){
    //创建集合容器,指定储存的数据类型
    //储存字符串
    ArrayList<String> array = new ArrayList<String>();

    //创建集合容器,储存整数
    ArrayList<Integer> array2 = new ArrayList<Integer>();

    //创建集合容器,储存手机类型
    ArrayList<Phone> array3 = new ArrayList<Phone>();
    }

    }


    --------------------------------------------------------------------------------

    /*

    二、方法

            ArrayList集合中的方法


    add(参数) 向集合中添加元素,数据存储进去
    方法中的参数类型,和定义几何对象时的类型必须一致

    ArrayList<Integer> array = new ArrayList<Integer>();
    array.add(3);

    get(int index) 取出集合中的元素,get方法的参数写入索引

    size() 返回集合的长度,集合存储元素的个数
    */
    import java.util.ArrayList;
    public class ArrayListDemo_1{
    public static void main(String[] args){
    //定义集合,储存字符串元素
    ArrayList<String> array = new ArrayList<String>();
    //调用集合方法add存储元素
    array.add("abc");
    array.add("itcast");
    array.add("love");
    array.add("java");
    //输出集合的长度,调用集合方法size
    int size = array.size();
    System.out.println(size);
    //取出集合中的元素,调用集合方法get
    String arr = array.get(3);
    System.out.println(arr);
    }

    }


    -----------------------------------------------------------------

    /*

        三、遍历及方法补充

    集合的遍历
    实现思想也是索引思想
    集合的索引从0开始,到size()-1结束
    方法get(int index)

    集合ArrayList方法补充
    add(int 索引,储存的元素) 将元素添加到指定的索引上
    set(int 索引,修改后的元素) 将指定索引的元素,进行修改
    remove(int 索引) 删除指定索引上的元素
    clear() 清空集合中的所有元素
    */
    import java.util.ArrayList;
    public class ArrayListDemo_2{
    public static void main(String[] args){
    ArrayList<Integer> array = new ArrayList<Integer>();
    array.add(121);
    array.add(122);
    array.add(123);
    array.add(124);
    array.add(125);
    array.add(126);

    //将索引2上添加元素7
    array.add(6,127);

    //将索引0上的元素修改成120
    array.set(0,120);

    //将索引4上的元素删除
    array.remove(0);

    //清空集合中的所有元素
    //array.clear();

    //对集合进行遍历
    //使用方法size+get组合进行遍历
    for(int i = 0;i < array.size();i++){
    System.out.println(array.get(i));
    }
    }
    }
    展开全文
  • Java ArrayList –如何声明,初始化和打印ArrayList 最近更新时间:2021年1月18日 本教程使用代码示例介绍如何声明,初始化和打印Java ArrayList。您还将了解Java的2D ArraylistArrayList的实现: ...

    本教程使用代码示例介绍如何声明,初始化和打印Java ArrayList。您还将了解Java的2D Arraylist和ArrayList的实现:

    ArrayList是数据结构,是Collections Framework的一部分,可以看作类似于数组和向量。

    ArrayList可以看作是动态数组,它使您可以随时或简单地说动态地添加或删除元素。

    换句话说,它的大小可以动态增加或减少,这与数组的大小一旦声明就保持静态是不同的。

    Java中的ArrayList类

    Java中的ArrayList数据结构由ArrayList类表示,该类是“ java.util ”包的一部分。

    ArrayList类的层次结构如下所示。

    ArrayList类的层次结构

    如您所见,ArrayList类实现了List接口,该接口又从Collection接口扩展而来。

    ArrayList类的一般定义如下:

    public class ArrayList<E>
    extends AbstractList<E>
    implements List<E>,RandomAccess, Cloneable, Serializable

    以下是ArrayList的一些区别特征:

    • Java的ArrayList类通过维护插入顺序来存储元素。
    • ArrayList允许在其中存储重复的元素。
    • ArrayList不同步,这是区分ArrayList和Java中的Vector类的要点。
    • Java中的ArrayList与C ++中的Vectors更加相同。
    • Java中的ArrayList还使用数组之类的索引,并支持随机访问。
    • ArrayList中元素的操作很慢,因为如果要从ArrayList中删除任何元素,则需要进行许多元素移位。
    • ArrayList类不能包含基本类型,而只能包含对象。在这种情况下,我们通常将其称为“对象的ArrayList”。因此,如果要存储元素的整数类型,则必须使用包装器类的Integer对象,而不要使用原始类型int。

    创建并声明ArrayList

    为了在程序中使用ArrayList类,您需要首先使用“ import”指令将其包括在程序中,如下所示:

    import java.util.ArrayList;

    要么

    import java.util.*;     //this will include all classes from java.util package

    将ArrayList类导入程序后,就可以创建ArrayList对象。

    常规ArrayList创建语法为:

    ArrayList <data_type> arrayList = new ArrayList <>();

    除了上述使用默认构造函数的语句之外,ArrayList类还提供了其他可重载的构造函数,可用于创建ArrayList。

    构造方法

    Java中的ArrayList类提供以下构造函数方法来创建ArrayList。

    方法1:ArrayList()

    此方法使用ArrayList类的默认构造函数,并用于创建一个空的ArrayList。

    此方法的一般语法为:

    ArrayList <数据类型>列表名称=new ArrayList <>();

    例如,您可以使用以下语句创建String类型的通用ArrayList。

    ArrayList<String> arraylist = new ArrayList<>();

    这将创建一个名为String的空ArrayList,名称为“ arraylist”。

    方法2:ArrayList(整数容量)

    此重载的构造函数可用于创建具有指定大小或容量(作为构造函数的参数提供)的ArrayList。

    此方法的一般语法为:

    ArrayList <数据类型>列表名称=new ArrayList <>(int容量);

    例:

    ArrayList<Integer> arraylist = new ArrayList<>(10);

    上面的语句创建一个空的ArrayList,名称为'arraylist',类型为Integer,容量为10。

    方法3:ArrayList(Collection <?扩展E> c)

    ArrayList类的第三个重载构造函数将一个已经存在的集合作为参数,并使用指定集合c中的元素作为其初始元素创建一个ArrayList。

    使用此构造函数初始化ArrayList的一般语法为:

    ArrayList <数据类型>列表名称=new ArrayList <>(集合c)

    例如,如果intList是一个包含元素{10,20,30,40,50}的现有集合,则以下语句将创建一个列表'arraylist',并将intList的内容作为其初始元素。

    ArrayList<Integer> ArrayList = new ArrayList<>(intList);

    ArrayList类还支持各种可用于操作列表内容的方法。我们将在即将到来的教程“ Java中的ArrayList方法”中详细讨论这些方法。

    用Java初始化ArrayList

    创建ArrayList后,可以通过多种方法用值初始化ArrayList。在本节中,我们将讨论这些方式。

    #1)使用Arrays.asList

    在这里,您可以使用Arrays类的asList方法传递一个转换为List的Array,以初始化ArrayList。

    通用语法:

    ArrayList<data_type> arrayListName = new ArrayList<data_type>(
                Arrays.asList (Object o1, Object o2, …, Object on));

    例:

    import java.util.*;
     
    public class Main {
       public static void main(String args[]) {
          //create and initialize ArrayList object myList with Arrays.asList method
         ArrayList<String> myList = new ArrayList<String>(
         Arrays.asList("One", "Two", "Three"));
         //print the ArrayList
         System.out.println("List contents:"+myList);
       }
    }

    输出:

    用Java初始化ArrayList

    #2)使用匿名内部类方法

    在这里,我们使用匿名内部类将ArrayList初始化为值。

    使用匿名内部类进行ArrayList初始化的一般语法如下:

    ArrayList <数据类型> arraylistName =new ArrayList <数据类型>(){{
    			add(对象o1); add(对象o2);…
    			add(对象);}};

    例:

    import java.util.*;
    public class Main {
       public static void main(String args[]) {
           //create and initialize ArrayList with anonymous inner class calls
           ArrayList<String> colors = new ArrayList<String>(){{
            add("Red");
            add("Blue");
            add("Purple");
               }};
          //print the ArrayList
        System.out.println("Content of ArrayList:"+colors);
       }
    }

    输出:

    使用匿名内部类方法

    #3)使用添加方法

    这是将元素添加到任何集合的常用方法。

    使用add方法将元素添加到ArrayList的一般语法为:

    ArrayList <数据类型> ArraylistName =new ArrayList <数据类型>();
    ArraylistName.add(value1);
    ArraylistName.add(value2);
    ArraylistName.add(value3);

    编程实例:

    import java.util.*;
    public class Main {
       public static void main(String args[]) {
           //create ArrayList
           ArrayList<String> colors = new ArrayList<String>();
           //add elements to the ArrayList using add method
           colors.add("Red");
           colors.add("Green");
           colors.add("Blue");
           colors.add("Orange");
           //print the ArrayList
           System.out.println("Content of ArrayList:"+colors);
       }

    输出:

    使用添加方法

    #4)使用Collection.nCopies方法

    此方法用于使用相同的值初始化ArrayList。我们提供要初始化的元素数和该方法的初始值。

    初始化的一般语法为:

    ArrayList <数据类型> arrayListName =new 				
    	ArrayList <数据类型>(Collections.nCopies(count,element));

    下面的示例演示了使用Collections.nCopies方法进行的数组初始化。

    import java.util.*;
    public class Main {
       public static void main(String args[]) {
           //create ArrayList with 10 elements
           //initialized to value 10 using Collections.nCopies
           ArrayList<Integer> intList = new ArrayList<Integer>(Collections.nCopies(10,10));
         
          //print the ArrayList
        System.out.println("Content of ArrayList:"+intList);
       }
    }

    输出:

    使用Collection.nCopies方法

    遍历ArrayList

    我们有以下几种方式遍历或遍历ArrayList:

    1. 使用for循环
    2. 通过for-each循环(增强的for-loop)。
    3. 使用Iterator界面。
    4. 通过ListIterator接口。
    5. 通过forEachRemaining()方法。

    实际上,通常使用这些方法来遍历集合。在本教程中,我们将看到与ArrayList有关的每种方法的示例。

    #1)使用for循环

    基于索引的for循环可用于遍历ArrayList并打印其元素。

    以下是使用for循环遍历和打印ArrayList的示例。

    import java.util.*;
    public class Main
    {
        public static void main(String[] args) {
            //create a list
            List<Integer> intList  = new ArrayList<>();
            intList.add(10);
            intList.add(20);
            intList.add(30);
            intList.add(40);
            intList.add(50);
           //create & initialize a new ArrayList with previous list
            ArrayList<Integer> arraylist = new ArrayList<>(intList);
            System.out.println("Contents of ArrayList using for-loop:");
            //use for loop to traverse through its elements and print it
            for(int i=0;i<intList.size();i++){
                   System.out.print(intList.get(i) + " ");
            }
        }
    }

    输出:

    通过forEachRemaining()方法

    这是遍历和打印ArrayList元素的最简单,最简单的方法,在其他集合的情况下也是如此。

    #2)通过for-each循环(增强的for循环)

    您也可以使用for-each循环或增强的for循环遍历ArrayList。在Java 8之前,它不包含lambda表达式。但是从Java 8开始,您还可以在for-each循环中包括Lambda表达式。

    下面的程序演示了对每个循环和lambda表达式使用ArrayList的遍历和打印。

    import java.util.*;
    public class Main
    {
        public static void main(String[] args) {
            //create a list
            List<Integer> intList  = new ArrayList<>();
            intList.add(10);
            intList.add(20);
            intList.add(30);
            intList.add(40);
            intList.add(50);
           //create & initialize a new ArrayList with previous list
            ArrayList<Integer> arraylist = new ArrayList<>(intList);
            System.out.println("Contents of ArrayList using for-each loop:");
           //use for-each loop to traverse through its elements and print it
             intList.forEach(val ->{
           System.out.print(val + " ");
            });
          }
    }

    输出:

    通过for-each循环

    #3)使用迭代器接口

    在前面的主题中,我们已经详细了解了Iterator接口。迭代器接口可用于遍历ArrayList并打印其值。

    以下程序显示了这一点。

    import java.util.*;
     
    public class Main
    {
        public static void main(String[] args) {
            //create a list
            List<Integer> intList  = new ArrayList<>();
            intList.add(5);
            intList.add(10);
            intList.add(15);
            intList.add(20);
            intList.add(25);
            //create & initialize a new ArrayList with previous list
            ArrayList<Integer> arraylist = new ArrayList<>(intList);
           System.out.println("Contents of ArrayList using Iterator interface:");
         //Traverse through the ArrayList using iterator
        Iterator iter=arraylist.iterator(); 
           while(iter.hasNext()){ 
                System.out.print(iter.next() + " "); 
           
           }
    }

    输出:

    使用迭代器界面

    #4)通过ListIterator接口

    您还可以使用ListIterator遍历ArrayList。ListIterator可用于向前和向后遍历ArrayList。

    让我们实现一个Java程序,该程序演示一个使用ListIterator的示例。

    import java.util.*; 
    class Main{ 
      public static void main(String args[]){ 
        //create a list and initiliaze it
        List<String> colors_list=new ArrayList<String>();//Creating arraylist
        colors_list.add("Red"); 
        colors_list.add("Green"); 
        colors_list.add("Blue"); 
        colors_list.add("Cyan");
        colors_list.add("Magenta");
        colors_list.add("Yellow");
        System.out.println("The contents of the list using ListIterator:");
        //Traverse the list using ListIterator
       ListIterator<String> color_iter=colors_list.listIterator(colors_list.size()); 
          while(color_iter.hasPrevious()) 
            
                String str=color_iter.previous(); 
                System.out.print(str + " "); 
            }   
     

    输出:

    通过ListIterator界面

    从输出中可以看到,在上面的程序中,使用ListIterator的hasPrevious()和previous()方法向后遍历ArrayList。

    #5)通过forEachRemaining()方法

    这是遍历ArrayList的方法之一,自Java 8起可用。

    下面的程序演示了遍历ArrayList的forEachRemaining()方法。

    import java.util.*; 
    class Main{ 
      public static void main(String args[]){ 
        //create a list and initiliaze it
        List<String> colors_list=new ArrayList<String>(); 
        colors_list.add("Red"); 
        colors_list.add("Green"); 
        colors_list.add("Blue"); 
        colors_list.add("Cyan");
        colors_list.add("Magenta");
        colors_list.add("Yellow");
        System.out.println("The contents of the list using forEachRemaining() method:");
        //Traverse the list using forEachRemaining () method
        Iterator<String> itr=colors_list.iterator(); 
            itr.forEachRemaining(val-> //lambda expression 
              
                System.out.print(val + " "); 
              }); 
     

    输出:

    通过forEachRemaining()方法

    我们将forEachRemaining()方法与Iterator一起使用。它与每个相似,我们在此方法内部使用lambda表达式。

    ArrayList Java示例

    在本节中,我们将看到Java中的ArrayList实现。作为示例,我们将通过创建,初始化和使用Java ArrayList执行各种操作来实现一个完整的示例。

    import java.util.ArrayList;
    class Main {
       public static void main(String[] args) {
        //Creating a generic ArrayList
        ArrayList<String> newList = new ArrayList<String>();
        //Size of arrayList
        System.out.println("Original size of ArrayList at creation: " + newList.size());
        //add elements to it
        newList.add("IND");
        newList.add("USA");
        newList.add("AUS");
        newList.add("UK");
     
        //print the size after adding elements
        System.out.println("ArrayList size after adding elements: " + newList.size());
     
        //Print ArrayList contents
        System.out.println("Contents of the ArrayList: " + newList);
     
        //Remove an element from the list
        newList.remove("USA");
        System.out.println("ArrayList contents after removing element(USA): " + newList);
     
        //Remove another element by index
        newList.remove(2);
        System.out.println("ArrayList contents after removing element at index 2: " + newList);
     
        //print new size
        System.out.println("Size of arrayList: " + newList.size());
        //print list contents
        System.out.println("Final ArrayList Contents: " + newList);
     }
    }

    输出:

    ArrayList Java示例

    Java中的二维ArrayList

    我们知道ArrayList没有像Arrays这样的维度。但是我们可以嵌套ArrayList,也称为“ 2D ArrayLists”或“ ArrayLists的ArrayList”。

    这些嵌套的ArrayList背后的简单思想是,给定一个ArrayList,此ArrayList的每个元素都是另一个ArrayList。

    让我们使用以下程序了解这一点。

    import java.util.*;
    public class Main {
       public static void main(String[] args)  {
             int num = 3;
            // declare an arrayList of ArrayLists or 2D ArrayList
            ArrayList<ArrayList<Integer>> intList = 
                   new ArrayList<ArrayList<Integer>>(num);
     
            // Create individual elements or ArrayLists and add them to intList as elements
            ArrayList<Integer> list_elem1 = new ArrayList<Integer>();
            list_elem1.add(10);
            intList.add(list_elem1);
     
            ArrayList<Integer> list_elem2 = new ArrayList<Integer>();
            list_elem2.add(20);
            list_elem2.add(30);
            intList.add(list_elem2);
     
            ArrayList<Integer> list_elem3 = new <Integer>();
            list_elem3.add(40);
            list_elem3.add(50);
            list_elem3.add(60);
            intList.add(list_elem3);
     
            System.out.println("Contents of 2D ArrayList(Nested ArrayList):");
            //print the 2D ArrayList or nested ArrayList
           for (int i = 0; i <intList.size(); i++) {
               for (int j = 0; j <intList.get(i).size(); j++) {
                     System.out.print(intList.get(i).get(j) + " ");
                }
             System.out.println();
            }
        }
    }

    输出:

    Java中的二维ArrayList

    上面的程序显示了2D ArrayList。在这里,首先,我们声明一个ArrayLists的ArrayList。然后,我们定义单独的ArrayList,将每个ArrayList添加到嵌套ArrayList时,它们将作为嵌套ArrayList的各个元素。

    要访问ArrayList的每个元素,我们需要调用get方法两次。首先访问嵌套ArrayList的行,然后访问行和列的各个交集。

    请注意,您可以增加ArrayList的嵌套级别来定义多维ArrayList。例如, 3D ArrayList将具有2D ArrayLists作为其元素,依此类推。

    经常问的问题

    Q#1)Java中的ArrayList是什么?

    答: Java中的ArrayList是动态数组。它本质上是可调整大小的,即在添加新元素时会增加大小,而在删除元素时会缩小。

    Q#2)Array和ArrayList有什么区别?

    答:数组为静态结构,声明后就无法更改其大小。ArrayList是动态数组,在添加或删除元素时会更改其大小。

    数组是Java中的基本结构,而ArrayList是Java中Collection Framework的一部分。另一个区别是,虽然Array使用下标([])访问元素,但ArrayList使用方法访问其元素。

    Q#3)ArrayList是一个列表吗?

    答: ArrayList是列表的子类型。ArrayList是一个类,而List是一个接口。

    Q#4)ArrayList是集合吗?

    答:不能。ArrayList是Collection的实现,后者是一个接口。

    Q#5)ArrayList如何增加其大小?

    答:内部ArrayList被实现为Array。ArrayList有一个size参数。将元素添加到ArrayList并达到size值时,ArrayList在内部添加另一个数组以容纳新元素。

    结论

    这是有关Java ArrayList类基础知识的教程。我们已经看到了ArrayList类的创建和初始化以及ArrayList的详细编程实现。

    我们还讨论了2D和多维ArrayList。ArrayList类支持各种可用于操作元素的方法。在我们即将发布的教程中,我们将介绍这些方法。

    展开全文
  • 怎么定义几个类和ArrayList,把这种结构的数据存储到ArrayList中。 再去把ArrayList中按照如上结构存储的数据读出来. ![图片说明](https://img-ask.csdn.net/upload/201906/25/1561445776_409691.png)
  • java中5种打印arraylist元素的方法

    千次阅读 2021-02-12 14:31:20
    import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class arraylist {public static void main(String [] args){//声明一个arraylistList list = new ArrayList();...
  • Java-创建自定义ArrayList

    千次阅读 2019-04-09 16:27:25
    * 自己实现一个ArrayList,帮助自己更好地理解ArrayLIst类的底层结构 */ public class MyArrayList /*implements List*/ { private Object[] elementData; private int size; public int getSize() { return size;...
  • Java中使用Arrays.asList初始化ArrayListpackage xiaoling;import java.util.Arrays;import java.util.ArrayList;import java.util.List;public class ListTest{public static void main(String[] args){List> ...
  • 如图,我看到这个例子中为了将list类型的coursesToSelect实例化,专门将他定义在封装类中,这样有什么好处吗,我觉得直接定义在如图所示的位置还方便点。 ![图片说明]...
  • JavaArrayList

    千次阅读 2021-02-12 20:10:02
    导入其所在包 import java.util.ArratList2.创建对象 ArrayList 对象名=new ArrayList<>();E:泛型数据类型,指定对象名中存放指定类型的数据,不可省略,需为引用数据类型3.使用 即对象名.方法(参数可能有...
  • 当您在Java中创建Integer类型的数组列表时,默认值是...Java - ArrayList默认初始值有没有更好的方法?默认值是多少?希望是有道理的。欢呼声int size = a.size();int last = a.get(size);if(last == null){return...
  • java代码-使用集合ArrayList对字符串进行存储和管理 任务: 1.定义ArrayList对象 2.存储学科名称,见运行效果图 3.输出集合中元素的个数 4.遍历输出集合中的所有元素
  • 初学javaArrayList集合做的一个简易库存管理系统,有添加,删除,修改,查看等功能,用Arraylist集合做的,不是用数据库,对初学者以后学习数据库操作有帮助,两个文件必须放在同一文件夹,Java1文件为源码,spkc...
  • ArrayList继承于List接口,除继承过来的方法外,还提供一些方法来操作内部用来存储列表的数组的大小。每个ArrayList实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向...
  • 展开全部java中的ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本。它提供了如下一些好32313133353236313431303231363533e4b893e5b19e31333366306434处:动态的增加和减少元素实现了...
  • import java.util.ArrayList; import java.util.Iterator; import java.util.Scanner; /** * @Author Ziph * @date 2020/2/19 * @Email mylifes1110@163.com */ public class TestDemo implemen
  • Java提供ArrayList类来存储不限定个数的对象,下面来详细介绍下其基本用法 ArrayList是一种泛型类,具有一个泛型类型 E。创建一个ArrayList时, 可以指定一 个具体的类型来替换 E 举个例子: ArrayList< ...
  • JavaArrayList类的使用方法

    千次阅读 2021-03-08 14:51:38
    JavaArrayList类的用法1、什么是ArrayListArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处:动态的增加和减少元素实现了ICollection和IList接口灵活的设置数组的大小2...
  • JavaArrayList的删除元素方法总结

    千次阅读 2020-05-24 22:57:44
    Java中循环遍历元素,一般有for循环遍历,foreach循环遍历,iterator遍历。 先定义一个List对象 List<String> list = new ArrayList<>(); list.add("1"); list.add("2"); list.add("3"); 一 、普通for...
  • Java中的ArrayList的容量

    千次阅读 2021-02-28 17:05:00
    ArrayList继承于List接口,除继承过来的方法外,还提供一些方法来操做内部用来存储列表的数组的大小。每一个ArrayList实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它老是至少等于列表的大小。随着向...
  • Java ArrayList

    2015-02-11 13:17:42
    InitArray自己编写的一个JAVA用的集合类,试试效果如何。
  • Java中使用ArrayList的10个示例–教程

    千次阅读 2020-05-27 15:05:39
    Java中的ArrayList是HashMap之后最常用的集合类。 Java ArrayList表示一个可自动调整大小的数组,并用于代替数组。 由于创建数组后我们无法修改数组的大小,因此我们更喜欢在Java中使用ArrayList,一旦数组满了,它...
  • 在类中存在的就是方法和属性了,...一、首先在java层先定义一个native方法: public native ArrayList<Rect> faceDetectSaveInfoFromJNI(Bitmap bitmap); 二、在naive层完成该方法的实现: extern "C" JNIEXPORT
  • java Arraylist清空复用

    2020-08-28 20:20:56
    打算是使用两层list,即一个list其中每一个元素又是一个list...ArrayList<ArrayList<int> > list = new ArrayList<ArrayList<int> >(); int k = 1; ArrayList<int> child_list = new Arra
  • JAVAArrayList之存储自定义对象

    千次阅读 2019-10-26 10:57:46
    ArrayList < Student > list = new ArrayList < > ( ) ; Student one = new Student ( "洪七公" , 20 ) ; Student two = new Student ( "欧阳锋" , 21 ) ; Student three = new ...
  • Java中使用ArrayList创建二维数组

    万次阅读 2019-04-30 16:35:20
    计蒜客data structure:Code_01 ...import java.util.ArrayList; import java.util.Scanner; /** * @author wangchong * @date 2019/4/30 16:09 * @email 876459397@qq.com * @CSDN https:/...
  • Java List ArrayList用法详解

    千次阅读 2016-06-17 16:35:34
    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) {...
  • JAVA泛型数组ArrayList详解

    千次阅读 2018-11-20 17:13:48
    下面来解释一下泛型数组ArrayList(泛型数组来解释一下这个原理): java没有增加泛型类之前: 在java增加泛型类之前,泛型设计是通过继承实现的。ArrayList类只维护一个Object引用的数组: public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 345,863
精华内容 138,345
关键字:

java定义arraylist

java 订阅