一个ArrayList里嵌套了一个ArrayList如何遍历取值（两个都取）
[问题点数：20分，结帖人az235]
一个ArrayList里嵌套了一个ArrayList如何遍历取值（两个都取）
[问题点数：20分，结帖人az235]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
相关帖子推荐：
2008年10月 .NET技术大版内专家分月排行榜第二
2008年10月 .NET技术大版内专家分月排行榜第二
本帖子已过去太久远了，不再提供回复功能。java，怎么判断ArrayList数组是否为空？_百度知道
java，怎么判断ArrayList数组是否为空？
如题，怎么判断？
提问者采纳
如果判断其为nulll则为
list==null 如果判断里面有没有元素..
list.size()==0祝楼主早日成功!!
其他类似问题
按默认排序
其他7条回答
List list =new ArrayList();------------------------这个是判断list里面是否有值。list.isEmpty(); //为空；
//不为空；-----------------------如果用 if(null == list) 即使list里面没有值也判断他不为空，应为已经为list对象new ArrayList了。
呵呵要判断数组是否为空只要引用一下，如果没有空指针错误就不是空的
1．你是要判断这个数组里的内容为空？ 2．还是要判断这个数组对象本身是空？ 1．List list = new ArrayList(); if(list.length&1)2．List list = new ArrayList(); if(list==null)
ArrayList.size()&1
ArrayList.length();看返回是否为0
直接写if(list == null) system.out.println(&数组为空&);
if(list == null || list.size() == 0)
arraylist的相关知识
您可能关注的推广
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁已有天涯账号？
这里是所提的问题，您需要登录才能参与回答。
"天涯问答"是天涯社区旗下的问题分享平台。在这里您可以提问，回答感兴趣的问题，分享知识和经历，无论您在何时何地上线都可以访问，此平台完全免费，而且注册非常简单。
下面java中的ArrayList.add()的问题怎么解决？
import java.util.*; public class ArrayListTest { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add(&one&); al.add(&two&); for (int i=1;i&al.size();i++) { System.out.println(al.get(i)); } } } /*ArrayListTest.java:7: 警告：[unchecked] 对作为普通类型 java.util.ArrayList 的成 员的 add(E) 的调用未经检查 al.add(&one&); ^ ArrayListTest.java:8: 警告：[unchecked] 对作为普通类型 java.util.ArrayList 的成 员的 add(E) 的调用未经检查 al.add(&two&); ^ 2 警告 */ 我用的是java version &1.6.0_01& &one&是对象啊。为什么还出错？
09-02-11 & 发布
既然你暗示就是ArrayList了，首选就从Arraylist想了可以试试:import java.util.ArrayLpublic class Test{ public static void main(String[]args){   ArrayList&ArrayList&Integer&& als = new ArrayList&ArrayList&Integer&& ();   ArrayList&Integer& a1 = new ArrayList&Integer&();   ArrayList&Integer& a2 = new ArrayList&Integer&();   ArrayList&Integer& a3 = new ArrayList&Integer&();   ArrayList&Integer& a4 = new ArrayList&Integer&();//下面是添加行，你可以用循环添加固定的行//每一列就是一个ArrayList&Integer&，你可以任意添加，长度不固定吧   als.add(a1);   als.add(a2);   als.add(a3);   als.add(a4);   System.out.println(als.size());  
}} tao_3000的方法可行，只是Integer[]创建时要指定维数可以自己写个算法自动增加维数对于你说的数据量问题，个人理解是这样的：达到了几十万几百万的数据量的时候，我想大概就是从数据库中吧数据读取出来，进行批量的处理或者更新之类的操作。你说得很对，如此庞大的数据量肯定会使效率降低，但是我们完全可以一次从数据库中读取几百条记录，进行操作关于如何从数据库中一次读取很少的记录，jdbc和hibernate都有相应的实现在者，数据量过大，呵呵，JVM可能崩溃哦 *_*
请登录后再发表评论!
北京动力节点基础班学费800元也有就业班的培训哦!学员工作大多都在5000元以上教学质量高，师资力量雄厚还有免费视频下载
请登录后再发表评论!关于ArrayList使用时常遇到的问题以及解决方法 - 责任能将能力发挥到极致 - ITeye技术网站
博客分类：
事例1：ArrayList在迭代的时候不能去改变自身的元素集合,否则会抛异常:java.util.ConcurrentModificationException
List&Integer& list = new ArrayList&Integer&();
list.add(new Random().nextInt(10));
list.add(new Random().nextInt(10));
//开始迭代
Iterator&Integer& iter = list.iterator();
while (iter.hasNext()) {
System.out.println("迭代:" + iter.next());
list.add(new Random().nextInt());
事例2:ArrayList在迭代的时候可以用迭代器删除ArrayList中的元素
List&Integer& list = new ArrayList&Integer&();
list.add(new Random().nextInt(10));
list.add(new Random().nextInt(10));
//开始迭代
Iterator&Integer& iter = list.iterator();
while (iter.hasNext()) {
System.out.println(iter.next()+"元素被删除");
iter.remove();
事例3：CopyOnWriteArrayList是线程安全的集合类，该集合在迭代的时候，可以改变自身的元素集合
List&Integer& syncList = new CopyOnWriteArrayList&Integer&();
syncList.add(1);
syncList.add(5);
Iterator&Integer& iter = syncList.iterator();
while (iter.hasNext()) {
flag = iter.next();
System.out.println("迭代:" + flag);
syncList.remove(new Integer(flag));
System.out.println("集合的大小：" + syncList.size());
事例4：CopyOnWriteArrayList是线程安全的集合类，该集合在迭代的时候，不能用迭代器去删除集合中的元素 ,否则会抛异常:java.lang.UnsupportedOperationException
List&Integer& syncList = new CopyOnWriteArrayList&Integer&();
syncList.add(1);
syncList.add(5);
Iterator&Integer& iter = syncList.iterator();
while (iter.hasNext()) {
System.out.println("迭代:" + iter.next());
iter.remove();
System.out.println("集合的大小：" + syncList.size());
浏览: 98571 次
来自: 杭州
请问你一下，你知道如何使用gradle来获取git版本号吗
如果 还有其他参数该怎么办呢
哥们你们解决了吗?这个问题折腾我很久了
我也想问啊，
如果com.yonge.web.util.Dat ...想请教一个问题：比如我new了一个List: List list = new ArrayList();并new了一个对象: A a = new A();……省略赋值语句此时我进行操作：list.add(a);而后我对a再次进行了一次赋值操作，比如：A b = new A();a =这时候我再次执行list.add(a);请问这时候list中第一次add进去的元素会不会改变？我之前有过一次经验，如果对象a是个类的全局变量，则list中第一次add进去的元素会跟着变；也不知道自己的这个经验记得还准不准，很是疑惑，想请教下大家。是不是对象a是局部变量就不会存在这种情况？还是我所说的这些根本就是不存在的？
问题的关键在于：
list.add(a);
这个方法执行过程中，传入给add方法参数的到底是什么？到底是a本身，还是a指向的对象。
&&& 可以这样看这个问题，任何一个变量都有两个属性：地址（在内存中保存数据所用的地址）和值（数据本身的值），通过对变量的使用来访问需要的数据。那么当对一个变量赋值时，到底是把要保存的值绑到变量上了，还是把保存该数据的内存地址绑定到变量上了呢？两种方式都能达到通过变量访问数据的目的，选择方式有由实现者决定。而JVM选择了前者。
&&& 在Java中，对于基本数据，实际上是直接把值绑到了变量上，对于对象，实际上是把对象的地址绑定到了变量上。所以，java里面赋值操作都是按值传递的，只不过对于对象而言，传的是对象的地址。
所以上面的问题就简单了，
List list = new ArrayList();
A a = new A();//a保存的是 new A()在堆上的地址
此时我进行操作：
list.add(a);
//把a的值copy到了add参数上（copy的是地址，add方法内对象已经和a再没有关系了），list的第一个元素也保存 new A()在堆上的地址
而后我对a再次进行了一次赋值操作，比如：
A b = new A();//b保存新的new A()在堆上的地址
a =//赋值拷贝，a保存新的new A()在堆上的地址
这时候我再次执行list.add(a);
* Appends the specified element to the end of this list.
* @param e element to be appended to this list
* @return &tt&true&/tt& (as specified by {@link Collection#add})
public boolean add(E e)
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] =
上面是ArrayList源码的中一个add方法的源码，在elementData中存储的e,其实是一个指向实际内存的一个地址！楼主所有的情况是：如果你更改此内存地址所指向的实际内存的数据，当然会更改ArrayList中的数据啦，但是如果你新增加一个指向新内存的地址，当然是不会改变之前插入的数据的。
ArrayList源码分析请参考：
以前就知道JAVA对象分对象引用和值引用，并且还知道8种基础数据类型，即引用时是值引用的数据类型，比如int,short,long,byte,float,double,char,boolean，其它都是对象引用。可是其它的对象引用我一直都以为跟c里面是一样的指针传递，直到今天才发现原来JAVA里面还是别有一番天地的。
&&& 1. 方法调用的时候，并不是类似c的指针传递，而是引用的复制
比如代码：
&&& void func1(List s) {
&&&&&&& s.add("dfdsa");
&&& }
&&& void test() {
&&&&&&& List&String& list = new ArrayList&String&();
&&&&&&& list.add("abc");
&&&&&&& func1(list);
&&&&&&& System.out.println(list.size()); // 此处结果为2
&&& }
以前一直以为在func1里面的s跟外面的list变量是同一个引用（暂且理解为指针好了）即在栈（stack）里面是同一个东东，这个结论无可厚非，可是看代码：
&&& void func(String s) {
&&& s += "tail";
&&& }
&&& void test() {
&&&&&&& String a = "abc";
&&&&&&& func(a);
&&&&&&& System.out.println(a); // 此处结果为abc&
&&& }
经过讨论才发现，原来在stack里面a和func里面的s是完全不同的两个引用，虽然它们指向同一个堆（heap）里面的对象，之所以跟上面的代码结果看起来不一样，只是因为String是一个非可变类（immutable），简单的说就是实例是不可被修改的。在func里面执行s += "tail";操作的时候，s这个引用已经变成指向heap里面另外一个值为"abctail"的对象了，老的s引用已经被废了，随时可以被gc回收了
&&& 2. String对象在内存中的位置
既然String是一个immutable的类，那么对于同样值的String实例，我们是可以不必重复创建的，于是就有了JVM中的String Pool的概念。简单的说，String Pool里面放着heap里面String对象的引用。看代码：
String s = "abc";
当程序执行该代码的时候，JVM会在String Pool里面通过equal("abc")方法查找有没有现成的String对象引用，如果没有，则在heap里面创建一个String对象并将该对象的引用保存到String Pool里面；如果有了，那么就直接返回该对象的引用。
再看一段非常类似的代码：
String s = new String("abc");
当程序执行该代码的时候，JVM会像普通对象一样生成这个String对象，在heap里面保存，直接返回引用，并不会与String Pool交互，这样一来，String Pool的优势就没有被发挥了，怎么办呢？难道我们就不去使用new的方法创建String了吗？答案是JVM还提供了一个方法:String.intern();来让String Pool管理这种String对象。
intern方法的工作原理是这样的：首先在heap里面创建一个完全一样的String对象，并且将该对象的引用放入String Pool中，最后返回给调用方，看代码：
&&&&&&& String s1=new String("abc");
&&&&&&& String s2=s1.intern();
&&&&&&& String s3="abc";
&&&&&&& System.out.println(s1==s2); //false
&&&&&&& System.out.println(s2==s3); //true
&&&&&&& System.out.println(s1==s3); //false
s1引用的是heap里面的一个普通String对象，在String Pool中没有该对象的引用
s2是heap中另一个String对象的引用，并且该对象的引用已经存在在String Pool中了
s3在创建的时候JVM通过查找String Pool发现已经有一个同样的对象，所以直接返回给s3一个到该对象的引用
结论：我们在写JAVA代码的时候要尽量避免使用String s = new String("abc");这种方式，因为这样产生的对象并没有“注册”到String Pool中，无法被重复使用，如果已经存在这种对象了，我们可以通过使用s = s.intern();的方式重新创建对象并“注册”到String Pool中，方便后面的重复使用。
&&& 3. 深入JVM内存的划分
由于JVM对与heap和stack内存的使用有其特殊的规则，深入了解JVM是如何使用内存的，非常有助于我们在写程序的时候搞清楚自己的对象到底在什么地方，从而可以帮助我们在多线程程序和性能要求较高的程序中优化自己代码，有兴趣的同学可以参考sun的官方文档（/docs/books/jvms/second_edition/html/Overview.doc.html#1732），下面仅就部分知识做简单描述。
&&& a. 每个线程都有自己独占的stack，里面存放的是当前线程执行的method及其局部变量
&&& b. heap中有部分是公共区域，存放的是类实例（class instance）和已分配内存的数组（array）
&&& c. heap中对于每个线程都有各自独立的内存区域，存放以下内容：
&&&&&&& 运行时常量池（runtime constant pool），上面提到的String Pool就属于其中的一部分
&&&&&&& 方法代码（method code），即线程要执行的方法代码
&&&&&&& 静态变量和方法（static variables and method），我们定义的static类型的变量和方法都存放在这里
String a="1213";
list.add(a);
a="cccc";
list.add(a);
System.out.println(list.get(0)+"==="+list.get(1));
结果:1213===cccc,传一般类型也是不变的哈
对象是传引用的；你去看看传值与传引用的区别就知道了；把A实例改成一个基本类型就不会出现这样的问题了。
确实是不会的。
但是楼上说的有一些不是很贴切。
/ /创建一个对象A，引用a指向对象A
A a = new A();
// 把对象A的引用放入List，对象A本身没有放进List
list.add(a);
// 创建一个对象A，引用b指向对象A
A b = new A();
// 这个时候引用a发生了变化，它指向了b引用的对象，是一个新的对象。
a =
// 这里同样是把a指向的新的对象的引用放入List，并不是把A对象本身放入List
list.add(a)
public class A {
public String getStr() {
public void setStr(String str) {
this.str =
public A(){
public A(String str){
当a是局部变量的时候
public static void main(String[] args) {
A a=new A("原来的A");
List list=new ArrayList();
list.add(a);
A b=new A("改变的A");
list.add(b);
System.out.println(a.str);
System.out.println(((A)list.get(0)).str);
System.out.println(((A)list.get(1)).str);
因为一开始 a指向new A("原来的A")对象的引用。。第一次add list的时候是new A("原来的A")对象添加到list
第二次a=b；
把a指向b的引用。b=new A("改变的A");
所以2次添加的对象不同。。
同时，a指向的对象也改变了。但是第一次插入的是不变的，就是结果看到的
当a是全局变量时
public class Test {
static A a=new A("原来的A");
public static void main(String[] args) {
List list=new ArrayList();
list.add(a);
A b=new A("改变的A");
list.add(b);
System.out.println(a.str);
System.out.println(((A)list.get(0)).str);
System.out.println(((A)list.get(1)).str);
情况一样·····
不会
// 创建一个对象A，引用a指向对象A
A a = new A();
// 把上面创建的对象A放入list中。
list.add(a);
// 创建一个对象A，引用b指向对象A
A b = new A();
// 这个时候引用a发生了变化，它指向了b引用的对象，是一个新的对象。
a =
// 把a指向的对象放入list中，这个时候list中有两个元素。
list.add(a)
已解决问题
未解决问题}