精华内容
下载资源
问答
  • Java ArrayList 用法

    2021-03-22 11:25:06
    JavaArrayList 用法 public static void main(String [] arg) { //实例化arrayList ArrayList<String> datArrayList=new ArrayList<String>(); //向ArrayList末尾添加元素 for(int i=0;i<10;i+...

    Java ArrayList 用法


    需要注意的地方
    ArrayList<类型> datArrayList=new ArrayList<类型>();
    这个类型必须是对象类型的不能是基本类型,int byte double…这些基本类型都不可以使用,但在java中可以使用Integer,Double,Byte等引用类型进行代替

    public static void main(String [] arg)
    	{
    		//实例化arrayList
    	ArrayList<String> datArrayList=new ArrayList<String>();
    	//向ArrayList末尾添加元素
    	for(int i=0;i<10;i++)
    	{
    		datArrayList.add(String.valueOf(i));
    	}
    	for(int i=0;i<datArrayList.size();i++)
    	{
    		System.out.printf("%4s",datArrayList.get(i));
    	}
    	System.out.println();
    	
    	//向指定位置添加元素
    	System.out.println("向指定位置添加元素");
    	datArrayList.add(8,String.valueOf(100));
    	for(int i=0;i<datArrayList.size();i++)
    	{
    		System.out.printf("%4s",datArrayList.get(i));
    	}
    	System.out.println();
    	
    	//移除指定元素
    	System.out.println("移除第一个元素");
    	datArrayList.remove(0);
    	for(int i=0;i<datArrayList.size();i++)
    	{
    		System.out.printf("%4s",datArrayList.get(i));
    	}
    	System.out.println();
    	
    	//获得指定下标的元素
    	System.out.println("获得第3个元素:");
    	System.out.println(datArrayList.get(3-1));
    	
    	//列表是否包含元素5
    	System.out.println("列表是否包含元素5:"+datArrayList.contains("5"));
    	
    	//设置指定下标的元素
    	datArrayList.set(6, "我爱你晏传利");
    	System.out.println("设置下标为6的元素:"+datArrayList.get(6));
    	
    	//列表是否为空
    	System.out.println("列表是否为空:"+datArrayList.isEmpty());
    	
    	//清除全部元素
    	System.out.println("清除全部元素");
    	datArrayList.clear();
    	System.out.println("List大小:"+datArrayList.size());
    	
    	}
    	
    	
    	
    
    展开全文
  • Java ArrayList用法

    2020-08-17 15:51:14
    1 ArrayList介绍 ArrayList简介 ArrayList 是一个数组队列,相当于动态数组。与Java中的数组相比,它的容量能动态增长。它继承于AbstractList,实现了List, RandomAccess, Cloneable, java.io.Serializable这些...

    转自:https://www.cnblogs.com/msymm/p/9872818.html

    1  ArrayList介绍

    ArrayList简介

    ArrayList 是一个数组队列,相当于 动态数组。与Java中的数组相比,它的容量能动态增长。它继承于AbstractList,实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

    ArrayList 继承了AbstractList,实现了List。它是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
    ArrayList 实现了RandmoAccess接口,即提供了随机访问功能。RandmoAccess是java中用来被List实现,为List提供快速访问功能的。在ArrayList中,我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。稍后,我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。

    ArrayList 实现了Cloneable接口,即覆盖了函数clone(),能被克隆。

    ArrayList 实现java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。

    和Vector不同,ArrayList中的操作不是线程安全的!所以,建议在单线程中才使用ArrayList,而在多线程中可以选择Vector或者CopyOnWriteArrayList。

    ArrayList的构造函数

    // 默认构造函数
    ArrayList()
    
    // capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时,容量会添加上一次容量大小的一半。
    ArrayList(int capacity)
    
    // 创建一个包含collection的ArrayList
    ArrayList(Collection<? extends E> collection)

    ArrayList的API

    // Collection中定义的API
    boolean             add(E object)
    boolean             addAll(Collection<? extends E> collection)
    void                clear()
    boolean             contains(Object object)
    boolean             containsAll(Collection<?> collection)
    boolean             equals(Object object)
    int                 hashCode()
    boolean             isEmpty()
    Iterator<E>         iterator()
    boolean             remove(Object object)
    boolean             removeAll(Collection<?> collection)
    boolean             retainAll(Collection<?> collection)
    int                 size()
    <T> T[]             toArray(T[] array)
    Object[]            toArray()
    // AbstractCollection中定义的API
    void                add(int location, E object)
    boolean             addAll(int location, Collection<? extends E> collection)
    E                   get(int location)
    int                 indexOf(Object object)
    int                 lastIndexOf(Object object)
    ListIterator<E>     listIterator(int location)
    ListIterator<E>     listIterator()
    E                   remove(int location)
    E                   set(int location, E object)
    List<E>             subList(int start, int end)
    // ArrayList新增的API
    Object               clone()
    void                 ensureCapacity(int minimumCapacity)
    void                 trimToSize()
    void                 removeRange(int fromIndex, int toIndex)

    2 ArrayList数据结构

    ArrayList的继承关系

    java.lang.Object
       ↳     java.util.AbstractCollection<E>
             ↳     java.util.AbstractList<E>
                   ↳     java.util.ArrayList<E>
    
    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

     ArrayList与Collection关系如下图

    ArrayList包含了两个重要的对象:elementData 和 size。

    (01) elementData 是"Object[]类型的数组",它保存了添加到ArrayList中的元素。实际上,elementData是个动态数组,我们能通过构造函数 ArrayList(int initialCapacity)来执行它的初始容量为initialCapacity;如果通过不含参数的构造函数ArrayList()来创建ArrayList,则elementData的容量默认是10。elementData数组的大小会根据ArrayList容量的增长而动态的增长,具体的增长方式,请参考源码分析中的ensureCapacity()函数。

    (02) size 则是动态数组的实际大小。

    3 ArrayList源码解析

    总结
    (01) ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时;若使用默认构造函数,则ArrayList的默认容量大小是10
    (02) 当ArrayList容量不足以容纳全部元素时,ArrayList会重新设置容量:新的容量=“(原始容量x3)/2 + 1”
    (03) ArrayList的克隆函数,即是将全部元素克隆到一个数组中。
    (04) ArrayList实现java.io.Serializable的方式。当写入到输出流时,先写入“容量”,再依次写入“每一个元素”;当读出输入流时,先读取“容量”,再依次读取“每一个元素”。

    4 ArrayList遍历方式

    ArrayList支持的3种遍历方式

    (01) 第一种,通过迭代器遍历。即通过Iterator去遍历。

    Integer value = null;
    Iterator iter = list.iterator();
    while (iter.hasNext()) {
        value = (Integer)iter.next();
    }

    (02) 第二种,随机访问,通过索引值去遍历。
    由于ArrayList实现了RandomAccess接口,它支持通过索引值去随机访问元素。

    Integer value = null;
    int size = list.size();
    for (int i=0; i<size; i++) {
        value = (Integer)list.get(i);        
    }

    (03) 第三种,for循环遍历。如下:

    Integer value = null;
    for (Integer integ:list) {
        value = integ;
    }

    下面通过一个实例,比较这3种方式的效率,实例代码(ArrayListRandomAccessTest.java)如下:

    import java.util.*;
    import java.util.concurrent.*;
    
    /*
     * @desc ArrayList遍历方式和效率的测试程序。
     *
     * @author skywang
     */
    public class ArrayListRandomAccessTest {
    
        public static void main(String[] args) {
            List list = new ArrayList();
            for (int i=0; i<100000; i++)
                list.add(i);
            //isRandomAccessSupported(list);
            iteratorThroughRandomAccess(list) ;
            iteratorThroughIterator(list) ;
            iteratorThroughFor2(list) ;
        
        }
    
        private static void isRandomAccessSupported(List list) {
            if (list instanceof RandomAccess) {
                System.out.println("RandomAccess implemented!");
            } else {
                System.out.println("RandomAccess not implemented!");
            }
    
        }
    
        public static void iteratorThroughRandomAccess(List list) {
    
            long startTime;
            long endTime;
            startTime = System.currentTimeMillis();
            for (int i=0; i<list.size(); i++) {
                list.get(i);
            }
            endTime = System.currentTimeMillis();
            long interval = endTime - startTime;
            System.out.println("iteratorThroughRandomAccess:" + interval+" ms");
        }
    
        public static void iteratorThroughIterator(List list) {
    
            long startTime;
            long endTime;
            startTime = System.currentTimeMillis();
            for(Iterator iter = list.iterator(); iter.hasNext(); ) {
                iter.next();
            }
            endTime = System.currentTimeMillis();
            long interval = endTime - startTime;
            System.out.println("iteratorThroughIterator:" + interval+" ms");
        }
    
    
        public static void iteratorThroughFor2(List list) {
    
            long startTime;
            long endTime;
            startTime = System.currentTimeMillis();
            for(Object obj:list)
                ;
            endTime = System.currentTimeMillis();
            long interval = endTime - startTime;
            System.out.println("iteratorThroughFor2:" + interval+" ms");
        }
    }

    运行结果

    iteratorThroughRandomAccess:3 ms
    iteratorThroughIterator:8 ms
    iteratorThroughFor2:5 ms

    由此可见,遍历ArrayList时,使用随机访问(即,通过索引序号访问)效率最高,而使用迭代器的效率最低!

    5 toArray异常

    6 ArrayList实例

    本文通过一个实例(ArrayListTest.java),介绍 ArrayList 中常用API的用法。

    import java.util.*;
    
    /*
     * @desc ArrayList常用API的测试程序
     * @author skywang 
     * @email kuiwu-wang@163.com
     */
    public class ArrayListTest {
    
        public static void main(String[] args) {
            
            // 创建ArrayList
            ArrayList list = new ArrayList();
    
            // 将“”
            list.add("1");
            list.add("2");
            list.add("3");
            list.add("4");
            // 将下面的元素添加到第1个位置
            list.add(0, "5");
    
            // 获取第1个元素
            System.out.println("the first element is: "+ list.get(0));
            // 删除“3”
            list.remove("3");
            // 获取ArrayList的大小
            System.out.println("Arraylist size=: "+ list.size());
            // 判断list中是否包含"3"
            System.out.println("ArrayList contains 3 is: "+ list.contains(3));
            // 设置第2个元素为10
            list.set(1, "10");
    
            // 通过Iterator遍历ArrayList
            for(Iterator iter = list.iterator(); iter.hasNext(); ) {
                System.out.println("next is: "+ iter.next());
            }
    
            // 将ArrayList转换为数组
            String[] arr = (String[])list.toArray(new String[0]);
            for (String str:arr)
                System.out.println("str: "+ str);
    
            // 清空ArrayList
            list.clear();
            // 判断ArrayList是否为空
            System.out.println("ArrayList is empty: "+ list.isEmpty());
        }
    }

     

    展开全文
  • java ArrayList用法

    2018-04-24 15:45:28
    JavaArrayList类详解1、什么是ArrayList ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处: 动态的增加和减少元素 实现了ICollection和IList接口 灵活的设置数组...

    Java中ArrayList类详解

    1、什么是ArrayList 
    ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处: 
    动态的增加和减少元素 
    实现了ICollection和IList接口 
    灵活的设置数组的大小

    2、如何使用ArrayList 
    最简单的例子: 
    ArrayList List = new ArrayList(); 
    for( int i=0;i <10;i++ ) //给数组增加10个Int元素 
    List.Add(i); 
    //..程序做一些处理 
    List.RemoveAt(5);//将第6个元素移除 
    for( int i=0;i <3;i++ ) //再增加3个元素 
    List.Add(i+20); 
    Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组

    这是一个简单的例子,虽然没有包含ArrayList所有的方法,但是可以反映出ArrayList最常用的用法

    3、ArrayList重要的方法和属性 
    1)构造器 
    ArrayList提供了三个构造器: 
    public ArrayList(); 
    默认的构造器,将会以默认(16)的大小来初始化内部的数组 
    public ArrayList(ICollection); 
    用一个ICollection对象来构造,并将该集合的元素添加到ArrayList 
    public ArrayList(int); 
    用指定的大小来初始化内部的数组

    2)IsSynchronized属性和ArrayList.Synchronized方法 
    IsSynchronized属性指示当前的ArrayList实例是否支持线程同步,而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。 
    如果使用非线程同步的实例,那么在多线程访问的时候,需要自己手动调用lock来保持线程同步,例如: 
    ArrayList list = new ArrayList(); 
    //... 
    lock( list.SyncRoot ) //当ArrayList为非线程包装的时候,SyncRoot属性其实就是它自己,但是为了满足ICollection的SyncRoot定义,这里还是使用SyncRoot来保持源代码的规范性 

    list.Add( “Add a Item” ); 
    }

    如果使用ArrayList.Synchronized方法返回的实例,那么就不用考虑线程同步的问题,这个实例本身就是线程安全的,实际上ArrayList内部实现了一个保证线程同步的内部类,ArrayList.Synchronized返回的就是这个类的实例,它里面的每个属性都是用了lock关键字来保证线程同步。

    3)Count属性和Capacity属性 
    Count属性是目前ArrayList包含的元素的数量,这个属性是只读的。 
    Capacity属性是目前ArrayList能够包含的最大数量,可以手动的设置这个属性,但是当设置为小于Count值的时候会引发一个异常。

    4)Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange 
    这几个方法比较类似 
    Add方法用于添加一个元素到当前列表的末尾 
    AddRange方法用于添加一批元素到当前列表的末尾 
    Remove方法用于删除一个元素,通过元素本身的引用来删除 
    RemoveAt方法用于删除一个元素,通过索引值来删除 
    RemoveRange用于删除一批元素,通过指定开始的索引和删除的数量来删除 
    Insert用于添加一个元素到指定位置,列表后面的元素依次往后移动 
    InsertRange用于从指定位置开始添加一批元素,列表后面的元素依次往后移动

    另外,还有几个类似的方法: 
    Clear方法用于清除现有所有的元素 
    Contains方法用来查找某个对象在不在列表之中

    其他的我就不一一累赘了,大家可以查看MSDN,上面讲的更仔细 
    5)TrimSize方法 
    这个方法用于将ArrayList固定到实际元素的大小,当动态数组元素确定不在添加的时候,可以调用这个方法来释放空余的内存。 
    6)ToArray方法 
    这个方法把ArrayList的元素Copy到一个新的数组中。 
    4、ArrayList与数组转换 
    例1: 
    ArrayList List = new ArrayList(); 
    List.Add(1); 
    List.Add(2); 
    List.Add(3);

    Int32[] values = (Int32[])List.ToArray(typeof(Int32));

    例2: 
    ArrayList List = new ArrayList(); 
    List.Add(1); 
    List.Add(2); 
    List.Add(3);

    Int32[] values = new Int32[List.Count]; 
    List.CopyTo(values);

    上面介绍了两种从ArrayList转换到数组的方法

    例3: 
    ArrayList List = new ArrayList(); 
    List.Add( “string” ); 
    List.Add( 1 ); 
    //往数组中添加不同类型的元素

    object[] values = List.ToArray(typeof(object)); //正确 
    string[] values = (string[])List.ToArray(typeof(string)); //错误

    和数组不一样,因为可以转换为Object数组,所以往ArrayList里面添加不同类型的元素是不会出错的,但是当调用ArrayList方法的时候,要么传递所有元素都可以正确转型的类型或者Object类型,否则将会抛出无法转型的异常。

    4、ArrayList与数组转换 
    例1: 
    ArrayList List = new ArrayList(); 
    List.Add(1); 
    List.Add(2); 
    List.Add(3);

    Int32[] values = (Int32[])List.ToArray(typeof(Int32));

    例2: 
    ArrayList List = new ArrayList(); 
    List.Add(1); 
    List.Add(2); 
    List.Add(3);

    Int32[] values = new Int32[List.Count]; 
    List.CopyTo(values);

    上面介绍了两种从ArrayList转换到数组的方法

    例3: 
    ArrayList List = new ArrayList(); 
    List.Add( “string” ); 
    List.Add( 1 ); 
    //往数组中添加不同类型的元素

    object[] values = List.ToArray(typeof(object)); //正确 
    string[] values = (string[])List.ToArray(typeof(string)); //错误

    和数组不一样,因为可以转换为Object数组,所以往ArrayList里面添加不同类型的元素是不会出错的,但是当调用ArrayList方法的时候,要么传递所有元素都可以正确转型的类型或者Object类型,否则将会抛出无法转型的异常。

    5、ArrayList最佳使用建议 
    这一节我们来讨论ArrayList与数组的差别,以及ArrayList的效率问题 
    1)ArrayList是Array的复杂版本 
    ArrayList内部封装了一个Object类型的数组,从一般的意义来说,它和数组没有本质的差别,甚至于ArrayList的许多方法,如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。 
    2)内部的Object类型的影响 
    对于一般的引用类型来说,这部分的影响不是很大,但是对于值类型来说,往ArrayList里面添加和修改元素,都会引起装箱和拆箱的操作,频繁的操作可能会影响一部分效率。 
    但是恰恰对于大多数人,多数的应用都是使用值类型的数组。 
    消除这个影响是没有办法的,除非你不用它,否则就要承担一部分的效率损失,不过这部分的损失不会很大。 
    3)数组扩容 
    这是对ArrayList效率影响比较大的一个因素。 
    每当执行Add、AddRange、Insert、InsertRange等添加元素的方法,都会检查内部数组的容量是否不够了,如果是,它就会以当前容量的两倍来重新构建一个数组,将旧元素Copy到新数组中,然后丢弃旧数组,在这个临界点的扩容操作,应该来说是比较影响效率的。 
    例1:比如,一个可能有200个元素的数据动态添加到一个以默认16个元素大小创建的ArrayList中,将会经过: 
    16*2*2*2*2 = 256 
    四次的扩容才会满足最终的要求,那么如果一开始就以: 
    ArrayList List = new ArrayList( 210 ); 
    的方式创建ArrayList,不仅会减少4次数组创建和Copy的操作,还会减少内存使用。

    例2:预计有30个元素而创建了一个ArrayList: 
    ArrayList List = new ArrayList(30); 
    在执行过程中,加入了31个元素,那么数组会扩充到60个元素的大小,而这时候不会有新的元素再增加进来,而且有没有调用TrimSize方法,那么就有1次扩容的操作,并且浪费了29个元素大小的空间。如果这时候,用: 
    ArrayList List = new ArrayList(40); 
    那么一切都解决了。 
    所以说,正确的预估可能的元素,并且在适当的时候调用TrimSize方法是提高ArrayList使用效率的重要途径。 

    4)频繁的调用IndexOf、Contains等方法(Sort、BinarySearch等方法经过优化,不在此列)引起的效率损失 

    首先,我们要明确一点,ArrayList是动态数组,它不包括通过Key或者Value快速访问的算法,所以实际上调用IndexOf、Contains等方法是执行的简单的循环来查找元素,所以频繁的调用此类方法并不比你自己写循环并且稍作优化来的快,如果有这方面的要求,建议使用Hashtable或SortedList等键值对的集合。 
    ArrayList al=new ArrayList();

    al.Add("How"); 
    al.Add("are"); 
    al.Add("you!");

    al.Add(100); 
    al.Add(200); 
    al.Add(300);

    al.Add(1.2); 
    al.Add(22.8);

    5)ToArray方法 
    这个方法把ArrayList的元素Copy到一个新的数组中。 

    使用ArrayList类
    ArrayList类实现了List接口,由ArrayList类实现的List集合采用数组结构保存对象。数组结构的优点是便于对集合进行快速的随机访问,如果经常需要根据索引位置访问集合中的对象,使用由ArrayList类实现的List集合的效率较好。数组结构的缺点是向指定索引位置插入对象和删除指定索引位置对象的速度较慢,如果经常需要向List集合的指定索引位置插入对象,或者是删除List集合的指定索引位置的对象,使用由ArrayList类实现的List集合的效率则较低,并且插入或删除对象的索引位置越小效率越低,原因是当向指定的索引位置插入对象时,会同时将指定索引位置及之后的所有对象相应的向后移动一位,如图1所示。当删除指定索引位置的对象时,会同时将指定索引位置之后的所有对象相应的向前移动一位,如图2所示。如果在指定的索引位置之后有大量的对象,将严重影响对集合的操作效率。

     

    就是因为用ArrayList类实现的List集合在插入和删除对象时存在这样的缺点,在编写例程06时才没有利用ArrayList类实例化List集合,下面看一个模仿经常需要随机访问集合中对象的例子。
    在编写该例子时,用到了Java.lang.Math类的random()方法,通过该方法可以得到一个小于10的double型随机数,将该随机数乘以5后再强制转换成整数,将得到一个0到4的整数,并随机访问由ArrayList类实现的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);      // 索引位置为 0
    list.add(b);      // 索引位置为 1
    list.add(c);      // 索引位置为 2
    list.add(d);      // 索引位置为 3
    list.add(e);      // 索引位置为 4
    System.out.println(list.get((int) (Math.random() * 5)));     // 模拟随机访问集合中的对象
    }

    我实际中的练习例子:

    复制代码
     1 package code;
     2 import java.util.ArrayList;
     3 import java.util.Iterator;
     4 public class SimpleTest {
     5  
     6  
     7 public static void main(String []args){
     8   
     9   ArrayList list1 = new ArrayList();  
    10   list1.add("one");
    11   list1.add("two");
    12   list1.add("three");
    13   list1.add("four");
    14   list1.add("five");
    15   list1.add(0,"zero");  
    16   System.out.println("<--list1中共有>" + list1.size()+ "个元素");  
    17   System.out.println("<--list1中的内容:" + list1 + "-->");
    18   
    19   ArrayList list2 = new ArrayList();
    20   list2.add("Begin");
    21   list2.addAll(list1);
    22   list2.add("End");
    23   System.out.println("<--list2中共有>" + list2.size()+ "个元素");  
    24   System.out.println("<--list2中的内容:" + list2 + "-->");
    25   
    26   ArrayList list3 =  new ArrayList();
    27   list3.removeAll(list1);
    28   System.out.println("<--list3中是否存在one: "+ (list3.contains("one")? "是":"否")+ "-->");
    29   
    30   list3.add(0,"same element");
    31   list3.add(1,"same element");
    32   System.out.println("<--list3中共有>" + list3.size()+ "个元素");  
    33   System.out.println("<--list3中的内容:" + list3 + "-->");
    34   System.out.println("<--list3中第一次出现same element的索引是" + list3.indexOf("same element") + "-->");
    35   System.out.println("<--list3中最后一次出现same element的索引是" + list3.lastIndexOf("same element") + "-->");
    36   
    37   
    38   System.out.println("<--使用Iterator接口访问list3->");
    39   Iterator it = list3.iterator();
    40   while(it.hasNext()){
    41    String str = (String)it.next();
    42    System.out.println("<--list3中的元素:" + list3 + "-->");
    43   }
    44   
    45   System.out.println("<--将list3中的same element修改为another element-->");
    46   list3.set(0,"another element");
    47   list3.set(1,"another element");
    48      System.out.println("<--将list3转为数组-->");
    49     // Object []  array =(Object[]) list3.toArray(new   Object[list3.size()] );
    50      Object [] array = list3.toArray();
    51      for(int i = 0; i < array.length ; i ++){
    52       String str = (String)array[i];
    53       System.out.println("array[" + i + "] = "+ str);      
    54      }     
    55      
    56      System.out.println("<---清空list3->");
    57      list3.clear();
    58      System.out.println("<--list3中是否为空: " + (list3.isEmpty()?"是":"否") + "-->");
    59      System.out.println("<--list3中共有>" + list3.size()+ "个元素"); 
    60   
    61   //System.out.println("hello world!");
    62  }
    63 }
    复制代码
    展开全文
  • java ArrayList 用法

    2018-04-28 12:19:34
    ArrayList 集合 的使用 集合不存储基本类型,只存储引用类型 也是引用数据类型 步骤: 1 导入包 java.util包中 2 创建引用数据类型变量 公式: 数据类型&lt;集合存储的数据类型&gt; 变量名 = ...
    /*
        ArrayList 集合 的使用
        集合不存储基本类型,只存储引用类型
        也是引用数据类型
        步骤:
          1 导入包 java.util包中
          2 创建引用数据类型变量
            
            公式:
            
            数据类型<集合存储的数据类型>  变量名 = new 数据类型<集合存储的数据类型>();
            
            集合存储的数据类型:要将数据存储到集合的容器中
            创建集合引用变量的时候,必须制定好,存储的类型是什么
            
            ArrayList<String> arr = new ArrayList<String>();
            
          3 变量名.方法
    */   
    import java.util.ArrayList;   
    public class ArrayListDemo{
        public static void main(String[] args){
            //创建集合容器,指定存储的数据类型
            //存储字符串
            ArrayList<String> array = new ArrayList<String>();
            
            //创建集合容器,存储整数
            //注意里面不能写int,因为不存储基本类型,要存对应的引用类型
            ArrayList<Integer> array2 = new ArrayList<Integer>();
            
            //创建集合容器,存储手机类型
            ArrayList<Phone> array3 = new ArrayList<Phone>();
        }
    }

    基本数据类型

    对应的引用数据类型表示形式

    byte

    Byte

    short

    Short

    Int

    Integer

    long

    Long

    float

    Float

    double

    Double

    char

    Character

    boolean

    Boolean

    集合的方法
    /*
        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,size方法的返回值类型 int
            int size = array.size();
            System.out.println(size);
            
            //获取集合中的一个元素,获取1索引的元素
            //集合的方法get,获取元素后结果数据类型
             String s = array.get(1);
             System.out.println(s);
             
        }
    }

    集合的遍历

    /*
        集合的遍历
        实现思想也是索引思想
        集合的索引从0开始,到size()-1
        方法get(int index)
    */
    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);
            
            //对集合进行遍历
            //使用方法 size+get组合进行遍历
            //集合没有length,只有size
            for (int i =0;i<array.size();i++){
                System.out.println(array.get(i));
            }
        }
    }


    展开全文
  • 本文通过实例讲解Java中如何使用ArrayList类。Java.util.ArrayList类是一个动态数组类型,也就是说,ArrayList对象既有数组的特征,也有链表的特征。可以随时从链表中添加或删除一个元素。ArrayList实现了List接口。...
  • Java ArrayList用法详解

    2020-09-05 21:17:08
    ArrayList类位于java.util包中,使用前需要引入它,语法格式如下: //引入ArrayList类 import java.util.ArrayList; //初始化ArrayList ArrayList<E> objectName = new ArrayList<>(); 上面的
  • Java ArrayList用法入门

    2017-07-03 10:32:00
    ArrayList用法:  ArrayList是接口List的实现类,所以推荐以List接口来使用。  1、创建ArrayList的List接口  例:  List books = new ArrayList();  Java支持泛形后,创建的同时可以指定元素的类型。  例: ...
  • 概述在本教程中,我们将看到如何使用不同的技术从JavaArrayList中删除元素。给定一个运动列表,让我们看看如何摆脱以下列表中的某些元素:二。ArrayList的删除ArrayList有两种方法可以移除元素,一种是传递要移除...
  • 来自:唐尤华...Arraylist 和 LinkedList 是 Java 集合框架中用来存储对象引用列表的两个类。Arraylist 和 LinkedList 都实现 List 接口。首先,让我们了解一下它们最重要的父接口——List。1. L...
  • 学习Java已经17天,来看看... List接口ArrayList用法;ArrayList_JDK源码分析; LinkedList的特点_链表_JDK源码分析; Vector用法和ArrayList区别;Map接口_HashMap_Hashtable的用法; HashMap的底层原理等。 Collec...
  • ):在第N个数据后面添加一个数据用法:在第1个元素后面添加E注意:ArrayList中必须有足够多的数据,例如ArrayList中没有任何数据,这个时候使用arraylist.add(1, "E");就会出现java.lang....
  • 资料介绍:JAVA300集大型基础视频课程(史上最全、最深、最细)中国首套大型JAVA技术视频【已更新完至300集】还在为如何学习JAVA技术而迷茫吗?还在为如何学习Android技术而迷茫吗?史上最全:覆盖工作中需要的所有技术...
  • JAVAArrayList用法

    2014-10-10 20:39:00
    JAVA中ArrayList用法 2011-07-20 15:02:03|分类:计算机专业|标签:javaarraylist用法|举报|字号订阅 Java学习过程中做题时,用到ArrayList,在网上寻找到的学习资料。 摘自: ...
  • ArrayList 实现java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。ArrayList 去重利用HashSet里面的元素不可重复利用list里面contains方法比较是否存在去重第一种方法Ar...
  • arraylist是动态数组,它具有三个好处分别是:动态的增加和减少元素 、实现了ICollection和IList接口、灵活的设置数组的大小,本文给大家介绍java arraylist遍历及Java arraylist 用法,感兴趣的朋友一起学习吧
  • 很多刚刚学习java编程的小伙伴对于java当中arraylist的常见用法都不是很熟悉,那么下面就一起通过一个示例来了解一下吧!java当中arraylist的常见用法:importjava.lang.reflect.Array;importjava.util.*;importjava....
  • 本文通过实例讲解Java中如何使用ArrayList类。Java.util.ArrayList类是一个动态数组类型,也就是说,ArrayList对象既有数组的特征,也有链表的特征。可以随时从链表中添加或删除一个元素。ArrayList实现了List接口。...
  • 展开全部-----------构造方法摘要ArrayList()构造一个初始容量为 10 的空列表。ArrayList(Collection extends E> c)构造一个包含指32313133353236313431303231363533e58685e5aeb931333337396164定 collection 的...
  • List studentList = new ArrayList(); studentList.add(zlj); studentList.add(dxy); studentList.add(cjc); studentList.add(lgc); System.out.println("按照年齡排序:"); Collections.sort(studentList, new ...
  • }获取或设置ArrayList可包含的元素数。2.publicvirtualintCount{get;}获取ArrayList中实际包含的元素数。Capacity是ArrayList可以存储的元素数。Count是ArrayList中实际包含的元素数。Capacity总是大于或等于Count...
  • 主要介绍了javaarraylist排序示例,学习一下arraylist用法,需要的朋友可以参考下
  • JavaArrayList用法

    千次阅读 多人点赞 2018-04-13 19:54:36
    一、ArrayList的添加方法1. 1方法1:依次按照顺序向ArrayList中添加数据。用法:将a添加到list中list.add("a");#例子:2. 2方法2:在第N个数据后面添加一个数据用法:在第1个元素后面添加Elist.add(1, &...
  • 那是,Array复杂的版本号,它具有以下优点,例如:动态的添加和降低元素实现了ICollection和IList接口灵活的设置数组的大小2、怎样使用ArrayList最简单的样例:ArrayListList=newArrayList();for(inti=0;i<10;i++...
  • java ArrayList用法

    2019-06-16 10:31:08
    ArrayList是一个动态变化的数组,既有数组的特性,也有链表的特性。...用法: 1、构造方法 ArrayList<type> list=new ArrayList<>(); //type可以是String,Integer and so on 2、在末尾添加元素...
  • System.Collections.ArrayList类是一个特殊的数组。通过添加和删除元素,就可以动态改变数组的长度。一.优点1. 支持自动改变大小的功能2. 可以灵活的插入元素3. 可以灵活的删除元素二.局限性跟一般的数组比起来,...
  • 写了一个java数组排序示例,这里分享给大家共同...import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;public class Test {public static void main(S...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,265
精华内容 906
关键字:

javaarraylist用法

java 订阅