Java集合类

list（不是线程安全的）

1. 接口可以被继承
2. 可以被多次实现

List list1 = new ArrayList();
ArrayList list2 = new ArrayList();

两条语句的区别：
第一句：只能用list接口中的方法
第二句：可以用ArrayList中的所有的方法，因为ArrayList是实现list接口，所以调用方法比第一种要多，还可以使用list里没有的接口
4.

		List<String> list = new ArrayList<>();
		list.add("aaa");
		list.add("bbb");
		// 如果确定了list里要放的元素，性能比较高，可以没有扩容操作
		List<String> list2 = Arrays.asList("aaa","bbb");

第二种方法比第一种添加的方法性能更高

		// 这样写不能在进行add操作
		List<String> list2 = Arrays.asList("aaa","bbb");
		list2.add("eee");
		System.out.println(list2.toString());

5. list删除元素

不能一边遍历，一边删除

public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("aaa");
		list.add("aaa");
		list.add("aaa");
		
		// list删除
		for (int i = 0; i < list.size(); i++) {
			if ("aaa".equals(list.get(i))) {
				list.remove(i);
			}
		}
		System.out.println(list);
		
	}

运行结果：（并没有完全删除干净）

原因如下图所示：

三种实现删除的方法

1. 倒叙删除

public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("aaa");
		list.add("aaa");
		list.add("aaa");
		
		// list删除
		for (int i = list.size()-1; i >=0 ; i--) {
			if ("aaa".equals(list.get(i))) {
				list.remove(i);
			}
		}
		System.out.println(list);
		
	}

2. 迭代器删除
3. lambaba删除

list判空

		List<String> list1 = new ArrayList<>();
		
		System.out.println(list1==null);

结果输出false

在pom.xml文件中加入hutool的配置

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.5.1</version>
</dependency>

可以使用CollectionUtil来判断集合是否为null

		List<String> list1 = new ArrayList<>();
		
		System.out.println(CollectionUtil.isEmpty(list1));

list线程不安全

public class MyThread implements Runnable{

	ArrayList<String> aaa;
	
	
	public MyThread(ArrayList<String> aaa) {
		// TODO Auto-generated constructor stub
		this.aaa = aaa;
	}


	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 100; i++) {
			aaa.add("aaa"+i);
			System.out.println(Thread.currentThread()+"在第"+i+"个"+aaa.get(i));
		}
		
	}

}

public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		MyThread m1 = new MyThread(list);
		MyThread m2 = new MyThread(list);
		
		new Thread(m1).start();
		new Thread(m2).start();
		
	}

Set

list 是有序可以重复的，Set是无序不可重复的

set（hashMap）是怎么判断两个对象相等的，底层实现用的都是用的hashMap
hashCode就是一个int的数

两个对象的hashCode相等，这两个数不一定相等，因为可能存在hash碰撞
两个对象的hashCode如果不相等，那么这两个对象一定不相等

hashMap判断两个key是否相等？

1. 先判断这两个对象的hashCode是否相等，如果相等，再去调用equals；如果不相等，就直接认为这两个对象不相等
   好处：equals需要比对太多元素，性能较差；hashCode直接比较，性能较高
2. 两个对象的equals相等，那么这两个对象一定相等
3. 为什么说重写equals必须要重写hashCode
   如果重写equals，不重写hashCode，两个比较的就不能对应起来了
   在hashMap里hashCode和equals是相互依赖的

hashMap线程安全

public class MyThread implements Runnable{
	HashMap<Integer, String> map;
	


	public MyThread(HashMap<Integer, String> map) {
		// TODO Auto-generated constructor stub
		this.map = map;
	}


	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 100; i++) {
			map.put(i, "map"+i);
			System.out.println(Thread.currentThread().getName()+"在第"+i+"个"+map.get(i));
		}
		
	}

}

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<>();
		MyThread m1 = new MyThread(map);
		MyThread m2 = new MyThread(map);
		
		new Thread(m1).start();
		new Thread(m2).start();
		
	}
	

map.keySet().size();获取hashMap所有的key的个数