江苏众安信科 Java 实习一面

1.集合的扩容机制

ArrayList 和Vector扩容机制总结： ArrayList 和Vector,底层都是Object数组，默认加载因子都是1（元素满了才扩展容量）.默认容量都是10；但是ArrayList 在jdk1.8时默认为空，当添加元素时，才初始化为10个容量。ArrayList：新容量为原容量的1.5倍，Vector:新容量为原容量的2倍.

ArrayList 默认初始容量为10，（jdk8的时候底层Object[] elementData数组初始化为{}，并没有创建长度为10的数组。在add元素时才创建了10个容量。） 线程不安全，查询速度快 　　　　底层数据结构是数组结构 　　　　扩容增量：原容量的 0.5倍，新容量为原容量的1.5倍。 　　　　如 ArrayList的容量为10，一次扩容后是容量为15

同样可以通过分析源码知道： Vector： 默认初始容量为10，（jdk7和jdk8一样都初始容量为10）。 线程安全，但速度慢 　　　　底层数据结构是数组结构 　　　　加载因子为1：即当 元素个数 超过 容量长度 时，进行扩容 　　　　扩容增量：原容量的 1倍，新容量为原容量的2倍。 　　　　如 Vector的容量为10，一次扩容后是容量为20

LinkedList没有扩容机制：

LinkedList：没有扩容机制，因为其底层是双向链表结构。不存在数组的扩容一说，没有初始化大小，也没有扩容的机制，就是一直在前面或者后面新增就好。

Set下的三个实现类集合HashSet和LinkedHashSet，TreeSet，扩容总结:LinkedHashSet，TreeSet没有数组的扩容机制

HashSet和HashMap扩容机制总结： HashSet和HashMap都是默认初始容量是16（jdk1.7的），但是jdk1.8做了优化，初始容量为0，第一次存元素的时候才扩容为16，加载因子是0.75，扩容为原来的2倍。而带LinkedHashSet和LinkedHashMap是链表不存在扩容的，HashSet:底层是数组+链表的结构。

Set(集) 元素无序的、不可重复。 HashSet：线程不安全，存取速度快 　　　　　底层实现是一个HashMap（保存数据）,HashSet:底层是数组+链表的结构，实现Set接口 　　　　　默认初始容量为16（jdk1.8及以后）（为何是16，见下方对HashMap的描述） 　　　　　加载因子为0.75：即当 元素个数 超过 容量长度的0.75倍 时，进行扩容 　　　　　扩容增量：原容量的 1 倍，新容量为原容量的2倍。 　　　　　　如 HashSet的容量为16，一次扩容后是容量为32。 　　　　　　因为构造一个HashSet，其实相当于新建一个HashMap，然后取HashMap的Key。 扩容机制和HashMap一样。

Map是一个双列集合: HashMap：jdk1.8默认初始容量0,当第一次put元素的时候才扩容为16，jdk1.7是初始化容量为16 　　　　　（为何是16：16是2^4，可以提高查询效率，另外，32=16<<1 –>至于详细的原因可另行分析，或分析源代码） 　　　　　加载因子为0.75：即当 元素个数 超过 容量长度的0.75倍 时，进行扩容 　　　　　扩容增量：原容量的 1 倍，新容量为原容量的2倍。 　　　　　　如 HashSet的容量为16，一次扩容后是容量为32 Hashtable默认初始容量11。 二、扩容加载因子(0.75)，当超出默认长度（int）（11*0.75）=8时，扩容为oldx2+1。新容量为原容量的2倍+1. int newCapacity = (oldCapacity << 1) + 1;

2.java的基本类型

3.包装类和基本类型的区别

1.int是基本数据类型，Integer是int的封装类，是引用类型。int默认值是0，而Integer默认值 是null，所以Integer能区分出0和null的情况。一旦java看到null，就知道这个引用还没有指向某个 对象，再任何引用使用前，必须为其指定一个对象，否则会报错。

2.基本数据类型在声明时系统会自动给它分配空间，而引用类型声明时只是分配了引用空间， 必须通过实例化开辟数据空间之后才可以赋值。数组对象也是一个引用对象，将一个数组赋值给另 一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看的见。

4.swap函数能不能交换 int 类型的数据

public class Swap
{
    public static void main(String[] args)
    {
        int c = 3;
        int d = 5;
        swap(c, d);
        System.out.println("c: " + c + "  d: " + d);

    }

    public static void swap(int a, int b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
}

运行结果： java Swap c: 3 d: 5

为什么调用swap()方法后并没有交换c、d的值呢，因为java只有值传递（没有引用传递），所以其实调用swap()时是把值赋给a、b,赋完后与c、d就没什么关系，c、d还是原来的值。其实就是值传递。不理解的话回去看看值传递。

解决方案：

1.通过数组对象交换

public class TestSwap {

	public static void main(String[] args){
		int a = 3;
		int b = 5;
		System.out.println("交换前："+"a="+a+" b="+b); 
		//以数组接收后赋值，注意赋值顺序，注意对应关系
		int[] arr = swap(a,b);
		a = arr[0];
		b = arr[1];
		System.out.println("交换后："+"a="+a+" b="+b); 
	}
	
	//交换
	private static int[] swap(int x, int y){
		//以数组形式返回
		return new int[]{y,x};
	}
}

2.通过反射与非类成员包装对象

public classTest{

    public static void main(String[] args) throws Exception{
           Integer a = 1;
           Integer b = 2;

           System.out.println("before : a=="+a+";b=="+b);
           swap(a,b);
           System.out.println("after