java --集合

总结：
1.HashSet与HashMap的区别？
HashSet只是实现了HashMap中的key。
2.HashSet去重原理？
当向HashSet中添加对象时，首先会调用对象的hashCode()方法，计算该对象的hash值，该值决定了该对象在HashSet中存储位置，若是该值没有被占用，则直接插入；若是被占用了，则经过equals()来比较这两个对象是否相同，若是相同，则后一个对象不能被添加进来。
3.HashSet与TreeSet的联系与区别？
3.1它们均可以去重，treeSet能够排序。
3.2向TreeSet中存放的元素必须是同一种类型。
3.3TreeSet中的元素从小到大排序
排序原理：向TreeSet中添加自定义类时，必需要重写compareTo方法，该方法决定使用什么规则来排序。
4.TreeMap与TreeSet同样
都须要重写hashCode方法与equals()方法，并且还须要实现compareTo方法。
5.Collection线程安全问题
只有hashTable与vector是线程安全的
若是须要线程安全，则须要加上synchronized转换
//线程安全
List<Integer> list2 = Collections.synchronizedList(list);

#1.java集合能够分为Collection和Map两大致系。
##1.collection接口
它有两个子接口
Set：元素无序、不可重复，无序指的是在内存中的位置是无序的
List：元素有序、能够重复
##2.Map接口
它是key-value的集合。
#2.Collection经常使用方法

public class TestCollection {
	@Test
	public void testCollection(){
		Collection<Object> collection = new ArrayList<>();
		//1.size():返回集合中元素的个数
		System.out.println(collection.size());
		//2.add(Object obj)：向集合中添加一个元素  
		collection.add(100);
		collection.add("panda");
		collection.add(new Date());
		//3.addAll(Collection coll)：将集合coll中全部的元素都添加到目前的集合中
		Collection<Object> collection2 = new ArrayList<>();
		collection2.addAll(collection);
		System.out.println(collection2);
		//4.isEmpty()：判断该集合是否为空  
		System.out.println(collection2.isEmpty());
		//5.clear()：清空集合元素
		collection2.clear();
		//6.contains(Object obj)：判断集合中是否包含指定的元素
		System.out.println(collection.contains(100));
		//7.containsAll(Collection coll)：判断当前集合是否包含coll中所有的元素
		Collection<Object> collection3 = new ArrayList<>();
		collection3.add("panda");
		System.out.println(collection.containsAll(collection3));
		//8.retainAll(Collection coll)：求当前集合与coll共有的元素，交集
		System.out.println(collection.retainAll(collection3));
		//9.remove(Object obj)：删除集合中obj元素，成功返回true
		System.out.println(collection.remove("zhangsan"));
		//10.removeAll(Collection coll)：求差集，成功返回true
		System.out.println(collection.removeAll(collection3));
		//11.equals(Object obj)：判断集合中的全部元素是否彻底相同
		System.out.println(collection.equals(collection3));
		//12.toArry()：将集合转换成数组
		Object[] obj = collection.toArray();
		System.out.println(obj);
		//13.iterator()：用来遍历集合
		Iterator<Object> iterator = collection.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

#3.List经常使用方法
list继承collection，所以，也继承了collection的全部方法。
##3.1.ArrayList

public class TestList {
	@Test
	public void testList(){
		
		List<Object> list = new ArrayList<>();
		list.add(111);
		list.add(222);
		list.add(333);
		//1.set(int index, E element)：修改index处的元素
		list.set(1, 444);
		System.out.println(list);
		//2.add(int index, E element):在index处插入一个元素
		list.add(1, 555);
		System.out.println(list);
		//3.indexOf(Object obj)：判断obj这个元素在list中首次出现的位置，若是不存在，返回-1.
		System.out.println(list.indexOf(666));
		//4.lastIndexOf(Object obj)：判断obj这个元素在list中最后一次出现的位置，若是不存在，返回-1.
		System.out.println(list.indexOf(777));
		//5.subList(int fromIndex, int toIndex)：截取list，包含fromIndex，不包含toIndex
		System.out.println(list.subList(1, 3));
	}
}

##3.2LinkedList
数组链表，适用于频繁的插入与删除。插入与删除操做只须要修改相应的指针便可。
#4.Set经常使用方法
##4.1HashSet

public class TestSet {
	@Test
	public void testSet(){
		HashSet<Object> set = new HashSet<>();
		set.add(null);
		set.add(123);
		set.add(new String("AA"));
		set.add(new String("AA"));
		//打印结果：[null, AA, 123]
		//能够看到"AA"去重了
		//String默认重写了hashCode和equals方法
		System.out.println(set);
		set.add(new Car("ford", 200000));
		set.add(new Car("ford", 200000));
		//打印结果：[null, AA, Car [brand=ford, price=200000], 123]
		//这里重写了Car的hashCode和equals方法
		//set中的元素存储原理--使用了hash算法
		//当向set中添加对象时，首先调用对象的hashCode()方法，计算该对象的hash值
		//该值决定了该对象在set中的存储位置。若此位置之间没有被占用，则直接存入。
		//若是被占用了，则经过equals()比较这两个对象是否相同
		//若是相同，则后一个对象不能在添加进来
		System.out.println(set);
	}
}

##4.2TreeSet

public void testSet(){
		/**
		 * TreeSet:
		 * 1.向TreeSet中添加的元素必须是同一个类型
		 * 2.TreeSet中的元素从小到大排序(去重了)
		 * 3.添加本身定义的类时，须要实现Comparable，且重写compareTo方法，重写该方法即规定按照什么规则排序
		 * 4.注意:自定义类的全部属性都必须参与比较，不然会出现数据丢失的状况
		 */
		Set<Object> set = new TreeSet<>();
		set.add(new Car("ford", 20000));
		set.add(new Car("bmw", 50000));
		set.add(new Car("audi", 40000));
		//我是按照价格排序
		System.out.println(set);
	}

@Override
	public int compareTo(Car o) {
		//注意：该类的全部属性都要参与比较
		//这样的话，能够实现多个属性排序
		int i = this.price.compareTo(o.price);
		if (i == 0) {
			return this.brand.compareTo(o.brand);
		}
		return i;
	}

#4.map
##4.1 hashMap

public class TestMap {
	@Test
	public void testMap(){
		Map<String, Object> map = new HashMap<>();
		map.put("123", "张三");
		map.put("456", "李四");
		map.put("345", "王五");
		//1.遍历key值
		Set<String> key = map.keySet();
		Iterator<String> it = key.iterator();
		String tmp = "";
		while (it.hasNext()) {
			tmp = (String) it.next();
			System.out.println(tmp);
		}
		//2.遍历value
		Collection<Object> coll = map.values();
		Iterator<Object> it2 = coll.iterator();
		String tmp2 = "";
		while (it2.hasNext()) {
			tmp2 = (String) it2.next();
			System.out.println(tmp2);
		}
		//3.遍历k-v对
		Set<Entry<String, Object>> set = map.entrySet();
		Iterator<Entry<String, Object>> it3 = set.iterator();
		String tmpKey = "";
		Object tmpValue = null;
		while (it3.hasNext()) {
			Entry<String, Object> en = it3.next();
			tmpKey = en.getKey();
			tmpValue = en.getValue();
			System.out.println("key:"+tmpKey+"---value:"+tmpValue);
		}
	}
}

##4.2TreeMap
同TreeSet同样排序，须要重写hashcode、equals方法，同时须要实现comparable的compareTo方法。
##4.3properties
1.在工程路径下新建db.properties文件
在配置文件输入信息

user = root
password = 123456

测试properties文件

public void testMap() throws FileNotFoundException, IOException{
		Properties prop  = new Properties();
		prop.load(new FileInputStream(new File("db.properties")));
		String user = prop.getProperty("user");
		//打印root
		System.out.println(user);
	}

#5.操做集合工具类Collections

public void testMap() {
		
		List<Integer> list = new ArrayList<>();
		list.add(12);
		list.add(45);
		list.add(35);
		list.add(28);
		System.out.println("天然顺序："+list);
		//反转list中的元素
		Collections.reverse(list);
		System.out.println("倒转："+list);
		//对list中的元素随机排序
		Collections.shuffle(list);
		System.out.println("随机排序："+list);
		//对list中的元素从小到大排序
		Collections.sort(list);
		System.out.println("由小到大排序："+list);
		//交换list中两个元素的位置
		Collections.swap(list, 1, 3);
		System.out.println("交换1和3位置："+list);
		//找list中元素的最大值
		System.out.println("最大值："+Collections.max(list));
	}

#6.Collection线程安全问题
线程安全概念：若是咱们某段代码在某个(或某些)进程中有多个线程运行，换句话说，存在一段代码，在进程中有多个线程会同时使用它，若是多个线程和单个线程运行的结果是同样的，则说明线程是安全的。
线程安全问题是由 全局变量 和 静态变量 引发的。若全部的线程对全局变量、静态变量只有读操做而没有写操做，则说这个全局变量、静态变量是线程安全的；不然当多个线程对全局变量、静态变量进行写操做时，须要考虑线程同步，不然会引发线程安全问题。
Collection接口中，只有hashtable与vector是线程安全的；其它的线程都不安全。
若是须要线程安全，则须要加上synchronized转换。

//线程安全
List<Integer> list2 = Collections.synchronizedList(list);

则list2是线程安全的。