01_01_java基础07_集合_泛型

1集合框架

1.1集合框架概述

1.1.1数组存储多个数据方面的特点：

• 一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。
• 另一方面，使用数组存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
• 数组在内存存储方面的特点：
  • 数组初始化以后，长度就确定了。
  • 数组中的添加的元素是依次紧密排列的，有序的，可以重复的。
  • 数组声明的类型，就决定了进行元素初始化时的类型。不是此类型的变量，就不能添加。
  • 可以存储基本数据类型值，也可以存储引用数据类型的变量
• 数组在存储数据方面的弊端：
  • 数组初始化以后，长度就不可变了，不便于扩展
  • 数组中提供的属性和方法少，不便于进行添加、删除、插入、获取元素个数等操作，且效率不高。
  • 数组存储数据的特点单一，只能存储有序的、可以重复的数据
• Java 集合框架中的类可以用于存储多个对象，还可用于保存具有映射关系的关联数组。

1.1.2集合框架体系（java.util包下）

Java 集合可分为 Collection 和 Map 两大体系：

• Collection接口：用于存储一个一个的数据，也称单列数据集合。
  • List子接口：用来存储有序的、可以重复的数据（主要用来替换数组，"动态"数组）
    • 实现类：ArrayList(主要实现类)、LinkedList、Vector
  • Set子接口：用来存储无序的、不可重复的数据（类似于高中讲的"集合"）
    • 实现类：HashSet(主要实现类)、LinkedHashSet、TreeSet
• Map接口：用于存储具有映射关系“key-value对”的集合，即一对一对的数据，也称双列数据集合。(类似于高中的函数、映射。(x1,y1),(x2,y2) —> y = f(x) )
  • HashMap(主要实现类)、LinkedHashMap、TreeMap、Hashtable、Properties

1.2collection接口及方法

1.2.1 添加

（1）add(E obj)：添加元素对象到当前集合中
（2）addAll(Collection other)：添加other集合中的所有元素对象到当前集合中，即this = this ∪ other

1.2.2 判断

（3）int size()：获取当前集合中实际存储的元素个数
（4）boolean isEmpty()：判断当前集合是否为空集合
（5）boolean contains(Object obj)：判断当前集合中是否存在一个与obj对象equals返回true的元素
（6）boolean containsAll(Collection coll)：判断coll集合中的元素是否在当前集合中都存在。即coll集合是否是当前集合的“子集”
（7）boolean equals(Object obj)：判断当前集合与obj是否相等

1.2.3 删除

（8）void clear()：清空集合元素
（9） boolean remove(Object obj) ：从当前集合中删除第一个找到的与obj对象equals返回true的元素。
（10）boolean removeAll(Collection coll)：从当前集合中删除所有与coll集合中相同的元素。即this = this - this ∩ coll
（11）boolean retainAll(Collection coll)：从当前集合中删除两个集合中不同的元素，使得当前集合仅保留与coll集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即this = this ∩ coll；

1.2.4 其它

（12）Object[] toArray()：返回包含当前集合中所有元素的数组
（13）hashCode()：获取集合对象的哈希值
（14）iterator()：返回迭代器对象，用于集合遍历

	@Test
	public void test6(){
		Integer[] arr = new Integer[]{1,2,3};
	    List list = Arrays.asList(arr);//asList(Object obj),传入的是一个对象，以数组内的个包装类传入
	    System.out.println(list.size());//3
	    System.out.println(list);
	    int[] arr1 = new int[]{1,2,3};
	    List list1 = Arrays.asList(arr1);/asList(Object obj),传入的是一个对象，以数组传入
	    System.out.println(list1.size());//1
	    System.out.println(list1);
	}

1.3Iterator(迭代器)接口

1.3.1 Iterator接口

• 在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同。
  • Collection接口与Map接口主要用于存储元素
  • Iterator，被称为迭代器接口，本身并不提供存储对象的能力，主要用于遍历Collection中的元素
• Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
  • public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
  • 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
• Iterator接口的常用方法如下：
  • public E next():返回迭代的下一个元素。
  • public boolean hasNext():如果仍有元素可以迭代，则返回 true。

    @Test
        public void test01(){
            Collection coll = new ArrayList();
            coll.add("小李广");
            coll.add("扫地僧");
            coll.add("石破天");
    
            Iterator iterator = coll.iterator();
            System.out.println(iterator.next());
            System.out.println(iterator.next());
            System.out.println(iterator.next());
            System.out.println(iterator.next()); //报NoSuchElementException异常
        }
    
        @Test
        public void test02(){
            Collection coll = new ArrayList();
            coll.add("小李广");
            coll.add("扫地僧");
            coll.add("石破天");
    
            Iterator iterator = coll.iterator();//获取迭代器对象
            while(iterator.hasNext()) {//判断是否还有元素可迭代
                System.out.println(iterator.next());//取出下一个元素
            }
        }
    

    

1.3.2 forEach

• 对于集合来讲，增强for循环的底层仍然使用迭代器

1.4Collection子接口1：List

1.4.1接口方法

List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。

• 插入元素
  • void add(int index, Object ele):在index位置插入ele元素
  • boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
• 获取元素
  • Object get(int index):获取指定index位置的元素
  • List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
• 获取元素索引
  • int indexOf(Object obj):返回obj在集合中首次出现的位置
  • int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
• 删除和替换元素
  • Object remove(int index):移除指定index位置的元素，并返回此元素
  • Object set(int index, Object ele):设置指定index位置的元素为ele

1.4.2实现类一：ArrayList

1.4.3实现类二：LinkedList（双链表）

1.4.4实现类三：Vector

• Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。

1.5Collection子接口2：Set

• java.util.Collection:存储一个一个的数据
  • 子接口：Set:存储无序的、不可重复的数据(高中学习的集合)
    • |---- HashSet：主要实现类；底层使用的是HashMap，即使用数组+单向链表+红黑树结构进行存储。（jdk8中）
      • |---- LinkedHashSet：是HashSet的子类；在现有的数组+单向链表+红黑树结构的基础上，又添加了一组双向链表，用于记录添加元素的先后顺序。即：我们可以按照添加元素的顺序 实现遍历。便于频繁的查询操作。
    • |---- TreeSet：底层使用红黑树存储。可以按照添加的元素的指定的属性的大小顺序进行遍历。

1.5.1Set接口概述

• 无序性：与添加的元素的位置有关
• HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法得到的哈希值相等，并且两个对象的 equals() 方法返回值为true。
• 对于存放在Set容器中的对象，对应的类一定要重写hashCode()和equals(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。
• HashSet集合中元素的无序性，在添加每一个元素到数组中时，具体的存储位置是由元素的hashCode()调用后返回的hash值决定的。导致在数组中每个元素不是依次紧密存放的，表现出一定的无序性。

1.5.2Set主要实现类：HashSet

1.5.3Set实现类之二：LinkedHashSet

1.5.4Set实现类之三：TreeSet

• 添加的元素只有是同一类型，才可以排序
• TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。
  • 自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。
    • 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
    • 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
  • 定制排序：如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。
    • 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
    • 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
• 对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 或compare(Object o1,Object o2)方法比较返回值。返回值为0，则认为两个对象相等。

1.6Map接口

1.6.1Map接口概述

• java.util.Map:存储一对一对的数据(key-value键值对，(x1,y1)、(x2,y2) --> y=f(x),类似于高中的函数)
  • |---- HashMap:主要实现类;线程不安全的，效率高;可以添加null的key和value值;底层使用数组+单向链表+红黑树结构存储（jdk8）
    • |---- LinkedHashMap:是HashMap的子类；在HashMap使用的数据结构的基础上，增加了一对双向链表，用于记录添加的元素的先后顺序，进而我们在遍历元素时，就可以按照添加的顺序显示。开发中，对于频繁的遍历操作，建议使用此类。
  • |---- TreeMap:底层使用红黑树存储;可以按照添加的key-value中的key元素的指定的属性的大小顺序进行遍历。需要考虑使用①自然排序 ②定制排序。
  • |---- Hashtable:古老实现类;线程安全的，效率低;不可以添加null的key或value值;底层使用数组+单向链表结构存储（jdk8）
    • |---- Properties:其key和value都是String类型。常用来处理属性文件。

1.6.2Map接口的常用方法

• 添加、修改操作：
  • Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
  • void putAll(Map m):将m中的所有key-value对存放到当前map中
• 删除操作：
  • Object remove(Object key)：移除指定key的key-value对，并返回value
  • void clear()：清空当前map中的所有数据
• 元素查询的操作：
  • Object get(Object key)：获取指定key对应的value
  • boolean containsKey(Object key)：是否包含指定的key
  • boolean containsValue(Object value)：是否包含指定的value
  • int size()：返回map中key-value对的个数
  • boolean isEmpty()：判断当前map是否为空
  • boolean equals(Object obj)：判断当前map和参数对象obj是否相等
• 元视图操作的方法：
  • Set keySet()：返回所有key构成的Set集合
  • Collection values()：返回所有value构成的Collection集合
  • Set entrySet()：返回所有key-value对构成的Set集合

1.6.3Map的主要实现类：HashMap

1.6.4 Map实现类之二：LinkedHashMap

1.6.5 Map实现类之三：TreeMap

• TreeMap存储 key-value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 key-value 对处于有序状态。
• TreeSet底层使用红黑树结构存储数据
• TreeMap 的 Key 的排序：
  • 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
  • 定制排序：创建 TreeMap 时，构造器传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口
• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

1.6.6 Map实现类之四：Hashtable

1.6.7 Map实现类之五：Properties

2泛型

2.1泛型概述

2.2比较器中使用泛型

2.3自定义泛型结构

2.3.1泛型基础说明

2.3.1自定义泛型类或泛型接口

2.3.1自定义泛型方法

• 泛型方法的格式：

  [访问权限]  <泛型>  返回值类型  方法名([泛型标识 参数名称])  [抛出的异常]{
      
  }
  

• 方法，也可以被泛型化，与其所在的类是否是泛型类没有关系。
• 泛型方法中的泛型参数在方法被调用时确定。
• 泛型方法可以根据需要，声明为static的。

1. 类SuperA是类A的父类，则G 与 G的关系：G 和 G是并列的两个类，没有任何子父类的关系。
   比如：ArrayList 、ArrayList没有关系

2. 类SuperA是类A的父类或接口，SuperA 与 A 的关系：SuperA 与A 有继承或实现的关系。
   即A 的实例可以赋值给SuperA 类型的引用（或变量）
   比如：List 与 ArrayList

   @Test
       public void test1(){
           //1.
           Object obj = null;
           String str = "AA";
   
           obj = str;  //基于继承性的多态的使用
   
           //2.
           Object[] arr = null;
           String[] arr1 = null;
   
           arr = arr1;//基于继承性的多态的使用
       }
   
       /*
       * 类SuperA是类A的父类，则G 与 G的关系：G 和 G是并列的两个类，没有任何子父类的关系。
       * */
       @Test
       public void test2(){
           ArrayList<Object> list1 = null;
           ArrayList<String> list2 = new ArrayList<>();
   
   //        list1 = list2;
           /*
           * 反证法：
           * 假设list1 = list2是可以的。
           * list2.add("AA");
           *
           * list1.add(123);
           *
           * String str = list2.get(1); //相当于取出的123赋值给了str，错误的。
           *
           * */
   
           method(list1);
   //        method(list2);//错误的
       }
   
       @Test
       public void test3(){
           Person<Object> per = null;
           Person<String> per1 = null;
   //        per = per1;
       }
   
       public void method(ArrayList<Object> list){
   
       }
   
       /*
       * 类SuperA是类A的父类或接口，SuperA 与 A的关系：SuperA 与A 有继承或实现的关系。
           即A的实例可以赋值给SuperA类型的引用（或变量）
       * */
       @Test
       public void test4(){
           List<String> list1 = null;
           ArrayList<String> list2 = new ArrayList<>();
   
           list1 = list2;
   
           list1.add("AA");
   
           method(list2);
       }
   
       public void method(List<String> list){
   
       }