集合框架体系
1可以动态保存任意多个对象，使用比较方便
2提供了一系列方便的操作对象的方法：add,remove,set,get等
Collection
Collection接口实现类的特点
1.Collection 实现子类可以存放多个元素，每个元素可以是Object
2.有些Collection的实现类，可以存放重复的元素，有些不可以
3.有些Collection的实现类，有些事有序的(List)，有些不是有序(Set)
4.Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的
Collection常用方法(以子类ArrayList演示)
点击查看代码
public static void main(String[] args) {
List list = new ArrayList();
//add:添加单个元素
list.add("toc");
list.add("10");
list.add(true);
System.out.println("list=" + list);
//remove：删除指定元素
list.remove(0);//删除第一个元素
//list.remove(true);//指定删除某个元素
System.out.println("list=" + list);
//contains:查找元素是否存在
System.out.println(list.contains("10"));
//size:获取元素个数
System.out.println(list.size());
//isEmpty:判断是否为空
System.out.println(list.isEmpty());
//clear：清空
//list.clear();
System.out.println("list=" + list);
//addAll:添加多个元素
ArrayList list2 = new ArrayList();
list2.addAll(list);
list.addAll(list2);
//containsAll:查找多个元素是都否存在
System.out.println(list.containsAll(list2));
//removeAll:删除多个元素
list.add("JavaP8");
list.removeAll(list2);
System.out.println(list);
}
Collection接口遍历元素方式
Collection接口遍历对象方式1-使用迭代器(Iterator)
1.Iterator对象称为迭代器，主要用于遍历 Collection 集合中的元素
2.索引实现了 Collection 接口的集合类都有一个 iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器。
3.Iterator 的结构。如图：
![]()
4.Iterator 仅用于遍历集合，Iterator本身并不存放对象
5.再调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用，且吓一跳记录无效，直接调用it。next()会抛出
点击查看代码
Collection col = new ArrayList();
col.add(new Book("三国演义","罗贯中",10.1));
col.add(new Book("小李飞刀","古龙",66.6));
col.add(new Book("红楼梦","曹雪芹",9.9));
System.out.println(col);
//遍历col
//1.先得到col对应的 迭代器
Iterator iterator = col.iterator();
//2.使用while循环遍历
while (iterator.hasNext()) {//判断是否还有数据
//返回下一个元素，类型是Object
Object object = iterator.next();
System.out.println(object);
}
System.out.println();
//3.当退出while循环后，这是 iterator 迭代器，指向最后的元素
// iterator。next();//NoSuchElementException
//4.如果希望再次遍历，需要重置我们的迭代器
iterator = col.iterator();
while (iterator.hasNext()) {
Object object = iterator.next();
System.out.println(object);
}
Collection接口遍历对象方式2-for循环增强
增强for循环，可以代替iterator迭代器，特点：增强fir就是简化版的iterator，本质一样。只能用于遍历集合或数组。语法：
for(元素类型 元素名：集合名或数组名){访问元素}
点击查看代码
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义","罗贯中",10.1));
col.add(new Book("小李飞刀","古龙",66.6));
col.add(new Book("红楼梦","曹雪芹",9.9));
//1.使用增强for 在Collection集合
//2.增强for，底层仍然是迭代器
//3.增强for 可以理解为就是简化版的迭代器
//4.快捷方式 I
for(Object book : col){
System.out.println(book);
}
}
练习
1、请编写程序
1.创建三个Dog{name,age},放入到ArrayList中，赋给List引用
2.用迭代器和增强for循环两种方式来遍历
3.重写Dog的toString方法，输出name和age
List
List接口基本介绍：
List接口时 Collection 接口的子接口
1.List 集合类中元素有序(即添加顺序和取出顺序一致)、且可重复。
2.List 集合中的每个元素都有对应的顺序索引，即支持索引。
3.List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
List接口的常用方法：
List 集合里添加了一些根据索引来操作集合元素的方法
1.void add(int index,Object ele):在index位置插入ele元素
2.boolean add All(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
3.Object get(int index)：获取指定index位置的元素
4.int indexOf(Object obj)：返回obj在集合中首次出现的位置
5.int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置
6.Object remove(int index)：移除指定index位置的元素，并返回此元素
7.Object set(int index，Object ele)：设置指定index位置的元素为ele，相当于是替换。
8.ListsubList(int fromIndex，int toIndex)：返回从formIndex到toIndex位置的子集合
点击查看代码
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");
System.out.println(list);
// 1.void add(int index,Object ele):在index位置插入ele元素
list.add(1,"小明");//在Index = 1 的位置插入一个对象
System.out.println(list);
// 2.boolean add All(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = new ArrayList();
list1.add("小黑");
list1.add("小明");
list1.addAll(1,list);
System.out.println(list1);
// 3.Object get(int index)：获取指定index位置的元素
System.out.println(list1.get(1));
// 4.int indexOf(Object obj)：返回obj在集合中首次出现的位置
System.out.println(list1.indexOf("张三"));
// 5.int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置
System.out.println(list1.lastIndexOf("小明"));
// 6.Object remove(int index)：移除指定index位置的元素，并返回此元素
System.out.println(list1.remove(2));
System.out.println(list1);
// 7.Object set(int index，Object ele)：设置指定index位置的元素为ele，相当于是替换。
System.out.println(list1.set(0,"小明"));
System.out.println(list1);
// 8.List subList(int fromIndex，int toIndex)：返回从formIndex到toIndex位置的子集合
//返回的子集合 fromIndex<=subList<toIndex
System.out.println(list1.subList(0,2));
List接口练习：
1.添加10个以上的元素(比如Stirng "hello")，在2号位插入一个元素"java开发"，获得第五个元素，删除第六个元素，修改第七个元素，在使用迭代器遍历集合。要求：使用List的实现类ArrayList完成
点击查看代码
List list = new ArrayList();
for (int i = 0; i < 11; i++) {
list.add("hello"+i);
}
System.out.println(list);
list.add(1,"java开发");
System.out.println(list.get(4));
System.out.println(list.remove(6));
System.out.println(list.set(7,"你好"));
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj="+obj);
}
2.使用List实现类添加三本书，并遍历，打印如下效果
名称： 价格： 作者：
名称： 价格： 作者：
名称： 价格： 作者：
1按价格排序，从低到高
2使用ArrayList、LinkedList和Vector三种集合实现
点击查看代码
public static void main(String[] args) {
List list = new ArrayList();
List list1 = new LinkedList();
List list2 = new Vector();
list.add(new Book("红楼梦","曹雪芹",100));
list.add(new Book("西游记","吴承恩",60));
list.add(new Book("水浒传","施耐庵",30));
list.add(new Book("三国演义","罗贯中",80));
for (Object o : list) {
System.out.println(o);
}
//冒泡排序
System.out.println("======");
sort(list);
for (Object o : list) {
System.out.println(o);
}
}
public static void sort(List list){//冒泡排序
for (int i = 0; i < list.size()-1; i++) {
for (int j = 0; j < list.size()-i-1; j++) {
//取出对象BOOK
Book book1 = (Book) list.get(j);
Book book2 = (Book) list.get(j+1);
if(book1.getPrice()>book2.getPrice()){
list.set(j,book2);
list.set(j+1,book1);
}
}
}
}
class Book {
private String name;
private String author;
private double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "名称：" + name +
"\t\t价格：" + price +
"\t\t作者：" + author;
}
}
ArrayList的注意事项：
1.permits all elements，intcluding null，ArrayList可以加入null，并且多个
2.ArrayList是有数组来实现数据库存储的
3.ArrayList基本等同于Vector，除了ArrayList是线程不安全(执行效率高)，在多线程情况下，不建议使用ArrayList
ArrayList的底层操作机制源码分析：
1.ArrayList中维护了一个Object类型的数组elementDate.transient Object[] elementData;//transient 表示瞬间,短暂的,表示该属性不会被序列化
2.当创建对象时，如果使用的是无参构造器，则初始elementData容量为0
3.当添加元素时：先判断是否需要扩容，如果需要扩容，则调用grow方法，否则直接添加元素到合适位置
4.如果使用的是无参构造器，如果第一次添加，需要扩容的话，则扩容elementData为10，如果需要再次扩容的话，则扩容elementData为1.5倍
5.如果使用的是指定容量capacity的构造器，则初始elementData容量为capacity
6.如果使用的是指定容量capacity的构造器，假如需要扩容，则直接扩容elementData为1.5倍
![]()
Vector
Vector基本介绍：
1.Vector类的说明定义
public class Vector<E>
extends AbstractList<E>
implements List<E>,RandomAccess,Cloneable,Serializable
2.Vector底层也是一个对象数组，protected Object[] elementData;
3.Vector 是线程同步的，即线程安全，Vector类的操作方法带有 synchronized
public synchronized E get(int index){
if(index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
4.在开发中，需要线程同步安全时
Vector 和 ArrayList 的比较：
|
底层结构 |
版本 |
线程安全(同步)效率 |
扩容倍数 |
| ArrayList |
可变数组 |
jdk1.2 |
不安全，效率高 |
如果有参构造1,5倍 如果是无参 1.第一次10 2.从第二次开始按1.5扩 |
| Vector |
可变数组 Object[] |
jdk1.0 |
|
如果是无参，默认10，蛮厚，就按2倍扩容 如果指定大小，则每次直接按2倍扩 |
LinkedList
LinkedList 的全面说明：
1.LinkedList底层实现了双向链表和双端队列特点
2.可以添加任意元素(元素可以重复)，包括null
3.线程不安全，没有实现同步
LinkedList 的底层操作机制：
1.LinkedList 底层维护了一个双向链表
2.LinkedList 中维护了两个属性first和last分别指向 首节点和尾结点
3.每个节点(Node对象)，里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表
4.所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高
5.模拟一个简单的双向链表
LinkedList 的增删改查：
点击查看代码
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println("linkedList = " + linkedList);//1,2,3
//删除结点
linkedList.remove();//默认删除第一个结点
//linkedList.remove(2);
System.out.println("linkedList = " + linkedList);//2,3
//修改某个结点对象
linkedList.set(1, 99);
System.out.println("linkedList = " + linkedList);//2,99
//得到某个结点对象
//get(1) 是得到双向链表的第二个对象
Object o = linkedList.get(1);
System.out.println(o);//99
//因为LinkedList 是 实现了 List 接口 ，遍历方式
Iterator iterator = linkedList.iterator();
System.out.println();
System.out.println("linkedList遍历");
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println("linkedList = " + next);
}
System.out.println("linkedList遍历增强for");
for (Object o1 : linkedList) {
System.out.println("linkedList = " + o1);
}
System.out.println("linkedList遍历普通for");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println("linkedList = "+linkedList.get(i));
}
/*
源码解读 linkedList.add(1) ：
1.LinkedList linkedList = new LinkedList();
public LinkedList(){}
2.这时linkeList 的属性 first = null last = null
3.执行 添加：
public boolean add(E e) {
linkLast(e);
return true;
}
4.将新的结点，加入到双向链表的最后
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.remove();//这里默认删除的是第一个结点
1.执行 removeFirst
public E remove() {
return removeFirst();
}
2.执行
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
3.执行 unlinkFirst，将 f 指向的双向链表的第一个结点拿掉
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
*/
}
ArrayList 和 LinkedList 的比较
|
底层结构 |
增删的效率 |
改查的效率 |
| ArrayList |
可变数组 |
较低数组扩容 |
较高 |
| LinkedList |
双向链表 |
jdk1.0 |
较低 |
如何选择 ArrayList 和LinkedList：
1.如果我们该的操作多，就选择ArrayList
2.如果我们增删的操作多，选择LinkedList
3.一般来说，在程序中，80%~90%都是查询，因此大部分情况下会选择ArrayList
4.在一个项目中，根据业务灵活选择。也可能一个模块使用的是ArrayList，另外一个模块是LinkedList
Set
set接口介绍
1.无序(添加和取出的顺序不一致)，没有索引
2.不允许重复元素，索引最多包含一个null
3.JDK API 中的 set接口的实现类有
参数类型 ：
E - 由此集合维护的元素的类型
所有超级接口：
Collection <E>， Iterable <E>
所有已知子接口:
NavigableSet <E>， SortedSet <E>
所有已知实现类：
AbstractSet，ConcurrentSkipListSet，CopyOnWriteArraySet，EnumSet，HashSet，JobStateReasons，LinkedHashSet，TreeSet
点击查看代码
public static void main(String[] args) {
//解读
//1.以Set 接口的实现类 HashSet 来讲解 Set 接口的方法
//2.set 接口的实现类的对象(Set接口对象)，不能存放重复的元素，可以添加null
//3.set 接口对象存放数据是无序的(即添加的顺序和取出的顺序不一致)
//4.注意：取出顺序的顺序虽然不是添加的顺序，但是它是固定的
Set set = new HashSet();
set.add("john");
set.add("lucy");
set.add("john");
set.add("jack");
set.add(null);
for (int i = 0; i < 6; i++) {
System.out.println(set);
}
//遍历
System.out.println("使用迭代器");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println("set=" + next);
}
System.out.println("使用增强for");
for (Object o : set) {
System.out.println("set = " + o);
}
//set 接口对象，不能通过索引来获取
}
Set接口的常用方法
和List接口一样，Set接口也是Collection的子接口，因此常用方法和Collection接口一样
Set接口的遍历方法
同Collection的遍历方式一样，因为Set接口时Collection接口的子接口
1.可以使用迭代器
2.增强for
3.不能使用索引的方式来获取
HashSet
HashSet的全面说明
1.HashSet 实现了Set接口
2.HashSet 实际上是 HashMao
3.可以存放null值，但是只能有一个null
public HashSet(){ map = new HashMap<>(); }
4.HashSet不保证元素是有序的，取决于hash后，在确定索引的结果
5.不能有重复元素/对象。
HashSet底层机制说明
HashSet 底层是(数组+链表+红黑树)
HashSet的添加元素底层是如何实现(hash()+equals())
1.HashSet底层是 HashMap
2.添加一个元素时，先得到hash值 会转成→索引值
3.找到存储数据表 table，看这个索引位置是否已经存放的有元素
4.如果没有，直接加入
5.如果有，调用equals比较，如果相同，就放弃添加，如果不相同，则添加到最后
6.在Java8中，如果一条链表的元素个数 到 TREEIFY_THRESHOLD (默认是8)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)
点击查看代码
public class HashSetSource {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add("java");//到此位置，第1次add分析完毕
hashSet.add("php");//到此位置，第2次add分析完毕
hashSet.add("java");//到此位置，第3次add分析完毕
System.out.println("set = " + hashSet);
/*
解读：
1.指向HashSet()
public HashSet() {
map = new HashMap<>();
}
2.执行add()
public boolean add(E e) {//e="java";
return map.put(e, PRESENT)==null;//(static) PRESENT = new Object();
}
3.执行put()，该方法会执行 hash(key) 得到key对应的hash值 算法：h = (key.hashCode()) ^ (h >>> 16)
public V put(K key, V value) {//key = "java"; value = PRESENT 共享
return putVal(hash(key), key, value, false, true);
}
4.执行putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;//定义了辅助变量
//table 就是 HashMap 的一个数组，类型是 Node[]
//if 语句表示如果当前table 是null，或者大小=0
//就第一次扩容，到16个空间
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//(1)根据kye，得到的hash 去计算该key应该存放到table表的哪个索引位置
// 并把这个位置的对象，赋给 p
//(2)判断p是否为null
//(2.1)如果 p 为 null ，表示还没有存放元素，就创建一个Node(key = "java"，value=PRESENT)
//(2.2)就放在该位置 tab[i] = newNode(hash，key，value，null)
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//在需要局部变量(辅助变量)时候，在创建
Node<Key,Value> e;K k;
//如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样，并且满足下面两个条件之一：
//(1)准备加入的key 和p 执行的Node 结点的 key 是同一个对象
//(2)p 执行的Node 结点的 key 的equals() 和准备加入的key比较后相同就不能加入
if (p.hash == hash &&//如果当前索引位置对于的链表的第一个元素和准备添加的key的hash值一样
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//在判断 p 是不是一颗红黑树
//如果是一颗红黑树，就调用 putTreeVal，来进行添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {//如果table 对应索引位置，已经是一个链表，就是用for循环比较
//(1)依次和该链表的每一个元素比较后，都不相同，则加入到该链表的最后
// 注意再把元素添加到链表后，立即判断 该链表是否已经达到8个结点，
// 就调用 treeifyBin() 对当前这个链表进行书华(转成红黑树)
// 注意，在转成红黑树时，要进行判断，判断条件:
// if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
// resize();
// 如果上面条件成立，先table扩容
// 只有上面条件不成立时，才进行转成红黑树
//(2)依次和该链表的每一个元素比较过程中，如果有相同的情况，就直接break;
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//size 就是我们没加入一个结点Node(key,value,hash,next),size++
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
5.
*/
}
}
HashSet的扩容和转成红黑树机制：
1.HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值(threshold)是16*加载因子(threshold)是16*加载因子(loadFactor)是0.75=12
2.如果table数组使用到了临界值12，就会扩容到16*2=32，行的临界值就是32*0.75=24，以此类推
3.在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是9)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)，否则仍然采用数组扩容机制
点击查看代码
public class HashSetIncrement {
public static void main(String[] args) {
/*
HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值(threshold)是16*加载因子
(threshold)是16*加载因子(loadFactor)是0.75=12
如果table数组使用到了临界值12，就会扩容到16*2=32，行的临界值就是32*0.75=24，以此类推
*/
HashSet hashSet = new HashSet();
// for (int i = 0; i <= 100; i++) {
// hashSet.add(i);
// }
/*
在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是9)，
并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)，否则仍然采用数组扩容机制
*/
// for (int i = 0; i <= 12; i++) {
// hashSet.add(new A(i));
// }
// System.out.println("hashSet = " + hashSet);
/*
当我们想hashSet增加一个元素，→Node→加入table，就算是增加一个
*/
for (int i = 0; i <= 7; i++) {//在table的某一条链表上添加了7个A对象
hashSet.add(new A(i));
}
for (int i = 0; i <= 7; i++) {//在table的某一条链表上添加了7个B对象
hashSet.add(new B(i));
}
}
}
class B {
private int n;
public B(int n) {
this.n = n;
}
@Override
public int hashCode() {
return 200;
}
}
class A {
private int n;
public A(int n) {
this.n = n;
}
@Override
public int hashCode() {
return 100;
}
}
练习：
1定义一个 Employee 类，该类包含：private成员属性name，age要求：
1.创建3个Employee 对象放入 HashSet中
2.当name和age的值相同时，认为是相同员工，不能添加到HashSet集合中
点击查看代码
class Employee{
private String name;
private int age;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Employee employee = (Employee) o;
return age == employee.age && Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add(new Employee("toc",18));
hashSet.add(new Employee("jack",20));
hashSet.add(new Employee("toc",18));
System.out.println(hashSet);
}
2定义一个Employee类，该类包含：private成员属性name，sal，birthday(Mydate类型)，其中birthday为MyDate类型(属性包括：year，month，day)，要求：
1.创建3个Employee放入HashSet
2.当name和birthday的值相同时，认为是相同员工，不能添加到HashSet集合中
点击查看代码
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add(new Employee01("王二",2000,new MyDate(11,22,33)));
hashSet.add(new Employee01("张三",2000,new MyDate(11,22,33)));
hashSet.add(new Employee01("王二",2000,new MyDate(11,22,33)));
System.out.println(hashSet);
}
class Employee01{
private String name;//名字
private double sal;//薪水
private MyDate birthday;//生日
public Employee01(String name, double sal, MyDate birthday) {
this.name = name;
this.sal = sal;
this.birthday = birthday;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Employee01 that = (Employee01) o;
return Objects.equals(name, that.name) && Objects.equals(birthday, that.birthday);
}
@Override
public int hashCode() {
return Objects.hash(name, birthday);
}
@Override
public String toString() {
return "Employee01{" +
"name='" + name + '\'' +
", sal=" + sal +
", birthday=" + birthday +
'}';
}
}
class MyDate{
private int year;//年
private int month;//月
private int day;//日
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
MyDate myDate = (MyDate) o;
return year == myDate.year && month == myDate.month && day == myDate.day;
}
@Override
public int hashCode() {
return Objects.hash(year, month, day);
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
}
LinkedHashSet
1.在LinkedHashSet中维护了一个hash表和双向链表(LinkedHashSet有head和tail)
2.每一个节点有pre和next属性，这样可以形成双向链表
3.在添加一个元素时，先求hash值，再求索引。确定该元素在hashtable的位置，然后将添加的元素加入到双向链表(如果已经存在，不添加[原则和hashset一样])
tail.next = new Element//简单指定
new Element.pre = tail
tail = new Element;
4.这样的话，我们遍历LinkedHashSet也能确保插入顺序和遍历顺序一致
点击查看代码
public static void main(String[] args) {
//分析 LinkedHashSet的底层机制
Set set = new LinkedHashSet();
set.add(new String("AA"));
set.add(456);
set.add(456);
set.add(new Customer("张",101));
set.add(123);
set.add("slz");
System.out.println(set);
/*
解读：
1.LinkedHashSet 加入顺序和取出元素/数据的顺序一致
2.LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类)
3.LinkedHashSet 底层结构 (数组table+双向链表)
4.添加一次时，直接将数组table 扩容到16，存放的结点类型是 LinkedHashMap$Entry
5.数组是 HashMap$Node[] 存放的元素/数据是 HashMap$Node类型
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
*/
}
class Customer{
private String name;
private int no;
public Customer(String name, int no) {
this.name = name;
this.no = no;
}
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", no=" + no +
'}';
}
}
练习
Car类(属性:name，price)，如果name和price一样，则认为是相同元素，不能添加
点击查看代码
public static void main(String[] args) {
LinkedHashSet linkedHashSet = new LinkedHashSet();
linkedHashSet.add(new Car("奥拓",1000));
linkedHashSet.add(new Car("奥迪",10000));
linkedHashSet.add(new Car("法拉利",1000000));
linkedHashSet.add(new Car("保时捷",11230000));
linkedHashSet.add(new Car("奥迪",10000));
System.out.print(linkedHashSet);
}
class Car{
private String name;
private double price;
public Car(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
//重写equals 方法 和hash方法
//当name 和 price 相同时，就返回相同的 hashCode 值，equals返回true
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Car car = (Car) o;
return Double.compare(car.price, price) == 0 &&
Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
"}\n";
}
}
TreeSet
点击查看代码
//解读：
/*
1.当我们使用无参构造器，创建TreeSet时，仍然是无序的
假如希望添加的元素，按照字符串大小来排序
2.使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
并指定排序规则
*/
//TreeSet treeSet = new TreeSet();
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//调用String的compareTo 方法进行字符串大小比较
return ((String) o1).compareTo((String) o2);
}
});
//添加数据
treeSet.add("jack");
treeSet.add("john");
treeSet.add("aaa");
System.out.println(treeSet);
/*
1.把构造器传入的比较对象，赋给了TreeSet底层的 TreeMap的属性this.comparator
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
2.在调用 treeSet.add("john");在底层会执行到
if (cpr != null) {//cpr就是我们的匿名内部类(对象)
do {
parent = t;
//动态绑定到我们的匿名内部类(对象)compare
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else//如果相等，即返回0，这个key就没有加入
return t.setValue(value);
} while (t != null);
}
*/
Map
Map接口实现类的特点
1.Map和Collection并列存在。用于保存具有映射关系的数据：key-Value
2.Map中的Key和value可以是任何引用类型的数据，会封装到HashMap$Node对象中
3.Map中的key不允许重复，原因和HashSet一样。
4.Map中的value可以重复
5.Map的key可以为null，value也可以为null，注意key为null，只能有一个，value为null，可以多个
6.常用String类作为Map的key
7.key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
8.Map存放数据的key-value，一对k-v是放在一个Node中的，又因为Node实现了Entry接口，有些书上也说 一对k-v就是一个 Entry
![]()
点击查看代码
//解读Map 接口实现类的特点，使用实现类HashMap
//1.Map与Collection并且存在。用于保存具有映射关系的数据：Key-Value(双列元素)
//2.Map中的key和value可以是任何引用类型的数据，会封装到 HashMap$Node 对象中
//3.Map中的key不允许重复，原因和HashSet一样。
//4.Map中的value可以重复
//5.Map的key可以为null，value也可以为null，注意key为null，只能有一个，value为null，可以多个
//6.常用String类作为Map的key
//7.key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
Map map = new HashMap();
map.put("no1","王二");//k-y
map.put("no2","张三");//k-y
map.put("no1","张三");//当有相同key，就相当于替换
map.put("no3","王二");//k-y
map.put(null,null);//k-y
map.put(null,"123");//等价替换
map.put("no4",null);//k-y
map.put("no5",null);//k-y
map.put(1,"李四");
map.put(new Object(),"王五");
//通过get方法，传入key，会返回对应的value
System.out.println(map.get("no2"));
System.out.println(map);
//解读
//1.k-v最后是 HashMap$Node node = newNode(hash,key,value,null)
//2.k-v为了方便程序员的遍历，还会创建EntrySet集合，该集合存放的元素的类型Entry，而一个Entry对象就有k,v
// EntrySet<Entry<K,V>>即: transient Set<Map.Entry<K,V>> entrySet;
//3.entrySet中，定义的类型是Map.Entry,但是实际上存放的还是HashMap$Node
// 这是因为static class Node<K,V> implements Map.Entry<k,V>
//4.当吧 HashMap$Node对象 存放到entrySet 就方便我们的遍历，因为Map.Entry提供了重要方法k getKey(); V getValue();
Set set = map.entrySet();
System.out.println(set.getClass());//HashMap$EntrySet
for (Object o :set) {
// System.out.println(o.getClass());//HashMap$Node
//为了从 HashMap$Node 取出K-V
//1，先做一个向下转型
Map.Entry entry = (Map.Entry) o;
System.out.println(entry.getKey()+"-"+entry.getValue());
}
Set set1 = map.keySet();
Collection values = map.values();
System.out.println(set1.getClass());
System.out.println(values.getClass());
Map接口常用方法
1.put：添加
2.remove：根据键删除映射关系
3.get：根据键获取值
4.size：获取元素个数
5.isEmpty：判断个数是否为0
6.clear：清除
7.containsKey：查找键是否存在
点击查看代码
//演示map接口常用方法
// 1.put：添加
Map map = new HashMap();
map.put("邓超", new Book("", 100));//OK
map.put("邓超", "孙俪");//替换
map.put("王宝强", "马蓉");//OK
map.put("宋", "马蓉");//OK
map.put("刘令博", null);//OK
map.put(null, "刘亦菲");//OK
map.put("鹿晗", "关晓彤");//OK
System.out.println("map = " + map);
// 2.remove：根据键删除映射关系
map.remove(null);
System.out.println("map = " + map);
// 3.get：根据键获取值
Object val = map.get("王宝强");
System.out.println(val);
// 4.size：获取元素个数
System.out.println("k-v = " + map.size());
// 5.isEmpty：判断个数是否为0
System.out.println(map.isEmpty());//F
// 6.clear：清除k-v
//map.clear();
System.out.println("map = " + map);
// 7.containsKey：查找键是否存在
System.out.println(map.containsKey("宋"));
Map遍历方式：
1.containsKey：查找键是否存在
2.keySet：获取所有的键
3.entrySet：获取所有关系k-v
4.values：获取所有的值
点击查看代码
Map map = new HashMap();
map.put("邓超", new Book("", 100));//OK
map.put("邓超", "孙俪");//替换
map.put("王宝强", "马蓉");//OK
map.put("宋", "马蓉");//OK
map.put("刘令博", null);//OK
map.put(null, "刘亦菲");//OK
map.put("鹿晗", "关晓彤");//OK
//第一组：先取出 所有的Key，通过Key 取出对应的Value
Set keySetet = map.keySet();
//(1)for增强
System.out.println("===第一种方法===");
for (Object key :keySetet) {
System.out.println(key+"-"+map.get(key));
}
//(2)迭代器
System.out.println("===第二种方法===");
Iterator iterator = keySetet.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key+"-"+map.get(key));
}
//第二组：把所有的values取出
Collection values = map.values();
//这里可以使用所有的Collections使用的遍历方法
//(1)增强for
System.out.println("===取出所有的 value 增强for===");
for (Object value : values) {
System.out.println(value);
}
//(2)迭代器
System.out.println("===取出所有的 value 迭代器===");
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()) {
Object value = iterator1.next();
System.out.println(value);
}
//第三组：通过EntrySet 来获取 k-v
Set entrySet = map.entrySet();//EntrySet<Map.Entry<K,V>>
//(1)增强for
System.out.println("===使用EntrySet 的 for增强===");
for (Object entry : entrySet) {
//将entry 转成 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey()+"-"+m.getValue());
}
//(2)迭代器
System.out.println("===使用EntrySet 的 迭代器===");
Iterator iterator2 = entrySet.iterator();
while (iterator2.hasNext()) {
Object entry = iterator2.next();
//System.out.println(entry.getClass());//HashMap$Noode-实现→Map.Entry(getKey,getValue)
//向下转型 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey()+"-"+m.getValue());
HashMap练习
使用HashMap添加3个员工对象，要求：
键：员工id
值：员工对象
并遍历显示工资>18000的员工(遍历方式最少两种)
员工类：姓名、工资、员工id
点击查看代码
Map map = new HashMap();
//添加对象
map.put(1,new Staff(1,"张三",20000));
map.put(2,new Staff(2,"李四",19000));
map.put(3,new Staff(3,"王二",10000));
//遍历两种方式
//1.使用KeySet→增强for
System.out.println("===增强for===");
Set keySet = map.keySet();
for (Object key :keySet) {
//现货区value
Staff staff = (Staff) map.get(key);
if(staff.getSal()>18000){
System.out.println(staff);
}
}
//2.使用EntrySet→迭代器
System.out.println("===迭代器===");
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
//通过entry 取得key和value
Staff sta = (Staff)entry.getValue();
if(sta.getSal()>18000){
System.out.println(sta);
}
}
HashMap小结：
1.Map接口的常用实现类：HashMap、Hashtable和Properties
2.HashMap是Map接口使用频率最高的实现类
3.HashMap是以key-val对的方式来存储数据
4.key不能重复，但是是值可以重复，允许使用null键和null值
5.如果添加相同的key，则会覆盖原来的key-val,等同于修改。(key不会替换,val会替换)
6.与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的
7.HashMap没有实现同步，因此是线程不安全的
HashMap底层机制
1.(k,v)是一个Node实现了Map.Entry<K,V>，查看HashMap的源码可以看到
2.jdk7.0的hashmap底层实现[数组+链表],jdk8.0底层[数组+链表+红黑树]
HashMap扩容机制
1.HashMap底层维护了Node类型的数组table，默认为null
2.当创建对象时，将加载因子(loadfactor)初始化为0.75
3.当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断元素的key和准备加入的key是否相等。如果相等，则直接替换val；如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容
4.第一次添加，则需要扩容table容量为16，临界值(threshold)为12(16*0.75)
5.以后再扩容，则需要扩容table容量为原来的2倍(32)，临界值为原来的2倍，即24，依此类推
6.在java8中，如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)
点击查看代码
HashMap map = new HashMap();
map.put("java",10);//OK
map.put("php",10);//OK
map.put("java",20);//替换value
System.out.println("map = "+map);
//解读
/*
1.执行构造器 new HashMap()
初始化加载因子 loadfactor = 0.75
HashMap$Node[] table = null
2.执行 put 调用 hash方法，计算key的hash值 (h = key.hashCode()) ^ (h >>> 16)
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
3.执行 putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果底层的table 数组为null，或者length=0，就扩容到16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//取出hash值对应的table的索引位置的Node，如果null，就直接把加入的k-v创建一个Node，
// 加入该位置即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;//辅助变量
//如果table的索引位置的key的hash相同和新的key的hash值相同，
//并满足(table现有的结点的key和准备添加的key是同一个对象 || equals返回真
//就认为不能加入新的K-V
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果找到的结点，后面是链表，就循环比较
for (int binCount = 0; ; ++binCount) {//死循环
if ((e = p.next) == null) {//如果整个链表，没有和他相同，就加到该链表的最后
p.next = newNode(hash, key, value, null);
//加入后,判断当前链表的个数,是否已经到8个,到8个,后就调用treeifyBin方法进行红黑树的转换
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;//替换，key对应value
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
5.关于树化(转成红黑树)
//如果table为null，或者大小还没有到64，暂时不书画，而是进行扩容
//否则才会真正的树化→剪枝
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
*/
HashTable
HashTable基本介绍
1.存放的元素是键值对：即K-V
2.hashtable 的键和值都不能为null，否则会抛出NullPointerException
3.hashtable 使用方法基本上和HashMap一样
4.hashtable 是线程安全的， hashMap是线程不安全的
点击查看代码
Hashtable table = new Hashtable();
table.put("toc",100);//ok
//table.put(null,100);//异常 NullPointerException
//table.put("toc",null);//异常 NullPointerException
table.put("john",100);//ok
table.put("john",80);//替换
System.out.println(table);
//Hashtable底层
/*
1.底层有数组 Hashtable$Entry[] 初始化大小为11
2.临界值 threshold 8 = 11 * 0.75
3.扩容：按照自己的扩容机制进行
4.执行 方法 addEntry(hash,key,value,index)；添加k-v 封装到
5.当 if(count >= threshold) 满足时，就进行扩容
按照 int newCapacity = (oldCapacity << 1)+1;的大小扩容
*/
Hashtable 和 HashMap 对比
|
版本 |
线程安全() |
|
允许null键null值 |
| HashMap |
1.2 |
不安全 |
高 |
可以 |
| Hashtable |
1.0 |
安全 |
第 |
不可以 |
TreeMap
点击查看代码
//默认的构造器，创建 TreeMap 是无序的(也没有排序)
//TreeMap treeMap = new TreeMap();
//要求：按照传入的 k(String) 的大小进行排序
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//按照传入的k(String) 的大小进行排序
//按照K（String） 的长度大小排序
//return ((String) o1).compareTo((String) o2);
return ((String) o1).length()-((String) o2).length();
}
});
treeMap.put("jack","杰克");
treeMap.put("tom","汤姆");
treeMap.put("kristina","克瑞斯提诺");
treeMap.put("smith","斯密斯");
treeMap.put("hsp","斯密斯");
System.out.println("treeMap = "+treeMap);
//解读：
/*
1.构造器，把传入的实现了 Comparator接口的匿名内部类(对象)，传给TreeMap的Comparator
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
2.调用put方法
2.1第一次添加，把k-v 封装到Entry 对象，放入 root
Entry<K,V> t = root;
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
2.2以后添加
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {//遍历所有的key，给当前key找到适当的位置
parent = t;
cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compare
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else//如果遍历过程中，发现准备添加key 和当前已有的key相等，就不添加
return t.setValue(value);
} while (t != null);
}
*/
Properties
1.Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据
2.它的使用特点和Hashtable类似
3.Properties 还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改
4.说明：工作后 xxx.properties文件通常作为配置文件
点击查看代码
Properties properties = new Properties();
//增加
properties.put("tom",100);
// properties.put(null,100);//抛出 空指针异常 NullPointerException
// properties.put("tom",null);/抛出 空指针异常 NullPointerException
//修改
properties.put("john",100);
properties.put("john",80);//如果有相同的key,value被替换
System.out.println(properties);
// 查找
// 通过k获取对应值
System.out.println(properties.get("john"));
//
System.out.println(properties.getProperty("john"));
//删除
properties.remove("tom");
System.out.println(properties);
//解读：
/*
1.Properties 继承 Hashta
2.可以通过 k-v 存放数据，key 和 value 不能为 null
3.如果有相同的key,value被替换
*/
总结-开发中如何选择集合实现类
再发开展，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择。
1.先判断存储的类型(一组对象[单列]或一组键值对[双列])
2.一组对象：Collection接口
允许重复：List
增删多：LinkedList[底层维护了一个双向链表]
改查多：ArrayList[底层维护 Object类型的可变数组]
不允许重复：Set
无序：HashSet [底层是HashMap，维护了一个哈希表 即(数组+链表+红黑树)]
排序：TreeSet
插入和取出顺序一致：LinkedHashSet，维护数组+双向链表
3.一组键值对：Map
键无序：HashMap[底层是：哈希表 jdk7：数组+链表，jdk8：数组+链表+红黑树]
键排序：TreeMap
键插入和取出顺序一致：LinkdHashMap
读取文件：Properties
作业
编程题：
1.封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题
2.只提供一个带参数的构造器，实例化对象时，只初始化标题;并且实例化两个对象:
新闻一：新冠确证病例超过两千万，数百万印度教信徒赴恒河"圣浴"引民众担忧
新闻二：男子突然想起两个元钱钓的鱼还在网兜里，捞起一看赶紧放生
3.讲新闻对象添加到ArrayList集合中，并进行倒序遍历
4.在遍历集合过程中,对新闻标题进行处理,超过15字的只保留前15个,然后加"..."
5.在控制台打印遍历出经过处理的新闻标题
点击查看代码
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(new News("新冠确证病例超过两千万，数百万印度教信徒赴恒河\"圣浴\"引民众担忧"));
arrayList.add(new News("男子突然想起两个元钱钓的鱼还在网兜里，捞起一看赶紧放生"));
for (int i = arrayList.size()-1; i>=0 ; i--) {
//System.out.println(arrayList.get(i));
News news = (News)arrayList.get(i);
System.out.println(processTitle(news.getTitle()));
}
}
//写一个方法，处理新闻标题
public static String processTitle(String title){
if(title == null){
return "";
}
if(title.length()>15){
return title.substring(0,15)+"...";
}else {
return title;
}
}
class News{
private String title;//标题
private String content;//内容
public News(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
return "news{" +
"title='" + title + '\'' +
'}';
}
}
2编程题
使用ArrayList完成对 对象Car{name，price}的各种操作
1.add：添加单个元素
2.remove：删除指定元素
3.contains：查找元素是否存在
4.size：获取元素个数
5.isEmpty：判断是否为空
6.clear：清空
7.addAll：添加多个元素
8.contatinsAll：查找多个元素是否都存在
9.removeAll：删除多个元素
使用增强for和迭代器来遍历索引car，需要重写Car的toString方法
Car car = new Car("宝马",400000);
Car car = new Car("宾利",5000000);
点击查看代码
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
Car car1 = new Car("宝马",400000);
Car car2 = new Car("宾利",5000000);
// * 1.add：添加单个元素
arrayList.add(car1);
arrayList.add(car2);
System.out.println(arrayList);
// * 2.remove：删除指定元素
arrayList.remove(car1);
System.out.println(arrayList);
// * 3.contains：查找元素是否存在
System.out.println(arrayList.contains(car1));
// * 4.size：获取元素个数
System.out.println(arrayList.size());
// * 5.isEmpty：判断是否为空
System.out.println(arrayList.isEmpty());
// * 6.clear：清空
//arrayList.clear();
System.out.println(arrayList);
// * 7.addAll：添加多个元素
arrayList.addAll(arrayList);
System.out.println(arrayList);
// * 8.contatinsAll：查找多个元素是否都存在
System.out.println(arrayList.containsAll(arrayList));
// * 9.removeAll：删除多个元素
//arrayList.removeAll(arrayList);
System.out.println(arrayList);
//使用增强for和迭代器来遍历索引car，需要重写Car的toString方法
for (Object o : arrayList) {
System.out.println(o);
}
//迭代器
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
}
class Car{
private String name;//姓名
private double price;//价格
public Car(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
3编程题
1.使用HashMap类实例化一个Map类型的对象m，键(String)和值(int)分别用于存储员工的姓名和工资，存入数据如下：jack-650、tom-1200、smith-2900
2.将jack的工资更改为2600
3.为所有员工工资加薪100
4.遍历集合中索引的员工
5.遍历集合中所有的工资
点击查看代码
//1.使用HashMap类实例化一个Map类型的对象m，键(String)和值(int)分别用于存储员工的姓名和工资，存入数据如下：jack-650、tom-1200、smith-2900
Map map = new HashMap();
map.put("jack",650);
map.put("tom",1200);
map.put("smith",2900);
System.out.println(map);
//2.将jack的工资更改为2600
map.put("jack",2600);
System.out.println(map);
//3.为所有员工工资加薪100
Set set = map.keySet();
for (Object o :set) {
map.put(o,(Integer)map.get(o)+100);
}
System.out.println(map);
//4.遍历集合中索引的员工
System.out.println("遍历员工姓名");
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
System.out.println(entry.getKey());
}
//5.遍历集合中所有的工资
System.out.println("遍历员工工资");
Collection values = map.values();
for (Object o :values) {
System.out.println(o);
}
4简答题
分析HashSet和TreeSet分别如何实现去重复的
1.HashSet去重复机制：hashCode()+equasl()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，酒精性equals比较[遍历比较]，如果比较后，不相同就加入，否则不加入
2.TreeSet的去重复机制：如果你传入一个Comparator匿名对象，就是用事先的compare去重复，如果方法返回0，就认为是相同的元素/数据，就不添加，如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Compareable接口的compareTo去重复
5代码分析
下面代码运行会不会抛出异常，并从源码层面说明原因
TreeSet treeSet = new TreeSet();
treeSet.add(new Person());
6下面代码输出什么
HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
p1.name = "CC";
set.remove(p1);
System.out.println(set);//[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
set.add(new Person(1001,"CC"));
System.out.println(set);//[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
set.add(new Person(1001,"AA"));
System.out.println(set);
浙公网安备 33010602011771号