面试题-Date:2021-03-03

1.ArrayList和LinkedList

1.1ArrayList和LinkedList有什么区别？如何选用？

• 就一次性的通过add从集合尾部添加元素后只需读取一次建议永ArrayList
• 如果要频繁的添加元素，或在完成添加后会频繁通过indexOf方法从集合里查找元素，建议永LinkedList

1.2ArrayList和LinkedList哪个是线程不安全的，哪个是线程安全的

ArrayList和LinkedList线程不安全，Vector线程安全

1.3ArrayList满了以后如何扩容

扩容时，ArrayList是扩容50%，Vector是100%

LinkedList是双向连表无需扩容

1.4Vector你还用吗？(其实很多项目里不用了)

Vector使用概率很少

1.5如何遍历？便利是能否修改(其实是fail-fast问题)

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

public class VisitError {

	public static void main(String[] args) {
		List<String> strList = new ArrayList<String>();
		strList.add("1");
		strList.add("2");
		strList.add("3");
		strList.add("4");	
		//correct
		for(int i = 0;i<strList.size();i++){
			System.out.println(strList.get(i));
		}			
		//throw Exception
		for(String str:strList){
			System.out.println(str);
			if("2".equals(str) )			{
				strList.remove("2");
			}
		}		
		//Error
		for(int i = 0;i<strList.size();i++){
			System.out.println(strList.get(i));
			if("2".equals(strList.get(i)) )			{
				strList.remove("2");
			}
		}
	}
}

在进行ArrayList的遍历时常常会抛出一个异常

foreach抛异常的原因

• foreach是通过迭代器Iterator来访问的
• ArrayList的remove方法是会调用fastremove
• 在其中modCount和expectedModCount不一致，抛异常

ArrayList是线程不安全的，如一线程在读，另一线程在改，该抛异常

在foreach里面遍历修改会抛异常原因就是迭代用Iterator

在for循环中为何不报错？

不经过迭代器，直接访问ArrayList,所以不会引起fail-fast

remove2，预期输出1,2,3,4。实际输出1.3.4

YI

以Iterator遍历和修改

可边遍历边修改,并且结果正确

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

public class VisitByItr {

	public static void main(String[] args) {
		List<String> strList = new ArrayList<String>();
		strList.add("1");
		strList.add("2");
		strList.add("3");
		Iterator<String> it = strList.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}		
		it = strList.iterator();
		while(it.hasNext()){
			String str=it.next();
			System.out.println(str);
			if("2".equals(str)) {				
				//strList.remove(str);//throw exception
				it.remove(); //correct
			}
		}		
	}
}

观察Iterator的remove方法，会发现，重置了expectedModCount

重置的动机是保证多个迭代器同时遍历时的数据一样

2.深拷贝和浅拷贝

定义一个Car类型的类，其中只有一个int类型id属性。创建个Car类的实例，假设是c，设置它的id是1。
通过new创建两个不同的ArrayList，分别是a1和a2，c对象分别放入a1和a2。
在a1这个ArrayList里，拿出c对象，并把它id设置成2，同时不
对存放在a2里的c对象做任何的修改。
问题是，完成上述步骤，a2里存放的c对象的id是多少?1还是2?

2.1浅拷贝

package part11;
import java.util.ArrayList;

class Car {
	private int i;

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	public Car(int i) {
		this.i = i;
	}
}

public class CopyDemo {

	public static void main(String[] args) {

		Car c = new Car(1);

		ArrayList<Car> a1 = new ArrayList<Car>();
		ArrayList<Car> a2 = new ArrayList<Car>();
		a1.add(c);
		a2.add(c);

		a1.get(0).setI(2);
		System.out.println(a2.get(0).getI());
	}
}

2.2深拷贝

import java.util.ArrayList;

class CarForDeepCopy implements Cloneable 
{
	private int i;
	public int getI() {
		return i;
	}
	public void setI(int i) {
		this.i = i;
	}
	
	
	public CarForDeepCopy(int i)
	{
		this.i = i;
	}
	
	public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class DeepCopy {

	public static void main(String[] args) {
		CarForDeepCopy c1 = new CarForDeepCopy(1);
		
		CarForDeepCopy c2 = null;
		try {
			c2 = (CarForDeepCopy)c1.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	       
	       ArrayList<CarForDeepCopy> a1 = new ArrayList<CarForDeepCopy>();
	       ArrayList<CarForDeepCopy> a2 = new ArrayList<CarForDeepCopy>();
	       a1.add(c1);
	       a2.add(c2);
	       
	       a1.get(0).setI(2);
	       System.out.println(a2.get(0).getI());

	}

}