java关于ArrayList,Vector,LinkedList,Set及其面试题+LeetCode136两种方式实现

ArrayList

• ArrayList的遍历补充

将list转换为数组 使用toArray()方法将列表转换为数组，再对数组进行遍历

@Test
void test01() {
	List<String> names = new ArrayList<>();
	names.add("张三");
	names.add("李四");
	names.add("王五");
	names.add("赵六");
	names.add("钱七");
	
	Object[] array = names.toArray();
	for (Object string : array) {
		System.out.println(string.toString());
	}
}

• ArrayList的常见方法

@Test
void test02() {
	List<String> names = new ArrayList<>();
	names.add("张三");
	names.add("李四");
	names.add("王五");
	names.add("赵六");
	names.add("钱七");
	
	List<String> names2 = Arrays.asList("刘德华", "张学友", "郭富城", "黎明");
	
	 列表的拼接
	names.addAll(names2);
	System.out.println(names);
	 清空列表
	names.clear();
	
	System.out.println(names.contains("张三"));
	System.out.println(names.contains("法外狂徒"));
	
	 使用匿名内部类实现遍历列表
	names.forEach(new Consumer<String>() {
		@Override
		public void accept(String t) {
			System.out.println(t);
		}
	});
	
}

• ArrayList值得注意的地方

在jdk8及其以后，如果初始化ArrayList使用的是无参构造，
则默认创建一个{}空数组，长度为0，只有第一次添加元素时，才会进行数组扩容， 默认创建一个大小为10的对象数组。
如果再次扩容，大小为：int newCapacity = oldCapacity + (oldCapacity >> 1);
为原来大写的1.5倍。 如果new ArrayList的时候，使用的有参的构造，则直接创建大小为参数大小的对象数组。

• 面试题

在java中，存在goto吗？

found: {
            if (o == null) {
                for (; i < size; i++) {
			if (es[i] == null) {
				# break
				break found;
			}
		}
                    
            } else {
                for (; i < size; i++)
                    if (o.equals(es[i]))
                        break found;
            }
            return false;
        }

java使用label技术实现C++中goto语法！！！

• 注意：如果数据是固定的，建议使用有参的构造函数来创建对应个ArrayList

Vector

中文意思：向量
也是一个动态对象数组，非常像ArrayList，其中的各种方法也和ArrayList类似

和ArrayList不同的地方：
需要注意的是，Vector提供的大多数方法，都是被同步锁修饰的方法，言外之意：Vector是一个线程安全类，主要使用的多线程环境下。
Vector初始化容量也是10，需要注意的是，每次扩容会是原有容量的2倍。ArrayList每次扩容会是原有容量的1.5倍

• Vector的定义方式：

@Test
void test07() {
	Vector<Integer> nums = new Vector<>();
	nums.add(123);
	nums.add(456);
	nums.add(789);
}

LinkedList

它也是一个非常常用的线性表，需要注意的是：
ArrayList和Vector底层都是动态数组实现的 ，
而LinkedList是基于双向链表的实现。

jdk1.2诞生的有LinkedList和ArrayList，Vector是jdk1.0诞生的。

LinkedList实现了Queue队列，应用方式如代码中的test09，它的底层实际是一个双端队列。
示例：

@Test
void test08() {
	List<String> list = new LinkedList<>();
	list.add("孙悟空");
	list.add("猪八戒");
	list.add("沙僧");
	for (String string : list) {
		System.out.println(string);
	}
}

@Test
void test09() {
	// 队列
	Deque<String> list = new LinkedList<>();
	list.add("孙悟空");
	list.add("猪八戒");
	list.add("沙僧");
	for (String string : list) {
		System.out.println(string);
	}
}

常见面试题：

1. ArrayList和Vector的区别？
2. ArrayList、Vector已经LinkedList的区别？
3. ArrayList和LinkedList区别？

Set接口

因为Set接口代表的集合，因此如下特点：

特点：
1、不能存在重复数据
2、元素没有顺序（因为使用的hash算法实现的）
3、一旦插入成功，顺序也就固定下来

示例：

package com.openlab.day17.List;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.function.Consumer;

import org.junit.jupiter.api.Test;

class TestSet {

	@Test
	void testSet01() {
		Set<Integer> set = new HashSet<>();
//		System.out.println(set.add(12));
//		System.out.println(set.add(12));
		// 如果添加的元素是已经存在，则不会添加
		set.add(12);
		set.add(13);
		set.add(1);
		set.add(122);
		set.add(123);
		set.add(124);
		System.out.println(set);
		
	}
	
	@Test
	void testSet02() {
		HashSet<String> names = new HashSet<>();
		names.add("张三");
		names.add("李四");
		names.add("王五");
		// 因为集合是无序的，因此不存在通过get方法获取元素
	}
	
	@Test
	void testSet03() {
		Set<Integer> set = new HashSet<>();
		set.add(12);
		set.add(13);
		set.add(1);
		set.add(122);
		set.add(123);
		set.add(124);
		
//		for (Integer i : set) {
//			System.out.println(i);
//		}
		
//		Iterator<Integer> it = set.iterator();
//		while (it.hasNext()) {
//			int i = it.next();
//			System.out.println(i);
//		}
		
		set.forEach(new Consumer<Integer>() {
			@Override
			public void accept(Integer t) {
				System.out.println(t);
			}
		});
		
	}
	
	@Test
	void testSet04() {
		Set<Integer> set = new HashSet<>();
		set.add(12);
		set.add(13);
		set.add(1);
		set.add(122);
		set.add(123);
		set.add(124);
		// 只能通过对象本身移除
//		set.remove(o);
		
//		Object[] array = set.toArray();
//		for (Object object : array) {
//			System.out.println(object);
//		}
		
		
	}

}

LeetCode136：
方法一：使用hash列表，循环遍历数组，如果在hash列表中不存在这个元素，就添加，如果不存在就移除。

@Test
int test01() {
	int[] nums={1,1,2};
	Set<Integer> set=new HashSet<>();
	for (int i : nums) {
		if(!set.contains(i)) {
			set.add(i);
		}else {
			set.remove(i);
		}
	}
	Object[] s=set.toArray();
	return (int)s[0];
}

方法二：数组中的全部元素的异或运算结果即为数组中只出现一次的数字。

public int singleNumber(int[] nums) {
     int single = 0;
    for (int num : nums) {
        single ^= num;
    }
    return single;
}