JAVA黑马培训整理笔记13-14-15

day13【Collection、泛型】

1.集合概念

集合：集合是java中提供的一种容器，可以用来存储多个数据。

集合和数组既然都是容器，它们有啥区别呢？

• 数组的长度是固定的。集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map

• Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，
• 分别是java.util.List和java.util.Set。
• List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。
• List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，
• Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。

2.Collection 常用功能

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

• public boolean add(E e)： 把给定的对象添加到当前集合中 。
• public void clear() :清空集合中所有的元素。
• public boolean remove(E e): 把给定的对象在当前集合中删除。
• public boolean contains(E e): 判断当前集合中是否包含给定的对象。
• public boolean isEmpty(): 判断当前集合是否为空。
• public int size(): 返回集合中元素的个数。
• public Object[] toArray(): 把集合中的元素，存储到数组中。

import java.util.ArrayList;
import java.util.Collection;

public class Demo1Collection {
    public static void main(String[] args) {
		// 创建集合对象 
    	// 使用多态形式
    	Collection<String> coll = new ArrayList<String>();
    	// 使用方法
    	// 添加功能  boolean  add(String s)
    	coll.add("小李广");
    	coll.add("扫地僧");
    	coll.add("石破天");
    	System.out.println(coll);

    	// boolean contains(E e) 判断o是否在集合中存在
    	System.out.println("判断  扫地僧 是否在集合中"+coll.contains("扫地僧"));

    	//boolean remove(E e) 删除在集合中的o元素
    	System.out.println("删除石破天："+coll.remove("石破天"));
    	System.out.println("操作之后集合中元素:"+coll);
    	
    	// size() 集合中有几个元素
		System.out.println("集合中有"+coll.size()+"个元素");

		// Object[] toArray()转换成一个Object数组
    	Object[] objects = coll.toArray();
    	// 遍历数组
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}

		// void  clear() 清空集合
		coll.clear();
		System.out.println("集合中内容为："+coll);
		// boolean  isEmpty()  判断是否为空
		System.out.println(coll.isEmpty());  	
	}
}

3.Iterator接口

Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Iterator接口的常用方法如下：

• public E next():返回迭代的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回 true。

public class IteratorDemo {
  	public static void main(String[] args) {
        // 使用多态方式 创建对象
        Collection<String> coll = new ArrayList<String>();

        // 添加元素到集合
        coll.add("串串星人");
        coll.add("吐槽星人");
        coll.add("汪星人");
        //遍历
        //使用迭代器 遍历   每个集合对象都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的数据类型
        while(it.hasNext()){ //判断是否有迭代元素
            String s = it.next();//获取迭代出的元素
            System.out.println(s);
        }
  	}
}

4.迭代器的实现原理

当遍历集合时，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

5.增强for

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

for(元素的数据类型  变量 : Collection集合or数组){ 
  	//写操作代码
}

public class NBForDemo1 {
    public static void main(String[] args) {
		int[] arr = {3,5,6,87};
       	//使用增强for遍历数组
		for(int a : arr){//a代表数组中的每个元素
			System.out.println(a);
		}
	}
}

public class NBFor {
    public static void main(String[] args) {        
    	Collection<String> coll = new ArrayList<String>();
    	coll.add("小河神");
    	coll.add("老河神");
    	coll.add("神婆");
    	//使用增强for遍历
    	for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
    		System.out.println(s);
    	}
	}
}

tips: 新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。

6.泛型

泛型：可以在类或方法中预支地使用未知的类型。

泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

例如，

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

含有泛型的接口

定义格式：

修饰符 interface接口名<代表泛型的变量> {  }
例如，

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

7.泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。

但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用：

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型

8.通配符高级使用----受限泛型

在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式： 类型名称 <? extends 类 > 对象名称
• 意义： 只能接收该类型及其子类

泛型的下限：

• 格式： 类型名称 <? super 类 > 对象名称
• 意义： 只能接收该类型及其父类型

day14 【List、Set、数据结构、Collections】

1.栈

栈 ： stack , 又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其

他任何位置进行添加、查找、删除等操作。

特点 ：

       *先进后出

       *栈的入口、出口的都是栈的顶端位置。

压栈 ：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。

弹栈 ：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

2.队列

队列 ： queue , 简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，

而在表的另一端进行删除。

特点：

       *先进先出

       *队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。

3.数组

数组 : Array , 是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。

特点：

            查询快，增删慢

4.链表

链表 : linked list , 由一系列结点 node （链表中每一个元素称为结点）组成，结点可以在运行时 i 动态生成。

每 个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

链表结构有单向链表与双向链表

5.红黑树

二叉树 ： binary tree , 是每个结点不超过 2 的有序 树（ tree ） 。

每个结点上都最多只能有两个子结点。 二叉树是每个节点最多有两个子树的树结构。

顶上的叫根结点，两边被称作 “ 左子树 ” 和 “ 右子树 ” 。

红黑树的约束:

1. 节点可以是红色的或者黑色的

2. 根节点是黑色的

3. 叶子节点 ( 特指空节点 ) 是黑色的

4. 每个红色节点的子节点都是黑色的

5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

红黑树的特点 :

速度特别快 , 趋近平衡树 , 查找叶子元素最少和最多次数不多于二倍

6.List集合

List 接口特点：

1. 它是一个元素存取有序的集合。例如，存元素的顺序是 11 、 22 、 33 。那么集合中，元素的存储就是按照 11、 22 、 33 的顺序完成的）。

2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。

3. 集合中可以有重复的元素，通过元素的 equals 方法，来比较是否为重复的元素。

 

List 作为 Collection 集合的子接口，不但继承了 Collection 接口中的全部方法，而且还增加了一些根据元素索引来操

作集合的特有方法，如下：

public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。

public E get(int index) : 返回集合中指定位置的元素。

public E remove(int index) : 移除列表中指定位置的元素 , 返回的是被移除的元素。

public E set(int index, E element) : 用指定元素替换集合中指定位置的元素 , 返回值的更新前的元素。

7.List的子类

ArrayList 集合

java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为

查询数据、遍历数据，所以 ArrayList 是最常用的集合。

 

LinkedList 集合

java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。

8.Set接口

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方

法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。与 List 接口不

同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set 集合有多个子类，这里我们介绍其中的 java.util.HashSet 、 java.util.LinkedHashSet 这两个集合。

HashSet 集合介绍

java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的 ( 即存取顺序

不一致 ) 。 java.util.HashSet 底层的实现其实是一个 java.util.HashMap 支持

HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性

的方式依赖于： hashCode 与 equals 方法。

9.HashSet集合存储数据的结构（哈希表）

在 JDK1.8 之前，哈希表底层采用数组 + 链表实现，即使用链表处理冲突，同一 hash 值的链表都存储在一个链表里。

但是当位于一个桶中的元素较多，即 hash 值相等的元素较多时，通过 key 值依次查找的效率较低。而 JDK1.8 中，哈

希表存储采用数组 + 链表 + 红黑树实现，当链表长度超过阈值（ 8 ）时，将链表转换为红黑树，这样大大减少了查找

时间。

简单的来说，哈希表是由数组 + 链表 + 红黑树（ JDK1.8 增加了红黑树部分）实现的，

10.HashSet存储自定义类型元素

给 HashSet 中存放自定义类型元素时，需要重写对象中的 hashCode 和 equals 方法，建立自己的比较方式，才能保

证 HashSet 集合中的对象唯一

LinkedHashSet

我们知道 HashSet 保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在 HashSet 下面有一个子类 java.util.LinkedHashSet ，它是链表和哈希表组合的一个数据存储结构。

11.可变参数 

在 JDK1.5 之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格

式：

修饰符 返回值类型 方法名 ( 参数类型 ... 形参名 ){ }

==等价于

修饰符 返回值类型 方法名 ( 参数类型 [] 形参名 ){ }

12.Collections

java.utils.Collections 是集合工具类，用来对集合进行操作。

部分方法如下：

public static <T> boolean addAll(Collection<T> c, T... elements) : 往集合中添加一些元素。

public static void shuffle(List<?> list) 打乱顺序 : 打乱集合顺序。

public static <T> void sort(List<T> list) : 将集合中元素按照默认规则排序。

public static <T> void sort(List<T> list ， Comparator<? super T> ) : 将集合中元素按照指定规则排 序。

13.Comparator比较器

我们还是先研究这个方法

public static <T> void sort(List<T> list) : 将集合中元素按照默认规则排序。

不过这次存储的是字符串类型。

public class CollectionsDemo2 { 
    public static void main(String[] args) { 
        ArrayList<String> list = new ArrayList<String>(); 
        list.add("cba"); 
        list.add("aba"); 
        list.add("sba"); 
        list.add("nba"); //排序方法 
        Collections.sort(list); 
        System.out.println(list); 
    } 
}

结果： [aba, cba, nba, sba]

14.简述Comparable和Comparator两个接口的区别。

Comparable ：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法

被称为它的自然比较方法。只能在类中实现 compareTo() 一次，不能经常修改类的代码实现自己想要的排序。实现

此接口的对象列表（和数组）可以通过 Collections.sort （和 Arrays.sort ）进行自动排序，对象可以用作有序映射中

的键或有序集合中的元素，无需指定比较器。

 

Comparator 强行对某个对象进行整体排序。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或

Arrays.sort ），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set 或

有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

day15 【map】

1.

Collection 中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

Map 中的集合，元素是成对存在的 ( 理解为夫妻 ) 。每个元素由键与值两部分组成，通过键可以找对所对应的 值。

Collection 中的集合称为 单列 集合， Map 中的集合称为 双列 集合。

需要注意的是， Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

2.

HashMap ：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需 要重写键的 hashCode() 方法、 equals() 方法。

LinkedHashMap ： HashMap 下有个子类 LinkedHashMap ，存储数据采用的哈希表结构 + 链表结构。通过链 表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的 hashCode() 方法、 equals() 方法。

3.map的常用方法

public V put(K key, V value) : 把指定的键与指定的值添加到 Map 集合中。

public V remove(Object key) : 把指定的键 所对应的键值对元素 在 Map 集合中删除，返回被删除元素的 值。

public V get(Object key) 根据指定的键，在 Map 集合中获取对应的值。

public Set<K> keySet() : 获取 Map 集合中所有的键，存储到 Set 集合中。

public Set<Map.Entry<K,V>> entrySet() : 获取到 Map 集合中所有的键值对对象的集合 (Set 集合 ) 。

public class MapDemo { 
    public static void main(String[] args) { 
        //创建 map对象 HashMap<String, String> map = new HashMap<String, String>(); 
        //添加元素到集合 map.put("黄晓明", "杨颖"); 
        map.put("文章", "马伊琍"); map.put("邓超", "孙俪"); 
        System.out.println(map); 

        //String remove(String key) 
        System.out.println(map.remove("邓超"));      
        System.out.println(map); 

        // 想要查看 黄晓明的媳妇 是谁 
        System.out.println(map.get("黄晓明"));         
        System.out.println(map.get("邓超")); 
    } 
}

4.Map集合遍历键找值方式 

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

1. 获取 Map 中所有的键，由于键是唯一的，所以返回一个 Set 集合存储所有的键。方法提示 : keyset()

2. 遍历键的 Set 集合，得到每一个键。

3. 根据键，获取键所对应的值。方法提示 : get(K key)

5.LinkedHashMap

 

 

 

16