集合
1. 集合的概述:
-
什么是集合?有什么用?
集合是一种容器。可以来容纳其他类型的数据。
-
集合为什么说在开发中用的比较多?
集合是一个容器,是一个载体,可以一次容纳多个对象,在实际开发中,假设连接数据库,数据库当中有10条记录,那么假设把这10条记录查询出来,在java程序中会将10条数据封装成10个java对象,然后将10个java对象放到某一个集合当中,将集合传到前端,然后遍历集合,将一个数据一个数据展现出来。
-
集合不能直接存储基本数据类型,另外集合也不能直接存储java对象,集合当中存储的都是java对象的内存地址。(或者说集合中存储的是引用)。
list.add(100)//自动装箱Integer
注意:
集合在java中本身是一个容器,是一个对象,也有内存地址。
集合在任何时候存储的都是"引用"。
-
在java中每一个不同的集合,底层会对应不同的数据结构。往不同的集合中存储元素,等于将数据放到了不同的数据结构当中。
-
什么是数据结构:
数据存储的结构就是数据结构,不同的数据结构,数据存储的方式不同。比如:数组,二叉树,链表,哈希表等。
如:
new ArrayList(); //创建一个集合对象,底层是数组 new LinkedList();//创建一个集合对象,底层是链表 new TreeSet();//创建一个集合对象,底层是二叉树
-
集合在java JDK中哪个包下?
java.util.*;
所有的集合类和集合接口都在java.util包下。
-
在java中集合元素分为两大类:
一类是单个方式存储元素:这一类集合中的超级父接口:java util.Collection;
一类是以键值对的方式存储元素:这一类集合的超级父接口是:java.util.map;
-
list和set集合的区别:
list:有序可重复,存储的元素有下标。有序:存进去是这个顺序,出来还是这个顺序。
set:无序不可重复。存储的元素没有下标。
-
list主要分为ArrayList,LinkedList,Vector,他们的区别:
- ArrayList:底层采用了数组这种数据结构,初始化容量是10,ArrayList是非线程安全的。
- LinkedList:底层采用了双向链表数据结构。
- Vector: 底层采用了数组这种数据结构,Vector集合是线程安全的,效率低,现在保证线程安全有别的方法,故用的少。
-
Set主要分为HashSet,SortedSet(接口),TreeSet等
- HashSet:实际上HashSet集合在new的时候,底层实际上new了一个HashMap集合。向HashSet集合中存储元素,实际上是存储到HashMap集合中去了。HashMap集合是一个哈希表数据结构。
- SortedSet:由于继承Set集合,所以它的特点也是无序不可重复的。但放在SortedSet中的元素可以自动按照大小顺序排序,故我们称SortedSet集合为可排序集合。
- TreeSet: 底层实际上是TreeMap new一个TreeSet集合的时候,底层实际上new一个TreeMap集合。往TreeSet集合中放数据的时候,实际上是将数据放到TreeMap集合中了。TreeMap集合底层采用了二叉树数据结构。
-
Map集合的特点:
- Map集合和Collection集合没关系。
- Map集合以key和value这种键值对的方式存储元素。
- key和value都是存储java对象的内存地址。
- 所有Map集合中的key是无序,不可重复的。
- Map集合中的key和Set集合存储元素特点相同。
-
Map主要分为HashMap,Hashtable(Properties),SortedMap(TreeMap)等。
- HashMap:底层是哈希表数据结构,是非线程安全的。
- Hashtable:底层也是哈希表数据结构,是线程安全的,其中所有方法都带有synchronized关键字,效率较低,现在使用较少,因为控制线程安全有其他更好的方案。
- SortedMap:首先是无序不可重复的,另外放在SortedMap集合Key部分的元素会自动按照大小顺序排序,称为可排序集合。
- TreeMap:底层数据结构是一个二叉树,key可以按照大小顺序排序。
- Properties:是线程安全的,因为继承Hashtable,另外Properties存储元素的时候也是采用key和value的形式存储,并且key和value只支持String类型,不支持其他类型。Properties被称为属性类。
2.Collection接口:
概述:
- Collection中能存放什么元素?
没有使用"泛型"之前,Collection中可以存储Object的所有子类型, 使用"泛型"之后,Collection中只能存储某个具体的类型。集合中不能直接存储基本数据类型,也不能存java对象,只能存储java对象的内存地址。
Collection中的常用方法:
/*
* 关于 java.util.Collection接口中的常用方法
* 1. Collection中能存放什么元素?
* 没有使用"泛型"之前,Collection中可以存储Object的所有子类型
* 使用"泛型"之后,Collection中只能存储某个具体的类型。
* 2. Collection常用方法:
* boolean add(Obeject e): 向集合中添加元素
* int size():获取集合元素的个数
* void clear(): 清空集合
* boolean contains(Object o):判断当前集合中是否包含元素o,包含返回true
* boolean remove(Object o): 删除集合中某个元素
* boolean isEmpty(): 判断集合是否为空
* Object[] toArray(): 把集合转化为数组
* */
public class CollectionTest01 {
public static void main(String[] args) {
//创建一个集合对象
//Collection c=new Collections(); //接口是抽象的,无法实例化
//多态
Collection c=new ArrayList();
//测试Collection接口中的常用方法
c.add(100); //自动装箱,实际上是放进去了一个对象的内存地址。
c.add(3.14); //自动装箱
c.add(new Object());//放一个Object对象
c.add(true); //放一个boolean类型
//获取集合中元素的个数
System.out.println("c集合中元素的个数为:"+c.size()); //4
//清空集合
c.clear();
System.out.println("c集合中元素的个数为:"+c.size()); //0
// 再向集合中添加元素:
c.add("hello"); //hello对象的内存地址放到了集合当中。
c.add("world");
c.add("小马");
//判断集合中是否包含"小马"
boolean flag=c.contains("小马");
System.out.println(flag);//true
//删除集合中某个元素:
c.remove("小马");
//判断集合是否为空
System.out.println(c.isEmpty()); //false
//把集合转换成数组
Object[]obj=c.toArray();
System.out.println(Arrays.toString(obj));
}
}
-
Collection中contains()方法:
-
boolean contains(Object o):判断集合中是否包含某个对象o ,如果包含返回true,不包含返回false
-
contains方法底层是怎么判断集合中是否包含某个元素的呢?
调用了equals方法进行比对,equals方法返回true,就表示包含这个元素。
故放在集合中的元素要重写equals方法。
/* * 深入Collection集合中的contains方法 * boolean contains(Object o) 判断集合是否包含某个对象o 如果包含返回true * */ public class CollectionTest04 { public static void main(String[] args) { //创建集对象 Collection c =new ArrayList(); c.add(new String("abc")); c.add(new String("def")); //集合中元素的个数 System.out.println("元素的个数是:"+c.size()); String x=new String("abc"); System.out.println(c.contains(x)); //true 判断集合中是否存在abc,比较的是内容 // contains()方法底层调用了equals(),Sting中重写了equals方法 } }
-
同样remove()方法底层也调用了equals方法。
public class CollectionTest05 { public static void main(String[] args) { Collection c1=new ArrayList(); String s1=new String("hello"); c1.add(s1); String s2=new String("hello"); c1.remove(s2); //s1.equals(s2) java认为s1和s2是一样的,删除s1就是删除s2. System.out.println(c1.size()); //0 } }
-
集合的遍历或迭代:
-
注意:集合结构只要发生改变,迭代器必须重新获取。如果还用原来老的迭代器,会发生异常
在迭代集合元素的过程中,不能调用集合对象的remove方法,删除元素 c.remove(o);会出现异常。
在迭代元素的过程中,一定要使用迭代器Iterator的remove方法,删除元素。不要使用集合自带的remove方法。
public class CollectionTest02 {
public static void main(String[] args) {
//注意:以下的遍历或迭代方式,是所有Collection通用的一种方式
//在Map集合中不能使用。在所有Collection以及子类中使用
//创建集合对象
Collection c=new ArrayList();
//添加元素
c.add("abc");
c.add("小马");
c.add(true);
c.add(new Object());
//对集合Collection进行遍历/迭代
//1. 获取集合对象的迭代器对象:Iterator
Iterator it=c.iterator();
//2. 通过以上获取的迭代器对象,开始迭代/遍历集合
// 注意:迭代器i最初并没有指向第一个元素
/*
以下两个方法是迭代器对象Iterator中的方法
boolean hasNext() :如果仍有元素可以迭代,则返回 true。
false表示没有更多元素可以迭代了。
Object next() : 返回迭代的下一个元素。让迭代器前进一位,并且将指向的元素返回(拿到)
* */
/* for (int i=0;i<c.size();i++){
if(it.hasNext()){
System.out.println(it.next());
}
}*/
while (it.hasNext()){
System.out.println(it.next());
}
}
}
-
关于remove():
public class CollectionTest06 { public static void main(String[] args) { Collection c=new ArrayList(); c.add(1); c.add(2); c.add(3); c.add(4); //注意:集合结构只要发生改变,迭代器必须重新获取 Iterator it=c.iterator(); while (it.hasNext()){ //编写代码时next()方法返回值类型必须是Object //Object o=it.next(); System.out.println(it.next()); } Collection c2=new ArrayList(); c2.add("abc"); c2.add("edf"); c2.add("xyz"); Iterator it1=c2.iterator(); while (it1.hasNext()){ Object o=it1.next(); //删除元素 //删除元素之后,集合的结构发生了变化,应该重新去获取迭代器 //但是,循环下一次的时候并没有重新获取迭代器,所以会出现异常。 //出异常的根本原因:集合中元素删除了,但没有更新迭代器(迭代器不知道集合发生变化) //c2.remove(o);//java.util.ConcurrentModificationException(导致迭代器的快照和原集合状态不同) //使用迭代器来删除:会自动更新迭代器,并且更新集合 it1.remove(); //删除的一定是迭代器指向的当前元素 System.out.println(o); } System.out.println(c2.size());//0 } }
3. List:
概述:
- List集合存储元素的特点:有序可重复。
有序:List集合中的元素有下标 从0开始,以1递增
可重复: 存储一个1,还存储1
特有的常用方法
- List既然是Collection接口的子接口,那么肯定List接口有自己特色的方法。
以下只列出List集合特有的常用方法:
void add(int index,String item); //在列表指定位置插入指定元素(第一个参数是下标) 方法使用不多,效率较低
Object set(int index,Object element)//修改指定下标位置的元素
Object get(int index);//根据下标获取元素 故有自己比较特殊的遍历方式,如下
int indexOf(Object o) //获取指定对象第一次出现的索引
int lastIndexOf(Object o)//获取指定对象最后一次出现处的索引
Object remove(int index) //删除指定下标位置的元素
-
List集合特有的遍历方式:
public class ListTest { public static void main(String[] args) { //创建List类型的集合 List myList=new ArrayList(); //添加元素 myList.add("A"); //默认都是向集合末尾添加元素 myList.add("B"); myList.add("C"); myList.add("D"); //因为有下标,所以list集合有自己比较特殊的遍历方式 //通过下标遍历 for (int i=0;i<myList.size();i++){ Object obj1=myList.get(i); System.out.println(obj1); } } }
-
方法测试如下:
public class ListTest01 {
public static void main(String[] args) {
//创建List类型的集合
List myList=new ArrayList();
//添加元素
myList.add("A"); //默认都是向集合末尾添加元素
myList.add("B");
myList.add("C");
myList.add("C");
myList.add("D");
myList.add(1,"king"); //在列表指定位置插入指定元素
//迭代
Iterator it=myList.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
//根据下标获取元素
Object obj=myList.get(1);
System.out.println(obj);
System.out.println("===========----");
//因为有下标,所以list集合有自己比较特殊的遍历方式
//通过下标遍历
for (int i=0;i<myList.size();i++){
Object obj1=myList.get(i);
System.out.println(obj1);
}
//获取指定对象第一次出现的索引
System.out.println(myList.indexOf("C")); //3
//获取指定对象最后一次出现处的索引
System.out.println(myList.lastIndexOf("C"));//4
//删除指定下标位置的元素
//删除下标为0 的元素
myList.remove(0);
System.out.println(myList.size());//5
//修改指定下标位置的元素
myList.set(0,"hamburg");
//遍历集合
for (int i=0;i<myList.size();i++){
System.out.println(myList.get(i));
}
}
}
ArrayList:
-
ArrayList集合初始化容量是10(底层先创建了一个长度为0的数组,当添加第一个元素的时候,初始化容量10 )
-
底层是Object类型的数组。
可在集合创建的时候,给定集合容量
List list1=new ArrayList(20);
-
ArrayList集合的扩容:
扩容到原容量的1.5倍。
-
ArrayList集合底层是数组,怎么优化?
尽可能少的扩容。因为数组扩容效率比较低,建议在使用ArrayList集合的时候,预估计元素的个数,给定一个初始化容量。
-
ArrayList的优缺点:
检索效率较高:每个元素占用空间大小相同,内存地址是连续的,知道首元素内存地址,然后知道下标,通过数学表达式计算出元素的内存地址,故检索效率高。
随机增删元素效率比较低,无法存储大数据量(很难找到一块非常巨大的连续内存空间),但是向数组末尾添加元素,效率还是比较高的。
-
面试官经常会问的一个问题:
这么多集合中,你用哪个集合比较多? ArrayList
-
ArrayList是非线程安全的集合。
-
ArrayList的三种构造方法:
/* * 集合ArrayList的构造方法 * */ public class ArrayListTest02 { public static void main(String[] args) { //默认初始化容量10 List myList=new ArrayList(); //指定初始化容量100 List myList1=new ArrayList(100); //创建一个hashSet集合 Collection c=new HashSet(); //添加元素 c.add(100); c.add(10); c.add(90); c.add(200); c.add(500); //通过这个构造方法可以将hashSet集合转化为List集合 List myList2=new ArrayList(c); for (int i=0;i<myList2.size();i++){ System.out.println(myList2.get(i)); } } }
LinkedList(双向链表):
-
单链表的数据结构:
对于链表数据结构来说,基本的单元是节点(Node)。
对于单向链表来说,任何一个节点Node中都有两个属性:第一:存储数据。第二:下一个节点的内存地址。
-
链表的优缺点:
优点:随机增删元素效率较高。(因为链表上的元素在空间存储上内存地址不连续,故增删元素不涉及到大量元素位移的问题)。
缺点:查询效率比较低。每一次查找某个元素的时候,都需要从头节点开始往下遍历。
-
双向链表的内部结构:
-
LinkedList集合没有初始化容量,最初这个链表中没有任何元素,first和last引用都是null。
Vector:
-
底层也是一个数组
-
初始化容量:10
-
怎么扩容的:扩容之后是原容量的2倍。
-
Vector中所有的方法都是线程同步的,都带有synchronized关键字,是线程安全的。效率比较低,使用的较少。
-
怎么将一个线程不安全的ArrayList集合转化成线程安全的:使用集合工具类:java.util.Collections
-
如:
public class VectorTest { public static void main(String[] args) { //创建一个Vector集合 Vector v=new Vector(); //添加元素 // 默认容量10 v.add(1); v.add(2); v.add(3); v.add(4); v.add(5); v.add(6); v.add(7); v.add(8); v.add(9); v.add(10); //满了之后扩容(扩容之后的容量是20) v.add(11); Iterator it=v.iterator(); while (it.hasNext()){ System.out.println(it.next()); } //将一个线程不安全的ArrayList集合转化成线程安全的 List myList=new ArrayList();//非线程安全的 //变成线程 安全的 Collections.synchronizedList(myList); //myList就是线程安全的了 myList.add("111"); myList.add("222"); myList.add("333"); } }
4. 泛型:
JDK5.0 推出的新特性:泛型
-
泛型这种语法机制,只在程序编译阶段起作用,只是给编译器参考的。
-
使用泛型的好处:
- 集合中存储的元素类型统一了。
- 从集合中取出的元素类型是泛型指定的类型,不需要进行大量的"向下转型"!
-
泛型的缺点:导致集合中存储的元素缺乏多样性!
-
大多数业务中,集合中元素的类型还是统一的,所以这种泛型特性被大家所认可。
代码:
public class GenericTest01 { public static void main(String[] args) { /* //不使用泛型机制 分析程序存在的缺点 List mylist=new ArrayList(); //准备对象 Cat c=new Cat(); Bird b=new Bird(); //将对象添加到集合当中 mylist.add(c); mylist.add(b); //遍历集合 取Cat让它抓老鼠,取Bird让它飞 Iterator it=mylist.iterator(); while (it.hasNext()){ Object obj=it.next(); if(obj instanceof Cat){ ((Cat) obj).catchMouse(); } if (obj instanceof Bird){ ((Bird) obj).fly(); } } */ //使用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(); //调用子类型特有的方法还是需要向下转化的! if(a instanceof Cat){ ((Cat) a).catchMouse(); } if (a instanceof Bird){ ((Bird) a).fly(); } } } } class Animal{ public void move(){ System.out.println("动物在移动"); } } class Cat extends Animal{ public void catchMouse(){ System.out.println("猫抓老鼠"); } } class Bird extends Animal{ public void fly(){ System.out.println("鸟儿在飞翔"); } }
-
JDK8之后引入了:自动类型推断机制。(又称为钻石表达式)
public class GenericTest02 { 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()){ System.out.println(it.next()); Animal a=it.next(); a.move(); } List<String>stringList=new ArrayList<>(); //类型不匹配 // stringList.add(new Cat()); //类型不匹配 // stringList.add(123); stringList.add("abc"); } }
-
自定义泛型:
- 自定义泛型的时候 <> 尖括号中的是一个标识符,随便写
- java源代码经常出现的是:和
* E是Element单词首字母 * T是Type单词首字母
5. foreach:
-
JDK5.0之后推出的新特性:叫做增强for循环,或者叫做foreach。
-
语法格式:
for(元素类型 变量名:数组或集合){ System.out.println(变量名); }
-
代码演示:
public class ForEacchTest01 { public static void main(String[] args) { //int类型数组 int[]arr={422,12,434,52442}; //遍历数组(普通for循环): for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } //foreach //语法格式 /* for(元素类型 变量名:数组或集合){ System.out.println(变量名); }*/ System.out.println("========================"); //foreach有一个缺点:没有下标。在需要使用下标的循环中,不建议使用for循环 for (int a:arr ) { System.out.println(a); } } }
-
结合的三种遍历方式:
public class ForEachTest02 { public static void main(String[] args) { List<String> strList=new ArrayList<>(); strList.add("A"); strList.add("B"); strList.add("C"); strList.add("D"); //遍历:使用迭代器方式 Iterator<String>it=strList.iterator(); while (it.hasNext()){ System.out.println(it.next()); } System.out.println("==========================="); //使用下标方式(只针对有下标的集合) for (int i=0;i<strList.size();i++){ System.out.println(strList.get(i)); } System.out.println("============================"); //使用foreach for (String a: strList) { System.out.println(a); } } }
6. Set:
1. HashSet:
-
存储时顺序和取出的顺序不同。
-
不可重复。
-
放到HashSet集合的元素实际上是放在HashMap集合Key部分。
-
初始化容量:16,初始化容量建议是2的倍数,扩容后是原容量的2倍。
-
代码演示:
public class HashSetTest01 { public static void main(String[] args) { Set<String>strs=new HashSet<>(); //添加元素: strs.add("c"); strs.add("A"); strs.add("C"); strs.add("B"); strs.add("A"); //遍历 for (String s:strs ) { System.out.println(s); } // /* * A * B * C * */ } }
2.TreeSet:
-
TreeSet集合存储元素的特点:
无序不可重复的,但是存储的元素可以自动按照大小顺序排序!称为可排序集合。
-
无序:这里的无序指的是存进去的顺序和取出来的顺序不同。并且没有下标。
-
TreeSet集合实际上是一个TreeMap,TreeMap底层是一个二叉树。
-
放到TreeSet集合中的元素,等同于放到TreeMap集合key部分。
-
代码演示:
public class TreeSetTest01 { public static void main(String[] args) { //创建集合对象 Set<String>strt=new TreeSet<>(); strt.add("A"); strt.add("B"); strt.add("Z"); strt.add("Y"); strt.add("Z"); strt.add("K"); strt.add("M"); for (String s: strt ) { System.out.println(s); } //遍历结果,从小到大自动排序 /* * A B K M Y Z * */ } }
-
TreeSet对自定义类型的排序:
-
需要指定自定义类型的排序规则。
-
第一种方式:
-
自定义的类实现:java.lang.Comparable接口。
-
在compareTo()方法中编写比较逻辑,比较规则,或按照什么进行比较。
-
-
代码如下:
/* * 对自定义的类型来说,TreeSet可以排序嘛? * 以下程序中对于Person类型来说,无法排序。因为没有指定Person对象之间的比较规则。 * */ public class TreeSetTest03 { public static void main(String[] args) { Person p1=new Person(10); Person p2=new Person(20); Person p3=new Person(9); Person p4=new Person(25); TreeSet<Person> ts=new TreeSet<>(); ts.add(p1); ts.add(p2); ts.add(p3); ts.add(p4); for (Person p: ts ) { System.out.println(p); } } } //放在TreeSet集合中的元素,需要实现java.lang.Comparable接口 //并且重写compareTo方法。 class Person implements Comparable<Person>{ int age; public Person(int age){ this.age=age; } public String toString(){ return "Person[age="+age+"]"; } //需要在这个方法中编写比较逻辑 或者比较规则,按照什么进行比较。 //比较规则最终还是由程序员指定的,比如按照年龄升序,或按照年龄降序 @Override public int compareTo(Person p) { // p1.compareTo(p2); //this是p1 //p是p2 //p1和p2比较,就是this和p比较。 /* int age1=this.age; int age2=p.age; if (age1==age2){ return 0; } else if(age1>age2){ return 1; } else{ return -1; }*/ //以上代码可以简化为: //return p.age-this.age; //降序 return this.age-p.age;//升序 } }
-
再如: 先按照年龄升序,如果年龄一样再按照姓名升序:
/* * 先按照年龄升序,如果年龄一样再按照姓名升序 * */ public class TreeSetTest05 { public static void main(String[] args) { TreeSet<Vip>ts=new TreeSet<>(); ts.add(new Vip("zhangsan",21)); ts.add(new Vip("lisi",20)); ts.add(new Vip("wangwu",20)); ts.add(new Vip("zhaoliu",10)); for (Vip v: ts) { System.out.println(v); } } } 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 会继续在右子树上找 * 返回<0 会继续在左子树上找 * */ @Override public int compareTo(Vip v) { if (this.age==v.age){ //如果年龄相同,按名字排序 //姓名是String类型,可以直接调用compareTo进行比较 return this.name.compareTo(v.name); } //年龄不一样 return this.age-v.age; } }
-
TreeSet集合中元素可排序的第二种方式:使用比较器方式。
代码如下(创建一个比较器类):
public class TreeSetTest06 { 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(1100)); wuGuis.add(new WuGui(900)); wuGuis.add(new WuGui(800)); wuGuis.add(new WuGui(1200)); //遍历 for (WuGui w: wuGuis) { System.out.println(w); } } } //乌龟 class WuGui { int age; public WuGui(int age) { this.age = age; } @Override public String toString() { return "小乌龟[" + "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; } }
-
使用匿名内部类的方式:
代码:
public class TreeSetTest07 { public static void main(String[] args) { //创建TreeSet集合的时候,需要使用这个比较器 //这样是不行的,没有通过构造方法传递一个比较器过去 //TreeSet<WuGui> wuGuis=new TreeSet<>(); //给构造方法传递一个比较器(这个类没有名字,直接new接口Comparator) 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(1100)); wuGuis.add(new WuGui(900)); wuGuis.add(new WuGui(800)); wuGuis.add(new WuGui(1200)); //遍历 for (WuGui w: wuGuis) { System.out.println(w); } } } //乌龟 class WuGui { int age; public WuGui(int age) { this.age = age; } @Override public String toString() { return "小乌龟[" + "age=" + age + ']'; } }
-
1. 自定义类型排序总结(代码见上):
总结:
-
放到TreeSet集合或TreeMap集合key部分的元素要想做到排序,包括两种方式:
-
第一种:放在集合中的元素实现java.lang.Comparable接口,重写compareTo()方法。
-
第二种:在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象(new Comparator(){})。重写compare()方法。
-
-
Comparable和Comparator怎么选择:
当比较规则不会发生改变的时候,或者说当比较规则只有1个的时候,建议实现Comparable接口。
如果比较规则有多个,并且需要多个比较规则直接频繁切换的时候,建议使用Comparator接口。
Comparator接口的设计符合OCP原则(开闭原则)
2. 自平衡二叉树数据结构:
-
TreeSet/TreeMap是自平衡二叉树,遵循左小右大原则存放,
-
遍历二叉树的时候有三种方式:(前中后说的是根的位置)
- 前序遍历:根左右
- 中序遍历:左根右:40 50 55 60 80 100 120 130 135 140 180 666
- 后序遍历:左右根
-
TreeSet集合/TreeMap集合采用的是:中序遍历方式。Iterator迭代器也采用中序遍历方式。1
-
如: 100 200 50 60 80 120 140 130 135 180 666 40 55的二叉树结构图:
5.
7. Map:
1. 介绍:
- 注意:Map和Collection没有继承关系。
- Map集合以key和value的方式存储数据:键值对。
- key和value都是引用数据类型。
- key和value都是存储对象的内存地址。
- key起到主导的地位,value是key的一个附属品。
2. 常用方法:
* 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集合通过entrySet()方法转化成的这个Set集合,Set集合中元素的类型是Map.Entry<K,V>
Map.Entry和String一样,都是一种类型的名字,只不过:Map.Entry是静态内部类。
-
代码演示:
public class MapTest01 { public static void main(String[] args) { //创建Map集合对象 Map<Integer,String> m=new HashMap<>(); //向Map集合中添加键值对 m.put(1,"xiaoma"); //1在这里进行了自动装箱 m.put(2,"xiaozhao"); m.put(3,"xiaochen"); m.put(4,"xiaohuang"); //通过key获取value String value=m.get(1); System.out.println(value); //xiaoma //获取键值对的数量 System.out.println("键值对的数量为: "+m.size()); //4 //通过key删除key-value m.remove(4); System.out.println("键值对的数量为: "+m.size()); //判断是否包含某个key //contains方法底层都是调用的equals进行比对的,所有自定义的类型需要重写equals方法。 System.out.println(m.containsKey(4)); //false //判断是否包含某个value System.out.println(m.containsValue("xiaozhao")); //true //获取所有的value Collection<String> values= m.values(); for (String a: values ) { System.out.println(a); } //清空集合 m.clear(); System.out.println("键值对的数量为: "+m.size()); //0 //判断是否为空 System.out.println(m.isEmpty()); //true } }
3. Map遍历(重点):
-
有两种方式:
-
通过 **Set keySet()**获取所有的key ,再通过遍历key,来遍历value。
-
通过**Set<Map.Entry<K,V>> entrySet()**方法,把Map集合直接全部转换成set集合,再去遍历,效率高。
注意:Set集合中元素的类型是:Map.Entry
-
/*
二种方式:
*/
public class MapTest02 {
public static void main(String[] args) {
//第一种方式:获取所有的key 通过遍历key,来遍历value
Map<Integer,String>m=new HashMap<>();
//向Map集合中添加键值对
m.put(1,"xiaoma");
m.put(2,"xiaozhao");
m.put(3,"xiaochen");
m.put(4,"xiaohuang");
//遍历Map集合
//获取所有的key 所有的key是一个set集合
Set<Integer> keys=m.keySet();
//遍历key 通过key获取value
//1:迭代器
Iterator<Integer>it=keys.iterator();
while (it.hasNext()){
//取出其中一个key
Integer key=it.next();
//通过key获取value
String value=m.get(key);
System.out.println(key+"="+value);
}
System.out.println("============================");
//2:foreach
for (Integer key:keys
) {
System.out.println(key+"="+m.get(key));
}
System.out.println("============================");
//第二种方式:Set<Map.Entry<K,V>> entrySet()
//以上这个方法是把Map集合直接全部转换成set集合
//Set集合中元素的类型是:Map.Entry
Set<Map.Entry<Integer,String>>set=m.entrySet();
//迭代器:
Iterator<Map.Entry<Integer,String>>it1=set.iterator();
while (it1.hasNext()){
Map.Entry<Integer,String>entry=it1.next();
Integer key=entry.getKey();
String value=entry.getValue();
System.out.println(key+"="+value);
}
System.out.println("============================");
//foreach
for (Map.Entry<Integer,String> a:
set) {
System.out.println(a.getKey()+"="+a.getValue());
}
}
}
4. HashMap:
1.介绍:
-
HashMap集合底层是哈希表/散列表的数据结构。
-
哈希表是一个怎样的数据结构:
- 哈希表是一个数组和单向链表的结合体
- 数组:在查询方面效率很高,随机增删方面效率很低
- 单向链表:在随机增删方面效率较高,在查询方法效率很低。
- 哈希表将以上的两种数据结构融合在一起,充分发挥它们各自的优点。
-
HashMap集合的key特点:
-
无序:因为不一定挂到哪个单向链表上。
-
不可重复:equals方法保证HashMap集合的key不可重复。如果key重复,value会被覆盖。
-
-
注意:放在HashMap集合key部分的元素其实就是放到HashSet集合中了。故HashSet集合中的元素也需要同时重写HashCode()和equals()方法。
2. 哈希表的数据结构:
-
最主要掌握的是:
map.put(k,v) v=map.get(k) 以上这两个方法的实现原理,是必须掌握的
-
如图:
-
哈希表HashMap使用不当时,无法发挥性能!
假设将所有hashCode()方法返回值固定为某个值,那么会导致底层哈希表变成了纯单向链表。这种情况我们称为:散列表分布不均匀。
-
那什么是散列表分布均匀?
假设有100个元素,10个单链表,那么每个单链表上有10 个节点,这是最好的。是散列表分布均匀的。 -
假设将所有的hashCode()方法返回值都设定为不一样的值,可以吗,有什么问题?
不行,因为这样的话导致底层哈希表就成为一维数组了,没有链表的概念了。也是散列分布不均匀。
散列分布均匀,需要你重写HashCode()时有一定的技巧。
-
HashMap集合的默认初始化容量是16,默认加载因子是0.75。扩容之后的容量是原容量的二倍。
这个默认加载因子是指:当HashMap集合底层数组的容量达到**75%**的时候,数组开始扩容。
-
重点:HashMap集合初始化容量必须是2的倍数,这也是官方推荐的。
这是因为达到散列表均匀,为了提高HashMap集合的存取效率,所必须的。
-
向HashMap集合中存,或者向HashMap集合中取,都是先调用hashCode方法,然后再调用equals方法。
3.重写hashCode和equals
-
如果一个类的equals方法重写了,那么hashCode()方法必须重写。并且equals方法返回如果是true ,那么hashCode()方法返回的值需要一样。
因为equals方法返回true表示两个对象相同,在同一个单向链表上比较。那么对于同一个单向链表的节点来说,他们的哈希值转换后的数组下标都是相同的,所以hashCode()方法的返回值也应该相同。
-
使用idea工具同时生成。
-
对于哈希表数据结构来说:
如果o1和o2的hash值相同,一定是放到同一个单链表上的。
当然如果o1和o2的hash值不同,但由于哈希算法执行结束之后转换的数组下标可能相同,此时会发生“哈希碰撞”。
4.HashMap集合的改进:
- 在JDK8之后,如果哈希表单向链表中元素超过8个,单向链表这种数据结构会变成红黑树数据结构。当红黑树上的节点数量小于6时,会重新把红黑树变成单向链表数据结构。这种方式也是为了提高检索效率。
- HashMap允许key和value为null。
5. HashMap和Hashtable的区别:
- Hashtable的key和value都是不能为null的。
- HashMap的key和value都是可以为null的。
- Hashtable方法都带有synchronized:线程安全的。线程安全有其他的方案,这个Hashtable对线程的处理导致效率较低,使用较少。
- Hashtable和HashMap一样,底层都是哈希表数据结构。
- Hashtable的初始化容量是11,默认加载因子是:0.75。
- Hashtable的扩容:原容量 * 2+1。
5.Properties属性类:
-
介绍:
Properties是一个Map集合,继承Hashtable,Properties的key和value都是String类型, Properties称为属性类对象。是线程安全的。
-
需要掌握的两个方法:
Object setProperty(String key, String value) //添加数据 String getProperty(String key) //通过key获取value
-
代码演示:
public class PropertiesTest01 { public static void main(String[] args) { //创建一个Properties对象 Properties pro=new Properties(); //需要掌握Properties的两个方法,一个存一个取 pro.setProperty("username","root"); pro.setProperty("password","123"); //通过key 获取value System.out.println(pro.getProperty("username")); //root } }
6.集合工具类Collections:
public class CollectionsTest01 {
public static void main(String[] args) {
//ArrayList集合不是线程安全的
List<String>list=new ArrayList<>();
//编程线程安全的
Collections.synchronizedList(list);
//排序
list.add("adf");
list.add("adz");
list.add("adc");
list.add("ade");
Collections.sort(list);
for (String s:
list) {
System.out.println(s);
}
//对Set集合如何排序
Set<String> set=new HashSet<>();
set.add("king");
set.add("king3");
set.add("king1");
set.add("king2");
//将Set集合转化成List集合
List<String>list1=new ArrayList<>(set);
Collections.sort(list1);
for (String s1:
list1) {
System.out.println(s1);
}
}
}