Java集合

最新推荐文章于 2022-04-21 19:23:50 发布

想成为大师啊

最新推荐文章于 2022-04-21 19:23:50 发布

阅读量293

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/xuexiwd/article/details/117363308

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

关于Java.util.Collection接口中常用的方法

Collection中能存放什么元素

没有使用“泛型”之前，Collection中可以存储Object的所有子类型
使用“泛型之后”，Collection中只能存储某个具体的类型
Collection中什么都能存，只要是Object的子类型就行。（集合中不能直接存储基本数据类型，也不能存java对象，只是存储Java对象的内存地址）

Collection中的常用方法

boolean add(Object e) （向集合中添加元素）
int size() 获取集合中元素的个数
void clear() 清空集合
boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false
boolean remove(Object o) 删除集合中的某个元素
boolean isEmpty() 判断该集合中元素的个数是否为0

public class Demo02 {
	public static void main(String[] args) {
		// 创建一个集合对象
		// Collection c = new Collection();// 接口是抽象的，无法实例化。
		//多态
		Collection c = new ArrayList();
		// 测试collection接口中的常用方法
		c.add(1200);// 自动装箱(java5的新特性)，实际上是放进去了一个对象的内存地址。Integer x = new Integer(1200);
		c.add(3.14);// 自动装箱
		c.add(new Object());
		c.add(new Student());
		c.add(true);// 自动装箱
		System.out.println("集合中元素个数是：" + c.size());// 5个
		
		c.clear();
		System.out.println("集合中元素个数是：" + c.size());// 0个
		
		c.add("hello");// "hello"对象的内存地址放到了集合当中
		c.add("world");// "world"对象的内存地址放到了集合当中
		c.add("浩克");
		c.add("绿巨人");
		c.add(1);

		boolean flag = c.contains("绿巨人");
		System.out.println(flag);// true
		boolean flag2 = c.contains("绿巨人2");
		System.out.println(flag);// false
		System.out.println(c.contains(1));// true

		c.remove(1);
		System.out.println(c.size());// 4

		System.out.println(c.isEmpty());// false
		c.clear();
		System.out.println(c.isEmpty());// true（true表示集合中没有元素了!）
	}
}

class Student{

}

迭代器

注意：以下的遍历方式/迭代方式，是所有collection通用的一种方式。

在Map集合中不能用，在所有的collection以及子类中使用。

在这里插入图片描述

public class Demo02 {
	public static void main(String[] args) {
		Collection c = new ArrayList();// 后面的集合无所谓，主要是看前面的collection接口，怎么遍历/迭代
		// 添加元素
		c.add("abc");
		c.add("def");
		c.add(100);
		c.add(new Object());
		// 对集合collection进行遍历/迭代
		// 第一步：获取集合对象的迭代器对象Iterator
		Iterator it = c.iterator();
		// 第二步：通过以上获取的迭代器对象开始迭代/遍历集合
		/*
		 以下两个方法是迭代器对象Iterator中的方法：
		 boolean hasNext()：如果仍有元素可以迭代，则返回true
		 object next()：返回迭代的下一个元素。
		 --------------------------------
		 void remove()：从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）。
		 */
//		boolean hasNext = it.hasNext();
//		if(hasNext) {
//			Object obj = it.next();
//			System.out.println(obj);
//		}
//		if(hasNext) {
//			Object obj = it.next();
//			System.out.println(obj);
//		}
//		if(hasNext) {
//			Object obj = it.next();
//			System.out.println(obj);
//		}
		while (it.hasNext()) {
			Object obj = it.next();
			System.out.println(obj);
		}
	}
}

迭代器是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址，迭代器修改了常规指针的接口。

迭代器对象有两个方法：

hasNext()
next()

在这里插入图片描述

一直取，不判断，会出现异常（java.util.NoSuchElementException）

while (true) {
	Object object = it.next();
	System.out.println(object);
}

public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();// ArrayList集合：有序可重复
		// 添加元素
		c.add(1);
		c.add(2);
		c.add(3);
		c.add(4);
		c.add(1);
		//迭代集合
		Iterator it = c.iterator();
		while (it.hasNext()) {
			Object obj = it.next();
			// 存进去是什么类型，取出来还是什么类型
//			if (obj instanceof Integer) {
//				System.out.println("Integer类型");
//			}
			// 只不过在输出的时候会转换成字符串。因为这里的println会调用tostring方法
			System.out.println(obj);
		}
		
		// HashSet集合：无序不可重复
		Collection l = new HashSet();
		// 无序：存进去和取出的顺序不一定相同。
		// 不可重复：存储100，不能再存储100
		l.add(1);
		l.add(1);
		l.add(2);
		l.add(4);
		Iterator it1 = l.iterator();
		while (it1.hasNext()) {
			Object obj = it1.next();
			System.out.println(obj);
		}
	}

深入collection集合的contains方法：

boolean contains(object o)：判断集合中是否包含某个对象o
如果包含返回true，反之返回false

contains方法是用来判断集合中的是否包含某个元素的方法，
那么它在底层通过调用equals方法进行比对
equals方法返回true，就表示包含这个元素

public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();
		String s1 = new String("abc");// s1 = 0x1111
		c.add(s1);// 放进去了一个"abc"
		String s2 = new String("def");// s2 = 0x2222
		c.add(s2);
		System.out.println("集合元素的个数："+c.size());
		String x = new String("abc");// s3 = 0x3333
		System.out.println(c.contains(x));// 判断集合中是否存在"abc"--> true
	}

在这里插入图片描述

没有重写equals方法之前：false

public class Demo02 {
	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();
		// 创建用户对象
		User u1 = new User("jack");
		c.add(u1);
		User u2 = new User("jack");
//		c.add(u2);	
		System.out.println(c.contains(u2));	// false
	}
}

class User{
	private String name;
	public User() {
		
	}
	public User(String name) {
		this.name = name;
	}
	
}

重写equals方法之后：true

public class Demo02 {
	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();
		// 创建用户对象
		User u1 = new User("jack");
		c.add(u1);
		User u2 = new User("jack");
//		c.add(u2);
		
//		System.out.println(c.contains(u2));	// false
		// 重写equals方法之后，比较的时候会比较name。
		System.out.println(c.contains(u2)); // true
		Integer x = new Integer(10000);
		c.add(x);
		Integer y = new Integer(10000);
		System.out.println(c.contains(y)); // true
		
		// Integer类的equals重写了
	}
}

class User{
	private String name;
	public User() {
		
	}
	public User(String name) {
		this.name = name;
	}
	
	// 重写equals方法
	// 将来调用equals方法的时候，一定是调用这个重写的equals方法。
	// 这个equals方法的比较原理：只要姓名一样就表示同一个用户。
	@Override
	public boolean equals(Object obj) {
		if(obj == null || !(obj instanceof User)) return false;
		if(obj == this) return true;
		User u = (User) obj;
		// 如果名字一样就表示同一个人。（不再比较内存地址，比较内容）
		return u.name.equals(this.name);
	}
	
}

放在集合里面的元素要重写equals方法；如果不重写则比较内存地址，重写则比较内容，object类的equals方法比较的是内存地址

remove底层也调用equals方法

public class Demo02 {
	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();
		// 创建字符串对象
		String s1 = new String("hello");
		c.add(s1);
		String s2 = new String("hello");
		c.remove(s2); // s1.equals(s2) Java认为s1和s2是一样的；删除s2就是删除s1。
		System.out.println(c.size()); // 0
		User u1 = new User("jack");
		User u2 = new User("jack");
		c.add(u1);
		c.remove(u2);
		System.out.println(c.contains(u2));
	}
}

class User{
	private String name;
	public User() {
		
	}
	public User(String name) {
		this.name = name;
	}
	
	// 重写equals方法
	// 将来调用equals方法的时候，一定是调用这个重写的equals方法。
	// 这个equals方法的比较原理：只要姓名一样就表示同一个用户。
	@Override
	public boolean equals(Object obj) {
		if(obj == null || !(obj instanceof User)) return false;
		if(obj == this) return true;
		User u = (User) obj;
		// 如果名字一样就表示同一个人。（不再比较内存地址，比较内容）
		return u.name.equals(this.name);
	}
	
}

集合元素的remove

当集合的结构发生改变时，迭代器必须重新获取，如果还是用以前老的迭代器，会出现异常：java.util.ConcurrentModificationException

在迭代集合元素的过程中，不能调用集合对象的remove方法，删除元素：

c.remove(o); // 迭代过程不能这样（直接通过集合去删除元素，没有通知迭代器。导致迭代器的快照和原集合状态不同）（集合元素删除了，但是没有更新迭代器，迭代器不知道集合变化了）
会出现：java.util.ConcurrentModificationException

使用迭代器来删除
it2.remove(); // 删除的一定是迭代器指向的当前的元素

获取的迭代器对象，迭代器用来遍历集合，此时相当于对当前集合的状态拍了一个快照

迭代器迭代的时候会参照这个快照进行迭代

迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。

public class Demo01 {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		
		// 此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器
		// 一定要注意：集合结构只要发生改变，迭代器必须重新获取
		// 当集合结构发生了改变，迭代器没有重新获取，调用next()时会出现java.util.ConcurrentModificationException异常
		// Iterator it = c.iterator();
				
		c.add(1);
		c.add(2);
		c.add(3);
		// 获取迭代器
		Iterator it = c.iterator();
		while (it.hasNext()) {
			// 编写代码时next()方法返回值类型必须是object
			Object obj = it.next();
			System.out.println(obj);
		}
		
		Collection c2 = new ArrayList();
		c2.add("abc");
		c2.add("def");
		c2.add("xyz");
		
		Iterator it2 = c2.iterator();
		while (it2.hasNext()) {
			Object object = it2.next();
			// 删除元素，集合结构发生了变化，应该重新去获取迭代器
			// 但是，循环下一次的时候并没有重新获取迭代器，所有会报异常：java.util.ConcurrentModificationException
//			c2.remove(object);
			// 使用迭代器来删除
			it2.remove(); // 删除的一定是迭代器指向的当前的元素
			System.out.println(object);
		}
		System.out.println(c2.isEmpty()); // true
	}
}

List中的常用方法

1.List集合存储元素特点：有序可重复

有序：List集合中的元素有下标。从0开始，以1递增。

可重复：存储一个1，还可以再存储1

2.List既然是Collection接口的子接口，那么肯定List接口有自己“特色”的方法：

void add(int index, Object element)
Object get(int index)
int indexof(Object o)
int lastIndexof(Object o)
Object remove(int index)
Object set(int index, Object element)

public class Demo01 {
	public static void main(String[] args) {
		// 创建List类型的集合
		List myList = new ArrayList();
//		List myList = new LinkedList();
//		List myList = new Vector();
		
		// 添加元素
		myList.add("A");	// 默认都是向集合末尾添加元素
		myList.add("B");
		myList.add("C");
		myList.add("C");
		myList.add("D");
		
		// 在列表的指定位置插入指定元素（第一个参数是下标，第二个参数是插入内容）
		// 这个方法使用不多，因为对于ArrayList集合来说效率比较低。
		myList.add(1, "king");
		
		// 迭代元素
		Iterator it = myList.iterator();
		while (it.hasNext()) {
			Object obj = it.next();
			System.out.println(obj);
		}
		// 根据下标获取元素
		Object firstobj = myList.get(0);
		System.out.println(firstobj);
		System.out.println("-------------------------");
		// 因为有下标，所以List集合有自己比较特殊的遍历方式
		// 通过下标遍历.[List集合特有的方式，Set没有]
		for(int i = 0;i<myList.size();i++) {
			System.out.println(myList.get(i));
		}
		
		// 获取指定对象第一次出现处的索引
		System.out.println(myList.indexOf("C")); // 3
		
		// 获取指定对象最后一次出现处的索引
		System.out.println(myList.lastIndexOf("C")); // 4
		
		// 删除指定下标位置的元素
		// 删除下标为0的元素
		myList.remove(0);
		System.out.println(myList.size()); // 5
		
		System.out.println("============================");
		
		// 修改指定位置的元素
		myList.set(2, "Soft");
		
		// 遍历集合
		for(int i=0;i<myList.size();i++) {
			System.out.println(myList.get(i));
		}
	}
}

计算机英语：
增删改查这几个单词要知道：
增：add，save，new
删：delete，drop，remove
改：update，set，modify
查：find，get，query，select

ArrayList集合

1.ArrayList集合初始化容量是10（底层先创建了一个长度为0的数组，当添加第一个元素的时候，初始化容量为10）

2.ArrayList集合底层是Object类型的数组Object[]

3.构造方法：new ArrayList(); 或者 new ArrayList(20);

4.ArrayList集合的扩容：增长到原容量的1.5倍；ArrayList集合底层是数组，优化：尽可能少的扩容，因为数组扩容效率比较低，建议在使用ArrayList集合的时候预估计元素的个数，给定一个初始化容量）

5.数组的优点：检索效率比较高。（每个元素占用空间大小相同，内存地址是连续的，知道首元素内存地址，然后知道下标，通过数学表达式计算出元素的内存地址，所以检索效率最高）

6.数组的缺点：随机增删元素效率比较低。另外数组无法存储大数据量。（很难找到一块非常巨大的连续的内存空间）

7.但是需要注意的是：向数组末尾添加元素，效率还是很高的。不受影响

8.面试常问的问题：这么多的集合中，你用哪个集合最多。答：ArryaList集合：因为往数组末尾添加元素，效率不受影响。另外，我们检索/查找某个元素的操作比较多。

9.ArrayList集合是非线程安全的。（不是线程安全的集合）

public class Demo01 {
	public static void main(String[] args) {
		
		// 默认初始化容量为10
		List list1 = new ArrayList();
		// 数组长度是10
		// 集合的size()方法是获取当前集合中元素的个数。不是获取集合的容量
		System.out.println(list1.size());	// 0
		
		// 指定初始化容量
		// 数组的长度是20
		List list2 = new ArrayList();
		// 集合的size()方法是获取当前集合中元素的个数。不是获取集合的容量。
		System.out.println(list2.size());	// 0
		
		list1.add(1);
		list1.add(2);
		list1.add(3);
		list1.add(4);
		list1.add(5);
		list1.add(6);
		list1.add(7);
		list1.add(8);
		list1.add(9);
		list1.add(10);
		
		System.out.println(list1.size());
		
		// 再加一个元素
		list1.add(11);
		
		// 100 二进制转换成10进制：00000100右移一位 00000010（2）	【4/2】
		// 原先是4，现在增长：2，增长后是6，增长之后的容量是之前容量的：1.5倍
	}
}

底层源码：oldCapacity >> 1（100 二进制转换为10进制：00000100右移一位 00000010（2）【4/2】。原先是4，现在增长：2，增长之后是6，增长之后的容量是之前的：1.5倍）

private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

位运算符

public class Demo01 {
	public static void main(String[] args) {
		// 5
		// >> 1 二进制右移1位
		// >> 2 二进制右移2位
		// 5的二进制位是：00000101	【5】
		// 5的二进制右移1位是：00000010	【2】
		System.out.println(5 >> 1); // 2（右移1位就是除以2）
		System.out.println(5 >> 2); // 1
		
		// 二进制左移1位
		// 10的二进制位是：00001010	【10】
		// 10的二进制左移1位：00010100	【20】
		System.out.println(10 << 1);	// 20
	}
}

集合ArrayList的构造方法

public class Demo01 {
	public static void main(String[] args) {
		// 默认初始化容量为10
		List myList1 = new ArrayList();
		
		// 指定初始化容量100
		List mylist2 = new ArrayList(100);
		
		// 创建一个HashSet集合
		Collection c = new HashSet();
		c.add(100);
		c.add(200);
		c.add(900);
		c.add(50);
		
		// 通过这个构造方法就可以将HashSet集合转换位List集合
		List mylist3 = new ArrayList(c);
		for (int i = 0; i < mylist3.size(); i++) {
			System.out.println(mylist3.get(i));
		}
	}
}

1.数组（顺序表）在表头插入元素（保持其余元素顺序不变），需要把其余元素向后移动一位

2.数组在表尾插入元素，则不需要移动任何元素

3.所以数组插入新元素在表尾效率相对于表头（其余任何位置）效率高

单向链表数据结构

对于链表数据结构来说：基础的单元是节点Node。

对于单向链表来说，任何一个节点Node中都有两个属性：

第一：存储的数据。

第二：下一节点的内存地址。

不需要占用连续的内存空间，但是由于多储存了地址，效率低

链表优点：随机增删元素效率较高。（因为增删元素不涉及到大量元素位移）

链表缺点：查询效率较低，每一次查找某个元素的时候都需要从头节点开始往下遍历。

在这里插入图片描述

链表类

package javase.danlink;

public class Link {

    // 头节点
    Node header = null;

    int size = 0;

    public int size(){
        return size;
    }

    // 向链表中添加元素的方法
    public void add(Object data){
        // 创建一个新的节点对象
        // 让之前单链表的末尾节点next指向新节点对象
        // 有可能这个元素是第一个，也可能是第二个，也可能是第三个。
        if (header == null){
            // 说明还没有节点。
            // new一个新的节点对象，作为头节点对象。
            // 这个时候的头节点既是一个头节点，又是一个末尾节点。
            header = new Node(data, null);
        }else{
            // 说明头不是空！
            // 头节点已经存在了
            // 找出当前末尾节点，让当前末尾节点的next是新节点。
            Node currentLastNode = findLast(header);
            currentLastNode.next = new Node(data, null);
        }
        size++;
    }

    // 专门查找末尾节点的方法（递归查找）
    private Node findLast(Node node) {
        if (node.next == null){
            // 如果一个节点的next是null
            // 说明这个节点就是末尾节点。
            return node;
        }
        // 程序能够到这里说明：node不是末尾节点。
        return findLast(node.next); // 递归算法
    }

    // 删除链表中某个数据的方法
    public void remove(Object obj){

    }

    // 修改链表中某个数据的方法
    public void modify(Object newObj){

    }

    // 查找链表中某个元素的方法
    public int find(Object obj){
        return 1;
    }
}

节点类

package javase.danlink;

public class Node {

    // 存储的数据
    Object data;

    // 下一个节点的内存地址
    Node next;

    public Node(){

    }

    public Node(Object data, Node next){
        this.data = data;
        this.next = next;
    }
}

测试类

package javase.danlink;

public class Test {
    public static void main(String[] args) {

        // 创建了一个集合对象
        Link link = new Link();

        // 往集合中添加元素
        link.add(100);
        link.add(200);
        link.add(300);
        link.add("abc");
        link.add("def");
        link.add("ghi");

        // 获取元素个数
        System.out.println(link.size);  // 6
    }
}

LinkedList集合底层也是有下标的。

注意：ArrayList之所以检索效率比较高，不是单纯因为下标的原因。是因为底层数组发挥的作用。

LinkedList集合照样有下标，但是检索/查找某个元素的时候效率比较低，因为只能从头节点开始一个一个遍历。

public class Test01 {
    public static void main(String[] args) {
        List list = new LinkedList();
        list.add("a");
        list.add("b");
        list.add("c");

        for (int i = 0; i < list.size(); i++){
            Object obj = list.get(i);
            System.out.println(obj);
        }
    }
}

链表的优点：

1、由于链表上的元素在空间存储上内存地址不连续，所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。

2、在以后的开发中，如果遇到随机增删集合中元素的业余比较多时，建议使用LinkedList

链表缺点：

1、不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率较低。

ArrayList：把检索发挥到极致。（末尾添加元素效率还是很高的。）

LinkedList：把随机增删发挥到极致。

加元素都是往末尾添加，所以ArrayList用的比LinkedList多

双向链表上基本的单元还是节点Node

在这里插入图片描述
添加第一个元素

添加第二个元素

在这里插入图片描述

	/**
     * Links e as first element.
     */
    private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

    /**
     * Links e as last element.
     */
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

LinkedList集合没有初始化

最初这个链表中没有任何元素。first和last引用都是null

不管是LinkedList还是ArrayList，以后写代码时不需要关心具体是哪个集合。

因为我们要面向接口编程，调用的方法都是接口中的方法。

public class Test01 {
    public static void main(String[] args) {
//        List list1 = new ArrayList(); // 这样写表示底层用了数组
        List list1 = new LinkedList();  // 这样写表示底层用来链表
        
		// 以下编程都是面向接口编程
        list1.add("123");
        list1.add("456");
        list1.add("789");
        for (int i = 0; i < list1.size(); i++){
            System.out.println(list1.get(i));
        }
    }
}

1、LinkedList集合是双向链表。

2、对于链表数据结构来说，随机增删效率较高。检索效率较低。

3、链表中的元素在空间存储上，内存地址不连续。

Vector

1、底层是个数组。

2、初始化容量：10

3、扩容之后是原容量的2倍。

4、Vector中所有的方法都是线程同步的，都带有synchronized关键字，是线程安全的。效率比较低，使用较少了。

5、使用集合工具类：java.util.Collections; 将一个线程不安全的ArrayList集合转换成线程安全的

java.util.Collection是集合接口
java.util.Collections是集合工具类

public class Test01 {
    public static void main(String[] args) {
        List vector = new Vector();
//        Vector vector = new Vector();
        vector.add(1);
        vector.add(2);
        vector.add(3);
        vector.add(4);
        vector.add(5);
        vector.add(6);
        vector.add(7);
        vector.add(8);
        vector.add(9);
        vector.add(10);
        vector.add(11);

        Iterator it = vector.iterator();

        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }

        // 这个可能以后要使用！！！
        List myList = new ArrayList();  // 非线程安全的。

        // 变成线程安全的
        Collections.synchronizedList(myList);   // 在这里没办法看效果，因为多线程没学，先记住

        // myList集合就是线程安全的了。
        myList.add("111");
        myList.add("222");
        myList.add("333");
    }
}

泛型

先不使用泛型

package javase.danlink;

import java.lang.reflect.Array;
import java.util.*;

public class Test01 {
    public static void main(String[] args) {

        // 不使用泛型机制，分析程序存在缺点
        List myList = new ArrayList();

        // 准备对象
        Cat c = new Cat();
        Bird b = new Bird();

        // 将对象添加到集合当中
        myList.add(c);
        myList.add(b);

        // 遍历集合，取出每个Animal，让它move
        Iterator it = myList.iterator();
        while(it.hasNext()){
            // 没有这个语法，通过迭代器取出的就是Object
            // Animal a = it.next();

            Object obj = it.next();
            // obj中没有move方法，无法调用，需要向下转型！
            if (obj instanceof Animal){
                Animal a = (Animal)obj;
                a.move();
            }
        }
    }
}

class Animal{

    // 父类自带方法
    public void move(){
        System.out.println("动物在移动！");
    }
}

class Cat extends Animal{
    // 特有方法
    public void catMouse(){
        System.out.println("猫抓老鼠");
    }
}

class Bird extends Animal{
    // 特有方法
    public void fly(){
        System.out.println("鸟儿在飞翔");
    }
}

使用泛型后

package javase.danlink;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {

        // 使用JDK5之后的泛型机制
        // 使用泛型List<Animal>之后，表示List集合中只允许存储Animal类型的数据。
        // 用泛型来指定集合中存储的数据类型。
        List<Animal> myList = new ArrayList<Animal>();

        // 指定List集合中只能存储Animal，那么存储String就编译报错了。
        // 这样用了泛型之后，集合中元素的数据类型更加统一了。
        // myList.add("abc");

        Cat c = new Cat();
        Bird b = new Bird();

        myList.add(c);
        myList.add(b);

        // 获取迭代器
        // 这个表示迭代器迭代的是Animal类型。
        Iterator<Animal> it = myList.iterator();

        while (it.hasNext()) {
            // 使用泛型之后，每一次迭代返回的数据都是Animal类型。
            Animal a = it.next();
            // 这里不需要进行强制类型转换，直接调用
            a.move();
        }
    }
}

class Animal{

    // 父类自带方法
    public void move(){
        System.out.println("动物在移动！");
    }
}

class Cat extends Animal{
    // 特有方法
    public void catMouse(){
        System.out.println("猫抓老鼠");
    }
}

class Bird extends Animal{
    // 特有方法
    public void fly(){
        System.out.println("鸟儿在飞翔");
    }
}

1、JDK5.0之后推出的新特性：泛型

2、泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的。（运行阶段泛型没用！）

3、使用泛型好处是：
第一：集合中存储的元素类型统一了。
第二：从集合中取出的元素类型是泛型指定的类型，不需要进行大量的“向下转型”！

4、泛型的缺点是：
导致集合中存储的元素缺乏多样性！
大多数业务中，集合中元素的类型还是统一的。所以这种泛型特性被大家所认可。

5、调用父类的方法不需要向下转换，调用子类方法需要向下转换。

调用子类方法

package javase.danlink;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {

        // 使用JDK5之后的泛型机制
        // 使用泛型List<Animal>之后，表示List集合中只允许存储Animal类型的数据。
        // 用泛型来指定集合中存储的数据类型。
        List<Animal> myList = new ArrayList<Animal>();

        // 指定List集合中只能存储Animal，那么存储String就编译报错了。
        // 这样用了泛型之后，集合中元素的数据类型更加统一了。
        // myList.add("abc");

        Cat c = new Cat();
        Bird b = new Bird();

        myList.add(c);
        myList.add(b);

        // 获取迭代器
        // 这个表示迭代器迭代的是Animal类型。
        Iterator<Animal> it = myList.iterator();

        while (it.hasNext()) {
//            // 使用泛型之后，每一次迭代返回的数据都是Animal类型。
//            Animal a = it.next();
//            // 这里不需要进行强制类型转换，直接调用
//            a.move();

            Animal a = it.next();
            if (a instanceof Cat){
                Cat x = (Cat)a;
                x.catMouse();
            }
            if (a instanceof Bird){
                Bird y = (Bird)a;
                y.fly();
            }
        }
    }
}

class Animal{

    // 父类自带方法
    public void move(){
        System.out.println("动物在移动！");
    }
}

class Cat extends Animal{
    // 特有方法
    public void catMouse(){
        System.out.println("猫抓老鼠");
    }
}

class Bird extends Animal{
    // 特有方法
    public void fly(){
        System.out.println("鸟儿在飞翔");
    }
}

JDK之后引入了：自动类型推断机制。（又称为钻石表达式）

public class Test01 {
    public static void main(String[] args) {
		// ArrayList<这里的类型会自动推断>()，前提是JDK8之后才允许
		// 自动类型推断，钻石表达式！
		List<Animal> myList = new ArrayList<>();
		
		myList.add(new Animal());
		myList.add(new Cat());
		myList.add(new Bird());

		// 遍历
		Iterator<Animal> it = myList.iterator();
		while(it.hasNext()){
			Animal a = it.next();
			a.move();
		}
    }
}

class Animal{

    // 父类自带方法
    public void move(){
        System.out.println("动物在移动！");
    }
}

class Cat extends Animal{
    // 特有方法
    public void catMouse(){
        System.out.println("猫抓老鼠");
    }
}

class Bird extends Animal{
    // 特有方法
    public void fly(){
        System.out.println("鸟儿在飞翔");
    }
}

package javase.danlink;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();

        // 类型不匹配
        // strList.add(new Cat());
        // strList.add("abc");
        strList.add("http://www.126.com");
        strList.add("http://www.baidu.com");
        strList.add("http://www.bjpowernode.com");

        // 类型不匹配
        // strList.add(123);

        // System.out.println(strList.size());

        Iterator<String> it1 = strList.iterator();
        while(it1.hasNext()){
            // 如果没有使用泛型
            /*
                Object obj = it1.next();
                if(obj instanceof String){
                    String ss = (String)obj;
                    ss.substring(7);
                }
             */
            // 直接通过迭代器获取String类型数据
            String s = it1.next();
            // 直接调用String类的substring方法截取字符串。
            String newStr = s.substring(7); // 截取字符串
            System.out.println(newStr);
        }
    }
}

class Animal{

    // 父类自带方法
    public void move(){
        System.out.println("动物在移动！");
    }
}

class Cat extends Animal{
    // 特有方法
    public void catMouse(){
        System.out.println("猫抓老鼠");
    }
}

class Bird extends Animal{
    // 特有方法
    public void fly(){
        System.out.println("鸟儿在飞翔");
    }
}

自定义泛型

自定义泛型的时候，<> 尖括号中的是一个标识符，随便写。

Java源代码中经常出现的是：E（是Element单词首字母）和 T（Type单词首字母）

泛型指定一个特定的类

public class GenericTest03<标识符随便写> {
	
	public void doSome(标识符随便写 o){
		System.out.prinitln(o);
	}

	public static void main(String[], args){
		
		// new对象的时候指定了泛型是：String类型
		GenericTest03<String> gt = new GenericTest03<>();

		// 类型不匹配
		// gt.doSome(100);

		gt.doSome("abc");

		// ===================================

		GenericTest03<Integer> gt2 = new  GenericTest03<>();
		gt2.doSome(100);
		
		// 类型不匹配
		// gt2.doSome("abc");

		MyIterator<String> mi = new MyIerator<>();
		String s1 = mi.get();

		MyIterator<Animal> mi2 = new MyIterator<>();
		Animal a = mi2.get();
		
		// 不用泛型就是Object类型
		// GenericTest03 gt3 = new GenericTest03();
		// gt3.doSome(new Object());
	}
}

class MyIterator<T> {
	public T get(){
		return null;
	}
}

JDK5.0之后推出了一个新特性：叫做增强for循环，或者叫做foreach

普通for循环

public class Test02 {
    public static void main(String[] args) {

        // int 类型数组
        int[] arr = {1, 2, 3, 4, 5};

        // 遍历数组（普通for循环）
        for (int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

增强for（foreach）

for(元素类型 变量名 : 数组或集合){
	System.out.println(变量名);
}

public class Test02 {
    public static void main(String[] args) {

        // int 类型数组
        int[] arr = {1, 2, 3, 4, 5};

        // 增强for（foreach）
        for (int i : arr){
            System.out.println(i);
        }
    }
}

foreach：没有下标，在需要使用下标的循环中，不建议使用

集合foreach

public class Test02 {
    public static void main(String[] args) {

        // 创建List集合
        List<String> strlist = new ArrayList<>();

        // 添加元素
        strlist.add("a");
        strlist.add("b");
        strlist.add("c");

		// 因为泛型使用的是String类型，所以是:string s
        for (String i : strlist){
            System.out.println(i);
        }
    }
}

集合不适用foreach

public class Test02 {
    public static void main(String[] args) {

        // 创建List集合
        List<String> strlist = new ArrayList<>();

        // 添加元素
        strlist.add("a");
        strlist.add("b");
        strlist.add("c");

		// 迭代器
        Iterator<String> it = strlist.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

		// 普通for循环
        System.out.println("=========================");
        for (int i=0;i<strlist.size();i++){
            System.out.println(strlist.get(i));
        }
    }
}

HashSet集合

1、存储时顺序和取出顺序不一样。

2、不可重复。

3、放到HashSet集合中的元素实际上是放到HashMap集合的key部分了。

public class Test02 {
    public static void main(String[] args) {

        Set<String> strSet = new HashSet<>();
        strSet.add("hello2");
        strSet.add("hello4");
        strSet.add("hello1");
        strSet.add("hello3");
        strSet.add("hello4");

        for (String s: strSet){
            System.out.println(s);
        }

        System.out.println("=============================");

        Iterator<String> it = strSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

TreeSet集合

TreeSet集合存储元素的特点：

1、无序不可重复，但是存储的元素可以自动按照大小顺序排序！
称为：可排序集合。

2、无序：这里的无序指的是存进去的顺序和取出来的顺序不同。并且没有下标。

public class Test02 {
    public static void main(String[] args) {
        // 创建集合对象
        Set<String> strs = new HashSet<>();
        // 添加元素
        strs.add("A");
        strs.add("B");
        strs.add("Z");
        strs.add("Y");
        strs.add("Z");
        strs.add("K");
        strs.add("M");

        // 遍历
        for (String s: strs){
            System.out.println(s);
        }
    }
}

Map

java.util.Map接口中常用方法：

1、Map和Collection没有继承关系。

2、Map集合以key和value的方式存储数据：键值对

key和value都是引用数据类型。

key和value都是存储对象的内存地址。

key起到主导的地位，value是key的一个附属品。

3、Map接口中的常用方法：
V put(K key, V value) 向Map集合中添加键值对

V get(Object key) 通过key获取value

void clear() 清空Map集合

boolean containsKey(Object key) 判断Map中是否包含某个key

boolean containsValue(Object value) 判断Map中是否包含某个value

boolean isEmpty() 判断Map集合中元素个数是否为0

Set<K,> keySet() 获取Map集合所有的key（所有的键是一个Set集合）

V remove(Object key) 通过key删除键值对

int size() 获取Map集合中的键值对的个数。

Collection<V.> values() 获取Map集合中所有的value，返回一个Collection

Set<Map.Entry<K,V>> entrySet() 将Map集合转换成Set集合

在这里插入图片描述
假设现在有一个Map集合，如下所示：

map1集合对象

key	value
1	zhangsan
2	lisi
3	wangwu
4	zhaoliu

Set set = map1.entrySet();

set集合对象

1=zhangsan 【注意：Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是 Map.Entry<K,V>】, Map.Entry<K,V>是一个静态内部类

2=lisi 【Map.Entry和String一样，都是一种类型的名字，只不过：Map.Entry是静态内部类，是Map中的静态内部类】

3=wangwu

4=zhaoliu

public class Test02 {

    // 声明一个静态内部类
    private static class InnerClass {

        // 静态方法
        public static void m1() {
            System.out.println("静态内部类的m1方法执行");
        }

        // 实例方法
        public void m2() {
            System.out.println("静态内部类中的实例方法执行！");
        }
    }
    public static void main(String[] args) {

        // 类名叫做：Test02.InnerClass
        Test02.InnerClass.m1();

        // 创建静态内部类对象
        Test02.InnerClass t = new Test02.InnerClass();
        t.m2();

        // 给一个Set集合
        // 该Set集合中存储的对象是：Test02.InnerClass类型
        Set<Test02.InnerClass> set = new HashSet<>();

        // 这个Set集合中存储的是字符串对象
        Set<String> set2 = new HashSet<>();

        Set<MyMap.MyEntry<Integer,String>> set3 = new HashSet<>();
    }
}

class MyMap {
    public static class MyEntry<K,V> {

    }
}

public class Test02 {
    public static void main(String[] args) {
    	// 创建Map集合对象
    	Map<Integer, String> map = new HashMap();
    	// 向Map集合中添加键值对
    	map.put(1, "zhangsan");	// 1在这里进行了自动装箱
    	map.put(2, "lisi");
    	map.put(3, "wangwu");
    	map.put(4, "zhaoliu");
    	//  通过key获取value
    	String value = map.get(2);
    	// 获取键值对的数量
    	System.out.println(map.size());
    	// 通过key删除key-value
    	map.remove(2);
    	System.out.println(map.size());
    	// 判断是否包含某个key
    	// contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法
    	System.out.println(map.containsKey(4)); // true
    	System.out.println(map.containsKey(new Integer(4))); // true
    	// 判断是否包含某个value
    	System.out.println(map.containsValue("wangwu")); // true
    	System.out.println(map.containsValue(new String("wangwu"))); // true

		// 获取所有的value
		Collection<String> values = map.values();
		for(String s: Values){
			System.out.println(s);
		}

    	map.clear();
    	System.out.println(map.size()); // 0
    	System.out.println(map.isEmpty()); // true 
    }
}

Map集合的遍历

public class Test02 {
    public static void main(String[] args) {
    	// 第一种方式：获取所有的key，通过遍历key，来遍历value
    	Map<Integer, String> map = new HashMap<>();
    	map.put(1, "zhangsan");	
    	map.put(2, "lisi");	
    	map.put(3, "wangwu");	
    	map.put(4, "zhaoliu");
    	// 遍历Map集合
    	// 获取所有的key，所有的key是一个Set集合
    	Set<Integer> keys = map.keySet();
    	// 遍历key，通过key获取value
    	// 迭代器可以
    	Iterator<Integer> it = keys.iterator();
    	while(it.hasNext()){
			// 取出其中一个key
			Integer key = it.next();
			// 通过key获取value
			String value = map.get(key);
			System.out.println(key+"="+value);
		}

		// foreach也可以
		for(Integer key:keys){
			System.out.println(key+"="+map.get(key));
		}

		// 第二种方式：Set<Map.Entry<K, V>> entrySet()
		// 以上这个方法是把Map集合直接全部转换成Set集合。
		// Set集合中元素的类型是：Map.Entry
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		// 遍历Set集合，每一次取出一次Node
		// 迭代器
		Iterator<Map.Entry<Integer, String>> it2 = set.iterator();
		while(it2.hasNext()){
			Map.Entry<Integer, String> node = it2.next();
			Integer key = node.getKey();
			String value = node.getValue();
			System.out.println(key + "=" + value);
		}

		// foreach
		// 这种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。
		// 这种方式比较适合于大数据量。
		for(Map.Entry<Integer, String> node : set){
			System.out.println(node.getKey() + "--->" + node.getValue());
		}
    }
}

HashMap集合

HashMap集合底层是哈希表数据结构，是非线程安全的。在JDK8之后，如果哈希表单向链表中元素超过8个，单向链表这种数据结构会变成红黑数据结构。当红黑树上的节点数量小于6时，会重新把红黑树变成单向链表数据结构。这种方式也是为了提高检索效率，二叉树的检索会再次缩小扫描范围。提高效率。

1、HashMap集合底层是哈希表/散列表的数据结构。

2、哈希表是一个数组和单向链表的结合体；
数组：在查询方面效率很高，随机增删方面效率很低；
单向链表：在随机增删方面效率很高，在查询方面效率很低；
哈希表：将以上的两种数据结构融合在一起，充分发挥它们各自的优点。
在这里插入图片描述

3、HashMap集合底层的源代码：

public class HashMap{
	
	// HashMap底层实际上就是一个数组。（一维数组）
	Node<K,V>[] table;

	// 静态的内部类HashMap.Node
	static class Node<K,V>{
		final int hash;	// 哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成下标。）
		final K key;	// 存储到Map集合中的那个key
		V value;	// 存储到Map集合中的那个value
		Node<K,V> next;	// 下一个节点的内存地址
	}
}

哈希表/散列表：一维数组，这个数组中每一个元素是一个单向链表。（数组和链表的结合体）

4、最主要掌握的是：

map.put(k, v)

v = map.get(k)

以上这两个方法的实现原理，是必须掌握的

5、HashMap集合的key部分特点：

无序，不可重复

无序：因为不一定挂到哪个单向链表上

不可重复：equals方法来保证HashMap集合的key不可重复。（如果key重复了，value会被覆盖）

放在HashMap集合key部分的元素其实就是放到HashSet集合中了
所以HashSet集合中的元素也需要同时重写hashCode()和equals()方法

6、哈希表HashMap使用不当时无法发挥性能！

假设将所有的hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了纯单向链表。这种情况称为：散列分布不均匀。

散列分布均匀：
	假设有100个元素，10个单项链表，那么每个单向链表上有10个节点，这是最好的，是散列分布均匀的。

假设将所有的hashCode()方法返回值都设定为不一样的值，可以吗？
	不行，因为这样的话导致底层哈希表就成为一维数组，没有链表的概念了。也是散列分布不均匀。

散列分布均匀需要你重写hashCode()方法时有一定的技巧。

7、重点：放在HashMap集合key部分的元素，以及放在HashSet集合中的元素，需要同时重写hashCode和equals方法。

8、HashMap集合的默认初始化容量是16，默认加载因子是0.75
这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组开始扩容。
重点，记住：HashMap集合初始化容量必须是2的倍数，这也是官方推荐的，这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。

在这里插入图片描述
注意：同一个单向链表上所有节点的hash相同，因为他们的数组下标是一样的。

但同一个链表上的k和k的equals方法肯定返回的是false，都不相等

map.put(k, v)实现原理：

第一步：先将k，v封装到Node对象当中。

第二步：底层会调用k的hashCode()方法得出hash值，然后通过哈希函数/哈希算法，将hash值转换成数组的下标，下标位置上如果没有任何元素，就把Node添加到这个位置上了。如果说下标对应的位置上有链表，此时会拿着k和链表上每一个节点中的k进行equals，如果所有的equals方法返回都是false，那么这个新节点将会被添加到链表的末尾。如果其中有一个equals返回了true，那么这个节点的value将会被覆盖。

v = map.get(k)实现原理：

先调用k的hashCode()方法得出哈希值，通过哈希算法转换成数组下标，通过数组下标快速定位到某个位置上，如果这个位置上什么都没有，返回null。如果这个，那么会拿着参数k和单项链表上的每个节点中的k进行equals，如果所有equals方法返回false，那么get方法返回null，只要其中有一个节点的k和参数k equals的时候返回true，那么此时这个节点value就是我们要找的value，get()方法最终返回这个要找的value。

哈希表的随机增删，以及查询效率高的原因是：

增删是在链表上完成的

查询也不需要都扫描，只需要部分扫描

重点：通过讲解可以得出HashMap集合的key，会先后调用两个方法，一个方法是hashCode()，一个方法是equals()，那么这两个方法都需要重写。

HashMap集合key部分的元素需要重写equals方法：equals方法比较的是内存地址，而我们需要比较内容

public class HashMapTest01{
	public static void main(String[] args){
		// 测试HashMap集合key部分的元素特点
		// Integer是key，它的hashCode和equals都重写了。
		map.put(1111, "zhangsan");
		map.put(6666, "lisi");
		map.put(7777, "wangwu");
		map.put(2222, "zhaoliu");
		map.put(2222, "king");

		System.out.println(map.size());		// 4

		// 遍历Map集合
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		for(Map.Entry<Integer, String> entry : set){
			// 验证结果：HashMap集合key部分元素：无序不可重复。
			System.out.println(entry.getKey() + "=" + entry.getValue());
		}
	}
}

Student

public class Student{
	private String name;

	public Student(){}

	public Student(String name){
		this.name = name;
	}

	public String getName(){
		return name;
	}
	
	public void setName(String name){
		this.name = name;
	}

	// hashCode

	// equals(如果学生名字一样，表示同一个学生)
	/*public boolean equals(Object obj){
		if(obj == null || !(obj instanceof Student)) return false;
		if(obj == this) return true;
		Student s = (Student)obj;
		return this.name.equals(s.name); 
	}*/

	@Override
	public boolean equals(Object o){
		if(this == o) return true;
		if(o == null || getClass() != o.getClass())	return false;
		Student student = (Student) o;
		return Object.equals(name, student.name);
	}

	@Override
	public int hashCode(){
		return Object.hash(name);
	}
}

HashMapTest02

public class HashMapTest02{
	public static void main(String[] args){
		Student s1 = new Student("zhangsan");
		Student s2 = new Student("zhangsan");
		
		// 重写equals方法之前是false
		// System.out.println(s1.equals(s2));	// false

		// 重写equals方法之后是true
		System.out.println(s1.equals(s2));	// true（s1和s2表示相等）

		// 重写hashCode之前
		System.out.println("s1的hashCode=" + s1.hashCode());	// 284720968
		System.out.println("s2的hashCode=" + s2.hashCode());	// 122883338

		// s1.equals(s2)结果已经是true了，表示s1和s2是一样的，相同的，那么往HashSet集合中放的话，
		// 按说只能放进去1个。（HashSet集合特点：无序不可重复）
		Set<Student> students = new HashSet<>();
		students.add(s1);
		students.add(s2);
		System.out.println(students.size());	// （重写hashCode前）这个结果按理说是1。但是结果是2，显然不符合HashSet集合存储特点。

		System.out.println(students.size()); // 1 重写hashCode之后
	}
}

向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！

equals方法有可能调用，也可能不调用。

拿put(k ,v)举例，什么时候equals不会调用？
k.hashCode()方法返回哈希值，哈希值经过哈希算法转换成数组下标。数组下标位置上如果是null，equals不需要执行。

拿get(k) 举例，什么时候equals不会调用？
如果单向链表上只有1个元素时，不需要调用equals方法。

注意：如果一个类的equals方法重写了，那么hashCode()方法必须重写。并且equals方法返回如果是true，hashCode()方法返回的值必须是一样的

equals方法返回true表示两个对象相同，在同一个单项链表上比较。那么对于同一个单向链表上的节点来说，他们的哈希值都是相同的。所以hashCode()方法的返回值也应该相同。

hashCode()方法和equals()方法不用研究了，直接使用IDEA工具生成，但是这两个方法需要同时生成。

终极结论：放在HashMap集合key部分的，以及放在HashSet集合中的元素，需要同时重写hashCode方法和equals方法

public class Product{
	private int no;
	private String name;

	public Product(){}

	public Product(int no, String name){
		this.no = no;
		this.name = name;
	}

	public int getNo(){
		return no;
	}

	public void setNo(int no){
		this.no = no;
	}
	
	public String getName(){
		return name;
	}

	public void setName(String name){
		this.name = name;
	}

	// 重写hashCode + equals
	// 假设业务要求：商品编号一样，并且商品名字相同，表示同一个商品
	
	@Override
	public boolean equals(Object obj){
		if(this == o) return true;
		if(o == null || getClass() != o.getClass()) return false;
		Product product = (Product) o;
		return no == product.no && Objects.equals(name, product.name);
	}

	@Override
	public int hashCode(){
		return Objects.hash(no, name);
	}
	
}

HashMap和HashTable的区别

HashMap集合允许key部分和value部分为null

但是要注意：HashMap集合的key null值只能有一个

public class HashMapTest03 {
	public static void main(String[] args) {
		Map map = new HashMap();

		map.put(null, null);
		// HashMap集合允许key为null
		System.out.println(map.size())	// 1
		
		// key重复的话，对应的value会被覆盖
		map.put(null, 100);
		System.out.println(map.size())	// 1
		 
		// 通过key获取value
		System.out.println(map.get(null));	// 100
	}
}

Hashtable的key和value都不能为null

Hashtable方法都带有synchronized：线程安全的。
线程安全有其他的方案，这个Hashtable对线程的处理导致效率较低，使用较少了。

Hashtable的初始化容量是11，默认加载因子是0.75

int hash = key.hashCode()
int index = ( hash & 0x7FFFFFFF) % tab.length;

Hashtable的扩容是：原容量 * 2 + 1

HashSet扩容后是原容量的2倍

public class HashtableTest01 {
	public static void main(String[] args) {
		Map map = new Hashtable();
		
		// map.put(null, "123");	// 报空指针异常
		// map.put("123", null); 	// 报空指针异常
	}
}

Properties

目前只需掌握Properties属性类对象的相关方法即可

Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。

Properties被称为属性类对象

Properties是线程安全的。

public class PropertiesTest01 {
	public static void main(String[] args) {
		// 创建一个Properties对象
		Properties pro = new Properties();
		 
		// 需要掌握Properties的两个方法，一个存，一个取
		pro.setProperty("url", "jdbc:mysql://localhost:3306/bjpowernode");
		pro.setProperty("driver", "com.mysql.jdbc.Driver");
		pro.setProperty("username", "root");
		pro.setProperty("password", "123");

		// 通过key获取value
		String url = pro.getProperty("url");
		String driver = pro.getProperty("driver");
		String username = pro.getProperty("username");
		String password = pro.getProperty("password");

		System.out.println(url);
		System.out.println(driver);
		System.out.println(username);
		System.out.println(password);
	}
}

TreeSet

1、TreeSet集合底层实际上是一个TreeMap

2、TreeMap集合底层是一个二叉树。

3、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。

4、TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序。

package javase.danlink;

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

public class Test03 {
    public static void main(String[] args) {
        // 创建一个TreeSet集合
        TreeSet<String> ts = new TreeSet<>();
        // 添加String
        ts.add("zhangsan");
        ts.add("lisi");
        ts.add("wangwu");
        ts.add("zhaoliu");

        // 遍历
        for(String s: ts){
            // 按照字典顺序，升序！
            System.out.println(s);
        }

        System.out.println("--------------------");

        TreeSet<Integer> ts1 = new TreeSet<>();
        ts1.add(10);
        ts1.add(40);
        ts1.add(20);
        ts1.add(1000);
        ts1.add(10);

        for (Integer i: ts1){
            // 升序！
            System.out.println(i);
        }
    }
}

TreeSet无法对自定义类型排序

以下程序中对于Person类型来说，无法排序。因为没有指定Person对象之间的比较规则。谁大谁小没有说明

package javase.danlink;

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

public class Test03 {
    public static void main(String[] args) {
        Person p1 = new Person(32);
        Person p2 = new Person(20);
        Person p3 = new Person(30);
        Person p4 = new Person(25);

        // 创建TreeSet集合
        TreeSet<Person> persons = new TreeSet<>();
        // 添加元素
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);

        // 遍历
        for (Person i: persons){
            System.out.println(i);
        }
    }
}


class Person{
    int age;
    public Person(int age){
        this.age = age;
    }

    // 重写toString方法
    public String toString(){
        return "Person[age=]"+age+"]";
    }
}

以上程序出现以下异常情况

Exception in thread “main” java.lang.ClassCastException: javase.danlink.Person cannot be cast to java.lang.Comparable
at java.util.TreeMap.compare(TreeMap.java:1294)
at java.util.TreeMap.put(TreeMap.java:538)
at java.util.TreeSet.add(TreeSet.java:255)
at javase.danlink.Test03.main(Test03.java:15)

出现以上错误的原因：Person类没有实现java.lang.Comparable接口

package javase.danlink;

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

public class Test03 {
    public static void main(String[] args) {
        Customer c1 = new Customer(32);
        Customer c2 = new Customer(20);
        Customer c3 = new Customer(30);
        Customer c4 = new Customer(25);

        // 创建TreeSet集合
        TreeSet<Customer> customers = new TreeSet<>();
        // 添加元素
        customers.add(c1);
        customers.add(c2);
        customers.add(c3);
        customers.add(c4);

        // 遍历
        for (Customer c: customers){
            System.out.println(c);
        }
    }
}

// 放在TreeSet集合中的元素需要实现java.lang.Comparable接口
// 并且实现compareTo方法，equals可以不写

class Customer implements Comparable<Customer>{ // c1.compareTo(c2);
    // this是c1
    // c是c2
    // c1和c2比较的时候，就是this和c比较
    int age;
    public Customer(int age){
        this.age = age;
    }

    // 需要在这个方法中编写比较逻辑，或者说比较的规则，按照什么进行比较！
    // k.compareTo(t.key)
    // 拿着参数k和集合中的每一个k进行比较，返回值可能是 >0,<0,=0
    @Override
    public int compareTo(Customer o) {
//        if (this.age == o.age){
//            return 0;
//        }else if (this.age > o.age){
//            return 1;
//        }else {
//            return -1;
//        }
        return this.age-o.age;
    }

    @Override
    public String toString() {
        return "Customer"+ age;
    }
}

TreeSet比较规则

package javase.danlink;

import sun.reflect.generics.tree.Tree;

import java.util.ArrayList;
import java.util.Collection;
import java.util.TreeSet;
/*
    先按照年龄升序，如果年龄一样的再按照姓名升序
 */
public class Test03 {
    public static void main(String[] args) {
        TreeSet<Vip> vips = new TreeSet<>();
        vips.add(new Vip("zhangsi", 20));
        vips.add(new Vip("zhangsan", 20));
        vips.add(new Vip("king", 18));
        vips.add(new Vip("soft", 17));
        for (Vip vip: vips){
            System.out.println(vip);
        }
    }
}

class Vip implements Comparable<Vip>{
    String name;
    int age;

    public Vip(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Vip{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /*
    compareTo方法的返回值很重要：
        返回0表示相同，value会覆盖
        返回>0，会继续在右子树上找。【10 - 9 = 1，1 > 0的说明左边这个数字比较大。所以在右子树上找。】
        返回<0，会继续在左子树上找。
     */

    @Override
    public int compareTo(Vip v) {
        // 写排序规则，按照什么进行比较
        if (this.age == v.age){
            // 年龄相同时按照名字排序
            // 姓名是String类型，可以直接对比。调用compareTo来完成比较
            return this.name.compareTo(v.name);
        }else{
            // 年龄不一样
            return this.age - v.age;
        }
    }
}

自平衡二叉树数据结构

1、TreeSet/TreeMap事自平衡二叉树。遵循左小右大原则存放。

2、遍历二叉树的时候有三种方式：

前序遍历：根左右
中序遍历：左根右
后序遍历：左右根

注意：前中后说的是“根”的位置。根在前面是前序，根在中间是中序，根在后面是后序。

3、TreeSet集合/TreeMap集合采用的是：中序遍历方式。Iterator迭代器采用的是中序遍历方式。左根右

4、100，200，50，60，80，120，140，130，135，180，666，40，55

在这里插入图片描述
存放的过程就是排序的过程，取出来就是自动按照大小顺序排序的

5、采用中序遍历取出：
40、50、55、60、80、100、120、130、135、140、180、200、666

存放时要依靠左小右大原则，所以这个存放的时候要进行比较

TreeSet集合中元素可排序的第二种方式：使用比较器方式

package javase.danlink;

import sun.reflect.generics.tree.Tree;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.TreeSet;
/*
    先按照年龄升序，如果年龄一样的再按照姓名升序
 */
public class Test03 {
    public static void main(String[] args) {
        // 创建TreeSet集合的时候，需要使用这个比较器。
        // TreeSet<WuGui> wuGuis = new TreeSet<>();// 这样不行，没有通过构造方法传递一个比较器进去
        // 给构造方法传递一个比较器
        TreeSet<WuGui> wuGuis = new TreeSet<>(new WuGuiComparator());
        wuGuis.add(new WuGui(1000));
        wuGuis.add(new WuGui(800));
        wuGuis.add(new WuGui(810));

        for (WuGui w: wuGuis){
            System.out.println(w);
        }
    }
}

class WuGui{
    int age;

    public WuGui(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "WuGui{" +
                "age=" + age +
                '}';
    }
}

// 单独在这里编写一个比较器
// 比较器实现java.util.Comparator接口。(Comparable是java.lang包下的。Comparator是java.util包下的。)
class WuGuiComparator implements Comparator<WuGui>{

    @Override
    public int compare(WuGui o1, WuGui o2) {
        return o1.age - o2.age;
    }
}

也可以通过匿名内部类的方式（这种类没有名字，直接new接口）

package javase.danlink;

import sun.reflect.generics.tree.Tree;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.TreeSet;
/*
    先按照年龄升序，如果年龄一样的再按照姓名升序
 */
public class Test03 {
    public static void main(String[] args) {
        // 创建TreeSet集合的时候，需要使用这个比较器。
        // TreeSet<WuGui> wuGuis = new TreeSet<>();// 这样不行，没有通过构造方法传递一个比较器进去
        // 给构造方法传递一个比较器
//        TreeSet<WuGui> wuGuis = new TreeSet<>(new WuGuiComparator());
        TreeSet<WuGui> wuGuis = new TreeSet<>(new Comparator<WuGui>() {
            @Override
            public int compare(WuGui o1, WuGui o2) {
                return o1.age - o2.age;
            }
        });
        wuGuis.add(new WuGui(1000));
        wuGuis.add(new WuGui(800));
        wuGuis.add(new WuGui(810));

        for (WuGui w: wuGuis){
            System.out.println(w);
        }
    }
}

class WuGui{
    int age;

    public WuGui(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "WuGui{" +
                "age=" + age +
                '}';
    }
}

// 单独在这里编写一个比较器
// 比较器实现java.util.Comparator接口。(Comparable是java.lang包下的。Comparator是java.util包下的。)
//class WuGuiComparator implements Comparator<WuGui>{
//
//    @Override
//    public int compare(WuGui o1, WuGui o2) {
//        return o1.age - o2.age;
//    }
//}

最终结论：放在TreeSet或者TreeMap集合key部分的元素要想做到排序，包括两种方式：

第一种：放在集合中的元素实现java.lang.Comparable接口。
第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。

如何选择Comparable和Comparator

当比较规则不会发生改变的时候，或者说当比较规则只有一个的时候，建议实现Comparable接口。

如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口

Comparator接口的设计符合OCP原则（Open Closed Principle：开闭原则，对扩展开放，对修改关闭）。

Collections工具类

package javase.danlink;

import sun.reflect.generics.tree.Tree;

import java.util.*;

/*
    先按照年龄升序，如果年龄一样的再按照姓名升序
 */
public class Test03 {
    public static void main(String[] args) {
        // ArrayList集合不是线程安全的。
        List<String> list = new ArrayList<>();

        // 变成线程安全的
        Collections.synchronizedList(list);

        // 排序
        list.add("abf");
        list.add("abx");
        list.add("abc");
        list.add("abe");

        Collections.sort(list);

        for (String s: list){
            System.out.println(s);
        }

        List<WuGui> wuGuis = new ArrayList<>();
        wuGuis.add(new WuGui(1000));
        wuGuis.add(new WuGui(8000));
        wuGuis.add(new WuGui(500));
        Collections.sort(wuGuis);

        for (WuGui w: wuGuis){
            System.out.println(w);
        }

        // Set集合排序
        Set<String> set = new HashSet<>();
        set.add("king");
        set.add("kingsoft");
        set.add("king2");
        set.add("king1");

        List<String> list1 = new ArrayList<>(set);
        Collections.sort(list1);

        for (String s: list1){
            System.out.println(s);
        }
        // 这种方式也可以排序
        // Collections.sort(List集合, 比较器对象);
    }
}

class WuGui implements Comparable<WuGui>{
    int age;

    public WuGui(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "WuGui{" +
                "age=" + age +
                '}';
    }

    @Override
    public int compareTo(WuGui o) {
        return this.age - o.age;
    }
}

想成为大师啊

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Java集合

关于Java.util.Collection接口中常用的方法Collection中能存放什么元素没有使用“泛型”之前，Collection中可以存储Object的所有子类型使用“泛型之后”，Collection中只能存储某个具体的类型集合后期我们会学习“泛型”语法。目前先不用管。Collection中什么都能存，只要是Object的子类型就行。（集合中不能直接存储基本数据类型，也不能存java对象，只是存储Java对象的内存地址）Collection中的常用方法boolean add(Ob
复制链接

扫一扫