总结:
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是线程安全的。