在这里，我们将给大家分享关于为什么ArrayList使用瞬态存储？的知识，让您更了解arraylist为什么可以扩容的本质，同时也会涉及到如何更有效地ArrayListal=newArrayList（

在这里，我们将给大家分享关于为什么ArrayList使用瞬态存储？的知识，让您更了解arraylist为什么可以扩容的本质，同时也会涉及到如何更有效地ArrayList al = new ArrayList（）;有什么区别？和ArrayList al = new ArrayList（0）？、ArrayList list = new ArrayList()在这个泛型为Integer的ArrayList中存放一个String类型的对象、ArrayList使用示例、Arrays.asList()返回的ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类的内容。

• 为什么ArrayList使用瞬态存储？（arraylist为什么可以扩容）
• ArrayList al = new ArrayList（）;有什么区别？和ArrayList al = new ArrayList（0）？
• ArrayList list = new ArrayList()在这个泛型为Integer的ArrayList中存放一个String类型的对象
• ArrayList使用示例
• Arrays.asList()返回的ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类

为什么ArrayList使用瞬态存储？（arraylist为什么可以扩容）

我正在阅读Java的ArrayList的源代码，并且遇到了它的支持数组声明：

private transient Object[] elementData;

为什么这需要是瞬态的？为什么不能对此类进行序列化？

谢谢您的帮助！

答案1

它 可以 被序列化;
该ArrayList班只是需要照顾的事情本身，而不是使用默认的机制。查看该类中的writeObject()和readObject()方法，它们是标准序列化机制的一部分。

如果您查看源代码，则会看到它writeObject()不保存后备阵列。相反，它一次将元素（包括空值）序列化到最大size()限制。这避免了序列化阵列的开销，尤其是避免了阵列末尾的任何未使用的插槽。反序列化时，由会创建一个最小所需大小的新支持数组readObject()。

ArrayList al = new ArrayList（）;有什么区别？和ArrayList al = new ArrayList（0）？

ArrayList list = new ArrayList()在这个泛型为Integer的ArrayList中存放一个String类型的对象

ArrayList使用示例

本教程演示如何在ArrayList上执行各种操作，一些常见的操作如下：

• 将元素添加到ArrayList中。
• 从ArrayList中删除元素。
• 从ArrayList中检索元素。
• 打印ArrayList的大小。
• 检查ArrayList中是否存在元素。
• 查找ArrayList中元素的索引。
• 从ArrayList中删除所有元素。

文件：ArrayListExample.java -

package com.jb51.cc.tutorial;

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();

        /*Adding elements into the list*/
        list.add(One);
        list.add(Two);
        list.add(Three);
        list.add(Four);
        list.add(Five);
        System.out.println(Elements in list:+list);

        /*Removing an element from the list*/
        String removedEle=list.remove(0); // Remove the first element
        System.out.println(Element revoved:+removedEle);
        System.out.println(Elements in list after removal:+list);

        /*Retrieving an element in the list*/
        String element=list.get(1);    // Get second element
        System.out.println(Element at second position:+element);

        /*Print size of List*/
        System.out.println(Number of elements:+list.size());

        /*Check if an element exist in the list*/
        System.out.println(Element exist:+list.contains(Five));

        /*Finding the index of an element*/
        System.out.println(Index of 'Four' is :+list.indexOf(Four));

        /*Removing all elements from the list*/
        list.clear();
        System.out.println(Elements in list:+list);
    }
}

执行上面示例代码，得到以下结果 -

Elements in list:[One Two Three Four Five]
Element revoved:One
Elements in list after removal:[Two Three Four Five]
Element at second position:Three
Number of elements:4
Element exist:true
Index of 'Four' is :2
Elements in list after clear:[]

Arrays.asList()返回的ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类

测试代码：

package array;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ArrayTest {
   
   
   

	@SuppressWarnings("unused")
	private static void asListTest(){
   
   
   
		String[] a = {
   
   
   "A", "B"};
		List<String> list = Arrays.asList(a);
		System.out.println(list.getClass().getName()); // java.util.Arrays$ArrayList
		System.out.println(list.contains("A")); // true
		list.add("C");
		/*
		 * Jerry: 2016-01-15 9:09PM:
	Arrays.asList() 会返回一个ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类java.util.Arrays.ArrayList 有set(), get(), contains()方法，
	但并不支持添加元素，所以大小是固定的，想要创建一个真正的ArrayList，你应该：
	ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));
		 */
	}
	
	private static void removeInLoop() {
   
   
   
		ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));

		// 下面这段代码会触发ConcurrentModificationException异常
                // 不能在循环里直接修改一个集合类实例

		/*for (String s : list) {
		    if (s.equals("a"))
		        list.remove(s);
		}*/
                // 应该用迭代器来完成
		Iterator<String> iter = list.iterator();
		while (iter.hasNext()) {
   
   
   
		    String s = iter.next();

		    if (s.equals("a")) {
   
   
   
		        iter.remove();
		    }
		}
		list.forEach(System.out::println);
	}
	public static void main(String[] args) {
   
   
   
	    // asListTest();
		removeInLoop();
		String[] a = {
   
   
   "A", "B"};
		// internal implementation: return new ArrayList<>(a);
		List<String> list1 = Arrays.asList(a);
		List<String> list2 = Arrays.asList(a);
		List<String> list3 = Arrays.asList(a);
		System.out.println(list1);
		System.out.println(list2);
		System.out.println(list3);
                /* 这行代码会触发异常：
             Exception in thread "main" java.lang.UnsupportedOperationException
	     at java.base/java.util.AbstractList.add(AbstractList.java:153)
	     at java.base/java.util.AbstractList.add(AbstractList.java:111)
	     at array.ArrayTest.main(ArrayTest.java:57)
                */
		// list3.add("C");
		System.out.println(list1.getClass().getCanonicalName());
	}
}

本文分享 CSDN - 汪子熙。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

今天关于为什么ArrayList使用瞬态存储？和arraylist为什么可以扩容的介绍到此结束，谢谢您的阅读，有关ArrayList al = new ArrayList（）;有什么区别？和ArrayList al = new ArrayList（0）？、ArrayList list = new ArrayList()在这个泛型为Integer的ArrayList中存放一个String类型的对象、ArrayList使用示例、Arrays.asList()返回的ArrayList，这是Arrays里内嵌的一个私有静态类，而并不是java.util.ArrayList类等更多相关知识的信息可以在本站进行查询。