关于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;
}
}