Java集合之Collection与之子类回顾

Posted 2020-10-10 Hugbugs

Java学习这么久，打算这几天回顾下java的基本知识点，首先是集合。

一、常用集合类关系图

Collection

　　|___List　　有序，可重复

　　　　|___ArrayList 　　底层数据结构是数组，增删慢，查询快；线程不安全，效率高

　　　　|___LinkedList　　底层数据结构是链表，增删快，查询慢；线程不安全，效率高

　　　　|___Vector　　 　　底层数据结构是数组，增删慢，查询快；线程安全，效率低

　　|___Set　　无序，不可重复

　　　　|___HashSet

　　　　|___TreeSet

Map

　　|___HashMap

　　|___TreeMap

二、集合两个问题（Why？Feature？）

1、Why？为什么使用集合？

 java是一种面向对象语言，为了方便对对象的操作，所以使用了集合。

2、Feature？集合有什么特点？即它和数组的不同点。

集合：①存储不同引用类型对象 ②长度可变

数组：①存储相同基本类型（包括数据类型和引用类型） ②长度不可变

三、Collection概述

 Collection的功能概述：
 1:添加功能

 boolean add(Object obj):添加一个元素
 boolean addAll(Collection c):添加一个集合的元素

 2:删除功能

 void clear():移除所有元素
 boolean remove(Object o):移除一个元素
 boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有) 注意：只要有一个元素被移除，就返回True

3:判断功能

 boolean contains(Object o)：判断集合中是否包含指定的元素
 boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有) 注意：要包含所有的元素，返回True
 boolean isEmpty()：判断集合是否为空

4:获取功能

 Iterator<E> iterator()(重点) 集合专用迭代器

 1 //创建集合
 2 
 3 Collection c= new ArrayList();
 4 
 5 //集合添加元素
 6 
 7 c.add("Hello");
 8 
 9 c.add("World");
10 
11 //使用迭代器
12 
13 Iterator it =c.iterator();
14 
15 While(it.hasNext ()){
16 
17 　　String s =(String) it.next()；
18 
19 　　System.out.println(s);
20 
21 }

 1 //迭代器源码
 2 public interface Inteator {
 3     boolean hasNext();
 4     Object next(); 
 5 }
 6 
 7 public interface Iterable {
 8     Iterator iterator();
 9 }
10 
11 public interface Collection extends Iterable {
12     Iterator iterator();
13 }
14 
15 public interface List extends Collection {
16     Iterator iterator();
17 }
18 
19 public class ArrayList implements List {
20     public Iterator iterator() {
21         return new Itr();
22     }
23     
24     private class Itr implements Iterator {
25         public boolean hasNext() {}
26         public Object next(){} 
27     }
28 }

5:长度功能

 int size():元素的个数

面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?

数组求长度用length属性

字符串求长度用length()方法

集合求长度用size()方法

6:交集功能

 boolean retainAll(Collection c)

两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?

假设有两个集合A，B。
A对B做交集，最终的结果保存在A中，B不变。
返回值表示的是A是否发生过改变。

7：把集合转换为数组

  Object[] toArray()

集合转换成数组例子

 1 //创建集合对象
 2 
 3 Collection c = new ArrayList();
 4 
 5 //添加元素
 6 
 7 c.add("Hello");
 8 
 9 c.add("World");
10 
11 //集合转换成数组
12 
13 Object[]  obj = c.toArray();
14 
15 //遍历集合
16 
17 for(int x =0;x<obj.length;x++){
18 
19 　　System.out.println(obj[x]);
20 
21 }

四、Collection下List特有功能

A:添加功能

void add(int index,Object element): 在指定位置添加元素

B:获取功能

Object get(int index):获取指定位置的元素

 1 //List的特有遍历---普通for 遍历
 2 //创建对象
 3 List list = new ArrayList();
 4 //添加元素
 5 list.add("Hello");
 6 list.add("World");
 7 //普通for遍历
 8 for(int x=0;x<list.size();x++){
 9      String s=(String)list.get(x);
10      System.out.println(s);
11 }

C:列表迭代器

ListIterator listIterator()：List集合特有的迭代器

D:删除功能

Object remove(int index)：根据索引删除元素,返回被删除的元素

E:修改功能

Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

五、引入泛型

泛型是将类型明确工作推迟到对象创建或者方法调用的时候。

泛型的格式：<数据类型>  注意：此处的数据类型只能是引用类型。int----Integer   

泛型的好处：

A.将运行期间的错误提前到编译期间

B.避免强制类型转换

 1 //创建集合对象加入泛型
 2 ArrayList<String> list = new ArrayList<String>()
 3 list.add("Hello");
 4 list.add("World");
 5 //使用迭代器
 6 Iterator<String> it = list.iterator();
 7 While(it.hasNext()){
 8 //使用泛型后不用进行类型强制转换
 9 　　String s = list.next();
10 　　System.out.println(s);
11 }

JDK7 新特性：泛型推断。

ArrayList<Student> array = new ArrayList<>();

将泛型定义到类上

public class ObjectTool<T> {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

将泛型定义到方法上

public class ObjectTool {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

将泛型定义到接口上

public interface Inter<T> {
    public abstract void show(T t);
}

高级通配符

<?>:任意类型，没有指定就是Object类型
<? extends E>:向下限定，E及其子类
<? super E>:向上限定，E及其父类

class  Animal{}
class Dog extends Animal{}
class Cat extends  Animal{}

Collection<?>  c = new ArrayList<Animal>();
Collection<?>  c =  new ArrayList<Dog>();
Collection<?>   c= new ArrayList<Cat>();

Collection<? extends Animal> c =new  ArrayList<Animal>();
Collection<? extends Animal> c =new ArrayList<Dog>();
Collection<? extends Animal> c = new ArrayList<Cat>();

Collection<? super Animal> c =new ArrayList<Animal>;
Collection<? super Animal> c = new ArrayList<Object>;

六、JDK 5 新特性

增强for遍历集合

格式：

for(数据类型  变量名：遍历的集合或数组名){

}

好处：简化了数组和集合的遍历方式。

缺点：需要遍历的集合或数组不能为空。

　　    解决方案：遍历之前做if判断。

ArrayList<String> list = null;
if(list!=null){
   for(String s :list){
        System.out.println(s);    
    }      
}

至此List有三种遍历方式

//创建集合对象
ArrayList<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
//第一种：迭代器遍历
Iterator<String> it =list.iterator();
While(it.hasNext()){
String s = list.next();
System.out.println(s);
}

//第二种:普通for遍历
for(int x=0;x<list.size();x++){
String s = list.get(x);
System.out.println(s);
}

//第三种：增强for遍历
for(String s :list){
System.out.println(s);
}

静态导入

import static 包名.类名.方法名
可以直接导入到方法

注意事项：①方法必须是静态的。②导入时有多个同名的静态方法，使用时必须要加前缀(包名.类名.方法名)

可变参数

如果一个方法的参数不固定，那么我们可以使用可变参数。

格式：

修饰符  返回值类型  方法名(数据类型...  变量名){  

}
//注意：这里的...不是省略号


例如：设计一个求和方法,传入的参数数量未知

public int sum(int...a){
    int sum =0;
    for(int i :a){
      sum+=i;
}      
   return sum;
}

注意：①这里的变量实际上是一个数组，所以可以使用增强for遍历。

　　　②如果一个方法除了可变参数还有别的参数，那么可变参数一定要放到参数的最后。

数组转集合　　　　　

 

public static <T> List<T> asList(T... a):把数组转成集合

List<String> list = Arrays.asList("hello","World","Java");

注意：虽然数组可以转成集合，但是这个集合的长度不可变，固定

七、List下ArrayList、Vector、LinkedList特有功能

//Vector特有功能

//添加功能
public void addElement(Object obj)     --------add()    

//获取功能
public Object elementAt(int index)     -------- get()    
public Enumeration elements()          --------Iterator iterator()
boolean hasMoreElements()              --------hasNext()
Object nextElement()                   --------next()

//LinkedList的特有功能：

//添加功能
public void addFirst(Object e)
public void addLast(Object e)

//获取功能
public Object getFirst()
public Obejct getLast()

//删除功能
public Object removeFirst()
public Object removeLast()

八、collection下set概述

set是一个元素无序且唯一的集合

HashSet：

HashSet为何存储元素是唯一的呢？

原因：HashSet底层依靠的是hashCode()和equals()方法。

先比较hashCode()，如果相同继续比较equals()，equals()返回true说明元素重复，返回false则添加进集合

HashSet 的add()源码：

interface Collection {
    ...
}

interface Set extends Collection {
    ...
}

class HashSet implements Set {
    private static final Object PRESENT = new Object();
    private transient HashMap<E,Object> map;
    
    public HashSet() {
        map = new HashMap<>();
    }
    
    public boolean add(E e) { //e=hello,world
        return map.put(e, PRESENT)==null;
    }
}

class HashMap implements Map {
    public V put(K key, V value) { //key=e=hello,world
    
    //看哈希表是否为空，如果空，就开辟空间
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        
        //判断对象是否为null
        if (key == null)
            return putForNullKey(value);

        //和对象的hashCode()方法相关
        int hash = hash(key); 
        
        //在哈希表中查找hash值
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            //这次的e其实是第一次的world
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
                //走这里其实是没有添加元素
            }
        }

        modCount++;
        addEntry(hash, key, value, i); //把元素添加
        return null;
    }
    
    transient int hashSeed = 0;
    
    final int hash(Object k) { //k=key=e=hello,
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode(); //这里调用的是对象的hashCode()方法

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
}


hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("world");

LinkedHashSet：

存储元素有序且唯一。

HashSet保证其存储元素唯一；Linked保证其存储元素有序（输入和输出元素有序）

TreeSet：

能够对元素按照某种规律进行排序；

A 自然排序，如果没有指定，则从小到大排序。

让元素所属的类实现自然排序接口 Comparable，重写接口中compareTo ()方法。

B 比较器排序。

让集合的构造方法接收一个比较器接口的子类对象 Comparator，此时可以使用匿名内部类方法实现排序。

//实现比较器排序的局部代码
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                // 姓名长度
                int num = s1.getName().length() - s2.getName().length();
                // 姓名内容
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
                        : num;
                // 年龄
                int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
                return num3;
            }
        });