目录
3. List 的三种遍历方式 [ArrayList, LinkedList,Vector]
8. ArrayList,LinkedList,Vector三者的相同点与不同点?
集合和数组的对比小结:
数组的长度是不可变的,集合的长度是可变的。
数组可以存基本数据类型和引用数据类型。
集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类。
一、概述
集合是一种存储数据的容器,较数组而言,集合可以存储不同类型的数据,且集合的容量是动态的,并且提供了一系列方法便于数据的操作。
二、集合体系
在Java中,集合可分为两大类,Collection接口下的单列集合和Map接口下的双列集合(存储键值对)
1. 单列集合体系图(部分)
2. 双列集合体系图(部分)
Collection接口继承了Iterable接口,所以其接口的实现类都是可迭代的对象。
Collection接口没有直接的实现子类,是通过它的子接口Set 和 List来实现的
3. Collection接口中规定的方法
4. Collection 集合的遍历:
(1)Iterator:迭代器,集合的专用遍历方式
Iterator<E> iterator():返回集合中的迭代器对象,该迭代器对象默认指向当前集合的0索引。
Iterator中的常用方法:
boolean hasNext():判断当前位置是否有元素可以被取出
E next():获取当前位置的元素
将迭代器对象移向下一个索引位置
注意:在调用iterator.next()方法之前必须要调用iterator.hasNext(进行检测。
若不调用,且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
迭代器修改第三方变量的值不会影响到集合中的元素
注意: 在使用Iterator迭代器遍历集合时,若往集合中添加了元素,会报错(并发修改异常)
删除集合中的元素则不会报错,因为Iterator接口中有一个remove()方法,但删除操作必须写在next()语句后面
解决并发修改异常,可使用ListIterator迭代器,但此迭代器只对List下的实现类使用
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
//System.out.println("col=" + col);
//1. 先得到 col 对应的 迭代器
Iterator iterator = col.iterator();
//2. 使用 while 循环遍历
// while (iterator.hasNext()) {//判断是否还有数据
// //返回下一个元素,类型是 Object
// Object obj = iterator.next();
// System.out.println("obj=" + obj);
// }
//快速生成快捷键 while => itit
//显示所有的快捷键的的快捷键 ctrl + j
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
//3. 当退出 while 循环后 , 这时 iterator 迭代器,指向最后的元素
// iterator.next();//NoSuchElementException
//4. 如果希望再次遍历,需要重置我们的迭代器
iterator = col.iterator();
System.out.println("===第二次遍历===");
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
(2)增强for循环:
增强for:简化数组和Collection集合的遍历 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
实现Iterable接口的类才可以使用迭代器和增强for
增强for的格式 格式: for(元素数据类型 变量名 : 数组或者Collection集合) {
//在此处使用变量即可,该变量就是元素
}
范例: ArrayList<String> list = new ArrayList<>(); //添加一些元素
for(String s : list) {
System.out.println(i);
}
(3)普通for循环
(4)三种循环使用场景
如果需要操作索引,使用普通for循环
如果在遍历的过程中需要删除元素,请使用迭代器
如果仅仅想遍历,那么使用增强for
三、list接口及实现类
1. List接口的特点
- 允许存储重复值
- 允许存储多个空值
- 存取是有序的,支持通过索引操作元素
- JDK中已知实现子类
2. List接口特有方法
List list = new ArrayList();
list.add("张三丰");
list.add("贾宝玉");
// void add(int index, Object ele):在 index 位置插入 ele 元素
//在 index = 1 的位置插入一个对象
list.add(1, "韩顺平");
System.out.println("list=" + list);
// 从 index 位置开始将 eles 中的所有元素添加进来
boolean addAll(int index, Collection eles):
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1, list2);
System.out.println("list=" + list);
// 获取指定 index 位置的元素
Object get(int index)
// 返回 obj 在集合中首次出现的位置
int indexOf(Object obj)
System.out.println(list.indexOf("tom"));//2
// 返回 obj 在当前集合中末次出现的位置
int lastIndexOf(Object obj)
list.add("韩顺平");
System.out.println("list=" + list);
System.out.println(list.lastIndexOf("韩顺平"));
// 移除指定 index 位置的元素,并返回此元素
Object remove(int index)
list.remove(0);
System.out.println("list=" + list);
//设置指定 index 位置的元素为 ele , 相当于是替换.
Object set(int index, Object ele)
list.set(1, "玛丽");
System.out.println("list=" + list);
//返回从 fromIndex 到 toIndex 位置的子集合
List subList(int fromIndex, int toIndex)
// 注意返回的子集合 fromIndex <= subList < toIndex
List returnlist = list.subList(0, 2);
System.out.println("returnlist=" + returnlist);
3. List 的三种遍历方式 [ArrayList, LinkedList,Vector]
4. ListIterator的使用:
(1)继承关系
ListerIterator继承自Iterator,并对其进行扩展,如反向迭代、迭代中添加元素、以及改变某个元素的值。
(2)案例演示
@Test
public void ListIteratorTest(){
// 创建集合
List<Integer> li = new ArrayList<>();
// 添加元素
Collections.addAll(li, 1, 2, 3, 4);
System.out.println("修改前"+li);
// 获取迭代器
ListIterator<Integer> ill = li.listIterator();
// 正向迭代
while (ill.hasNext()) {
Integer next = ill.next();
if (next.equals(3))
// 修改
ill.set(100);
}
System.out.println("修改后"+li);
// 反向迭代
while (ill.hasPrevious()) {
Integer pre = ill.previous();
System.out.print(pre + "\t");
}
}
5. List常见子类介绍
(1)ArrayList
ArrayList 的注意事项
ArrayList:底层数据结构是数组,查询快,增删慢
ArrayList 的底层操作机制源码分析
扩容机制
eg.
ArrayList<Integer> arr = new ArrayList();
arr.add(1);
执行过程(源码):
1.执行构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
2.执行add()
public boolean add(E e) {
// 判断是否需要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
3. 执行ensureCapacityInternal(int minCapacity)
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
4.执行calculateCapacity,确认最小需要的容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
5.执行ensureExplicitCapacity(),判断当前数组长度和所需最小容量之间的关系,决定是否进行扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
6.grow(int minCapacity),扩容
int oldCapacity = elementData.length;
// 扩容为原来的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 扩容后是否满足需求
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 超过最大容量的处理
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
// 数据拷贝
elementData = Arrays.copyOf(elementData, newCapacity);
(2)Vector
Vector与AraayList都是通过数组进行数据的存储,不同的地方在于Vector是线程安全的,在多线程环境能够保证数据的一致性。
除此之外的一些不同之处
构造方法的不同:
eg. Vector<Integer> vec = new Vector<>();
过程如下:
1. public Vector() {
this(10);
}
2. public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
3. public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
扩容机制的不同
// 前面确认是否需要扩容的步骤类似ArrayList
// 实现扩容
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// Vector 的扩容取决于capacityIncrement,在capacityIncrement不大于0情况下扩容为原来的2倍数
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
(3)LinkedList
LinkedList:底层数据结构是链表,查询慢,增删快
LinkedList 的底层操作机制
LinkedList集合的特有功能
在序列末尾添加元素
eg.在序列末尾添加一个元素
源码:
1. public boolean add(E e) {
linkLast(e);
return true;
}
2. 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++;
}
图解(此处箭头为双向箭头)
因为使用的是链表,所以不存在扩容问题。(删除元素以及在指定位置插入元素原理相同)
6. List接口常见实现类小结
ArrayList使用数组存储数据,适合查询较多的场景。LinkedList使用的是来链表,在遍历上效率较低,但增加或删除元素效率较高。如果是在多线程环境下,且需要考虑线程安全问题,则选择Vector.
7. 注意事项
- LinkedList增加(删除)元素的效率一定高于ArrayList么?事无绝对,数组增加(删除)元素效率低的本质原因是会对增加(删除)之后位置元素的影响,需要将元素前移(后移)。所以,当增加(删除)的元素位于序列的末尾,不需要移动任何元素时,ArrayList的效率是高于LinkedList的。
- ArrayList 和 LinkedList 的比较
8. ArrayList,LinkedList,Vector三者的相同点与不同点?
相同点:
三个类都实现了List接口,存储数据的形式特点相同,都是存储可重复的有序的数据。
不同点:
(1)ArrayList类主要是实现类,虽然效率高,但是线程不安全。底层用的是Object[]数组存储。从查找的时间复杂度来说它属于O(I)。删除元素的时间复杂度O(n)。
(2)LinkedList类主要是用于频繁插入,删除操作,当然它的效率比ArrayList高,所以它的线程安全程度比ArrayList更低,底层使用的是双向链表存储。从查找的时间复杂度来说属于O(n)。插入删除的时间复杂度属于O(I)。
(3)Vector属于比较古老的一种类,效率比较低,反之线程比较安全,底层使用的是Object[]数组存储。
四、set接口及实现类
1. set接口的特点
- 不允许存储重复值(可以去除重复)
- 仅且允许存储一个空值
- 存取是无序的(存取顺序不一致,另外linkedHashSet看起来是有序的)
- 没有带索引的方法,所以不能使用普通for循环遍历,也不能通过索引来获取,删除Set集合里面的元素
2. set接口已知方法:
Set 接口同 List 接口,都是 Collection 的子接口,因此,常用方法和 Collection 接口一样
3.set 常见子类介绍
(1)HashSet
HashSet集合特点:
底层数据结构是哈希Map(表)
对集合的迭代顺序不作任何保证,也就是说不保证存储和取出的元素顺序一致
没有带索引的方法,所以不能使用普通for循环遍历
由于是Set集合,所以元素唯一
哈希值
哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值 public int hashCode():返回对象的哈希码值
对象的哈希值特点 :同一个对象多次调用hashCode()方法返回的哈希值是相同的
默认情况下,不同对象的哈希值是不同的。而重写hashCode()方法,可以实现让不同对象的哈希值相同
public HashSet() { // HashSet 底层实现为HashMap // jdk8之前HashMap通过哈希表实现(数组+链表) // jdk8之后通过数组+链表+红黑树实现 ,当挂载的元素过多,不利于查询,所以在JDK8以后, 当链表长度超过8的时候,自动转换为红黑树。 存储流程不变。 map = new HashMap<>(); }public HashMap() { // loadFactor加载因子,用于计算threshold(扩容阈值) = 容量 * 加载因子 this.loadFactor = DEFAULT_LOAD_FACTOR; // 0.75 }扩容机制
容量变为原来的2倍数,且扩容阈值也变为原来的2倍数
eg.
源码:
1.方法入口
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
2.
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
3. 通过特定算法计算对象的hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
4.
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 辅助变量
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 是否进行第一次扩容,初始容量16,初始加载因子0.75
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 通过计算出的hash值与table表当前最大索引值进行计算得出元素放置的位置
// 如果该位置为空,直接存入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 如果该位置有元素
else {
Node<K,V> e; K k;
// 首先与头节点进行比较,如果与头节点相同,则不添加
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 与头节点不同,判断表的这个位置存储的是链表还是树,如果已转化为树,则调用putTreeVal(...)
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 以上都不满足,与头节点不同且还未转化为树结构
// 与链表的每个节点进行比较,有相同或到达末尾就结束比较
else {
for (int binCount = 0; ; ++binCount) {
// 判断添加后是否会触发链表转化为红黑树
// 转化机制 单条链表元素个数为 TREEIFY_THRESHOLD(8) ,
// 且table表的容量达到MIN_TREEIFY_CAPACITY(64)
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;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
总结:
创建一个默认长度16,默认加载因为0.75的数组,数组名table
根据元素的哈希值跟数组的长度计算出应存入的位置
判断当前位置是否为null,如果是null直接存入
如果位置不为null,表示有元素,则调用equals方法比较属性值
如果一样,则不存,如果不一样,则存入数组,老元素挂在新元素下面 当数组存满到16*0.75=12时,就自动扩容,每次扩容原先的两倍
HashSet 底层是 HashMap, 第一次添加时,table 数组扩容到 16,临界值(threshold)是 16*
加载因子(loadFactor)是 0.75 = 12,如果 table 数组使用到了临界值 12,就会扩容到 16 * 2 = 32,
新的临界值就是 32*0.75 = 24, 依次类推
在 Java8 中, 如果一条链表的元素个数到达 TREEIFY_THRESHOLD(默认是 8 ),并且
table 的大小 >= MIN_TREEIFY_CAPACITY(默认 64),就会进行树化(红黑树), 否则仍然采用数
组扩容机制
链表长度>=8、且Entry[ ]数组长度>=64时,链表转化成红黑树结构,若数组长度<64则会扩容。
红黑树节点数<=6的时候退化成链表。
利用HashSet存储自定义元素,必须重写hashCode和equals方法
//如果 name 和 age 值相同,则返回相同的 hash 值
@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);
}
注意事项
- HashSet的去重与元素在内部的排序与hashCode()和equals(Object object)方法相关,可根据需求对两个方法进行重写。
(2)TreeSet
a. TreeSet集合概述
(1)元素有序,可以按照一定的规则进行排序,具体排序方式取决于构造方法
TreeSet():根据其元素的自然排序进行排序
TreeSet(Comparator comparator) :根据指定的比较器进行排序
(2)没有带索引的方法,所以不能使用普通for循环遍历
(3)由于是Set集合,所以不包含重复元素的集合
b. 想要使用TreeSet, 需要制定排序规则
(a) 自然排序Comparable的使用
使用空参构造创建TreeSet集合
自定义的类实现Comparable接口
重写里面的compareTo方法
(b) 比较器排序Comparator的使用
TreeSet的带参构造方法使用的是比较器排序对元素进行排序的
比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(T o1,T o2)方法
重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
c. 两种比较方式小结:
自然排序:自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序。
比较器 排序:创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,
根据返回值进行排序。
在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,使用比较器排序
两种方式中,关于返回值的规则:
如果返回值为负数,表示当前存入的元素是较小值,存左边
如果返回值为0,表示当前存入的元素跟集合中元素重复了,不存
如果返回值为正数,表示当前存入的元素是较大值,存右边
d. TreeSet添加元素:
通过传入的比较器进行比较或通过对象实现comparable接口重写的compareTo方法进行比较,
根据返回值进行元素排序和判断是否添加,返回0就认为是重复元素不进行添加,
返回值不为0则按照比较规则进行元素排序。
e. 注意事项:
(a) TreeSet添加的元素通常为可进行比较的一些对象,要么满足传入比较器的比较规则,要么实现了Comparable接口。
(b) TreeSet存储的通常是一类元素,或能够通过比较器进行比较的元素。
(c) 常见异常
- java.lang.ClassCastException
eg.
异常根源
public int compareTo(String anotherString)
f. 两种排序方式代码实现
(a)自然排序Comparable的使用
-
案例需求
-
存储学生对象并遍历,创建TreeSet集合使用无参构造方法
-
要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
-
-
实现步骤
-
用TreeSet集合存储自定义对象,无参构造方法使用的是自然排序对元素进行排序的
-
自然排序,就是让元素所属的类实现Comparable接口,重写compareTo(T o)方法
-
重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
-
-
代码实现
-
学生类
public class Student implements Comparable<Student> { private String name; private int age; public Student() { } public Student(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 int compareTo(Student s) { // return 0; // return 1; // return -1; //按照年龄从小到大排序 int num = this.age - s.age; // int num = s.age - this.age; //年龄相同时,按照姓名的字母顺序排序 int num2 = num==0?this.name.compareTo(s.name):num; return num2; } }
public class TreeSetDemo02 { public static void main(String[] args) { //创建集合对象 TreeSet<Student> ts = new TreeSet<Student>(); //创建学生对象 Student s1 = new Student("xishi", 29); Student s2 = new Student("wangzhaojun", 28); Student s3 = new Student("diaochan", 30); Student s4 = new Student("yangyuhuan", 33); Student s5 = new Student("linqingxia",33); Student s6 = new Student("linqingxia",33); //把学生添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); ts.add(s6); //遍历集合 for (Student s : ts) { System.out.println(s.getName() + "," + s.getAge()); } } }
(b)比较器排序Comparator的使用
-
案例需求
-
存储学生对象并遍历,创建TreeSet集合使用带参构造方法
-
要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
-
-
实现步骤
-
用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序对元素进行排序的
-
比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(T o1,T o2)方法
-
重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
-
-
代码实现
-
学生类
public class Student { private String name; private int age; public Student() { } public Student(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; } }
public class TreeSetDemo { public static void main(String[] args) { //创建集合对象 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { //this.age - s.age //s1,s2 int num = s1.getAge() - s2.getAge(); int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; return num2; } }); //创建学生对象 Student s1 = new Student("xishi", 29); Student s2 = new Student("wangzhaojun", 28); Student s3 = new Student("diaochan", 30); Student s4 = new Student("yangyuhuan", 33); Student s5 = new Student("linqingxia",33); Student s6 = new Student("linqingxia",33); //把学生添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); ts.add(s6); //遍历集合 for (Student s : ts) { System.out.println(s.getName() + "," + s.getAge()); } } }
g. TreeSet案例
-
成绩排序案例
-
案例需求
-
用TreeSet集合存储多个学生信息(姓名,语文成绩,数学成绩),并遍历该集合
-
要求:按照总分从高到低出现
-
-
代码实现
-
学生类
public class Student { private String name; private int chinese; private int math; public Student() { } public Student(String name, int chinese, int math) { this.name = name; this.chinese = chinese; this.math = math; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getChinese() { return chinese; } public void setChinese(int chinese) { this.chinese = chinese; } public int getMath() { return math; } public void setMath(int math) { this.math = math; } public int getSum() { return this.chinese + this.math; } }
public class TreeSetDemo { public static void main(String[] args) { //创建TreeSet集合对象,通过比较器排序进行排序 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { // int num = (s2.getChinese()+s2.getMath())-(s1.getChinese()+s1.getMath()); //主要条件 int num = s2.getSum() - s1.getSum(); //次要条件 int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num; int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2; return num3; } }); //创建学生对象 Student s1 = new Student("林青霞", 98, 100); Student s2 = new Student("张曼玉", 95, 95); Student s3 = new Student("王祖贤", 100, 93); Student s4 = new Student("柳岩", 100, 97); Student s5 = new Student("风清扬", 98, 98); Student s6 = new Student("左冷禅", 97, 99); // Student s7 = new Student("左冷禅", 97, 99); Student s7 = new Student("赵云", 97, 99); //把学生对象添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); ts.add(s6); ts.add(s7); //遍历集合 for (Student s : ts) { System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath() + "," + s.getSum()); } } }
-
不重复的随机数案例
-
案例需求
-
编写一个程序,获取10个1-20之间的随机数,要求随机数不能重复,并在控制台输出
-
-
代码实现
public class SetDemo { public static void main(String[] args) { //创建Set集合对象 // Set<Integer> set = new HashSet<Integer>(); Set<Integer> set = new TreeSet<Integer>(); //创建随机数对象 Random r = new Random(); //判断集合的长度是不是小于10 while (set.size()<10) { //产生一个随机数,添加到集合 int number = r.nextInt(20) + 1; set.add(number); } //遍历集合 for(Integer i : set) { System.out.println(i); } } }
-
-
(3)LinkedHashSet
五、Map接口及实现类
1. 2. Map接口的特点
- 存储键值对,键唯一对应值,可以通过键寻找对应的值,反之则不行
- 键不能重复(实现类只能有一个键为空),允许值重复
2. Map接口方法
//演示 map 接口常用方法
Map map = new HashMap();
map.put("邓超", new Book("", 100));
map.put("邓超", "孙俪");//替换-> 一会分析源码
map.put("王宝强", "马蓉");//OK
map.put("宋喆", "马蓉");//OK
map.put("刘令博", null);//OK
map.put(null, "刘亦菲");//OK
map.put("鹿晗", "关晓彤");//OK
map.put("hsp", "hsp 的老婆");
System.out.println("map=" + map);
// remove:根据键删除映射关系
map.remove(null);
System.out.println("map=" + map);
// get:根据键获取值
Object val = map.get("鹿晗");
System.out.println("val=" + val);
// size:获取元素个数
System.out.println("k-v=" + map.size());
// isEmpty:判断个数是否为 0
System.out.println(map.isEmpty());//F
// clear:清除 k-v
map.clear();
System.out.println("map=" + map);
// containsKey:查找键是否存在
System.out.println("结果=" + map.containsKey("hsp"));//T
3. Map 接口遍历方法
1) containsKey:查找键是否存在
2) keySet:获取所有的键
3)entrySet:获取所有关系k-v
4)values:获取所有的值
Map map = new HashMap();
map.put("邓超", "孙俪");
map.put("王宝强", "马蓉");
map.put("宋喆", "马蓉");
map.put("刘令博", null);
map.put(null, "刘亦菲");
map.put("鹿晗", "关晓彤");
//第一组: 先取出 所有的 Key , 通过 Key 取出对应的 Value
Set keyset = map.keySet();
//(1) 增强 for
System.out.println("-----第一种方式-------");
for (Object key : keyset) {
System.out.println(key + "-" + map.get(key));
}
//(2) 迭代器
System.out.println("----第二种方式--------");
Iterator iterator = keyset.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 iterator2 = values.iterator();
while (iterator2.hasNext()) {
Object value = iterator2.next();
System.out.println.println(value);
}
//第三组: 通过 EntrySet 来获取 k-v
Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>
//(1) 增强 for
System.out.println("----使用 EntrySet 的 for 增强(第 3 种)----");
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 的 迭代器(第 4 种)----");
Iterator iterator3 = entrySet.iterator();
while (iterator3.hasNext()) {
Object entry = iterator3.next();
//System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
//向下转型 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
4. Map常用实现类学习
HashMap、TreeMap和HashTable
HashMap、TreeMap的数据存储方式,以及添加元素时的执行过程可见上文HashSet和TreeSet处介绍
HashMap 小结
HashMap 底层机制及源码剖析
HashTable特点:
- 键和值都不能为null
- 线程安全
- 效率较低
构造方法
eg. Hashtable<String, Integer> ht = new Hashtable<>();
ht.put("1",100);
执行过程:
1.
public Hashtable() {
this(11, 0.75f);
}
2.
public Hashtable(int initialCapacity, float loadFactor)
3.判断是否添加元素(省略部分代码)
public synchronized V put(K key, V value){
// 值不能为空
if (value == null) {
throw new NullPointerException();
}
// ... 省略代码为判断键是否已经存在,方式为计算hash值,确认放在table表的位置
// 为空直接放入
// 不为空对该位置的链表元素依次进行判断
addEntry(hash, key, value, index);
return null;
}
4. 添加元素(省略部分代码)
private void addEntry(int hash, K key, V value, int index) {
// 判断是否进行扩容
// 如果扩容,需要重新计算元素存放的位置
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// 将元素放置在指定位置
tab[index] = new Entry<>(hash, key, value, e);
}
5.扩容部分(省略部分代码)
protected void rehash() {
// 扩容倍数为
// 不超过最大值new = old*2 + 1;
// 超过则等于
int newCapacity = (oldCapacity << 1) + 1;
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
// 重新确定阈值
// 将已经存放的元素按照之前的流程重新计算位置添加
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
5. Hashtable 和 HashMap 对比
6. Map 接口实现类-Properties
//1. Properties 继承 Hashtable
//2. 可以通过 k-v 存放数据,当然 key 和 value 不能为 null
//增加
Properties properties = new Properties();
//properties.put(null, "abc");//抛出 空指针异常
//properties.put("abc", null); //抛出 空指针异常
properties.put("john", 100);//k-v
properties.put("lucy", 100);
properties.put("lic", 100);
properties.put("lic", 88);//如果有相同的 key , value 被替换
System.out.println("properties=" + properties);
//通过 k 获取对应值
System.out.println(properties.get("lic"));//88
//删除
properties.remove("lic");
System.out.println("properties=" + properties);
//修改
properties.put("john", "约翰");
System.out.println("properties=" + properties);
}
六、适用场景分析
七、Collection和Collections区别
- Collection是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供最大化的统一操作方式。
以下接口实现了Collection接口:
map、set、list、vector - Collections是一个包装类。它包含各种有关集合操作的静态多态方法。此类不能实例化,就像一个工具类,服务于Java的Collection框架。
- (1)排序(Sort)
(2)反转(Reverse)
(3)替换所有元素(Fill)
(4)拷贝(copy)
(5)返回Collections中最小元素(min)
(6)返回Collections中最小元素(max)
八、泛型:
使用传统方法:
使用泛型:
泛型介绍: