java集合框架、面试

集合

集合的概念：是一种工具类，也是一个容器，可以用于存储数量 不等的多个对象。

数组与集合:数组与集合都是容器用来存放对象 数组长度固定 操作繁杂 集合提供很多功能 操作简单 提高开发效率

一.Collection集合

​ Collection是一个接口 它定义了集合需要哪些方法 定义集合的相关特性

​ 1.存储元素的特点:可以存储Object类型的元素

​ 2.常用方法:见API

​ 3.实现类:没有直接实现类 只有间接实现类

​ 4.集合元素的遍历:因为没有直接实现类 所以不讨论

​ ![2019-03-25_103857](timg.jpg

二.List集合

​ 1.存储元素的特点:

a)存储元素是有序的
b)存储元素是有下标的
c)存储的元素是可以重复的
d)存储Object类型的元素

​ 2.常用方法:

a) 增 
		add(元素);在末尾进行添加
		add(下标,元素); 在指定下标添加一个元素
		在通过下标插入时 一定要从0开始 否则会出现java.lang.IndexOutOfBoundsException 
b) 删
		remove(元素);从前往后找 出现的第一个该元素被删除  返回删除失败或成功
		remove(下标);删除指定下标的元素  返回被删除的该元素
c) 改 	
		set(下标,新元素);将指定下标的元素 替换为新元素 返回值被替换的元素
d) 查
		get(下标);通过某个下标来获取一个元素 返回值为该元素
		
		在指定某个下标时 如果没有该下标 都会出现java.lang.IndexOutOfBoundsException 
e) 获取集合中的元素个数  
		size();集合的元素个数

​ 3.实现类:

a)ArrayList
	存储机制:由数组来实现
	特点:查询快 增删慢
	出现版本:JDK1.2   线程不安全 效率较高
b)Vector
	存储机制:由数组来实现
	特点:查询快 增删慢
	出现版本:JDK1.0  线程安全 效率较低
c)LinkedList
	存储机制:链表
	特点:查询慢 增删快
	出现版本:JDK1.2   线程不安全 效率较高
	
	如果需要一个经常查询的List集合 则选择ArrayList
	如果需要一个经常增删的List集合 则选择LinkedList

​ 4.集合元素的遍历:

访问集合中每一个元素 被称为集合元素的遍历
1.通过for循环进行集合遍历 利用集合下标  必须掌握
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}

2.foreach JDK1.5之后推出的遍历方式 必须掌握  (通过迭代器遍历来实现)
    for(集合中元素数据类型 变量名:被遍历的集合对象){
        //通过该变量名访问每个集合元素
    }
   for(泛型类型 变量名:被遍历的集合对象){
        //通过该变量名访问每个集合元素
    }
	每次循环 都会取一个被遍历的集合中一个元素 并给该变量赋值  这个变量相当于一个特殊的局部变量
	for(Object obj:list){
		System.out.println(obj);
	}
foreach遍历时不可以进行集合元素的增删	
foreach还可以用来遍历数组

3.迭代器遍历 (了解)
	a)获取迭代器  通过 iterator();
	b)进行循环 循环条件为 迭代器对象.hasNext():判断当前这个元素是否是有效地
			  通过 迭代器对象.next();来移动迭代器的指向 从而获取当前元素的内容
			  
	while(iterator.hasNext()){
		System.out.println(iterator.next());
	}
迭代器遍历时可以通过remove方法进行元素的删除

int i = 0;
while(iterator.hasNext()){
    if(i==10){
        System.out.println("进入该条件");
        iterator.remove();
    }
    iterator.next();
    i++;
}

​ 5.集合的泛型

​ 统一集合中所存储的元素类型

a)语法:
	ArrayList<泛型> list = new ArrayList<泛型>();
	泛型填写了什么类型 那么这个集合就只能存放什么类型
	List<Student> java156 = new ArrayList<Student>();

集合的泛型 如果想使用基本数据类型 则必须使用对应的包装类

​ 6.泛型类 了解

a)语法:
	class 类名<泛型>{
    
	}
	泛型可以在本类型被使用 用来占位
	当创建对象时 所有使用泛型地方都被创建对象时填写的类型所覆盖
	数据类型进行了参数化
	class MyClass<T>{
        public T m1(T t){
            return t;
        }
	}
	MyClass<String> class1 = new MyClass<String>();
	在创建对象时 指定了T的类型 那对于class1这个对象的m1方法就变成了:
	    public String m1(String t){
            return t;
        }

​ 7.泛型接口 JDK1.5之后可用 拓展

a)语法:
	interface 接口名<泛型>{
    	
	}
	在定义该泛型接口的实现类时 可以指定泛型的数据类型
	那么该实现类中所有使用该泛型的地方都会被替换为指定的泛型数据类型
	interface MyInterfacer<T>{
		T m1(T t);
	}
	当给MyInterfacer的泛型指定为String类型时 该实现类中所有使用该泛型的位置都会变为String
class MyClass2 implements MyInterfacer<String>{
	@Override
	public String m1(String t) {
		// TODO Auto-generated method stub
		return null;
	}
}

​ 如果未规定泛型 则泛型都会被指定为Object

三.集合的工具类 Collections

​ Collections 是 java.util下的工具类 用来帮助我们对集合进行一定的操作

​ 工具类:用来帮助我们开发的一个类 里面的方法都实现了一种独立的功能 并且为了使用方便将所有方法定义为静态方法

​ 常见的三个方法:

1.Collections.reverse(集合对象); 将参数中的目标集合元素进行倒序

2.Collections.shuffle(集合对象); 将参数中的目标集合元素随机排列 

3.Collections.sort(集合对象); 将参数中的目标集合元素进行排序 排序规则依据与元素的compareTo(); 这就意味着该目标集合中元素是可排序的

四.Set集合

1.存储元素的特点: 存储Object类型 无序无下标 元素不可重复

2.常用方法:全部继承于Collection

增
add(E e); 给set集合增加一个元素 返回值为是否增加成功
删
remove(Object o);删除与参数相同的元素 返回值为是否删除成功
查
contains(Object o);验证该元素是否在set集合中存在

size();获取当前set集合中所存元素的个数

3.实现类:

a)HashSet
	因为HashSet的去重机制  所以一般我们存储自定义类型时 需要重写hashCode 也需要重写eqauls
	重写hashCode的原则:尽量保证内容相同元素 hasCode的返回值一致
	JDK 1.2 线程不安全 效率高
b)SortedSet接口下的 TreeSet  
	自动给所存元素进行排序(按照一定规则)
    TreeSet中所存入的元素必须是可被排序的  所以需要实现Comparable并且重写compareTo方法
    TreeSet是通过compareTo方法来进行去重的 当compareTo方法返回一个0时说明二者相同 则去重
    所以 TreeSet中所存储的元素 不用一定重写hashCode与eqauls 
    JDK 1.2 线程不安全 效率高
c)LinkedHashSet
	和HashSet一致  底层实现也一样  存储自定义类型时 需要重写hashCode 也需要重写eqauls
	LinkedHashSet遍历时 元素的顺序与存入顺序一致
	因为LinkedHashSet会通过一个链表 来记录输入顺序
	JDK 1.4 线程不安全 效率高

4.集合元素的遍历:

a)foreach
for(泛型类型 变量名:目标集合名){
	通过变量名来实际操作集合元素
}
for (String str : set) {
	System.out.println(str);
}
b)迭代器遍历(了解)
	1)获取迭代器
	Iterator<String> iterator = set.iterator();
    2)通过迭代器的 hasnext方法判断是否还有下一个  next来进行迭代
    while(iterator.hasNext()){
		System.out.println(iterator.next());
	}

五.map集合

​ 1.存储元素的特点:

​ Map集合中所存储的是key-value 键值对

​ key:Object类型 无序 无下标 唯一 很像Set

​ value:Object类型 无序无下标 可重复 很像Collection

​ 2.常用方法:

增 改
put(key,value)如果是添加则返回null 如果是修改替换则返回的是被替换的value
删
remove(key) 通过键来删除该键值对 返回被删除的值
查
get(key) 获取该键所对应的值  如果该键不存在则返回null

​ 3.实现类:

a)HashMap基础
	HashMap遍历时 键的顺序无序
	JDK1.2 线程不安全 效率高  键值对可以为null
	因为HashMap的去重机制  所以一般我们键存储自定义类型时 需要重写hashCode 也需要重写eqauls
	重写hashCode的原则:尽量保证内容相同元素 hasCode的返回值一致
	实际上HashSet就是没有值的 只有键的HashMap
b)Hashtable 
	Hashtable与HashMap的底层实现一致 只是没有进行键与值的非空处理
	JDK1.0 线程安全 效率低   键值对不可为null
c)Properties
	Hashtable的子类 键值对不可为null
	常用来做配置文件
	JDK1.0 线程安全 效率低  
d)LinkedHashMap
	HashMap的子类
    LinkedHashMap遍历时 键的顺序与输入顺序一致
   	LinkedHashMap与HashMap的底层实现一致 只是通过链表记录了键的插入顺序
	1.4 线程不安全 效率高  键值对可以为null
e)SortedMap接口下的TreeMap
	TreeMap会根据一定的规则 给键进行排序 键必须是可被排序的  所以键需要实现Comparable并且重写compareTo方法
	TreeMap是通过compareTo方法来进行去重的 当compareTo方法返回一个0时说明二者相同 则去重
    所以 TreeMap中所存储的键 不用一定重写hashCode与eqauls 

​ 4.集合元素的遍历:

a)键遍历(基础)
	1).获取所有Key  所有的key相当于一个set集合  
	Set<Integer> set = map.keySet();
	2).遍历该set集合 可以获取所有的键 并还可同时使用get方法获取value
	for (Integer integer : set) {
		System.out.println(integer+"-"+map.get(integer));
	}
b)值遍历
	1)获取所有值  所有值value相当于一个Collection集合
	Collection<String> values = map.values();
	2)遍历该Collection集合 可以获取所有的值 
	for (String string : values) {
		System.out.println(string);
	}
c)键值对遍历
	1)获取所有的键值对  所有key-value相当于一个Set集合
	Set<Entry<Integer,String>> entrySet = map.entrySet();
	2)遍历键值对对应的set集合 可以获取每一个键值对  并且键值对对象有三个常用方法 
												getKey():获取该键值对的键
                                                getValue():获取该键值对的值
                                                setValue(值):修改该键值对的值
    for (Entry<Integer, String> entry : entrySet) {
		if(entry.getKey()==1){
			entry.setValue("dzd");
		}
		System.out.println(entry.getKey()+"-"+entry.getValue());
	}