目录
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"));//T3. 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)
八、泛型：
使用传统方法：
使用泛型：
泛型介绍：
213
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
